fix: refactor config loading and model generation to use getAdminInstance

Author: yaroslav8765

adminforth/commands/createCustomComponent/configLoader.js

@@ -7,16 +7,16 @@ import dotenv from "dotenv";
 dotenv.config({ path: '.env.local', override: true });
 dotenv.config({ path: '.env', override: true });
 
-export async function loadAdminForthConfig() {
+export async function getAdminInstance() {
   const configFileName = 'index.ts';
   const configPath = path.resolve(process.cwd(), configFileName);
-
+  console.log('Loading config from', configPath);
   try {
     await fs.access(configPath);
   } catch (error) {
     console.error(chalk.red(`\nError: Configuration file not found at ${configPath}`));
     console.error(chalk.yellow(`Please ensure you are running this command from your project's root directory and the '${configFileName}' file exists.`));
-    process.exit(1);
+    return null;
   }
 
   try {
@@ -29,7 +29,17 @@ export async function loadAdminForthConfig() {
     const configModule = _require(configPath);
 
     const adminInstance = configModule.admin || configModule.default?.admin;
+    return adminInstance;
+  } catch (error) {
+    console.error(chalk.red(`\nError loading or parsing configuration file: ${configPath}`));
+    console.error(error);
+    return null;
+  }
+}
 
+export async function loadAdminForthConfig() {
+  try {
+    const adminInstance = getAdminInstance();
 
     if (!adminInstance) {
         throw new Error(`Could not find 'admin' export in ${configFileName}. Please ensure your config file exports the AdminForth instance like: 'export const admin = new AdminForth({...});'`);

adminforth/commands/generateModels.js

@@ -3,6 +3,7 @@ import path from "path";
 import { toPascalCase, mapToTypeScriptType, getInstance } from "./utils.js";
 import dotenv from "dotenv";
 import { callTsProxy } from "./callTsProxy.js";
+import { getAdminInstance } from "../commands/createCustomComponent/configLoader.js";
 
 const envFileArg = process.argv.find((arg) => arg.startsWith("--env-file="));
 const envFilePath = envFileArg ? envFileArg.split("=")[1] : ".env";
@@ -24,44 +25,39 @@ async function generateModels() {
   }
 
   let modelContent = "// Generated model file\n\n";
-  const files = fs.readdirSync(currentDirectory);
   let instanceFound = false;
-  for (const file of files) {
-    if (file.endsWith(".js") || file.endsWith(".ts")) {
-      const instance = await getInstance(file, currentDirectory);
-      if (instance) {
-        await instance.discoverDatabases();
-        instanceFound = true;
-        for (const resource of instance.config.resources) {
-          if (resource.columns) {
-            const typeName = toPascalCase(resource.resourceId);
 
-            const tsCode = `
-              export async function exec() {
-                const columns = ${JSON.stringify(resource.columns)};
-                const typeName = "${typeName}";
-                function mapToTypeScriptType(type) {
-                  const map = { "int": "number", "varchar": "string", "boolean": "boolean" };
-                  return map[type] || "any";
-                }
+  const instance = await getAdminInstance();
+  if (instance) {
+    await instance.discoverDatabases();
+    instanceFound = true;
+    for (const resource of instance.config.resources) {
+      if (resource.columns) {
+        const typeName = toPascalCase(resource.resourceId);
+        const tsCode = `
+          export async function exec() {
+            const columns = ${JSON.stringify(resource.columns)};
+            const typeName = "${typeName}";
+            function mapToTypeScriptType(type) {
+              const map = { "integer": "number", "varchar": "string", "boolean": "boolean", "date": "string", "datetime": "string", "decimal": "number", "float": "number", "json": "Record<string, any>", "text": "string", "string": "string", "time": "string" };
+              return map[type] || "any";
+            }
 
-                let typeStr = \`export type \${typeName} = {\\n\`;
-                for (const col of columns) {
-                  if (col.name && col.type) {
-                    typeStr += \`  \${col.name}: \${mapToTypeScriptType(col.type)};\\n\`;
-                  }
-                }
-                typeStr += "}\\n\\n";
-                return typeStr;
+            let typeStr = \`export type \${typeName} = {\\n\`;
+            for (const col of columns) {
+              if (col.name && col.type) {
+                typeStr += \`  \${col.name}: \${mapToTypeScriptType(col.type)};\\n\`;
               }
-            `;
-
-            const result = await callTsProxy(tsCode);
-            modelContent += result;
+            }
+            typeStr += "}\\n\\n";
+            return typeStr;
           }
-        };
+        `;
+
+        const result = await callTsProxy(tsCode);
+        modelContent += result;
       }
-    }
+    };
   }
 
   if (!instanceFound) {