adminforth 1.19.0 → 1.20.1-next.1

package/commands/bundle.js

@@ -1,28 +1,22 @@
-import fs from "fs";
-import { getInstance } from "./utils.js";
+import { callTsProxy, findAdminInstance } from "./callTsProxy.js";
+
 
 async function bundle() {
-  const currentDirectory = process.cwd();
-  const files = fs.readdirSync(currentDirectory);
-  let instanceFound = false;
+  console.log("Bundling admin SPA...");
+  const instance = await findAdminInstance();
+    
+
+  try {
+    await callTsProxy(`
+      import { admin } from './${instance.file}.js';
 
-  for (const file of files) {
-    if (file.endsWith(".js") || file.endsWith(".ts")) {
-      try {
-        const instance = await getInstance(file, currentDirectory);
-        if (instance) {
-          await instance.bundleNow({ hotReload: false });
-          instanceFound = true;
-          break;
-        }
-      } catch (error) {
-        console.error(`Error: Could not bundle '${file}'`, error);
+      export async function exec() {
+        return await admin.bundleNow({ hotReload: false });
       }
-    }
-  }
-  if (!instanceFound) {
-    console.error("Error: No valid instance found to bundle.");
-    return;
+    `);
+
+  } catch (e) {
+    console.log(`Running file ${file} failed`, e);
   }
 }
 

package/commands/callTsProxy.js

@@ -0,0 +1,121 @@
+// callTsProxy.js
+import { spawn } from "child_process";
+import path from "path";
+import fs from "fs";
+import chalk from "chalk";
+
+const currentFilePath = import.meta.url;
+const currentFileFolder = path.dirname(currentFilePath).replace("file:", "");
+
+export function callTsProxy(tsCode) {
+
+  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")
+    ]);
+
+    let stdout = "";
+    let stderr = "";
+
+    child.stdout.on("data", (data) => {
+      stdout += data;
+    });
+
+    child.stderr.on("data", (data) => {
+      stderr += data;
+    });
+
+    child.on("close", (code) => {
+      if (code === 0) {
+        try {
+          const parsed = JSON.parse(stdout);
+          parsed.capturedLogs.forEach((log) => {
+            console.log(...log);
+          });
+
+          if (parsed.error) {
+            reject(new Error(`${parsed.error}\n${parsed.stack}`));
+          }
+          resolve(parsed.result);
+        } catch (e) {
+          reject(new Error("Invalid JSON from tsproxy: " + stdout));
+        }
+      } else {
+        console.error(`tsproxy exited with non-0, this should never happen, stdout: ${stdout}, stderr: ${stderr}`);
+        reject(new Error(stderr));
+      }
+    });
+
+    process.env.HEAVY_DEBUG && console.log("🪲 Writing to tsproxy stdin...\n'''", tsCode, "'''");
+    child.stdin.write(tsCode);
+    child.stdin.end();
+  });
+}
+
+export async function findAdminInstance() {
+  process.env.HEAVY_DEBUG && console.log("🌐 Finding admin instance...");
+  const currentDirectory = process.cwd();
+
+  let files = fs.readdirSync(currentDirectory);
+  let instanceFound = {
+    file: null,
+    version: null,
+  };
+  // try index.ts first
+  if (files.includes("index.ts")) {
+    files = files.filter((file) => file !== "index.ts");
+    files.unshift("index.ts");
+  }
+
+  for (const file of files) {
+    if (file.endsWith(".ts")) {
+      const fileNoTs = file.replace(/\.ts$/, "");
+      process.env.HEAVY_DEBUG && console.log(`🪲 Trying bundleing ${file}...`);
+      try {
+        res = await callTsProxy(`
+          import { admin } from './${fileNoTs}.js';
+
+          export async function exec() {
+            return admin.formatAdminForth();
+          }
+        `);
+        instanceFound.file = fileNoTs;
+        instanceFound.version = res;
+        break;
+
+      } catch (e) {
+        // do our best to guess that this file has a good chance to be admin instance
+        // and show the error so user can fix it
+        const fileContent = fs.readFileSync(file, "utf-8");
+        if (fileContent.includes("export const admin")) {
+          console.error(chalk.red(`Error running ${file}:`, e));
+          process.exit(1);
+        }
+        process.env.HEAVY_DEBUG && console.log(`🪲 File ${file} failed`, e);
+      }
+    }
+  }
+  if (!instanceFound.file) {
+    console.error(
+      chalk.red(
+        `Error: No valid instance found to bundle.\n` +
+        `Make sure you have a file in the current directory with a .ts extension, and it exports an ` +
+        chalk.cyan.bold('admin') +
+        ` instance like:\n\n` +
+        chalk.yellow('export const admin = new AdminForth({...})') +
+        `\n\nFor example, adminforth CLI creates an index.ts file which exports the admin instance.`
+      )
+    );
+    process.exit(1);
+  }
+  return instanceFound;
+}
+
+// Example usage:
+// callTsProxy(`
+//   import admin from './admin';
+//   function exec() {
+//     return admin.doX();
+//   }
+// `).then(console.log).catch(console.error);

package/commands/cli.js

@@ -7,6 +7,41 @@ import bundle from "./bundle.js";
 import createApp from "./createApp/main.js";
 import generateModels from "./generateModels.js";
 import createPlugin from "./createPlugin/main.js";
+import createComponent from "./createCustomComponent/main.js";
+import chalk from "chalk";
+import path from "path";
+import fs from "fs";
+
+function showHelp() {
+  console.log(
+    chalk.white("Available commands:\n") +
+    chalk.green('  create-app') + chalk.white('         Create a new AdminForth app\n') +
+    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')
+  );
+}
+
+function currentFileDir(importMetaUrl) {
+  const filePath = importMetaUrl.replace("file://", "");
+  const fileDir = path.dirname(filePath);
+  return fileDir;
+}
+
+function showVersion() {
+  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;
+
+  console.log(
+    chalk.white('AdminForth CLI version: ') +
+    chalk.cyan.bold(ADMINFORTH_VERSION)
+  );
+}
+
 switch (command) {
   case "create-app":
     createApp(args);
@@ -20,8 +55,23 @@ switch (command) {
   case "bundle":
     bundle();
     break;
-  default:
+  case "component":
+    createComponent(args);
+    break;
+  case "help":
+  case "--help":
+  case "-h":
+    showHelp();
+    break;
+  case "--version":
+  case "version":
+  case "-v":
+    showVersion();
+    break;
+  default: {
     console.log(
-      "Unknown command. Available commands: create-app, create-plugin, generate-models, bundle"
+      "Unknown command."
     );
+    showHelp();
+  }
 }

package/commands/createApp/templates/.dockerignore.hbs

@@ -0,0 +1,4 @@
+node_modules
+{{#if sqliteFile}}
+{{ sqliteFile }}
+{{/if}}

package/commands/createApp/templates/.env.prod.hbs

@@ -0,0 +1,6 @@
+NODE_ENV=production
+DATABASE_URL=sqlite://.db.sqlite
+DATABASE_URL={{dbUrl}}
+{{#if prismaDbUrl}}
+PRISMA_DATABASE_URL={{prismaDbUrl}}
+{{/if}}

package/commands/createApp/templates/Dockerfile.hbs

@@ -0,0 +1,7 @@
+FROM node:{{nodeMajor}}-slim
+WORKDIR /code/
+ADD package.json package-lock.json /code/
+RUN npm ci  
+ADD . /code/
+RUN --mount=type=cache,target=/tmp npx adminforth bundle
+CMD ["sh", "-c", "npm run migrate:prod && npm run prod"]

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

@@ -60,9 +60,9 @@ if (import.meta.url === `file://${process.argv[1]}`) {
   app.use(express.json());
 
   const port = 3500;
-
+  
   await admin.bundleNow({ hotReload: process.env.NODE_ENV === 'development' });
-  console.log('Bundling AdminForth done. For faster serving consider calling bundleNow() from a build script.');
+  console.log('Bundling AdminForth SPA done.');
 
   admin.express.serve(app)
 

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

@@ -8,11 +8,14 @@
   "license": "ISC",
   "description": "",
   "scripts": {
-    "env": "dotenvx run -f .env.local -f .env --overload --",
-    "start": "npm run env -- tsx watch index.ts",
-    "migrateLocal": "npm run env -- npx prisma migrate deploy",
-    "makemigration": "npm run migrateLocal; npm run env -- npx --yes prisma migrate dev",
-    "test": "echo \"Error: no test specified\" && exit 1"
+    "dev": "npm run _env:dev -- tsx watch index.ts",
+    "prod": "npm run _env:prod -- tsx index.ts",
+    "start": "npm run dev",
+    "makemigration": "npm run _env:dev -- npx --yes prisma migrate dev --create-only",
+    "migrate:local": "npm run _env:dev -- npx --yes prisma migrate deploy",
+    "migrate:prod": "npm run _env:prod -- npx --yes prisma migrate deploy",
+    "_env:dev": "dotenvx run -f .env -f .env.local --",
+    "_env:prod": "dotenvx run -f .env.prod --"
   },
   "engines": {
     "node": ">=20"

package/commands/createApp/templates/readme.md.hbs

@@ -9,13 +9,13 @@ npm ci
 Migrate the database:
 
 ```bash
-npm run migrateLocal
+npm run migrate:local
 ```
 
 Start the server:
 
 ```bash
-npm start
+npm run dev
 ```
 
 {{#if prismaDbUrl}}
@@ -32,6 +32,18 @@ npm run makemigration -- --name <name_of_changes>
 Your colleagues will need to pull the changes and run `npm run migrateLocal` to apply the migration in their local database.
 {{/if}}
 
+## Deployment tips
+
+You have Dockerfile ready for production deployment. You can test the build with:
+
+```bash
+docker build -t {{appName}}-image .
+docker run -p 3500:3500 {{appName}}-image
+```
+
+To set non-sensitive environment variables in production, use `.env.prod` file.
+For sensitive variables, use direct docker environment variables or secrets from your vault.
+
 ## Documentation
 
 - [Customizing AdminForth Branding](https://adminforth.dev/docs/tutorial/Customization/branding/)

package/commands/createApp/utils.js

@@ -7,8 +7,12 @@ import path from 'path';
 import { Listr } from 'listr2'
 import { fileURLToPath } from 'url';
 import {ConnectionString} from 'connection-string';
-import {execa} from 'execa';
+import { exec } from 'child_process';
+
 import Handlebars from 'handlebars';
+import { promisify } from 'util';
+
+const execAsync = promisify(exec);
 
 export function parseArgumentsIntoOptions(rawArgs) {
   const args = arg(
@@ -145,18 +149,19 @@ async function scaffoldProject(ctx, options, cwd) {
   await fse.copy(sourceAssetsDir, targetAssetsDir);
 
   // Write templated files
-  writeTemplateFiles(dirname, projectDir, {
+  await writeTemplateFiles(dirname, projectDir, {
     dbUrl: connectionString.toString(),
     prismaDbUrl,
     appName,
     provider,
+    nodeMajor: parseInt(process.versions.node.split('.')[0], 10),
   });
 
   return projectDir;  // Return the new directory path
 }
 
 async function writeTemplateFiles(dirname, cwd, options) {
-  const { dbUrl, prismaDbUrl, appName, provider } = options;
+  const { dbUrl, prismaDbUrl, appName, provider, nodeMajor } = options;
 
   // Build a list of files to generate
   const templateTasks = [
@@ -191,10 +196,15 @@ async function writeTemplateFiles(dirname, cwd, options) {
       dest: '.env.local',
       data: { dbUrl, prismaDbUrl },
     },
+    {
+      src: '.env.prod.hbs',
+      dest: '.env.prod',
+      data: { dbUrl, prismaDbUrl },
+    },
     {
       src: 'readme.md.hbs',
       dest: 'README.md',
-      data: { dbUrl, prismaDbUrl },
+      data: { dbUrl, prismaDbUrl, appName },
     },
     {
       // We'll write .env using the same content as .env.sample
@@ -218,6 +228,18 @@ async function writeTemplateFiles(dirname, cwd, options) {
       dest: 'custom/tsconfig.json',
       data: {},
     },
+    {
+      src: 'Dockerfile.hbs',
+      dest: 'Dockerfile',
+      data: { nodeMajor },
+    },
+    {
+      src: '.dockerignore.hbs',
+      dest: '.dockerignore',
+      data: {
+        sqliteFile: detectDbProvider(options.db).startsWith('sqlite') ? options.db.split('://')[1] : null,
+      },
+    }
   ];
 
   for (const task of templateTasks) {
@@ -228,22 +250,25 @@ async function writeTemplateFiles(dirname, cwd, options) {
     // fse.ensureDirSync(path.dirname(destPath));
 
     if (task.empty) {
-      fs.writeFileSync(destPath, '');
+      await fs.promises.writeFile(destPath, '');
     } else {
       const templatePath = path.join(dirname, 'templates', task.src);
       const compiled = renderHBSTemplate(templatePath, task.data);
-      fs.writeFileSync(destPath, compiled);
+      await fs.promises.writeFile(destPath, compiled);
     }
   }
 }
 
 async function installDependencies(ctx, cwd) {
-  const customDir = ctx.customDir;
+  const nodeBinary = process.execPath; // Path to the Node.js binary running this script
+  const npmPath = path.join(path.dirname(nodeBinary), 'npm'); // Path to the npm executable
 
-  await Promise.all([
-    await execa('npm', ['install'], { cwd }),
-    await execa('npm', ['install'], { cwd: customDir }),
+  const customDir = ctx.customDir;
+  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}`));
 }
 
 function generateFinalInstructions(skipPrismaSetup, options) {
@@ -251,15 +276,15 @@ function generateFinalInstructions(skipPrismaSetup, options) {
   if (!skipPrismaSetup)
     instruction += `
   ${chalk.dim('// Go to the project directory')}
-  ${chalk.cyan(`$ cd ${options.appName}`)}\n`;
+  ${chalk.dim('$')}${chalk.cyan(` cd ${options.appName}`)}\n`;
 
     instruction += `
   ${chalk.dim('// Generate and apply initial migration')}
-  ${chalk.cyan('$ npm run makemigration -- --name init')}\n`;
+  ${chalk.dim('$')}${chalk.cyan(' npm run makemigration -- --name init && npm run migrate:local')}\n`;
 
   instruction += `
   ${chalk.dim('// Start dev server with tsx watch for hot-reloading')}
-  ${chalk.cyan('$ npm start')}\n
+  ${chalk.dim('$')}${chalk.cyan(' npm run dev')}\n
 `;
 
   instruction += '😉 Happy coding!';

package/commands/createCustomComponent/configLoader.js

@@ -0,0 +1,57 @@
+import fs from 'fs/promises';
+import path from 'path';
+import chalk from 'chalk';
+import jiti from 'jiti';
+
+
+export async function loadAdminForthConfig() {
+  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);
+  }
+
+  try {
+    const _require = jiti(import.meta.url, {
+        interopDefault: true,
+        cache: true,
+        esmResolve: true,
+    });
+
+    const configModule = _require(configPath);
+
+    const adminInstance = configModule.admin || configModule.default?.admin;
+
+
+    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({...});'`);
+    }
+
+    const config = adminInstance.config;
+
+    if (!config || typeof config !== 'object') {
+        throw new Error(`Invalid configuration found in admin instance from ${configFileName}. Expected admin.config to be an object.`);
+    }
+
+    if (!config.resources || !Array.isArray(config.resources)) {
+        console.warn(chalk.yellow(`Warning: The loaded configuration seems incomplete. Missing 'resources' array.`));
+    }
+     if (!config.customization?.customComponentsDir) {
+        console.warn(chalk.yellow(`Warning: 'customization.customComponentsDir' is not defined in the config. Defaulting might occur elsewhere, but defining it is recommended.`));
+     }
+
+
+    console.log(chalk.dim(`Loaded configuration from ${configPath}`));
+    return config;
+
+  } catch (error) {
+    console.error(chalk.red(`\nError loading or parsing configuration file: ${configPath}`));
+    console.error(error);
+    process.exit(1);
+  }
+}