feat: implement cascading deletion for related records in delete

adminforth/dataConnectors/mysql.ts

@@ -74,8 +74,28 @@ class MysqlConnector extends AdminForthBaseConnector implements IAdminForthDataS
     }));
   }
 
+  private async hasPgCascadeFk(tableName: string): Promise<void> {
+    const [fkResults] = await this.client.execute(
+      `
+      SELECT
+        TABLE_NAME AS child_table,
+        CONSTRAINT_NAME
+      FROM information_schema.REFERENTIAL_CONSTRAINTS
+      WHERE CONSTRAINT_SCHEMA = DATABASE()
+        AND REFERENCED_TABLE_NAME = ?
+        AND DELETE_RULE = 'CASCADE'
+      `,
+      [tableName]
+    );
+
+    for (const fk of fkResults as any[]) {
+      afLogger.warn(`The database has ON DELETE CASCADE, which may conflict with adminForth cascade deletion and upload logic. Please remove it.`);
+    }
+  }
+
   async discoverFields(resource) {
     const [results] = await this.client.execute("SHOW COLUMNS FROM " + resource.table);
+    await this.hasPgCascadeFk(resource.table);
     const fieldTypes = {};
     results.forEach((row) => {
       const field: any = {};

adminforth/dataConnectors/postgres.ts

@@ -68,10 +68,31 @@ class PostgresConnector extends AdminForthBaseConnector implements IAdminForthDa
         const sampleRow = sampleRowRes.rows[0] ?? {};
         return res.rows.map(row => ({ name: row.column_name, sampleValue: sampleRow[row.column_name] }));
       }
-
+
+    private async hasPgCascadeFk(tableName: string, schema = 'public'): Promise<boolean> {
+        const res = await this.client.query(
+            `
+            SELECT 1
+            FROM pg_constraint
+            WHERE contype = 'f'
+            AND confrelid = ($2 || '.' || $1)::regclass
+            AND confdeltype = 'c'
+            LIMIT 1
+            `,
+            [tableName, schema]
+        );
+
+        return res.rowCount > 0;
+    }
+
     async discoverFields(resource) {
 
         const tableName = resource.table;
+        const hasCascade = await this.hasPgCascadeFk(tableName);
+
+        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/documentation/docs/tutorial/08-Plugins/03-ForeignInlineList.md

@@ -187,4 +187,35 @@ plugins: [
 
 ```
 
-This setup will show, in the show view for each record, the `aparts` resource without any filters. And you don’t have to modify the `aparts` resource.
+This setup will show, in the show view for each record, the `aparts` resource without any filters. And you don’t have to modify the `aparts` resource.
+
+
+## Cascade delete for foreign resources
+
+There might be cases when you want to control what happens with child records when a parent record is deleted.
+You can configure this behavior in the `foreignResource` section using the `onDelete` option.
+
+```ts title="./resources/apartments.ts"
+
+export default {
+  resourceId: 'aparts',
+  ...
+  columns: [
+    ...
+    {
+      name: 'realtor_id',
+      foreignResource: {
+        resourceId: 'adminuser', 
+        //diff-add
+        onDelete: 'cascade' // cascade or setNull
+      }
+    }
+  ],
+}
+
+```
+
+#### The onDelete option supports two modes:
+
+- `cascade`: When a parent record is deleted, all related child records will be deleted automatically.
+- `setNull`: When a parent record is deleted, child records will remain, but their foreign key will be set to null.

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) 
+            await restApi.deleteWithCascade(res as AdminForthResource, recordId, { adminUser, response});
+
             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,7 +126,7 @@ export async function interpretResource(
 export default class AdminForthRestAPI implements IAdminForthRestAPI {
 
   adminforth: IAdminForth;
-
+  
   constructor(adminforth: IAdminForth) {
     this.adminforth = adminforth;
   }
@@ -152,6 +152,47 @@ export default class AdminForthRestAPI implements IAdminForthRestAPI {
       }
     }
   }
+  async deleteWithCascade(resource: AdminForthResource, primaryKey: string, context: {adminUser: any, response: any}): Promise<{ error: string | null }> {
+    const { adminUser, response } = context;
+
+    const record = await this.adminforth.connectors[resource.dataSource].getRecordByPrimaryKey(resource, primaryKey);
+
+    if (!record){ 
+      return {error: `Record with id ${primaryKey} not found`};
+    }
+
+    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) {
+          const childResult = await this.deleteWithCascade(childRes, childRecord[childPk], context);
+          if (childResult?.error) {
+            return childResult;
+          }
+        }
+      }
+
+      if (strategy === 'setNull') {
+        for (const childRecord of childRecords) {
+          await this.adminforth.resource(childRes.resourceId).update(childRecord[childPk], {[foreignColumn.name]: null});
+        }
+      }
+    }
+    const deleteResult = await this.adminforth.deleteResourceRecord({resource, record, adminUser, recordId: primaryKey, response});
+    return { error: deleteResult.error};
+  }
 
   registerEndpoints(server: IHttpServer) {
     server.endpoint({
@@ -1481,6 +1522,11 @@ export default class AdminForthRestAPI implements IAdminForthRestAPI {
               return { error };
             }
 
+            const { error: cascadeError } = await this.deleteWithCascade(resource, body.primaryKey, {adminUser, response});
+            if (cascadeError) {
+              return { error: cascadeError };
+            }
+
             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 = {