fix: make adminforth bundle to use ts proxy - no compilation needed

Author: ivictbor

adminforth/commands/bundle.js

@@ -1,27 +1,50 @@
 import fs from "fs";
-import { getInstance } from "./utils.js";
+import { callTsProxy } from "./callTsProxy.js";
+import chalk from "chalk";
 
 async function bundle() {
+  console.log("Bundling admin SPA...");
   const currentDirectory = process.cwd();
-  const files = fs.readdirSync(currentDirectory);
-  let instanceFound = false;
 
+  let files = fs.readdirSync(currentDirectory);
+  let instanceFound = false;
+  // 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(".js") || file.endsWith(".ts")) {
+    if (file.endsWith(".ts")) {
+      const fileNoTs = file.replace(/\.ts$/, "");
+      process.env.HEAVY_DEBUG && console.log(`🪲 Trying bundleing ${file}...`);
       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);
+        await callTsProxy(`
+          import { admin } from './${fileNoTs}.js';
+
+          export async function exec() {
+            return await admin.bundleNow({ hotReload: false });
+          }
+        `);
+        instanceFound = true;
+        break;
+
+      } catch (e) {
+        process.env.HEAVY_DEBUG && console.log(`🪲 File ${file} failed`, e);
       }
     }
   }
   if (!instanceFound) {
-    console.error("Error: No valid instance found to bundle.");
+    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.`
+      )
+    );
     return;
   }
 }

adminforth/commands/callTsProxy.js

@@ -0,0 +1,62 @@
+// callTsProxy.js
+import { spawn } from "child_process";
+import path from "path";
+
+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);
+          });
+          resolve(parsed.result);
+        } catch (e) {
+          reject(new Error("Invalid JSON from tsproxy: " + stdout));
+        }
+      } else {
+        try {
+          const parsedError = JSON.parse(stderr);
+          process.env.HEAVY_DEBUG && console.error("🪲 Error from tsproxy. Captured logs:", parsedError.capturedLogs);
+          reject(new Error(parsedError.error));
+        } catch (e) {
+          reject(new Error(stderr));
+        }
+      }
+    });
+
+    process.env.HEAVY_DEBUG && console.log("🪲 Writing to tsproxy stdin...\n'''", tsCode, "'''");
+    child.stdin.write(tsCode);
+    child.stdin.end();
+  });
+}
+
+
+// Example usage:
+// callTsProxy(`
+//   import admin from './admin';
+//   function exec() {
+//     return admin.doX();
+//   }
+// `).then(console.log).catch(console.error);

adminforth/commands/proxy.ts

@@ -0,0 +1,53 @@
+// tsproxy.ts
+import { writeFile, unlink } from 'fs/promises';
+import { randomUUID } from 'crypto';
+import { pathToFileURL } from 'url';
+import path from 'path';
+
+(async () => {
+  const chunks: Buffer[] = [];
+
+  for await (const chunk of process.stdin) {
+    chunks.push(chunk);
+  }
+
+  const code = Buffer.concat(chunks).toString();
+
+  const tmpFileName = `.tmp-tsproxy-${randomUUID()}.ts`;
+  
+  const tmpFile = path.join(process.cwd(), tmpFileName);
+
+  const origLog = console.log;
+  let capturedLogs: any[] = [];
+  console.log = (...args: any[]) => {
+    capturedLogs.push(args);
+  }
+
+  process.env.HEAVY_DEBUG && console.log(`🪲 TMP proxy file: ${tmpFile}`);
+  process.env.HEAVY_DEBUG && console.log(`🪲 Current working directory: ${process.cwd()}`);
+  
+  try {
+    // Save code to a temp file
+    await writeFile(tmpFile, code);
+
+    // Dynamically import the file
+    const module = await import(pathToFileURL(tmpFile).href);
+
+    if (typeof module.exec !== 'function') {
+      throw new Error("Module does not export an 'exec' function");
+    }
+
+    const result = await Promise.resolve(module.exec());
+
+    // Restore original console.log
+    console.log = origLog;
+    console.log(JSON.stringify({ result, capturedLogs }));
+  } catch (error: any) {
+    // Restore original console.log
+    console.log = origLog;
+    console.error(JSON.stringify({ error: error.message, capturedLogs }));
+    process.exit(1);
+  } finally {
+    await unlink(tmpFile).catch(() => {});
+  }
+})();

adminforth/index.ts

@@ -144,7 +144,7 @@ class AdminForth implements IAdminForth {
 
 
 
-    console.log(`${this.formatAdminForth()} v${ADMINFORTH_VERSION} starting up`)
+    console.log(`${this.formatAdminForth()} v${ADMINFORTH_VERSION} initializing...`);
   }
 
   formatAdminForth() {