feat: enhance resource file generation and column synchronization logic

NoOne7135 · NoOne7135 · commit 0b9e62360f1c · 2026-05-12T14:14:39.000+03:00
diff --git a/adminforth/commands/callTsProxy.js b/adminforth/commands/callTsProxy.js
@@ -8,6 +8,27 @@ import dotenv from "dotenv";
 const currentFilePath = import.meta.url;
 const currentFileFolder = path.dirname(currentFilePath).replace("file:", "");
 
+function getLocalBinPath(currentDirectory) {
+  return path.join(currentDirectory, "node_modules", ".bin");
+}
+
+function getLocalBinExecutable(currentDirectory, command) {
+  const extension = process.platform === "win32" ? ".cmd" : "";
+  const executablePath = path.join(getLocalBinPath(currentDirectory), `${command}${extension}`);
+  return fs.existsSync(executablePath) ? executablePath : command;
+}
+
+function getEnvWithLocalBin(currentDirectory) {
+  const pathKey = process.platform === "win32" ? "Path" : "PATH";
+  const localBinPath = getLocalBinPath(currentDirectory);
+  const currentPath = process.env[pathKey] || "";
+
+  return {
+    ...process.env,
+    [pathKey]: [localBinPath, currentPath].filter(Boolean).join(path.delimiter),
+  };
+}
+
 export function callTsProxy(tsCode, silent=false) {
 
   const currentDirectory = process.cwd();
@@ -22,8 +43,8 @@ export function callTsProxy(tsCode, silent=false) {
 
   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")], {
-      env: process.env,
+    const child = spawn(getLocalBinExecutable(currentDirectory, "tsx"), [path.join(currentFileFolder, "proxy.ts")], {
+      env: getEnvWithLocalBin(currentDirectory),
     });
     let stderr = "";
     let stdoutLogs = [];
@@ -36,8 +57,16 @@ export function callTsProxy(tsCode, silent=false) {
       stderr += data;
     });
 
+    child.on("error", (error) => {
+      reject(error);
+    });
+
     child.on("close", (code) => {
       const tsProxyResult = stdoutLogs.find(log => log.includes('>>>>>>>'));
+      if (!tsProxyResult) {
+        reject(new Error(`Invalid JSON from tsproxy. stdout: ${stdoutLogs.join("")}, stderr: ${stderr}`));
+        return;
+      }
       const preparedStdout = tsProxyResult.slice(tsProxyResult.indexOf('>>>>>>>') + 7, tsProxyResult.lastIndexOf('<<<<<<<'));
       const preparedStdoutLogs = stdoutLogs.filter(log => !log.includes('>>>>>>>'));
       if (code === 0) {
diff --git a/adminforth/commands/createResource/generateResourceFile.js b/adminforth/commands/createResource/generateResourceFile.js
@@ -4,6 +4,32 @@ import path from "path";
 import chalk from "chalk";
 import Handlebars from "handlebars";
 import { fileURLToPath } from 'url';
+import { parse } from "@babel/parser";
+import * as recast from "recast";
+import { namedTypes as n, builders as b } from "ast-types";
+
+const DATA_SOURCE_RE = /dataSource:\s*["'](.+?)["']/;
+const ADMINFORTH_DATA_TYPE_KEYS = {
+  string: "STRING",
+  integer: "INTEGER",
+  float: "FLOAT",
+  decimal: "DECIMAL",
+  boolean: "BOOLEAN",
+  date: "DATE",
+  datetime: "DATETIME",
+  time: "TIME",
+  text: "TEXT",
+  json: "JSON",
+};
+
+const parser = {
+  parse(source) {
+    return parse(source, {
+      sourceType: "module",
+      plugins: ["typescript"],
+    });
+  },
+};
 
 export async function renderHBSTemplate(templatePath, data){
   const templateContent = await fs.readFile(templatePath, "utf-8");
@@ -22,14 +48,35 @@ export async function generateResourceFile({
 
   if (fsSync.existsSync(baseFilePath)) {
     const content = await fs.readFile(baseFilePath, "utf-8");
-    const match = content.match(/dataSource:\s*["'](.+?)["']/);
+    const match = content.match(DATA_SOURCE_RE);
     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 };
+      const syncedColumnsCount = await syncResourceColumns(baseFilePath, content, columns);
+      return {
+        alreadyExists: true,
+        path: baseFilePath,
+        fileName: baseFileName,
+        resourceId: table,
+        syncedColumnsCount,
+      };
     } else {
       const suffixedFileName = `${table}_${dataSource}.ts`;
       const suffixedFilePath = path.resolve(process.cwd(), resourcesDir, suffixedFileName);
+      if (fsSync.existsSync(suffixedFilePath)) {
+        const suffixedContent = await fs.readFile(suffixedFilePath, "utf-8");
+        const suffixedMatch = suffixedContent.match(DATA_SOURCE_RE);
+        const suffixedDataSource = suffixedMatch?.[1];
+        if (suffixedDataSource === dataSource) {
+          const syncedColumnsCount = await syncResourceColumns(suffixedFilePath, suffixedContent, columns);
+          return {
+            alreadyExists: true,
+            path: suffixedFilePath,
+            fileName: suffixedFileName,
+            resourceId: `${table}_${dataSource}`,
+            syncedColumnsCount,
+          };
+        }
+      }
       return await writeResourceFile(suffixedFilePath, suffixedFileName, {
         table,
         columns,
@@ -63,7 +110,7 @@ async function writeResourceFile(filePath, fileName, {
     dataSource,
     resourceId,
     label: table.charAt(0).toUpperCase() + table.slice(1),
-    columns,
+    columns: columns.map(normalizeColumnForTemplate),
   };
 
   const content = await renderHBSTemplate(templatePath, context);
@@ -74,3 +121,150 @@ async function writeResourceFile(filePath, fileName, {
 
   return { alreadyExists: false, path: filePath, fileName, resourceId };
 }
+
+async function syncResourceColumns(filePath, content, discoveredColumns) {
+  const ast = recast.parse(content, { parser });
+  const columnsArray = findResourceColumnsArray(ast);
+
+  if (!columnsArray) {
+    throw new Error(`Could not find resource columns array in ${filePath}`);
+  }
+
+  const existingColumnNames = new Set(
+    columnsArray.elements
+      .filter((element) => n.ObjectExpression.check(element))
+      .map((element) => getObjectPropertyValue(element, "name"))
+      .filter(Boolean)
+  );
+
+  const columnsToImport = discoveredColumns.filter((column) => !existingColumnNames.has(column.name));
+
+  if (!columnsToImport.length) {
+    console.log(chalk.green(`✅ Resource is already in sync: ${filePath}`));
+    return 0;
+  }
+
+  console.log(chalk.cyan(`ℹ️ Going to import ${formatColumnsCount(columnsToImport.length)}: ${columnsToImport.map((column) => column.name).join(", ")}`));
+
+  columnsArray.elements.push(...columnsToImport.map(createColumnAstNode));
+
+  const newContent = recast.print(ast, {
+    tabWidth: 2,
+    useTabs: false,
+    trailingComma: true,
+    wrapColumn: 1,
+  }).code;
+
+  await fs.writeFile(filePath, newContent, "utf-8");
+  console.log(chalk.green(`✅ Imported ${formatColumnsCount(columnsToImport.length)} into resource file: ${filePath}`));
+
+  return columnsToImport.length;
+}
+
+function findResourceColumnsArray(ast) {
+  let columnsArray = null;
+
+  recast.visit(ast, {
+    visitObjectExpression(path) {
+      const properties = path.node.properties;
+      const columnsProp = findObjectProperty(properties, "columns");
+      const hasResourceShape = findObjectProperty(properties, "dataSource") && findObjectProperty(properties, "table");
+
+      if (hasResourceShape && columnsProp && n.ArrayExpression.check(columnsProp.value)) {
+        columnsArray = columnsProp.value;
+        return false;
+      }
+
+      this.traverse(path);
+    },
+  });
+
+  return columnsArray;
+}
+
+function findObjectProperty(properties, name) {
+  return properties.find((property) => (
+    n.ObjectProperty.check(property) &&
+    getPropertyKeyName(property) === name
+  ));
+}
+
+function getPropertyKeyName(property) {
+  if (n.Identifier.check(property.key)) {
+    return property.key.name;
+  }
+  if (n.StringLiteral.check(property.key) || n.Literal.check(property.key)) {
+    return property.key.value;
+  }
+  return null;
+}
+
+function getObjectPropertyValue(objectExpression, name) {
+  const property = findObjectProperty(objectExpression.properties, name);
+  if (!property) {
+    return null;
+  }
+  if (n.StringLiteral.check(property.value) || n.Literal.check(property.value)) {
+    return property.value.value;
+  }
+  return null;
+}
+
+function createColumnAstNode(column) {
+  const properties = [
+    b.objectProperty(b.identifier("name"), b.stringLiteral(column.name)),
+  ];
+
+  if (column.type) {
+    properties.push(
+      b.objectProperty(
+        b.identifier("type"),
+        b.memberExpression(b.identifier("AdminForthDataTypes"), b.identifier(getAdminForthDataTypeKey(column.type)))
+      )
+    );
+  }
+
+  if (column.isPrimaryKey) {
+    properties.push(b.objectProperty(b.identifier("primaryKey"), b.booleanLiteral(true)));
+  }
+
+  if (column.isUUID) {
+    properties.push(
+      b.objectProperty(
+        b.identifier("components"),
+        b.objectExpression([
+          b.objectProperty(b.identifier("list"), b.stringLiteral("@/renderers/CompactUUID.vue")),
+        ])
+      )
+    );
+  }
+
+  properties.push(
+    b.objectProperty(
+      b.identifier("showIn"),
+      b.objectExpression([
+        b.objectProperty(b.identifier("all"), b.booleanLiteral(true)),
+      ])
+    )
+  );
+
+  return b.objectExpression(properties);
+}
+
+function formatColumnsCount(count) {
+  return `${count} column${count === 1 ? "" : "s"}`;
+}
+
+function normalizeColumnForTemplate(column) {
+  if (!column.type) {
+    return column;
+  }
+  return {
+    ...column,
+    type: getAdminForthDataTypeKey(column.type),
+  };
+}
+
+function getAdminForthDataTypeKey(type) {
+  return ADMINFORTH_DATA_TYPE_KEYS[type] || type;
+}
diff --git a/adminforth/commands/createResource/main.js b/adminforth/commands/createResource/main.js
@@ -43,7 +43,7 @@ export default async function createResource(args) {
     import { admin } from './${instance.file}.js';
     export async function exec() {
       await admin.discoverDatabases();
-      const columns = await admin.getAllColumnsInTable("${table.table}");
+      const columns = await admin.getAllColumnsInTable("${table.table}", "${table.db}");
       setTimeout(process.exit);
       return columns;
     }
@@ -55,7 +55,7 @@ export default async function createResource(args) {
     dataSource: table.db,
   });
 
-  injectResourceIntoIndex({
+  await injectResourceIntoIndex({
     table: resourceId,
     resourceId: resourceId,
     label: toTitleCase(table.table),
diff --git a/adminforth/index.ts b/adminforth/index.ts
@@ -521,7 +521,8 @@ class AdminForth implements IAdminForth {
   }
 
   async getAllColumnsInTable(
-    tableName: string
+    tableName: string,
+    dataSourceId?: string
   ): Promise<{ [dataSourceId: string]: Array<{ name: string; type?: string; isPrimaryKey?: boolean; isUUID?: boolean; }> }> {
     const results: { [dataSourceId: string]: Array<{ name: string; type?: string; isPrimaryKey?: boolean;  isUUID?: boolean; }> } = {};
   
@@ -530,7 +531,9 @@ class AdminForth implements IAdminForth {
     }
   
     await Promise.all(
-      Object.entries(this.connectors).map(async ([dataSourceId, connector]) => {
+      Object.entries(this.connectors)
+        .filter(([connectorDataSourceId]) => !dataSourceId || connectorDataSourceId === dataSourceId)
+        .map(async ([dataSourceId, connector]) => {
         if (typeof connector.getAllColumnsInTable === 'function') {
           try {
             const columns = await connector.getAllColumnsInTable(tableName);
diff --git a/adminforth/modules/codeInjector.ts b/adminforth/modules/codeInjector.ts
@@ -147,6 +147,10 @@ class CodeInjector implements ICodeInjector {
 
 
   async doesUserHasPnpmLockFile(dir: string): Promise<boolean> {
+    if (!dir) {
+      return false;
+    }
+
     const usersPackagePath = path.join(dir, 'package.json');
     let packageContent: { dependencies: any, devDependencies: any } = null;
     try {
