feat: implement cascading deletion checks for MySQL, Postgres, and SQLite connectors

kulikp1 · kulikp1 · commit 1cbb6533e1ce · 2026-03-09T09:57:00.000+02:00
diff --git a/adminforth/dataConnectors/mysql.ts b/adminforth/dataConnectors/mysql.ts
@@ -1,5 +1,5 @@
 import dayjs from 'dayjs';
-import { AdminForthResource, IAdminForthSingleFilter, IAdminForthAndOrFilter, IAdminForthDataSourceConnector } from '../types/Back.js';
+import { AdminForthResource, IAdminForthSingleFilter, IAdminForthAndOrFilter, IAdminForthDataSourceConnector, AdminForthConfig } from '../types/Back.js';
 import { AdminForthDataTypes,  AdminForthFilterOperators, AdminForthSortDirections, } from '../types/Common.js';
 import AdminForthBaseConnector from './baseConnector.js';
 import mysql from 'mysql2/promise';
@@ -74,28 +74,52 @@ class MysqlConnector extends AdminForthBaseConnector implements IAdminForthDataS
     }));
   }
 
-  private async hasPgCascadeFk(tableName: string): Promise<void> {
-    const [fkResults] = await this.client.execute(
+  async checkCascadeWhenUploadPlugin(resource: AdminForthResource, config: AdminForthConfig) {
+    const currentResource = config.resources.find(r => r.resourceId === resource.resourceId);
+    if (!currentResource) return;
+      const hasUploadPlugin = currentResource.plugins?.some(p => p.className === "UploadPlugin");
+  
+    if (hasUploadPlugin) {
+      const tableName = (resource.table);
+      afLogger.warn(`Table "${tableName}" has ON DELETE CASCADE, which may conflict with adminForth UploadPlugin.`);
+    }
+  }
+
+  async hasMySQLCascadeFk(resource: AdminForthResource, config: AdminForthConfig): Promise<boolean> {
+
+    const cascadeColumn = resource.columns.find(c => c.foreignResource?.onDelete === 'cascade');
+    if (!cascadeColumn) return false;
+
+    const parentResource = config.resources.find(r => r.resourceId === cascadeColumn.foreignResource.resourceId);
+
+    if (!parentResource) return false;
+
+    const [rows] = await this.client.execute(
       `
-      SELECT
-        TABLE_NAME AS child_table,
-        CONSTRAINT_NAME
+      SELECT 1
       FROM information_schema.REFERENTIAL_CONSTRAINTS
       WHERE CONSTRAINT_SCHEMA = DATABASE()
         AND REFERENCED_TABLE_NAME = ?
         AND DELETE_RULE = 'CASCADE'
+      LIMIT 1
       `,
-      [tableName]
+      [parentResource.table]
     );
 
-    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.`);
+    const hasCascade = (rows as any[]).length > 0;
+
+    if (hasCascade) {
+      afLogger.warn(`Table "${parentResource.table}" has ON DELETE CASCADE, which may conflict with adminForth cascade deletion.`);
     }
+    
+    return hasCascade;
   }
 
-  async discoverFields(resource) {
+  async discoverFields(resource: AdminForthResource, config: AdminForthConfig) {
+    await this.checkCascadeWhenUploadPlugin(resource, config);
+
     const [results] = await this.client.execute("SHOW COLUMNS FROM " + resource.table);
-    await this.hasPgCascadeFk(resource.table);
+    await this.hasMySQLCascadeFk(resource, config);
     const fieldTypes = {};
     results.forEach((row) => {
       const field: any = {};
diff --git a/adminforth/dataConnectors/postgres.ts b/adminforth/dataConnectors/postgres.ts
@@ -1,5 +1,5 @@
 import dayjs from 'dayjs';
-import { AdminForthResource, IAdminForthSingleFilter, IAdminForthAndOrFilter, IAdminForthDataSourceConnector } from '../types/Back.js';
+import { AdminForthResource, IAdminForthSingleFilter, IAdminForthAndOrFilter, IAdminForthDataSourceConnector, AdminForthConfig } from '../types/Back.js';
 import { AdminForthDataTypes, AdminForthFilterOperators, AdminForthSortDirections, } from '../types/Common.js';
 import AdminForthBaseConnector from './baseConnector.js';
 import pkg from 'pg';
@@ -69,7 +69,11 @@ class PostgresConnector extends AdminForthBaseConnector implements IAdminForthDa
         return res.rows.map(row => ({ name: row.column_name, sampleValue: sampleRow[row.column_name] }));
       }
     
-    private async hasPgCascadeFk(tableName: string, schema = 'public'): Promise<boolean> {
+    async checkForeignResourceCascade(resource: AdminForthResource, config: AdminForthConfig, schema = 'public'): Promise<boolean> {
+        const cascadeColumn = resource.columns.find(c => c.foreignResource?.onDelete === 'cascade');
+        if (!cascadeColumn) return; 
+
+        const parentResource = config.resources.find(r => r.resourceId === cascadeColumn.foreignResource.resourceId);
         const res = await this.client.query(
             `
             SELECT 1
@@ -79,20 +83,37 @@ class PostgresConnector extends AdminForthBaseConnector implements IAdminForthDa
             AND confdeltype = 'c'
             LIMIT 1
             `,
-            [tableName, schema]
+            [parentResource.table, schema]
         );
 
-        return res.rowCount > 0;
-    }
+        const hasCascade = res.rowCount > 0;
+        if (hasCascade) {
+            afLogger.warn(
+                `Table "${parentResource.table}" has ON DELETE CASCADE, which may conflict with adminForth cascade deletion`
+            );
+        }
 
-    async discoverFields(resource) {
+        return hasCascade;
+    }
 
-        const tableName = resource.table;
-        const hasCascade = await this.hasPgCascadeFk(tableName);
+    async checkCascadeWhenUploadPlugin(resource: AdminForthResource, config: AdminForthConfig) {
+        const currentResource = config.resources.find(r => r.resourceId === resource.resourceId);
+        if (!currentResource) return;
+        const hasUploadPlugin = currentResource.plugins?.some(p => p.className === "UploadPlugin");
 
-        if (hasCascade) {
-            afLogger.warn(`The database has ON DELETE CASCADE, which may conflict with adminForth cascade deletion and upload logic. Please remove it.`);
+        if (hasUploadPlugin) {
+            const tableName = (resource.table);
+            afLogger.warn(
+                `Table "${tableName}" has ON DELETE CASCADE, which may conflict with adminForth UploadPlugin.`
+            );
         }
+    }
+
+    async discoverFields(resource: AdminForthResource, config: AdminForthConfig) {
+        await this.checkForeignResourceCascade(resource, config);
+        await this.checkCascadeWhenUploadPlugin(resource, config);
+
+        const tableName = resource.table;
         const stmt = await this.client.query(`
         SELECT
             a.attname AS name,
diff --git a/adminforth/dataConnectors/sqlite.ts b/adminforth/dataConnectors/sqlite.ts
@@ -1,5 +1,5 @@
 import betterSqlite3 from 'better-sqlite3';
-import { IAdminForthDataSourceConnector, IAdminForthSingleFilter, IAdminForthAndOrFilter, AdminForthResource, AdminForthResourceColumn } from '../types/Back.js';
+import { IAdminForthDataSourceConnector, IAdminForthSingleFilter, IAdminForthAndOrFilter, AdminForthResource, AdminForthResourceColumn, AdminForthConfig } from '../types/Back.js';
 import AdminForthBaseConnector from './baseConnector.js';
 import dayjs from 'dayjs';
 import { AdminForthDataTypes,  AdminForthFilterOperators, AdminForthSortDirections } from '../types/Common.js';
@@ -38,16 +38,47 @@ class SQLiteConnector extends AdminForthBaseConnector implements IAdminForthData
     }));
   }
 
-    async discoverFields(resource: AdminForthResource): Promise<{[key: string]: AdminForthResourceColumn}> {
+    async checkCascadeWhenUploadPlugin(resource: AdminForthResource, config: AdminForthConfig) {
+      const currentResource = config.resources.find(r => r.resourceId === resource.resourceId);
+      if (!currentResource) return;
+        const hasUploadPlugin = currentResource.plugins?.some(p => p.className === "UploadPlugin");
+      
+      if (hasUploadPlugin) {
+        const tableName = (resource.table);
+        afLogger.warn(`Table "${tableName}" has ON DELETE CASCADE, which may conflict with adminForth UploadPlugin.`);
+      }
+    }
+
+    async hasSQLiteCascadeFk(resource: AdminForthResource, config: AdminForthConfig, fkMap: { [colName: string]: boolean }): Promise<boolean> {
+
+      const hasAdminCascade = resource.columns?.some(c => c.foreignResource?.onDelete === 'cascade');
+      if (!hasAdminCascade) return false; 
+
+      const hasDbCascade = Object.values(fkMap).some(v => v);
+      console.log("resource.resourceId" , resource.resourceId);
+
+      if (hasDbCascade) {
+        const tableName = (resource.table);
+        afLogger.warn(
+          
+          `Table "${tableName}" has ON DELETE CASCADE, which may conflict with adminForth cascade deletion`
+        );
+      }
+
+      return hasDbCascade;
+    }
+
+    async discoverFields(resource: AdminForthResource, config: AdminForthConfig): Promise<{[key: string]: AdminForthResourceColumn}> {
+        await this.checkCascadeWhenUploadPlugin(resource, config);
+
         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';
-        });
+        fkRows.forEach(fk => {fkMap[fk.from] = fk.on_delete?.toUpperCase() === 'CASCADE';})
+        await this.hasSQLiteCascadeFk(resource, config, fkMap);
         const fieldTypes = {};
         rows.forEach((row) => {
           const field: any = {};
@@ -94,9 +125,6 @@ class SQLiteConnector extends AdminForthBaseConnector implements IAdminForthData
           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
         });
