Merge branch 'next' of github.com:devforth/adminforth into next

Author: ivictbor

adminforth/commands/createResource/generateResourceFile.js

@@ -17,31 +17,60 @@ export async function generateResourceFile({
   dataSource = "maindb",
   resourcesDir = "resources"
 }) {
-  const fileName = `${table}.ts`;
-  const filePath = path.resolve(process.cwd(), resourcesDir, fileName);
+  const baseFileName = `${table}.ts`;
+  const baseFilePath = path.resolve(process.cwd(), resourcesDir, baseFileName);
 
-  if (fsSync.existsSync(filePath)) {
-    console.log(chalk.yellow(`⚠️ File already exists: ${filePath}`));
-    return { alreadyExists: true, path: filePath };
+  if (fsSync.existsSync(baseFilePath)) {
+    const content = await fs.readFile(baseFilePath, "utf-8");
+    const match = content.match(/dataSource:\s*["'](.+?)["']/);
+    const existingDataSource = match?.[1];
+    if (existingDataSource === dataSource) {
+      console.log(chalk.yellow(`⚠️ File already exists with same dataSource: ${baseFilePath}`));
+      return { alreadyExists: true, path: baseFilePath, fileName: baseFileName, resourceId: table };
+    } else {
+      const suffixedFileName = `${table}_${dataSource}.ts`;
+      const suffixedFilePath = path.resolve(process.cwd(), resourcesDir, suffixedFileName);
+      return await writeResourceFile(suffixedFilePath, suffixedFileName, {
+        table,
+        columns,
+        dataSource,
+        resourceId: `${table}_${dataSource}`,
+      });
+    }
   }
+
+  return await writeResourceFile(baseFilePath, baseFileName, {
+    table,
+    columns,
+    dataSource,
+    resourceId: table,
+  });
+}
+
+async function writeResourceFile(filePath, fileName, {
+  table,
+  columns,
+  dataSource,
+  resourceId,
+}) {
   const __filename = fileURLToPath(import.meta.url);
   const __dirname = path.dirname(__filename);
   const templatePath = path.resolve(__dirname, "templates/resource.ts.hbs");
   console.log(chalk.dim(`Using template: ${templatePath}`));
+
   const context = {
     table,
     dataSource,
-    resourceId: table,
+    resourceId,
     label: table.charAt(0).toUpperCase() + table.slice(1),
     columns,
   };
 
   const content = await renderHBSTemplate(templatePath, context);
-
   await fs.mkdir(path.dirname(filePath), { recursive: true });
   await fs.writeFile(filePath, content, "utf-8");
 
   console.log(chalk.green(`✅ Generated resource file: ${filePath}`));
 
-  return { alreadyExists: false, path: filePath };
+  return { alreadyExists: false, path: filePath, fileName, resourceId };
 }

adminforth/commands/createResource/main.js

@@ -2,19 +2,17 @@ import { callTsProxy, findAdminInstance } from "../callTsProxy.js";
 import { toTitleCase } from '../utils.js';
 import { generateResourceFile } from "./generateResourceFile.js";
 import { injectResourceIntoIndex } from "./injectResourceIntoIndex.js";
-import { select } from "@inquirer/prompts";
+import { search, Separator } from "@inquirer/prompts";
 
 export default async function createResource(args) {
-  console.log("Bundling admin SPA...");
   const instance = await findAdminInstance();
-  console.log("🪲 Found admin instance:", instance.file);
-  console.log("🪲 Found admin instance:", instance.file);
-  console.log(JSON.stringify(instance));
   const tables = await callTsProxy(`
     import { admin } from './${instance.file}.js';
     export async function exec() {
       await admin.discoverDatabases();
-      return await admin.getAllTables();
+      const allTables = await admin.getAllTables();
+      setTimeout(process.exit); 
+      return allTables;
     }
   `);
 
@@ -25,28 +23,41 @@ export default async function createResource(args) {
     }))
   );
 
-  const table = await select({
-    message: "🗂 Choose a table to generate a resource for:",
-    choices: tableChoices,
+  const table = await search({
+    message: '🔍 Choose a table to generate a resource for:',
+    source: async (input = '') => {
+      const term = input.toLowerCase();
+      const choices = tableChoices
+        .filter(c =>
+          c.name.toLowerCase().includes(term)
+        )
+        .map(c => ({ name: c.name, value: c.value }));
+      return [
+        ...choices,
+        new Separator(),
+      ];
+    },
   });
 
   const columns = await callTsProxy(`
     import { admin } from './${instance.file}.js';
     export async function exec() {
       await admin.discoverDatabases();
-      return await admin.getAllColumnsInTable("${table.table}");
+      const columns = await admin.getAllColumnsInTable("${table.table}");
+      setTimeout(process.exit);
+      return columns;
     }
   `);
-  console.log("🪲 Found columns:", columns);
 
-  generateResourceFile({
+  const { resourceId } = await generateResourceFile({
     table: table.table,
     columns: columns[table.db],
     dataSource: table.db,
   });
+
   injectResourceIntoIndex({
-    table: table.table,
-    resourceId: table.table,
+    table: resourceId,
+    resourceId: resourceId,
     label: toTitleCase(table.table),
     icon: "flowbite:user-solid",
   });

adminforth/dataConnectors/clickhouse.ts

@@ -30,7 +30,36 @@ class ClickhouseConnector extends AdminForthBaseConnector implements IAdminForth
       // }
     });
   }
-
+  async getAllTables(): Promise<Array<string>> {
+    const res = await this.client.query({
+        query: `
+            SELECT name
+            FROM system.tables
+            WHERE database = '${this.dbName}'
+        `,
+        format: 'JSON',
+    });
+    const jsonResult = await res.json();
+    return jsonResult.data.map((row: any) => row.name);
+  }
+  
+  async getAllColumnsInTable(tableName: string): Promise<string[]> {
+    const res = await this.client.query({
+      query: `
+        SELECT name
+        FROM system.columns
+        WHERE database = '${this.dbName}' AND table = {table:String}
+      `,
+      format: 'JSON',
+      query_params: {
+        table: tableName,
+      },
+    });
+  
+    const jsonResult = await res.json();
+    return jsonResult.data.map((row: any) => row.name);
+  }
+  
     async discoverFields(resource: AdminForthResource): Promise<{[key: string]: AdminForthResourceColumn}> {
         const tableName = resource.table;
 
@@ -79,7 +108,7 @@ class ClickhouseConnector extends AdminForthBaseConnector implements IAdminForth
           field._underlineType = baseType;
           field._baseTypeDebug = baseType;
           field.required = row.notnull == 1;
-          field.primaryKey = row.pk == 1;
+          field.primaryKey = row.is_in_primary_key == 1;
           field.default = row.dflt_value;
           fieldTypes[row.name] = field
         });

adminforth/dataConnectors/mongo.ts

@@ -46,7 +46,42 @@ class MongoConnector extends AdminForthBaseConnector implements IAdminForthDataS
         [AdminForthSortDirections.asc]: 1,
         [AdminForthSortDirections.desc]: -1,
     };
+    async getAllTables(): Promise<Array<string>>{
+        const db = this.client.db();
+    
+        const collections = await db.listCollections().toArray();
+    
+        return collections.map(col => col.name);
+    }
 
+    async getAllColumnsInTable(collectionName: string): Promise<Array<string>> {
+
+        const sampleDocs = await this.client.db().collection(collectionName).find({}).sort({ _id: -1 }).limit(100).toArray();
+        
+        const fieldSet = new Set<string>();
+        
+        function flattenObject(obj: any, prefix = '') {
+            Object.entries(obj).forEach(([key, value]) => {
+            const fullKey = prefix ? `${prefix}.${key}` : key;
+            if (fullKey.startsWith('_id.') && typeof value !== 'string' && typeof value !== 'number') {
+                return;
+              }
+            if (value && typeof value === 'object' && !Array.isArray(value) && !(value instanceof Date)) {
+                flattenObject(value, fullKey);
+            } else {
+                fieldSet.add(fullKey);
+            }
+            });
+        }
+        
+        for (const doc of sampleDocs) {
+            flattenObject(doc);
+        }
+        
+        return Array.from(fieldSet);
+    }
+      
+    
     async discoverFields(resource) {
         return resource.columns.filter((col) => !col.virtual).reduce((acc, col) => {
             if (!col.type) {

adminforth/dataConnectors/mysql.ts

@@ -39,6 +39,29 @@ class MysqlConnector extends AdminForthBaseConnector implements IAdminForthDataS
     [AdminForthSortDirections.desc]: 'DESC',
   };
 
+  async getAllTables(): Promise<Array<string>> {
+    const [rows] = await this.client.query(
+        `
+        SELECT table_name
+        FROM information_schema.tables
+        WHERE table_schema = DATABASE() AND table_type = 'BASE TABLE';
+        `
+    );
+    return rows.map((row: any) => row.TABLE_NAME);
+  }
+
+  async getAllColumnsInTable(tableName: string): Promise<Array<string>> {
+    const [rows] = await this.client.query(
+        `
+        SELECT column_name
+        FROM information_schema.columns
+        WHERE table_name = ? AND table_schema = DATABASE();
+        `,
+        [tableName]
+    );
+    return rows.map((row: any) => row.COLUMN_NAME);
+  }
+
   async discoverFields(resource) {
     const [results] = await this.client.execute("SHOW COLUMNS FROM " + resource.table);
     const fieldTypes = {};

adminforth/dataConnectors/postgres.ts

@@ -45,6 +45,24 @@ class PostgresConnector extends AdminForthBaseConnector implements IAdminForthDa
         [AdminForthSortDirections.desc]: 'DESC',
     };
 
+    async getAllTables(): Promise<Array<string>> {
+        const res = await this.client.query(`
+            SELECT table_name
+            FROM information_schema.tables
+            WHERE table_schema = 'public' AND table_type = 'BASE TABLE';
+        `);
+        return res.rows.map(row => row.table_name);
+    }
+    
+    async getAllColumnsInTable(tableName: string): Promise<Array<string>> {
+        const res = await this.client.query(`
+            SELECT column_name
+            FROM information_schema.columns
+            WHERE table_name = $1 AND table_schema = 'public';
+        `, [tableName]);
+        return res.rows.map(row => row.column_name);
+    }
+      
     async discoverFields(resource) {
 
         const tableName = resource.table;

adminforth/documentation/docs/tutorial/03-Customization/13-standardPagesTuning.md

@@ -136,6 +136,22 @@ export default {
   ]
 ```
 
+### Virtual scroll
+
+Set `options.listVirtualScrollEnabled` to true to enable virtual scrolling in the table
+
+```typescript title="./resources/apartments.ts"
+export default {
+      resourceId: 'aparts',
+      options: {
+        ...
+//diff-add
+        listVirtualScrollEnabled: true,
+      }
+    }
+  ]
+```
+
 ### Custom row click action
 
 By default, when you click on a record in the list view, the show view will be opened.