feat: implement cascading deletion for related records in delete

adminforth/dataConnectors/mysql.ts

@@ -76,6 +76,29 @@ class MysqlConnector extends AdminForthBaseConnector implements IAdminForthDataS
 
   async discoverFields(resource) {
     const [results] = await this.client.execute("SHOW COLUMNS FROM " + resource.table);
+    const [fkResults] = await this.client.execute(`
+      SELECT
+        kcu.TABLE_NAME AS child_table,
+        kcu.COLUMN_NAME AS column_name,
+        rc.DELETE_RULE AS delete_rule
+      FROM information_schema.KEY_COLUMN_USAGE kcu
+      JOIN information_schema.REFERENTIAL_CONSTRAINTS rc
+        ON kcu.CONSTRAINT_NAME = rc.CONSTRAINT_NAME
+        AND kcu.CONSTRAINT_SCHEMA = rc.CONSTRAINT_SCHEMA
+      WHERE kcu.REFERENCED_TABLE_NAME = ?
+        AND kcu.TABLE_SCHEMA = DATABASE()
+    `, [resource.table]);
+
+    const fkMap: Record<string, { cascade: boolean; childTable: string }> = {};
+    for (const fk of fkResults as any[]) {
+      fkMap[String(fk.column_name)] = {
+        cascade: String(fk.delete_rule).toUpperCase() === 'CASCADE',
+        childTable: fk.child_table
+      };
+      if (fkMap[fk.column_name].cascade) {
+        afLogger.warn(`The database has ON DELETE CASCADE, which may conflict with adminForth cascade deletion and upload logic. Please remove it.`);      
+      }
+    }
     const fieldTypes = {};
     results.forEach((row) => {
       const field: any = {};

adminforth/dataConnectors/postgres.ts

@@ -69,9 +69,50 @@ class PostgresConnector extends AdminForthBaseConnector implements IAdminForthDa
         return res.rows.map(row => ({ name: row.column_name, sampleValue: sampleRow[row.column_name] }));
       }
 
+    private async getPgFkCascadeMap(
+        tableName: string,
+        schema = 'public'
+    ): Promise<Record<string, { cascade: boolean; targetTable: string }>> {
+        const res = await this.client.query(
+            `
+            SELECT
+                att.attname AS column_name,
+                rel.relname AS child_table,
+                p.relname AS parent_table,
+                con.confdeltype AS confdeltype
+            FROM pg_constraint con
+            JOIN pg_class rel ON rel.oid = con.conrelid
+            JOIN pg_namespace nsp ON nsp.oid = rel.relnamespace
+            JOIN LATERAL unnest(con.conkey) WITH ORDINALITY AS k(attnum, ord) ON TRUE
+            JOIN pg_attribute att 
+                ON att.attrelid = con.conrelid AND att.attnum = k.attnum
+            JOIN pg_class p ON p.oid = con.confrelid
+            WHERE con.contype = 'f'
+            AND nsp.nspname = $2
+            AND p.relname = $1
+            `,
+            [tableName, schema]
+        );
+
+        const fkMap: Record<string, { cascade: boolean; targetTable: string }> = {};
+
+        for (const row of res.rows) {
+            fkMap[row.column_name.toLowerCase()] = {
+                cascade: row.confdeltype === 'c',
+                targetTable: row.parent_table,
+            };
+        }
+        return fkMap;
+    }
+
     async discoverFields(resource) {
 
         const tableName = resource.table;
+        const fkMap = await this.getPgFkCascadeMap(tableName);
+        const hasCascade = Object.values(fkMap).some(fk => fk.cascade);
+        if (hasCascade) {
+            afLogger.warn(`The database has ON DELETE CASCADE, which may conflict with adminForth cascade deletion and upload logic. Please remove it.`);
+        }
         const stmt = await this.client.query(`
         SELECT
             a.attname AS name,

adminforth/dataConnectors/sqlite.ts

@@ -42,6 +42,12 @@ class SQLiteConnector extends AdminForthBaseConnector implements IAdminForthData
         const tableName = resource.table;
         const stmt = this.client.prepare(`PRAGMA table_info(${tableName})`);
         const rows = await stmt.all();
+        const fkStmt = this.client.prepare(`PRAGMA foreign_key_list(${tableName})`);
+        const fkRows = await fkStmt.all();
+        const fkMap: { [colName: string]: boolean } = {};
+        fkRows.forEach(fk => {
+            fkMap[fk.from] = fk.on_delete?.toUpperCase() === 'CASCADE';
+        });
         const fieldTypes = {};
         rows.forEach((row) => {
           const field: any = {};
@@ -86,6 +92,11 @@ class SQLiteConnector extends AdminForthBaseConnector implements IAdminForthData
           field._baseTypeDebug = baseType;
           field.required = row.notnull == 1;
           field.primaryKey = row.pk == 1;
+
+          field.cascade = fkMap[row.name] || false;
+          if (field.cascade) {
+            afLogger.warn(`The database has ON DELETE CASCADE, which may conflict with adminForth cascade deletion and upload logic. Please remove it.`);
+          }
           field.default = row.dflt_value;
           fieldTypes[row.name] = field
         });

adminforth/modules/configValidator.ts

@@ -30,7 +30,7 @@ import {
 import AdminForth from "adminforth";
 import { AdminForthConfigMenuItem } from "adminforth";
 import { afLogger } from "./logger.js";
-
+import AdminForthRestAPI from './restApi.js';
 
 export default class ConfigValidator implements IConfigValidator {
 
@@ -282,8 +282,9 @@ export default class ConfigValidator implements IConfigValidator {
               return;
             }
 
-            await connector.deleteRecord({ resource: res as AdminForthResource, recordId });
-            // call afterDelete hook
+            const restApi = new AdminForthRestAPI (this.adminforth) 
+            restApi.deleteWithCascade(res as AdminForthResource, recordId, { adminUser, response, body: undefined, query: undefined, headers: undefined, cookies: undefined, requestUrl: undefined});
+
             await Promise.all(
               (res.hooks.delete.afterSave).map(
                 async (hook) => {
@@ -620,6 +621,12 @@ export default class ConfigValidator implements IConfigValidator {
         }
 
         if (col.foreignResource) {
+          if (col.foreignResource.onDelete && (col.foreignResource.onDelete !== 'cascade' && col.foreignResource.onDelete !== 'setNull')){
+              errors.push (`Resource "${res.resourceId}" column "${col.name}" has wrong delete strategy, you can use 'setNull' or 'cascade'`);
+          }
+          if (col.foreignResource.onDelete === 'setNull' && col.required) {
+            errors.push(`Resource "${res.resourceId}" column "${col.name}" cannot use onDelete 'setNull' because column is required (non-nullable).`);
+          }
           if (!col.foreignResource.resourceId) {
             // resourceId is absent or empty
             if (!col.foreignResource.polymorphicResources && !col.foreignResource.polymorphicOn) {

adminforth/modules/restApi.ts

@@ -126,6 +126,7 @@ export async function interpretResource(
 export default class AdminForthRestAPI implements IAdminForthRestAPI {
 
   adminforth: IAdminForth;
+  static deleteWithCascade: any;
 
   constructor(adminforth: IAdminForth) {
     this.adminforth = adminforth;
@@ -152,6 +153,42 @@ export default class AdminForthRestAPI implements IAdminForthRestAPI {
       }
     }
   }
+  async deleteWithCascade(resource: AdminForthResource, primaryKey: any, context: {body: any, adminUser: any, query: any, headers: any, cookies: any, requestUrl: any, response: any}) {
+    const { adminUser, response } = context;
+
+    const record = await this.adminforth.connectors[resource.dataSource].getRecordByPrimaryKey(resource, primaryKey);
+
+    if (!record) return;
+
+    const childResources = this.adminforth.config.resources.filter(r =>r.columns.some(c => c.foreignResource?.resourceId === resource.resourceId));
+
+    for (const childRes of childResources) {
+      const foreignColumn = childRes.columns.find(c => c.foreignResource?.resourceId === resource.resourceId);
+
+      if (!foreignColumn?.foreignResource?.onDelete) continue;
+
+      const strategy = foreignColumn.foreignResource.onDelete;
+
+      const childRecords = await this.adminforth.resource(childRes.resourceId).list(Filters.EQ(foreignColumn.name, primaryKey));
+
+      const childPk = childRes.columns.find(c => c.primaryKey)?.name;
+      if (!childPk) continue;
+
+      if (strategy === 'cascade') {
+        for (const childRecord of childRecords) {
+          await this.deleteWithCascade(childRes, childRecord[childPk], context);
+        }
+      }
+
+      if (strategy === 'setNull') {
+        for (const childRecord of childRecords) {
+          await this.adminforth.resource(childRes.resourceId).update(childRecord[childPk], {[foreignColumn.name]: null});
+        }
+      }
+    }
+
+    await this.adminforth.deleteResourceRecord({resource, record, adminUser, recordId: primaryKey, response, extra: context});
+  }
 
   registerEndpoints(server: IHttpServer) {
     server.endpoint({
@@ -1481,6 +1518,8 @@ export default class AdminForthRestAPI implements IAdminForthRestAPI {
               return { error };
             }
 
+            await this.deleteWithCascade(resource, body.primaryKey, {body, adminUser, query, headers, cookies, requestUrl, response});
+
             const { error: deleteError } = await this.adminforth.deleteResourceRecord({ 
               resource, record, adminUser, recordId: body['primaryKey'], response, 
               extra: { body, query, headers, cookies, requestUrl, response } 

adminforth/types/Back.ts

@@ -2037,6 +2037,7 @@ export interface AdminForthForeignResource extends AdminForthForeignResourceComm
       afterDatasourceResponse?: AfterDataSourceResponseFunction | Array<AfterDataSourceResponseFunction>,
     },
   },
+  onDelete?: 'cascade' | 'setNull'
 }
 
 export type ShowInModernInput = {