@titanpl/packet 1.0.0 → 1.4.0

package/ts/titan/builder.js

@@ -1,121 +1,74 @@
-import { bundle } from "./bundle.js";
 import fs from "fs";
 import path from "path";
+import { pathToFileURL } from "url";
+import esbuild from "esbuild";
+
+export async function buildMetadata(root, dist) {
+    const isTs = fs.existsSync(path.join(root, "tsconfig.json")) || fs.existsSync(path.join(root, "app", "app.ts"));
+    const appDir = path.join(root, "app");
+    const appFile = isTs ? "app.ts" : "app.js";
+    const appPath = path.join(appDir, appFile);
+
+    if (!fs.existsSync(appPath)) {
+        console.error(`\x1b[31m❌ app/${appFile} not found.\x1b[0m`);
+        process.exit(1);
+    }
 
-const cyan = (t) => `\x1b[36m${t}\x1b[0m`;
-const green = (t) => `\x1b[32m${t}\x1b[0m`;
-
-const routes = {};
-const dynamicRoutes = {};
-const actionMap = {};
-
-function addRoute(method, route) {
-    const key = `${method.toUpperCase()}:${route}`;
-
-
-    return {
-        reply(value) {
-            routes[key] = {
-                type: typeof value === "object" ? "json" : "text",
-                value
-            };
-        },
-
-        action(name) {
-            if (route.includes(":")) {
-                if (!dynamicRoutes[method]) dynamicRoutes[method] = [];
-                dynamicRoutes[method].push({
-                    method: method.toUpperCase(),
-                    pattern: route,
-                    action: name
-                });
-            } else {
-                routes[key] = {
-                    type: "action",
-                    value: name
-                };
-                actionMap[key] = name;
-            }
-        }
-    };
-}
-
-/**
- * @typedef {Object} RouteHandler
- * @property {(value: any) => void} reply - Send a direct response
- * @property {(name: string) => void} action - Bind to a server-side action
- */
-
-/**
- * Titan App Builder
- */
-const t = {
-    /**
-     * Define a GET route
-     * @param {string} route 
-     * @returns {RouteHandler}
-     */
-    get(route) {
-        return addRoute("GET", route);
-    },
-
-    /**
-     * Define a POST route
-     * @param {string} route 
-     * @returns {RouteHandler}
-     */
-    post(route) {
-        return addRoute("POST", route);
-    },
-
-    log(module, msg) {
-        console.log(`[\x1b[35m${module}\x1b[0m] ${msg}`);
-    },
-
-    /**
-     * Start the Titan Server
-     * @param {number} [port=3000] 
-     * @param {string} [msg=""] 
-     */
-    async start(port = 3000, msg = "") {
-        try {
-            console.log(cyan("[Titan] Preparing runtime..."));
-            await bundle();
+    try {
+        let appUrl;
+        if (isTs) {
+            const dotTitan = path.join(root, ".titan");
+            const compiledApp = path.join(dotTitan, "app.js");
 
-            const base = path.join(process.cwd(), "server");
-            if (!fs.existsSync(base)) {
-                fs.mkdirSync(base, { recursive: true });
+            if (!fs.existsSync(dotTitan)) {
+                fs.mkdirSync(dotTitan, { recursive: true });
             }
 
-            const routesPath = path.join(base, "routes.json");
-            const actionMapPath = path.join(base, "action_map.json");
-
-            fs.writeFileSync(
-                routesPath,
-                JSON.stringify(
-                    {
-                        __config: { port },
-                        routes,
-                        __dynamic_routes: Object.values(dynamicRoutes).flat()
-                    },
-                    null,
-                    2
-                )
-            );
-
-            fs.writeFileSync(
-                actionMapPath,
-                JSON.stringify(actionMap, null, 2)
-            );
-
-            console.log(green("✔ Titan metadata written successfully"));
-            if (msg) console.log(cyan(msg));
-
-        } catch (e) {
-            console.error(`\x1b[31m[Titan] Build Error: ${e.message}\x1b[0m`);
-            process.exit(1);
+            await esbuild.build({
+                entryPoints: [appPath],
+                outfile: compiledApp,
+                bundle: true,
+                platform: "node",
+                format: "esm",
+                packages: "external",
+                logLevel: "silent"
+            });
+            appUrl = pathToFileURL(compiledApp).href;
+        } else {
+            appUrl = pathToFileURL(appPath).href;
         }
-    }
-};
 
-export default t;
+        const cacheBuster = `?t=${Date.now()}`;
+        await import(appUrl + cacheBuster);
+
+        const config = globalThis.__TITAN_CONFIG__ || { port: 3000, threads: 4, stack_mb: 8 };
+        const routes = globalThis.__TITAN_ROUTES_MAP__ || {};
+        const dynamicRoutes = globalThis.__TITAN_DYNAMIC_ROUTES__ || {};
+        const actionMap = globalThis.__TITAN_ACTION_MAP__ || {};
+
+        const routesPath = path.join(dist, "routes.json");
+        const actionMapPath = path.join(dist, "action_map.json");
+
+        fs.writeFileSync(
+            routesPath,
+            JSON.stringify(
+                {
+                    __config: config,
+                    routes,
+                    __dynamic_routes: Object.values(dynamicRoutes).flat()
+                },
+                null,
+                2
+            )
+        );
+
+        fs.writeFileSync(
+            actionMapPath,
+            JSON.stringify(actionMap, null, 2)
+        );
+
+    } catch (err) {
+        console.error("\x1b[31m❌ Failed to parse routes from application logic\x1b[0m", err);
+        process.exit(1);
+    }
+}

package/ts/titan/bundle.js

@@ -1,123 +1,227 @@
-import fs from "fs";
-import path from "path";
-import esbuild from "esbuild";
-import { createRequire } from "module";
-
-const require = createRequire(import.meta.url);
-
-/* ------------------------------------------------------------------
-   Node Builtin Rewrite Map
------------------------------------------------------------------- */
-
-const NODE_BUILTIN_MAP = {
-  "fs": "@titanpl/node/fs",
-  "node:fs": "@titanpl/node/fs",
-
-  "path": "@titanpl/node/path",
-  "node:path": "@titanpl/node/path",
-
-  "os": "@titanpl/node/os",
-  "node:os": "@titanpl/node/os",
-
-  "crypto": "@titanpl/node/crypto",
-  "node:crypto": "@titanpl/node/crypto",
-
-  "process": "@titanpl/node/process",
-  "node:process": "@titanpl/node/process",
-
-  "events": "@titanpl/node/events",
-  "node:events": "@titanpl/node/events",
-
-  "util": "@titanpl/node/util",
-  "node:util": "@titanpl/node/util"
-};
-
-/* ------------------------------------------------------------------
-   Titan Node Compatibility Plugin
------------------------------------------------------------------- */
-
-const titanNodeCompatPlugin = {
-  name: "titan-node-compat",
-  setup(build) {
-    build.onResolve({ filter: /.*/ }, args => {
-      const replacement = NODE_BUILTIN_MAP[args.path];
-      if (!replacement) return;
-
-      // MUST return absolute path for esbuild
-      const resolved = require.resolve(replacement);
-      return { path: resolved };
-    });
-  }
-};
-
-/* ------------------------------------------------------------------
-   Main Bundle Entry
------------------------------------------------------------------- */
-
-export async function bundle() {
-  const root = process.cwd();
-  const actionsDir = path.join(root, "app", "actions");
-  const outDir = path.join(root, "server", "src", "actions");
-
-  await bundleJs(actionsDir, outDir);
-}
-
-/* ------------------------------------------------------------------
-   Bundle JS Actions
------------------------------------------------------------------- */
-
-async function bundleJs(actionsDir, outDir) {
-  if (!fs.existsSync(actionsDir)) return;
-
-  fs.mkdirSync(outDir, { recursive: true });
-
-  // Clean old bundles
-  const oldFiles = fs.readdirSync(outDir);
-  for (const file of oldFiles) {
-    fs.unlinkSync(path.join(outDir, file));
-  }
-
-  const files = fs
-    .readdirSync(actionsDir)
-    .filter(f => f.endsWith(".js") || f.endsWith(".ts"));
-
-  if (files.length === 0) return;
-
-  for (const file of files) {
-    const actionName = path.basename(file, path.extname(file));
-    const entry = path.join(actionsDir, file);
-    const outfile = path.join(outDir, actionName + ".jsbundle");
-
-    await esbuild.build({
-      entryPoints: [entry],
-      outfile,
-      bundle: true,
-      format: "iife",
-      globalName: "__titan_exports",
-      platform: "node",          // important for npm libs
-      target: "es2020",
-      logLevel: "silent",
-      plugins: [titanNodeCompatPlugin],
-
-      banner: {
-        js: "var Titan = t;"
-      },
-
-      footer: {
-        js: `
-(function () {
-  const fn =
-    __titan_exports["${actionName}"] ||
-    __titan_exports.default;
-
-  if (typeof fn !== "function") {
-    throw new Error("[Titan] Action '${actionName}' not found or not a function");
-  }
-
-  globalThis["${actionName}"] = globalThis.defineAction(fn);
-})();
-`
-      }
-    });
-  }
-}
+/**
+ * Bundle.js (TypeScript Version)
+ * Handles esbuild bundling with comprehensive error reporting and TypeScript type checking
+ */
+
+import esbuild from 'esbuild';
+import path from 'path';
+import fs from 'fs';
+import { fileURLToPath } from 'url';
+import { createRequire } from 'module';
+import ts from 'typescript';
+import { renderErrorBox, parseEsbuildError } from './error-box.js';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+// Required for resolving node_modules inside ESM
+const require = createRequire(import.meta.url);
+
+/**
+ * Titan Node Builtin Rewrite Map
+ */
+const NODE_BUILTIN_MAP = {
+    "fs": "@titanpl/node/fs",
+    "node:fs": "@titanpl/node/fs",
+    "path": "@titanpl/node/path",
+    "node:path": "@titanpl/node/path",
+    "os": "@titanpl/node/os",
+    "node:os": "@titanpl/node/os",
+    "crypto": "@titanpl/node/crypto",
+    "node:crypto": "@titanpl/node/crypto",
+    "process": "@titanpl/node/process",
+    "util": "@titanpl/node/util",
+    "node:util": "@titanpl/node/util",
+};
+
+const titanNodeCompatPlugin = {
+    name: "titan-node-compat",
+    setup(build) {
+        build.onResolve({ filter: /.*/ }, args => {
+            if (NODE_BUILTIN_MAP[args.path]) {
+                try {
+                    const resolved = require.resolve(NODE_BUILTIN_MAP[args.path]);
+                    return { path: resolved };
+                } catch (e) {
+                    throw new Error(`[TitanPL] Failed to resolve Node shim: ${NODE_BUILTIN_MAP[args.path]}`);
+                }
+            }
+        });
+    }
+};
+
+function getTitanVersion() {
+    try {
+        const pkgPath = require.resolve("@titanpl/cli/package.json");
+        return JSON.parse(fs.readFileSync(pkgPath, "utf-8")).version;
+    } catch (e) {
+        return "1.0.0";
+    }
+}
+
+export class BundleError extends Error {
+    constructor(message, errors = [], warnings = []) {
+        super(message);
+        this.name = 'BundleError';
+        this.errors = errors;
+        this.warnings = warnings;
+        this.isBundleError = true;
+    }
+}
+
+/**
+ * Run TypeScript type checking
+ */
+async function checkTypes(root) {
+    const tsconfigPath = path.join(root, 'tsconfig.json');
+    if (!fs.existsSync(tsconfigPath)) return;
+
+    const configFile = ts.readConfigFile(tsconfigPath, ts.sys.readFile);
+    if (configFile.error) {
+        throw new BundleError("Failed to load tsconfig.json", [configFile.error]);
+    }
+
+    const parsedConfig = ts.parseJsonConfigFileContent(
+        configFile.config,
+        ts.sys,
+        root
+    );
+
+    const program = ts.createProgram(parsedConfig.fileNames, parsedConfig.options);
+    const diagnostics = ts.getPreEmitDiagnostics(program);
+
+    if (diagnostics.length > 0) {
+        const errors = diagnostics.map(d => {
+            const message = ts.flattenDiagnosticMessageText(d.messageText, '\n');
+            if (d.file) {
+                const { line, character } = d.file.getLineAndCharacterOfPosition(d.start);
+                return {
+                    title: 'TypeScript Error',
+                    message: message,
+                    file: d.file.fileName,
+                    line: line + 1,
+                    column: character + 1,
+                    location: `at ${d.file.fileName}:${line + 1}:${character + 1}`,
+                    codeFrame: `${line + 1} | ${d.file.text.split('\n')[line]}\n${' '.repeat(String(line + 1).length)} | ${' '.repeat(character)}^`
+                };
+            }
+            return { title: 'TypeScript Error', message: message };
+        });
+
+        throw new BundleError(`TypeScript checking failed with ${diagnostics.length} error(s)`, errors);
+    }
+}
+
+async function validateEntryPoint(entryPoint) {
+    const absPath = path.resolve(entryPoint);
+    if (!fs.existsSync(absPath)) {
+        throw new BundleError(`Entry point does not exist: ${entryPoint}`, [{ text: `Cannot find file: ${absPath}`, location: { file: entryPoint } }]);
+    }
+}
+
+/**
+ * Bundles a single file
+ */
+export async function bundleFile(options) {
+    const { entryPoint, outfile, format = 'iife', globalName = '__titan_exports', target = 'es2020' } = options;
+
+    await validateEntryPoint(entryPoint);
+
+    const outDir = path.dirname(outfile);
+    if (!fs.existsSync(outDir)) fs.mkdirSync(outDir, { recursive: true });
+
+    try {
+        const result = await esbuild.build({
+            entryPoints: [entryPoint],
+            bundle: true,
+            outfile,
+            format,
+            globalName,
+            platform: 'node',
+            target,
+            logLevel: 'silent',
+            plugins: [titanNodeCompatPlugin],
+            banner: { js: "var Titan = t;" },
+            footer: options.footer || {}
+        });
+
+        if (result.errors?.length) {
+            throw new BundleError(`Build failed`, result.errors);
+        }
+    } catch (err) {
+        if (err.errors) throw new BundleError(`Build failed`, err.errors);
+        throw err;
+    }
+}
+
+/**
+ * Main TS Bundler
+ */
+export async function bundle(options = {}) {
+    const root = options.root || process.cwd();
+    const outDir = options.outDir || path.join(root, 'dist');
+    const titanVersion = getTitanVersion();
+
+    // 1. Mandatory Type Check for TS apps
+    try {
+        await checkTypes(root);
+    } catch (error) {
+        console.error();
+        if (error.isBundleError && error.errors?.length) {
+            for (let i = 0; i < error.errors.length; i++) {
+                const errorInfo = error.errors[i];
+                errorInfo.titanVersion = titanVersion;
+                console.error(renderErrorBox(errorInfo));
+                console.error();
+            }
+        } else {
+            console.error(renderErrorBox({ title: 'TypeScript Error', message: error.message, titanVersion }));
+        }
+        throw new Error('__TITAN_BUNDLE_FAILED__');
+    }
+
+    // 2. Bundle Actions
+    const actionsDir = path.join(root, 'app', 'actions');
+    const bundleDir = path.join(outDir, 'actions');
+
+    if (fs.existsSync(bundleDir)) fs.rmSync(bundleDir, { recursive: true, force: true });
+    fs.mkdirSync(bundleDir, { recursive: true });
+
+    if (!fs.existsSync(actionsDir)) return;
+
+    const files = fs.readdirSync(actionsDir).filter(f => (f.endsWith('.ts') || f.endsWith('.js')) && !f.endsWith('.d.ts'));
+
+    for (const file of files) {
+        const actionName = path.basename(file, path.extname(file));
+        const entryPoint = path.join(actionsDir, file);
+        const outfile = path.join(bundleDir, actionName + ".jsbundle");
+
+        try {
+            await bundleFile({
+                entryPoint,
+                outfile,
+                footer: {
+                    js: `
+(function () {
+  const fn = __titan_exports["${actionName}"] || __titan_exports.default;
+  if (typeof fn !== "function") throw new Error("[TitanPL] Action '${actionName}' not found or not a function");
+  globalThis["${actionName}"] = globalThis.defineAction(fn);
+})();`
+                }
+            });
+        } catch (error) {
+            console.error();
+            if (error.isBundleError && error.errors?.length) {
+                for (const err of error.errors) {
+                    const errorInfo = parseEsbuildError(err);
+                    errorInfo.titanVersion = titanVersion;
+                    console.error(renderErrorBox(errorInfo));
+                    console.error();
+                }
+            } else {
+                console.error(renderErrorBox({ title: 'Build Error', message: error.message, titanVersion }));
+            }
+            throw new Error('__TITAN_BUNDLE_FAILED__');
+        }
+    }
+}