adminforth 2.4.0-next.3 → 2.4.0-next.300

package/commands/callTsProxy.js

@@ -3,18 +3,28 @@ import { spawn } from "child_process";
 import path from "path";
 import fs from "fs";
 import chalk from "chalk";
+import dotenv from "dotenv";
 
 const currentFilePath = import.meta.url;
 const currentFileFolder = path.dirname(currentFilePath).replace("file:", "");
 
 export function callTsProxy(tsCode, silent=false) {
 
+  const currentDirectory = process.cwd();
+  const envPath = path.resolve(currentDirectory, ".env");
+  const envLocalPath = path.resolve(currentDirectory, ".env.local");
+  if (fs.existsSync(envLocalPath)) {
+    dotenv.config({ path: envLocalPath, override: true });
+  }
+  if (fs.existsSync(envPath)) {
+    dotenv.config({ path: envPath, override: true });
+  }
+
   process.env.HEAVY_DEBUG && console.log("🌐 Calling tsproxy with code:", path.join(currentFileFolder, "proxy.ts"));
   return new Promise((resolve, reject) => {
-    const child = spawn("tsx", [
-      path.join(currentFileFolder, "proxy.ts")
-    ]);
-
+    const child = spawn("tsx", [path.join(currentFileFolder, "proxy.ts")], {
+      env: process.env,
+    });
     let stdout = "";
     let stderr = "";
 

package/commands/cli.js

@@ -12,6 +12,7 @@ import createResource from "./createResource/main.js";
 import chalk from "chalk";
 import path from "path";
 import fs from "fs";
+import { fileURLToPath } from 'url';
 
 function showHelp() {
   console.log(
@@ -20,23 +21,30 @@ function showHelp() {
     chalk.green('  create-plugin') + chalk.white('      Create a plugin for your AdminForth app\n') +
     chalk.green('  generate-models') + chalk.white('    Generate TypeScript models from your databases\n') +
     chalk.green('  bundle') + chalk.white('             Bundles your AdminForth app SPA for production\n') +
-    chalk.green('  component') + chalk.white('          Scaffold a custom Vue component\n')
+    chalk.green('  component') + chalk.white('          Scaffold a custom Vue component\n') +
+    chalk.green('  resource') + chalk.white('            Scaffold a custom resource\n')
   );
 }
 
-function currentFileDir(importMetaUrl) {
-  const filePath = importMetaUrl.replace("file://", "");
+export function currentFileDir(importMetaUrl) {
+  const filePath = fileURLToPath(importMetaUrl);
   const fileDir = path.dirname(filePath);
   return fileDir;
 }
 
-function showVersion() {
+export function getVersion() {
   const ADMIN_FORTH_ABSOLUTE_PATH = path.join(currentFileDir(import.meta.url), '..');
   
   const package_json = JSON.parse(fs.readFileSync(path.join(ADMIN_FORTH_ABSOLUTE_PATH, 'package.json'), 'utf8'));
   
   const ADMINFORTH_VERSION  = package_json.version;
 
+  return ADMINFORTH_VERSION;
+}
+
+function showVersion() {
+  const ADMINFORTH_VERSION = getVersion();
+
   console.log(
     chalk.white('AdminForth CLI version: ') +
     chalk.cyan.bold(ADMINFORTH_VERSION)

package/commands/createApp/templates/api.ts.hbs

@@ -0,0 +1,10 @@
+import { Express } from "express";
+import { IAdminForth } from "adminforth";
+
+export function initApi(app: Express, admin: IAdminForth) {
+  app.get(`${admin.config.baseUrl}/api/hello/`,
+    (req, res) => {
+      res.json({ message: "Hello from AdminForth API!" });
+    }
+  );
+}

package/commands/createApp/templates/custom/tsconfig.json.hbs

@@ -2,9 +2,8 @@
   "compilerOptions": {
     "baseUrl": ".",
     "paths": {
-      "@/": "../node_modules/adminforth/dist/spa/src/",
-      "": "../node_modules/adminforth/dist/spa/node_modules/",
-      "@@/*": "."
+      "@/*": ["../node_modules/adminforth/dist/spa/src/*"],
+      "@@/*": ["./*"]
     }
   }
 }

package/commands/createApp/templates/index.ts.hbs

@@ -3,6 +3,8 @@ import AdminForth from 'adminforth';
 import usersResource from "./resources/adminuser.js";
 import { fileURLToPath } from 'url';
 import path from 'path';
+import { Filters } from 'adminforth';
+import { initApi } from './api.js';
 
 const ADMIN_BASE_URL = '';
 
@@ -15,6 +17,12 @@ export const admin = new AdminForth({
     rememberMeDays: 30,
     loginBackgroundImage: 'https://images.unsplash.com/photo-1534239697798-120952b76f2b?q=80&w=3389&auto=format&fit=crop&ixlib=rb-4.0.3&ixid=M3wxMjA3fDB8MHxwaG90by1wYWdlfHx8fGVufDB8fHx8fA%3D%3D',
     loginBackgroundPosition: '1/2',
+    loginPromptHTML: async () => { 
+      const adminforthUserExists = await admin.resource("adminuser").count(Filters.EQ('email', 'adminforth')) > 0;
+      if (adminforthUserExists) {
+        return "Please use <b>adminforth</b> as username and <b>adminforth</b> as password"
+      }
+    },
   },
   customization: {
     brandName: "{{appName}}",
@@ -23,7 +31,8 @@ export const admin = new AdminForth({
     brandLogo: '@@/assets/logo.svg',
     datesFormat: 'DD MMM',
     timeFormat: 'HH:mm a',
-    showBrandNameInSidebar: true,
+  showBrandNameInSidebar: true,
+  showBrandLogoInSidebar: true,
     emptyFieldPlaceholder: '-',
     styles: {
       colors: {
@@ -57,13 +66,12 @@ export const admin = new AdminForth({
   ],
 });
 
-const currentFilePath = fileURLToPath(import.meta.url);
-const executedFilePath = path.resolve(process.argv[1]);
-
-if (currentFilePath === executedFilePath) {
+if (fileURLToPath(import.meta.url) === path.resolve(process.argv[1])) {
   const app = express();
   app.use(express.json());
 
+  initApi(app, admin);
+
   const port = 3500;
   
   admin.bundleNow({ hotReload: process.env.NODE_ENV === 'development' }).then(() => {

package/commands/createApp/templates/package.json.hbs

@@ -22,7 +22,7 @@
   },
   "dependencies": {
     "@dotenvx/dotenvx": "^1.34.0",
-    "adminforth": "latest",
+    "adminforth": "{{adminforthVersion}}",
     "express": "latest-4"
   },
   "devDependencies": {

package/commands/createApp/utils.js

@@ -11,9 +11,31 @@ import { exec } from 'child_process';
 
 import Handlebars from 'handlebars';
 import { promisify } from 'util';
+import { getVersion } from '../cli.js';
 
 const execAsync = promisify(exec);
 
+function detectAdminforthVersion() {
+  try {
+    const version =  getVersion();
+
+    if (typeof version !== 'string') {
+      throw new Error('Invalid version format');
+    }
+
+    if (version.includes('next')) {
+      return 'next';
+    }
+    return 'latest';
+  } catch (err) {
+    console.warn('⚠️ Could not detect AdminForth version, defaulting to "latest".');
+    return 'latest';
+  }
+}
+
+const adminforthVersion = detectAdminforthVersion();
+
+
 export function parseArgumentsIntoOptions(rawArgs) {
   const args = arg(
     {
@@ -203,13 +225,21 @@ async function writeTemplateFiles(dirname, cwd, options) {
     {
       src: 'package.json.hbs',
       dest: 'package.json',
-      data: { appName },
+      data: { 
+        appName,
+        adminforthVersion: adminforthVersion,
+       },
     },
     {
       src: 'index.ts.hbs',
       dest: 'index.ts',
       data: { appName },
     },
+    {
+      src: 'api.ts.hbs',
+      dest: 'api.ts',
+      data: {},
+    },
     {
       src: '.gitignore.hbs',
       dest: '.gitignore',
@@ -285,13 +315,21 @@ async function writeTemplateFiles(dirname, cwd, options) {
 
 async function installDependencies(ctx, cwd) {
   const isWindows = process.platform === 'win32';
-  const npmCmd = isWindows ? 'npm.cmd' : 'npm';
-  
+
+  const nodeBinary = process.execPath; 
+  const npmPath = path.join(path.dirname(nodeBinary), isWindows ? 'npm.cmd' : 'npm');
   const customDir = ctx.customDir;
-  const res = await Promise.all([
-    await execAsync(`${npmCmd} install`, { cwd, env: { PATH: process.env.PATH } }),
-    await execAsync(`${npmCmd} install`, { cwd: customDir, env: { PATH: process.env.PATH } }),
-  ]);
+  if (isWindows) {
+    const res = await Promise.all([
+      await execAsync(`npm install`, { cwd, env: { PATH: process.env.PATH } }),
+      await execAsync(`npm install`, { cwd: customDir, env: { PATH: process.env.PATH } }),
+    ]);
+  } else {
+    const res = await Promise.all([
+      await execAsync(`${nodeBinary} ${npmPath} install`, { cwd, env: { PATH: process.env.PATH } }),
+      await execAsync(`${nodeBinary} ${npmPath} install`, { cwd: customDir, env: { PATH: process.env.PATH } }),
+    ]);
+  }
   // console.log(chalk.dim(`Dependencies installed in ${cwd} and ${customDir}: \n${res[0].stdout}${res[1].stdout}`));
 }
 

package/commands/createCustomComponent/configLoader.js

@@ -2,18 +2,20 @@ import fs from 'fs/promises';
 import path from 'path';
 import chalk from 'chalk';
 import jiti from 'jiti';
+import dotenv, { config } 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);
-
   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 {
@@ -26,8 +28,19 @@ export async function loadAdminForthConfig() {
     const configModule = _require(configPath);
 
     const adminInstance = configModule.admin || configModule.default?.admin;
+    return { adminInstance, configPath, configFileName };
+  } catch (error) {
+    console.error(chalk.red(`\nError loading or parsing configuration file: ${configPath}`));
+    console.error(error);
+    return null;
+  }
+}
 
+export async function loadAdminForthConfig() {
+  
+  const { adminInstance, configPath, configFileName } = await getAdminInstance();
 
+  try {
     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({...});'`);
     }
@@ -50,7 +63,7 @@ export async function loadAdminForthConfig() {
     return config;
 
   } catch (error) {
-    console.error(chalk.red(`\nError loading or parsing configuration file: ${configPath}`));
+    console.error(chalk.red(`\nError loading or parsing configuration file: ${configPath},  error: ${error}`));
     console.error(error);
     process.exit(1);
   }

package/commands/createCustomComponent/configUpdater.js

@@ -254,7 +254,7 @@ export async function updateResourceConfig(resourceId, columnName, fieldType, co
 }
 
 
-export async function injectLoginComponent(indexFilePath, componentPath) {
+export async function injectLoginComponent(indexFilePath, componentPath, injectionType) {
     console.log(chalk.dim(`Reading file: ${indexFilePath}`));
     const content = await fs.readFile(indexFilePath, 'utf-8');
     const ast = recast.parse(content, {
@@ -263,6 +263,7 @@ export async function injectLoginComponent(indexFilePath, componentPath) {
   
     let updated = false;
     let injectionLine = null;
+    let targetProperty = null;
   
     recast.visit(ast, {
       visitNewExpression(path) {
@@ -293,20 +294,23 @@ export async function injectLoginComponent(indexFilePath, componentPath) {
           const loginPageInjections = getOrCreateProp(customization, 'loginPageInjections');
           if (!n.ObjectExpression.check(loginPageInjections)) return false;
   
-          let underInputsProp = loginPageInjections.properties.find(
-            p => n.ObjectProperty.check(p) && n.Identifier.check(p.key) && p.key.name === 'underInputs'
+          // Determine target property based on injection type
+          targetProperty = injectionType === 'beforeLogin' ? 'panelHeader' : 'underInputs';
+          
+          let targetProp = loginPageInjections.properties.find(
+            p => n.ObjectProperty.check(p) && n.Identifier.check(p.key) && p.key.name === targetProperty
           );
   
-          if (underInputsProp) {
-            const currentVal = underInputsProp.value;
-            injectionLine = underInputsProp.loc?.start.line ?? null;
+          if (targetProp) {
+            const currentVal = targetProp.value;
+            injectionLine = targetProp.loc?.start.line ?? null;
             if (n.StringLiteral.check(currentVal)) {
               if (currentVal.value !== componentPath) {
-                underInputsProp.value = b.arrayExpression([
+                targetProp.value = b.arrayExpression([
                   b.stringLiteral(currentVal.value),
                   b.stringLiteral(componentPath),
                 ]);
-                console.log(chalk.dim(`Converted 'underInputs' to array with existing + new path.`));
+                console.log(chalk.dim(`Converted '${targetProperty}' to array with existing + new path.`));
               } else {
                 console.log(chalk.dim(`Component path already present as string. Skipping.`));
               }
@@ -316,26 +320,26 @@ export async function injectLoginComponent(indexFilePath, componentPath) {
               );
               if (!exists) {
                 currentVal.elements.push(b.stringLiteral(componentPath));
-                console.log(chalk.dim(`Appended new component path to existing 'underInputs' array.`));
+                console.log(chalk.dim(`Appended new component path to existing '${targetProperty}' array.`));
               } else {
                 console.log(chalk.dim(`Component path already present in array. Skipping.`));
               }
             } else {
-              console.warn(chalk.yellow(`⚠️ 'underInputs' is not a string or array. Skipping.`));
+              console.warn(chalk.yellow(`⚠️ '${targetProperty}' is not a string or array. Skipping.`));
               return false;
             }
           } else {
             const newProperty = b.objectProperty(
-                b.identifier('underInputs'), 
-                b.stringLiteral(componentPath)
-              );
-              
-              if (newProperty.loc) {
-                console.log(chalk.dim(`Adding 'underInputs' at line: ${newProperty.loc.start.line}`));
-              }
-              
-              loginPageInjections.properties.push(newProperty);
-              console.log(chalk.dim(`Added 'underInputs': ${componentPath}`));
+              b.identifier(targetProperty), 
+              b.stringLiteral(componentPath)
+            );
+            
+            if (newProperty.loc) {
+              console.log(chalk.dim(`Adding '${targetProperty}' at line: ${newProperty.loc.start.line}`));
+            }
+            
+            loginPageInjections.properties.push(newProperty);
+            console.log(chalk.dim(`Added '${targetProperty}': ${componentPath}`));
           }
   
           updated = true;
@@ -353,7 +357,7 @@ export async function injectLoginComponent(indexFilePath, componentPath) {
     await fs.writeFile(indexFilePath, outputCode, 'utf-8');
     console.log(
       chalk.green(
-        `✅ Successfully updated CRUD injection in resource file: ${indexFilePath}` +
+        `✅ Successfully updated login ${targetProperty} injection in: ${indexFilePath}` +
         (injectionLine !== null ? `:${injectionLine}` : '')
       )
     );

package/commands/createCustomComponent/fileGenerator.js

@@ -129,7 +129,7 @@ export async function generateLoginOrGlobalComponentFile(componentFileName, inje
     const __filename = fileURLToPath(import.meta.url);
     const __dirname = path.dirname(__filename);
     let templatePath;
-    if (injectionType === 'afterLogin') {
+    if (injectionType === 'afterLogin' || injectionType === 'beforeLogin') {
       templatePath = path.join(__dirname, 'templates', 'login', `${injectionType}.vue.hbs`);
     } else {
       templatePath = path.join(__dirname, 'templates', 'global', `${injectionType}.vue.hbs`);

package/commands/createCustomComponent/main.js

@@ -188,7 +188,11 @@ async function handleCrudPageInjectionCreation(config, resources) {
   const injectionPosition = await select({
     message: 'Where exactly do you want to inject the component?',
     choices: [
+      ...(crudType === 'create' || crudType === 'edit'
+        ? [{ name: '💾 Save button on create/edit page', value: 'saveButton' }, new Separator()]
+        : []),
       { name: '⬆️ Before Breadcrumbs', value: 'beforeBreadcrumbs' },
+      { name: '➡️ Before Action Buttons', value: 'beforeActionButtons' },
       { name: '⬇️ After Breadcrumbs', value: 'afterBreadcrumbs' },
       { name: '📄 After Page', value: 'bottom' },
       { name: '⋯ threeDotsDropdownItems', value: 'threeDotsDropdownItems' },
@@ -206,13 +210,15 @@ async function handleCrudPageInjectionCreation(config, resources) {
     },
   });
 
-  const isThin = await select({
-    message: 'Will this component be thin enough to fit on the same page with list (so list will still shrink)?',
-    choices: [
-      { name: 'Yes', value: true },
-      { name: 'No', value: false },
-    ],
-  });
+  const isThin = crudType === 'list'
+    ? await select({
+        message: 'Will this component be thin enough to fit on the same page with list (so list will still shrink)?',
+        choices: [
+          { name: 'Yes', value: true },
+          { name: 'No', value: false },
+        ],
+      })
+    : false;
   const formattedAdditionalName = additionalName
     ? additionalName[0].toUpperCase() + additionalName.slice(1)
     : '';
@@ -257,6 +263,7 @@ async function handleLoginPageInjectionCreation(config) {
   const injectionType = await select({
     message: 'Select injection type:',
     choices: [
+      { name: 'Before Login and password inputs', value: 'beforeLogin' },
       { name: 'After Login and password inputs', value: 'afterLogin' },
       { name: '🔙 BACK', value: '__BACK__' },
     ],
@@ -287,7 +294,7 @@ async function handleLoginPageInjectionCreation(config) {
       console.log(chalk.dim(`Component generation successful: ${absoluteComponentPath}`));
       const configFilePath = path.resolve(process.cwd(), 'index.ts');
       console.log(chalk.dim(`Injecting component: ${configFilePath}, ${componentFileName}`));
-      await injectLoginComponent(configFilePath, `@@/${componentFileName}`);
+      await injectLoginComponent(configFilePath, `@@/${componentFileName}`, injectionType);
       
       console.log(
         chalk.bold.greenBright('You can now open the component in your IDE:'),

package/commands/createCustomComponent/templates/customCrud/beforeActionButtons.vue.hbs

@@ -0,0 +1,38 @@
+<template>
+  <div class="flex items-center p-4 md:p-5 gap-2">
+    <button
+      type="button"
+      @click="handleClick"
+      class="text-white bg-blue-600 hover:bg-blue-700 focus:ring-4 focus:outline-none focus:ring-blue-300 font-medium rounded-lg text-sm px-4 py-2.5 text-center dark:bg-blue-500 dark:hover:bg-blue-600 dark:focus:ring-blue-800"
+    >
+      {{ '{{' }} $t('Example') {{ '}}' }}
+    </button>
+  </div>
+</template>
+
+<script setup lang="ts">
+import { onMounted } from 'vue';
+import { useI18n } from 'vue-i18n';
+import adminforth from '@/adminforth';
+import { AdminForthResourceCommon, AdminUser } from "@/types/Common";
+
+const { t } = useI18n();
+
+const props = defineProps<{
+  record: any
+  resource: AdminForthResourceCommon
+  adminUser: AdminUser
+  meta?: any
+}>();
+
+onMounted(() => {
+  // Logic on mount if needed
+});
+
+function handleClick() {
+  adminforth.alert({
+    message: t('Confirmed'),
+    variant: 'success',
+  });
+}
+</script>

package/commands/createCustomComponent/templates/customCrud/saveButton.vue.hbs

@@ -0,0 +1,28 @@
+<template>
+  <button
+    class="px-4 py-2 border border-blue-500 text-blue-600 rounded hover:bg-blue-50 disabled:opacity-50"
+    :disabled="props.disabled || props.saving || !props.isValid"
+    @click="props.saveRecord()"
+  >
+    <span v-if="props.saving">Saving…</span>
+    <span v-else>Save</span>
+  </button>
+</template>
+
+<script setup lang="ts">
+
+const props = defineProps<{
+  record: any
+  resource: any
+  adminUser: any
+  meta: any
+  saving: boolean
+  validating: boolean
+  isValid: boolean
+  disabled: boolean
+  saveRecord: () => Promise<void>
+}>();
+</script>
+
+<style scoped>
+</style>

package/commands/createCustomComponent/templates/login/beforeLogin.vue.hbs

@@ -0,0 +1,18 @@
+<template>
+  <div class="text-center text-gray-500 text-sm mt-4">
+    Login Page Text
+  </div>
+</template>
+
+<script setup>
+import { onMounted } from 'vue';
+
+const props = defineProps<{
+  reason: String
+}>();
+
+onMounted(() => {
+  // Logic on mount if needed
+});
+</script>
+

package/commands/createPlugin/templates/custom/tsconfig.json.hbs

@@ -3,15 +3,12 @@
     "baseUrl": ".", // This should point to your project root
     "paths": {
       "@/*": [
-        // "node_modules/adminforth/dist/spa/src/*"
-        "../../../spa/src/*"
+        "../node_modules/adminforth/dist/spa/src/*"
       ],
       "*": [
-        // "node_modules/adminforth/dist/spa/node_modules/*"
-        "../../../spa/node_modules/*"
+        "../node_modules/adminforth/dist/spa/node_modules/*"
       ],
       "@@/*": [
-        // "node_modules/adminforth/dist/spa/src/*"
         "."
       ]
     }

package/commands/createPlugin/templates/package.json.hbs

@@ -5,7 +5,7 @@
   "types": "dist/index.d.ts",
   "type": "module",
   "scripts": {
-    "build": "tsc && rsync -av --exclude 'node_modules' custom dist/ && npm version patch"
+    "build": "tsc && rsync -av --exclude 'node_modules' custom dist/"
   },
   "keywords": [],
   "author": "",

package/commands/generateModels.js

@@ -2,6 +2,8 @@ import fs from "fs";
 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";
@@ -23,39 +25,45 @@ 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;
-        instance.config.resources.forEach((resource) => {
-          if (resource.columns) {
-            modelContent += `export type ${toPascalCase(
-              resource.resourceId
-            )} = {\n`;
-            resource.columns.forEach((column) => {
-              if (column.name && column.type) {
-                modelContent += `  ${column.name}: ${mapToTypeScriptType(
-                  column.type
-                )};\n`;
+  const { adminInstance, configPath, configFileName } = await getAdminInstance();
+  if (adminInstance) {
+    await adminInstance.discoverDatabases();
+    instanceFound = true;
+    for (const resource of adminInstance.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\`;
               }
-            });
-            modelContent += `}\n\n`;
+            }
+            typeStr += "}\\n\\n";
+            return typeStr;
           }
-        });
+        `;
+
+        const result = await callTsProxy(tsCode);
+        modelContent += result;
       }
-    }
+    };
   }
 
   if (!instanceFound) {
     console.error("Error: No valid instance found to generate models.");
     return;
   }
-
   fs.writeFileSync(modelFilePath, modelContent, "utf-8");
   console.log(`Generated TypeScript model file: ${modelFilePath}`);
   return true;