adminforth 1.21.0 → 1.22.0

package/commands/createCustomComponent/configUpdater.js

@@ -205,3 +205,282 @@ export async function updateResourceConfig(resourceId, columnName, fieldType, co
         throw new Error(`Failed to update resource file ${path.basename(filePath)}: ${error.message}`);
     }
 }
+
+
+export async function injectLoginComponent(indexFilePath, componentPath) {
+    console.log(chalk.dim(`Reading file: ${indexFilePath}`));
+    const content = await fs.readFile(indexFilePath, 'utf-8');
+    const ast = recast.parse(content, {
+        parser: typescriptParser,
+    });
+
+    let updated = false;
+
+    recast.visit(ast, {
+        visitNewExpression(path) {
+            if (
+                n.Identifier.check(path.node.callee) &&
+                path.node.callee.name === 'AdminForth' &&
+                path.node.arguments.length > 0 &&
+                n.ObjectExpression.check(path.node.arguments[0])
+            ) {
+                const configObject = path.node.arguments[0];
+
+                let customizationProp = configObject.properties.find(
+                    p => n.ObjectProperty.check(p) && n.Identifier.check(p.key) && p.key.name === 'customization'
+                );
+
+                if (!customizationProp) {
+                    const customizationObj = b.objectExpression([]);
+                    customizationProp = b.objectProperty(b.identifier('customization'), customizationObj);
+                    configObject.properties.push(customizationProp);
+                    console.log(chalk.dim(`Added missing 'customization' property.`));
+                }
+
+                const customizationValue = customizationProp.value;
+                if (!n.ObjectExpression.check(customizationValue)) return false;
+
+                let loginPageInjections = customizationValue.properties.find(
+                    p => n.ObjectProperty.check(p) && n.Identifier.check(p.key) && p.key.name === 'loginPageInjections'
+                );
+
+                if (!loginPageInjections) {
+                    const injectionsObj = b.objectExpression([]);
+                    loginPageInjections = b.objectProperty(b.identifier('loginPageInjections'), injectionsObj);
+                    customizationValue.properties.push(loginPageInjections);
+                    console.log(chalk.dim(`Added missing 'loginPageInjections'.`));
+                }
+
+                const injectionsValue = loginPageInjections.value;
+                if (!n.ObjectExpression.check(injectionsValue)) return false;
+
+                let underInputsProp = injectionsValue.properties.find(
+                    p => n.ObjectProperty.check(p) && n.Identifier.check(p.key) && p.key.name === 'underInputs'
+                );
+
+                if (underInputsProp) {
+                    underInputsProp.value = b.stringLiteral(componentPath);
+                    console.log(chalk.dim(`Updated 'underInputs' to ${componentPath}`));
+                } else {
+                    injectionsValue.properties.push(
+                        b.objectProperty(b.identifier('underInputs'), b.stringLiteral(componentPath))
+                    );
+                    console.log(chalk.dim(`Added 'underInputs': ${componentPath}`));
+                }
+
+                updated = true;
+                this.abort();
+            }
+            return false;
+        }
+    });
+
+    if (!updated) {
+        throw new Error(`Could not find AdminForth configuration in file: ${indexFilePath}`);
+    }
+
+    const outputCode = recast.print(ast).code;
+    await fs.writeFile(indexFilePath, outputCode, 'utf-8');
+    console.log(chalk.green(`✅ Successfully updated login injection in: ${indexFilePath}`));
+}
+
+
+export async function injectGlobalComponent(indexFilePath, injectionType, componentPath) {
+    console.log(chalk.dim(`Reading file: ${indexFilePath}`));
+    const content = await fs.readFile(indexFilePath, 'utf-8');
+    const ast = recast.parse(content, {
+        parser: typescriptParser,
+    });
+
+    let updated = false;
+    
+    console.log(JSON.stringify(injectionType));
+    recast.visit(ast, {
+        visitNewExpression(path) {
+            if (
+                n.Identifier.check(path.node.callee) &&
+                path.node.callee.name === 'AdminForth' &&
+                path.node.arguments.length > 0 &&
+                n.ObjectExpression.check(path.node.arguments[0])
+            ) {
+                const configObject = path.node.arguments[0];
+
+                let customizationProp = configObject.properties.find(
+                    p => n.ObjectProperty.check(p) && n.Identifier.check(p.key) && p.key.name === 'customization'
+                );
+
+                if (!customizationProp) {
+                    const customizationObj = b.objectExpression([]);
+                    customizationProp = b.objectProperty(b.identifier('customization'), customizationObj);
+                    configObject.properties.push(customizationProp);
+                    console.log(chalk.dim(`Added missing 'customization' property.`));
+                }
+
+                const customizationValue = customizationProp.value;
+                if (!n.ObjectExpression.check(customizationValue)) return false;
+
+                let globalInjections = customizationValue.properties.find(
+                    p => n.ObjectProperty.check(p) && n.Identifier.check(p.key) && p.key.name === 'globalInjections'
+                );
+
+                if (!globalInjections) {
+                    const injectionsObj = b.objectExpression([]);
+                    globalInjections = b.objectProperty(b.identifier('globalInjections'), injectionsObj);
+                    customizationValue.properties.push(globalInjections);
+                    console.log(chalk.dim(`Added missing 'globalInjections'.`));
+                }
+
+                const injectionsValue = globalInjections.value;
+                if (!n.ObjectExpression.check(injectionsValue)) return false;
+                console.log(JSON.stringify(injectionType));
+                let injectionProp = injectionsValue.properties.find(
+                    p => n.ObjectProperty.check(p) && n.Identifier.check(p.key) && p.key.name === injectionType
+                );
+                if (injectionProp) {
+                    const currentValue = injectionProp.value;
+          
+                    if (n.ArrayExpression.check(currentValue)) {
+                      currentValue.elements.push(b.stringLiteral(componentPath));
+                      console.log(chalk.dim(`Added '${componentPath}' to existing array in '${injectionType}'`));
+                    } else if (n.StringLiteral.check(currentValue)) {
+                      injectionProp.value = b.arrayExpression([
+                        b.stringLiteral(currentValue.value),
+                        b.stringLiteral(componentPath)
+                      ]);
+                      console.log(chalk.dim(`Converted '${injectionType}' from string to array and added '${componentPath}'`));
+                    } else {
+                      throw new Error(`Unsupported value type for '${injectionType}'. Must be string or array.`);
+                    }
+                  } else {
+                    injectionsValue.properties.push(
+                      b.objectProperty(
+                        b.identifier(injectionType),
+                        b.arrayExpression([b.stringLiteral(componentPath)])
+                      )
+                    );
+                    console.log(chalk.dim(`Added new array for '${injectionType}' with '${componentPath}'`));
+                  }
+          
+                  updated = true;
+                  this.abort();
+                }
+                return false;
+              }
+    });
+
+    if (!updated) {
+        throw new Error(`Could not find AdminForth configuration in file: ${indexFilePath}`);
+    }
+
+    const outputCode = recast.print(ast).code;
+    await fs.writeFile(indexFilePath, outputCode, 'utf-8');
+    console.log(chalk.green(`✅ Successfully updated global injection '${injectionType}' in: ${indexFilePath}`));
+}
+
+export async function updateCrudInjectionConfig(resourceId, crudType, injectionPosition, componentPathForConfig, isThin) {
+    const filePath = await findResourceFilePath(resourceId);
+    console.log(chalk.dim(`Attempting to update resource CRUD injection: ${filePath}`));
+  
+    let content;
+    try {
+      content = await fs.readFile(filePath, 'utf-8');
+    } catch (error) {
+      console.error(chalk.red(`❌ Error reading resource file: ${filePath}`));
+      throw new Error(`Could not read resource file ${filePath}.`);
+    }
+  
+    try {
+      const ast = recast.parse(content, {
+        parser: typescriptParser
+      });
+  
+      let updateApplied = false;
+  
+      recast.visit(ast, {
+        visitExportDefaultDeclaration(path) {
+          const declaration = path.node.declaration;
+          let objectExpressionNode = null;
+  
+          if (n.TSAsExpression.check(declaration) && n.ObjectExpression.check(declaration.expression)) {
+            objectExpressionNode = declaration.expression;
+          } else if (n.ObjectExpression.check(declaration)) {
+            objectExpressionNode = declaration;
+          }
+  
+          if (!objectExpressionNode) {
+            console.warn(chalk.yellow(`Warning: Default export in ${filePath} is not an ObjectExpression. Skipping update.`));
+            return false;
+          }
+  
+          const getOrCreateObjectProp = (obj, propName) => {
+            let prop = obj.properties.find(p => n.ObjectProperty.check(p) && n.Identifier.check(p.key) && p.key.name === propName);
+            if (!prop) {
+              const newObject = b.objectExpression([]);
+              prop = b.objectProperty(b.identifier(propName), newObject);
+              obj.properties.push(prop);
+            }
+            return prop.value;
+          };
+  
+          const options = getOrCreateObjectProp(objectExpressionNode, 'options');
+          if (!n.ObjectExpression.check(options)) return false;
+  
+          const pageInjections = getOrCreateObjectProp(options, 'pageInjections');
+          if (!n.ObjectExpression.check(pageInjections)) return false;
+  
+          let crudProp = pageInjections.properties.find(p =>
+            n.ObjectProperty.check(p) && n.Identifier.check(p.key) && p.key.name === crudType
+          );
+  
+          if (!crudProp) {
+            crudProp = b.objectProperty(
+              b.identifier(crudType),
+              b.objectExpression([])
+            );
+            pageInjections.properties.push(crudProp);
+          }
+  
+          const crudValue = crudProp.value;
+          if (!n.ObjectExpression.check(crudValue)) return false;
+  
+          let injectionProp = crudValue.properties.find(p =>
+            n.ObjectProperty.check(p) && n.Identifier.check(p.key) && p.key.name === injectionPosition
+          );
+  
+          const newInjectionObject = b.objectExpression([
+            b.objectProperty(b.identifier('file'), b.stringLiteral(componentPathForConfig)),
+            b.objectProperty(
+              b.identifier('meta'),
+              b.objectExpression([
+                b.objectProperty(b.identifier('thinEnoughToShrinkTable'), b.booleanLiteral(!!isThin)),
+              ])
+            ),
+          ]);
+          
+          if (injectionProp) {
+            injectionProp.value = newInjectionObject;
+            console.log(chalk.dim(`Updated '${injectionPosition}' injection for '${crudType}'.`));
+          } else {
+            crudValue.properties.push(b.objectProperty(b.identifier(injectionPosition), newInjectionObject));
+            console.log(chalk.dim(`Added '${injectionPosition}' injection for '${crudType}'.`));
+          }
+  
+          updateApplied = true;
+          this.abort();
+          return false;
+        }
+      });
+  
+      if (!updateApplied) {
+        throw new Error(`Could not inject CRUD component in resource ${resourceId}.`);
+      }
+  
+      const outputCode = recast.print(ast).code;
+      await fs.writeFile(filePath, outputCode, 'utf-8');
+      console.log(chalk.dim(`✅ Successfully updated CRUD injection in resource file: ${filePath}`));
+  
+    } catch (error) {
+      console.error(chalk.red(`❌ Error processing resource file: ${filePath}`));
+      throw new Error(`Failed to inject CRUD component in ${path.basename(filePath)}: ${error.message}`);
+    }
+  }

package/commands/createCustomComponent/fileGenerator.js

@@ -1,4 +1,5 @@
 import fs from 'fs/promises';
+import fsSync from 'fs';
 import path from 'path';
 import chalk from 'chalk';
 import Handlebars from 'handlebars';
@@ -16,22 +17,30 @@ async function renderHBSTemplate(templatePath, data) {
 }
 
 async function generateVueContent(fieldType, { resource, column }) {
-  const componentName = `${resource.label}${column.label}${fieldType.charAt(0).toUpperCase() + fieldType.slice(1)}`;
-  const columnName = column.name;
+  const hasColumn = !!column;
+  const componentName = hasColumn
+    ? `${resource.label}${column.label}${fieldType.charAt(0).toUpperCase() + fieldType.slice(1)}`
+    : `${resource.label}${fieldType.charAt(0).toUpperCase() + fieldType.slice(1)}`;
+
   const resourceId = resource.resourceId;
 
   const __filename = fileURLToPath(import.meta.url);
   const __dirname = path.dirname(__filename);
-  const templatePath = path.join(__dirname, 'templates', 'customFields', `${fieldType}.vue.hbs`);
+
+  const templatePath = hasColumn
+    ? path.join(__dirname, 'templates', 'customFields', `${fieldType}.vue.hbs`)
+    : path.join(__dirname, 'templates', 'customCrud', `${fieldType}.vue.hbs`);
 
   console.log(chalk.dim(`Using template: ${templatePath}`));
 
   const context = {
     componentName,
-    columnName,
     resourceId,
     resource,
-    column
+    ...(hasColumn && {
+      column,
+      columnName: column.name,
+    }),
   };
 
   try {
@@ -43,6 +52,7 @@ async function generateVueContent(fieldType, { resource, column }) {
   }
 }
 
+
 export async function generateComponentFile(componentFileName, fieldType, context, config) {
 
   const customDirRelative = 'custom';
@@ -50,7 +60,10 @@ export async function generateComponentFile(componentFileName, fieldType, contex
   const projectRoot = process.cwd();
   const customDirPath = path.resolve(projectRoot, customDirRelative);
   const absoluteComponentPath = path.resolve(customDirPath, componentFileName);
-
+  if (fsSync.existsSync(absoluteComponentPath)) {
+    console.log(chalk.yellow(`⚠️ Component file already exists: ${absoluteComponentPath}`));
+    return {"alreadyExists": true, "path": absoluteComponentPath}
+  }
   try {
     await fs.mkdir(customDirPath, { recursive: true });
     console.log(chalk.dim(`Ensured custom directory exists: ${customDirPath}`));
@@ -60,7 +73,7 @@ export async function generateComponentFile(componentFileName, fieldType, contex
     await fs.writeFile(absoluteComponentPath, fileContent, 'utf-8');
     console.log(chalk.green(`✅ Generated component file: ${absoluteComponentPath}`));
 
-    return absoluteComponentPath;
+    return {"alreadyExists": false, "path": absoluteComponentPath}
 
   } catch (error) {
     console.error(chalk.red(`❌ Error creating component file at ${absoluteComponentPath}:`));
@@ -70,3 +83,66 @@ export async function generateComponentFile(componentFileName, fieldType, contex
     throw error;
   }
 }
+
+export async function generateCrudInjectionComponent(componentFileName, crudType, context, config) {
+  const customDirRelative = 'custom';
+  const projectRoot = process.cwd();
+  const customDirPath = path.resolve(projectRoot, customDirRelative);
+  const absoluteComponentPath = path.resolve(customDirPath, componentFileName);
+
+  if (fsSync.existsSync(absoluteComponentPath)) {
+    console.log(chalk.yellow(`⚠️ Component file already exists: ${absoluteComponentPath}`));
+    return { alreadyExists: true, path: absoluteComponentPath };
+  }
+
+  try {
+    await fs.mkdir(customDirPath, { recursive: true });
+    console.log(chalk.dim(`Ensured custom directory exists: ${customDirPath}`));
+
+    const fileContent = await generateVueContent(crudType, context);
+
+    await fs.writeFile(absoluteComponentPath, fileContent, 'utf-8');
+    console.log(chalk.green(`✅ Generated component file: ${absoluteComponentPath}`));
+
+    return { alreadyExists: false, path: absoluteComponentPath };
+  } catch (error) {
+    console.error(chalk.red(`❌ Error creating component file at ${absoluteComponentPath}:`));
+    throw error;
+  }
+}
+
+export async function generateLoginOrGlobalComponentFile(componentFileName, injectionType, context) {
+  const customDirRelative = 'custom';
+  const projectRoot = process.cwd();
+  const customDirPath = path.resolve(projectRoot, customDirRelative);
+  const absoluteComponentPath = path.resolve(customDirPath, componentFileName);
+
+  if (fsSync.existsSync(absoluteComponentPath)) {
+    console.log(chalk.yellow(`⚠️ Component file already exists: ${absoluteComponentPath}`));
+    return { alreadyExists: true, path: absoluteComponentPath };
+  }
+
+  try {
+    await fs.mkdir(customDirPath, { recursive: true });
+    console.log(chalk.dim(`Ensured custom directory exists: ${customDirPath}`));
+
+    const __filename = fileURLToPath(import.meta.url);
+    const __dirname = path.dirname(__filename);
+    let templatePath;
+    if (injectionType === 'afterLogin') {
+      templatePath = path.join(__dirname, 'templates', 'login', `${injectionType}.vue.hbs`);
+    } else {
+      templatePath = path.join(__dirname, 'templates', 'global', `${injectionType}.vue.hbs`);
+    }
+
+    const fileContent = await renderHBSTemplate(templatePath, context);
+
+    await fs.writeFile(absoluteComponentPath, fileContent, 'utf-8');
+    console.log(chalk.green(`✅ Generated login injection component: ${absoluteComponentPath}`));
+
+    return { alreadyExists: false, path: absoluteComponentPath };
+  } catch (error) {
+    console.error(chalk.red(`❌ Error creating login component at ${absoluteComponentPath}`));
+    throw error;
+  }
+}