feat: skip Prisma prompt for non-empty databases

Author: NoOne7135

adminforth/commands/createApp/utils.js

@@ -40,6 +40,13 @@ const adminforthVersion = detectAdminforthVersion();
 const SUPPORTED_DB_URL_SCHEMES = ['sqlite://', 'postgresql://', 'mongodb://', 'mysql://', 'clickhouse://'];
 const PRISMA_MIGRATION_DB_PROTOCOLS = ['sqlite', 'postgres', 'postgresql', 'mysql'];
 const DEFAULT_DB_URL = 'sqlite://.db.sqlite';
+const DATABASE_CONNECTOR_IMPORTS = {
+  sqlite: '../../dist/dataConnectors/sqlite.js',
+  postgresql: '../../dist/dataConnectors/postgres.js',
+  mysql: '../../dist/dataConnectors/mysql.js',
+  mongodb: '../../dist/dataConnectors/mongo.js',
+  clickhouse: '../../dist/dataConnectors/clickhouse.js',
+};
 
 
 export function parseArgumentsIntoOptions(rawArgs) {
@@ -58,7 +65,6 @@ export function parseArgumentsIntoOptions(rawArgs) {
   return {
     appName: args['--app-name'],
     db: args['--db'],
-    dbProvided: args['--db'] !== undefined,
     useNpm: args['--use-npm'],
   };
 }
@@ -113,7 +119,7 @@ ENGINE = MergeTree()
 ORDER BY id;
 \`\`\`
 
-ClickHouse does not enforce UNIQUE constraints like PostgreSQL, MySQL, or SQLite. AdminForth authentication expects `email` values in `adminuser` to be unique, so enforce this in your ingestion/application logic and remove duplicate email rows to avoid ambiguous logins.`;
+ClickHouse does not enforce UNIQUE constraints like PostgreSQL, MySQL, or SQLite. AdminForth authentication expects \`email\` values in \`adminuser\` to be unique, so enforce this in your ingestion/application logic and remove duplicate email rows to avoid ambiguous logins.`;
   }
 
   if (provider === 'mongodb') {
@@ -164,8 +170,30 @@ export async function promptForMissingOptions(options) {
       db: options.db || answers.db,
       useNpm: options.useNpm || answers.useNpm,
   };
-  resolvedOptions.existingDb = options.dbProvided || resolvedOptions.db !== DEFAULT_DB_URL;
-  resolvedOptions.includePrismaMigrations = !resolvedOptions.existingDb && isPrismaMigrationDbUrl(resolvedOptions.db);
+  resolvedOptions.databaseCleanState = { blockingObjects: [] };
+  resolvedOptions.existingDb = false;
+
+  await inspectDatabaseCleanState(resolvedOptions);
+
+  if (
+    resolvedOptions.includePrismaMigrations === undefined &&
+    isPrismaMigrationDbUrl(resolvedOptions.db) &&
+    !resolvedOptions.existingDb
+  ) {
+    const prismaAnswer = await inquirer.prompt([{
+      type: 'select',
+      name: 'includePrismaMigrations',
+      message: 'Include Prisma migrations? >',
+      choices: [
+        { name: 'Yes', value: true },
+        { name: 'No', value: false },
+      ],
+      default: true,
+    }]);
+    resolvedOptions.includePrismaMigrations = prismaAnswer.includePrismaMigrations;
+  } else {
+    resolvedOptions.includePrismaMigrations = Boolean(resolvedOptions.includePrismaMigrations) && !resolvedOptions.existingDb;
+  }
 
   return resolvedOptions;
 }
@@ -234,6 +262,50 @@ function generateDbUrlForAfProd(connectionString) {
   return connectionString.toString();
 }
 
+function getSqliteInspectionUrl(dbUrl, appName) {
+  const connectionString = parseConnectionString(dbUrl);
+  const sqliteFile = connectionString.host;
+  const resolvedSqliteFile = path.isAbsolute(sqliteFile)
+    ? sqliteFile
+    : path.join(process.cwd(), appName, sqliteFile);
+
+  if (!fs.existsSync(resolvedSqliteFile)) {
+    return null;
+  }
+
+  return `sqlite://${resolvedSqliteFile}`;
+}
+
+async function inspectDatabaseCleanState(options) {
+  const connectionString = parseConnectionString(options.db);
+  const provider = detectDbProvider(connectionString.protocol);
+  let inspectionDbUrl = connectionString.toString();
+
+  if (provider === 'sqlite') {
+    const sqliteInspectionUrl = getSqliteInspectionUrl(options.db, options.appName);
+    if (!sqliteInspectionUrl) {
+      options.databaseCleanState = { blockingObjects: [] };
+      options.existingDb = false;
+      return;
+    }
+    inspectionDbUrl = sqliteInspectionUrl;
+  }
+
+  const Connector = (await import(DATABASE_CONNECTOR_IMPORTS[provider])).default;
+  const connector = new Connector();
+  await connector.setupClient(inspectionDbUrl);
+
+  try {
+    options.databaseCleanState = await connector.isDatabaseEmpty();
+  } finally {
+    if (typeof connector.close === 'function') {
+      await connector.close();
+    }
+  }
+
+  options.existingDb = options.databaseCleanState.blockingObjects.length > 0;
+}
+
 function initialChecks(options) {
   return [
     {

adminforth/dataConnectors/baseConnector.ts

@@ -4,6 +4,7 @@ import {
   IAdminForthSort, IAdminForthSingleFilter, IAdminForthAndOrFilter,
   AdminForthConfig,
   IAggregationRule, IGroupByRule, IGroupByDateTrunc,
+  DatabaseCleanState,
 } from "../types/Back.js";
 
 
@@ -696,5 +697,9 @@ export default class AdminForthBaseConnector implements IAdminForthDataSourceCon
     throw new Error('getAllColumnsInTable() must be implemented in subclass');
   }
 
+  async isDatabaseEmpty(): Promise<DatabaseCleanState> {
+    throw new Error('isDatabaseEmpty() must be implemented in subclass');
+  }
+
 
 }

adminforth/dataConnectors/clickhouse.ts

@@ -1,4 +1,4 @@
-import { IAdminForthDataSourceConnector, IAdminForthSingleFilter, IAdminForthAndOrFilter, AdminForthResource, AdminForthResourceColumn, IAggregationRule, IGroupByRule, IGroupByDateTrunc, IGroupByField } from '../types/Back.js';
+import { IAdminForthDataSourceConnector, IAdminForthSingleFilter, IAdminForthAndOrFilter, AdminForthResource, AdminForthResourceColumn, IAggregationRule, IGroupByRule, IGroupByDateTrunc, IGroupByField, DatabaseCleanState } from '../types/Back.js';
 import AdminForthBaseConnector from './baseConnector.js';
 import dayjs from 'dayjs';
 import utc from 'dayjs/plugin/utc.js';
@@ -87,6 +87,23 @@ class ClickhouseConnector extends AdminForthBaseConnector implements IAdminForth
       sampleValue: sampleRow[col.name],
     }));
   }
+
+  async isDatabaseEmpty(): Promise<DatabaseCleanState> {
+    const res = await this.client.query({
+      query: `
+        SELECT database, name, engine
+        FROM system.tables
+        WHERE database = currentDatabase()
+          AND database NOT IN ('system', 'information_schema', 'INFORMATION_SCHEMA')
+          AND is_temporary = 0
+      `,
+      format: 'JSONEachRow',
+    });
+    const rows = await res.json();
+    return {
+      blockingObjects: rows.map((row: any) => row.name),
+    };
+  }
 
     async discoverFields(resource: AdminForthResource): Promise<{[key: string]: AdminForthResourceColumn}> {
         const tableName = resource.table;

adminforth/dataConnectors/mongo.ts

@@ -1,7 +1,7 @@
 import dayjs from 'dayjs';
 import { MongoClient } from 'mongodb';
 import { Decimal128, Double } from 'bson';
-import { IAdminForthDataSourceConnector, IAdminForthSingleFilter, IAdminForthAndOrFilter, AdminForthResource, IAggregationRule, IGroupByRule, IGroupByDateTrunc, IGroupByField } from '../types/Back.js';
+import { IAdminForthDataSourceConnector, IAdminForthSingleFilter, IAdminForthAndOrFilter, AdminForthResource, IAggregationRule, IGroupByRule, IGroupByDateTrunc, IGroupByField, DatabaseCleanState } from '../types/Back.js';
 import AdminForthBaseConnector from './baseConnector.js';
 import { afLogger } from '../modules/logger.js';
 import { AdminForthDataTypes, AdminForthFilterOperators, AdminForthSortDirections, } from '../types/Common.js';
@@ -166,6 +166,15 @@ class MongoConnector extends AdminForthBaseConnector implements IAdminForthDataS
             };
         });
     }
+
+    async isDatabaseEmpty(): Promise<DatabaseCleanState> {
+        const collections = await this.client.db().listCollections({}, { nameOnly: true }).toArray();
+        return {
+            blockingObjects: collections
+                .filter((collection) => !collection.name.startsWith('system.'))
+                .map((collection) => collection.name),
+        };
+    }
 
 
     async discoverFields(resource) {

adminforth/dataConnectors/mysql.ts

@@ -1,6 +1,6 @@
 import dayjs from 'dayjs';
 import utc from 'dayjs/plugin/utc.js';
-import { AdminForthResource, IAdminForthSingleFilter, IAdminForthAndOrFilter, IAdminForthDataSourceConnector, AdminForthConfig, IAggregationRule, IGroupByRule, IGroupByDateTrunc, IGroupByField } from '../types/Back.js';
+import { AdminForthResource, IAdminForthSingleFilter, IAdminForthAndOrFilter, IAdminForthDataSourceConnector, AdminForthConfig, IAggregationRule, IGroupByRule, IGroupByDateTrunc, IGroupByField, DatabaseCleanState } from '../types/Back.js';
 import { AdminForthDataTypes,  AdminForthFilterOperators, AdminForthSortDirections, } from '../types/Common.js';
 import AdminForthBaseConnector from './baseConnector.js';
 import mysql from 'mysql2/promise';
@@ -77,6 +77,18 @@ class MysqlConnector extends AdminForthBaseConnector implements IAdminForthDataS
     }));
   }
 
+  async isDatabaseEmpty(): Promise<DatabaseCleanState> {
+    const [rows] = await this.client.execute(`
+      SELECT table_schema, table_name
+      FROM information_schema.tables
+      WHERE table_schema = DATABASE()
+        AND table_type = 'BASE TABLE'
+    `);
+    return {
+      blockingObjects: rows.map((row: any) => row.TABLE_NAME ?? row.table_name),
+    };
+  }
+
   async hasMySQLCascadeFk(resource: AdminForthResource, config: AdminForthConfig): Promise<boolean> {
 
     const cascadeColumn = resource.columns.find(c => c.foreignResource?.onDelete === 'cascade');

adminforth/dataConnectors/postgres.ts

@@ -1,5 +1,5 @@
 import dayjs from 'dayjs';
-import { AdminForthResource, IAdminForthSingleFilter, IAdminForthAndOrFilter, IAdminForthDataSourceConnector, AdminForthConfig, IAggregationRule, IGroupByRule, IGroupByDateTrunc, IGroupByField } from '../types/Back.js';
+import { AdminForthResource, IAdminForthSingleFilter, IAdminForthAndOrFilter, IAdminForthDataSourceConnector, AdminForthConfig, IAggregationRule, IGroupByRule, IGroupByDateTrunc, IGroupByField, DatabaseCleanState } from '../types/Back.js';
 import { AdminForthDataTypes, AdminForthFilterOperators, AdminForthSortDirections, } from '../types/Common.js';
 import AdminForthBaseConnector from './baseConnector.js';
 import pkg from 'pg';
@@ -89,6 +89,19 @@ 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] }));
       }
+
+    async isDatabaseEmpty(): Promise<DatabaseCleanState> {
+        const res = await this.client.query(`
+            SELECT table_schema, table_name
+            FROM information_schema.tables
+            WHERE table_type = 'BASE TABLE'
+              AND table_schema NOT IN ('pg_catalog', 'information_schema')
+              AND table_schema NOT LIKE 'pg_toast%'
+        `);
+        return {
+            blockingObjects: res.rows.map((row) => `${row.table_schema}.${row.table_name}`),
+        };
+    }
 
     async checkForeignResourceCascade(resource: AdminForthResource, config: AdminForthConfig, schema = 'public'): Promise<void> {
         const cascadeColumn = resource.columns.find(c => c.foreignResource?.onDelete === 'cascade');

adminforth/dataConnectors/qdrant.ts

@@ -9,6 +9,7 @@ import type {
 	IAdminForthDataSourceConnector,
 	IAdminForthSingleFilter,
 	IAdminForthSort,
+	DatabaseCleanState,
 } from '../types/Back.js';
 import {
 	AdminForthDataTypes,
@@ -95,6 +96,13 @@ class QdrantConnector extends AdminForthBaseConnector implements IAdminForthData
 		return (collections.collections ?? []).map((collection: { name: string }) => collection.name);
 	}
 
+	async isDatabaseEmpty(): Promise<DatabaseCleanState> {
+		const collections = await this.client.getCollections();
+		return {
+			blockingObjects: (collections.collections ?? []).map((collection: { name: string }) => collection.name),
+		};
+	}
+
   // discover fields 
 	async discoverFields(resource) {
 			return resource.columns.filter((col) => !col.virtual).reduce((acc, col) => {

adminforth/dataConnectors/sqlite.ts

@@ -1,5 +1,5 @@
 import betterSqlite3 from 'better-sqlite3';
-import { IAdminForthDataSourceConnector, IAdminForthSingleFilter, IAdminForthAndOrFilter, AdminForthResource, AdminForthResourceColumn, AdminForthConfig, IAggregationRule, IGroupByRule, IGroupByDateTrunc, IGroupByField } from '../types/Back.js';
+import { IAdminForthDataSourceConnector, IAdminForthSingleFilter, IAdminForthAndOrFilter, AdminForthResource, AdminForthResourceColumn, AdminForthConfig, IAggregationRule, IGroupByRule, IGroupByDateTrunc, IGroupByField, DatabaseCleanState } from '../types/Back.js';
 import AdminForthBaseConnector from './baseConnector.js';
 import dayjs from 'dayjs';
 import { AdminForthDataTypes,  AdminForthFilterOperators, AdminForthSortDirections } from '../types/Common.js';
@@ -51,6 +51,19 @@ class SQLiteConnector extends AdminForthBaseConnector implements IAdminForthData
       sampleValue: sampleRow[col.name],
     }));
   }
+
+  async isDatabaseEmpty(): Promise<DatabaseCleanState> {
+    const stmt = this.client.prepare(`
+      SELECT name
+      FROM sqlite_schema
+      WHERE type = 'table'
+        AND name NOT LIKE 'sqlite_%'
+    `);
+    const rows = stmt.all();
+    return {
+      blockingObjects: rows.map((row) => row.name),
+    };
+  }
 
     async hasSQLiteCascadeFk(resource: AdminForthResource, config: AdminForthConfig): Promise<boolean> {
       const cascadeColumn = resource.columns?.find(c => c.foreignResource?.onDelete === 'cascade');

adminforth/types/Back.ts

@@ -276,6 +276,10 @@ export interface IAdminForthSort {
   direction: AdminForthSortDirections 
 }
 
+export type DatabaseCleanState = {
+  blockingObjects: string[];
+};
+
 export interface IAdminForthDataSourceConnector {
 
   client: any;
@@ -297,6 +301,12 @@ export interface IAdminForthDataSourceConnector {
    * Function to get all columns in table.
    */
   getAllColumnsInTable(tableName: string): Promise<Array<{ name: string; type?: string; isPrimaryKey?: boolean; sampleValue?: any; }>>;
+
+  /**
+   * Function to check whether database has no user data.
+   */
+  isDatabaseEmpty(): Promise<DatabaseCleanState>;
+
   /**
    * Optional.
    * You an redefine this function to define how one record should be fetched from database.