Merge branch 'main' of github.com:devforth/adminforth into next

Author: ivictbor

README.md

@@ -92,3 +92,29 @@ npm run namemigration -- --name desctiption_of_changes
 ```
 
 
+### Testing CLI commands during development
+
+
+Make sure you have not `adminforth` globally installed. If you have it, remove it:
+
+
+```sh
+npm uninstall -g adminforth
+```
+
+Then, in the root of the project, run once:
+
+```
+cd adminforth/adminforth
+npm run build
+```
+
+This will automatically make an npm link to the `adminforth` package in the root of the project.
+
+Then, go to testing app, e.g. created with CLI, and use next command:
+
+```
+npx -g adminforth <your command under development>
+```
+
+This will always run latest version of adminforth package.

adminforth/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);
   }
 }
 

adminforth/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);

adminforth/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();
+  }
 }

adminforth/commands/createApp/templates/.dockerignore.hbs

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

adminforth/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}}

adminforth/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"]

adminforth/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)
 

adminforth/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"

adminforth/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/)