@orion-js/core 4.3.3 → 4.4.1

package/dist/index.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 // src/index.ts
-import chalk15 from "chalk";
+import chalk14 from "chalk";
 import { Command } from "commander";
 
 // src/helpers/execute.ts
@@ -34,7 +34,7 @@ async function create_default({ name, kit }) {
 }
 
 // src/dev/index.ts
-import chalk5 from "chalk";
+import chalk4 from "chalk";
 
 // src/dev/runner/index.ts
 import chalk2 from "chalk";
@@ -46,10 +46,10 @@ import fs2 from "fs";
 import fs from "fs";
 import path from "path";
 var ensureDirectory = (filePath) => {
-  const dirname2 = path.dirname(filePath);
-  if (fs.existsSync(dirname2)) return true;
-  ensureDirectory(dirname2);
-  fs.mkdirSync(dirname2);
+  const dirname3 = path.dirname(filePath);
+  if (fs.existsSync(dirname3)) return true;
+  ensureDirectory(dirname3);
+  fs.mkdirSync(dirname3);
 };
 var ensureDirectory_default = ensureDirectory;
 
@@ -63,15 +63,18 @@ async function writeFile_default(path3, content) {
 import { spawn } from "child_process";
 import chalk from "chalk";
 
+// src/dev/devBuildPath.ts
+var devBuildPath = "./.orion/build/index.js";
+
 // src/dev/runner/getArgs.ts
 function getArgs(options, command) {
   if (options.node) {
-    const startCommand2 = "tsx";
-    const args2 = ["watch", "--clear-screen=false", ...command.args, "./app/index.ts"];
+    const startCommand2 = "node";
+    const args2 = ["--enable-source-maps", ...command.args, devBuildPath];
     return { startCommand: startCommand2, args: args2 };
   }
   const startCommand = "bun";
-  const args = ["--watch", ...command.args, "./app/index.ts"];
+  const args = ["--watch", ...command.args, devBuildPath];
   return { startCommand, args };
 }
 
@@ -99,14 +102,16 @@ function getRunner(options, command) {
     console.log(chalk2.bold("=> Cleaning directory...\n"));
   }
   const startApp = () => {
-    appProcess = startProcess(options, command);
-    appProcess.on("exit", (code, signal) => {
+    const startedProcess = startProcess(options, command);
+    appProcess = startedProcess;
+    startedProcess.on("exit", (code, signal) => {
+      if (appProcess === startedProcess) appProcess = null;
       if (!code || code === 143 || code === 0 || signal === "SIGTERM" || signal === "SIGINT") {
       } else {
         console.log(chalk2.bold(`=> Error running app. Exit code: ${code}`));
       }
     });
-    writeFile_default(".orion/process", `${appProcess.pid}`);
+    writeFile_default(".orion/process", `${startedProcess.pid}`);
   };
   const stop = () => {
     if (appProcess) {
@@ -132,9 +137,6 @@ function getRunner(options, command) {
   };
 }
 
-// src/dev/watchAndCompile/index.ts
-import ts4 from "typescript";
-
 // src/dev/watchAndCompile/cleanDirectory.ts
 import fs3 from "fs";
 import path2 from "path";
@@ -159,11 +161,120 @@ async function cleanDirectory(directory) {
   }
 }
 
-// src/dev/watchAndCompile/getHost.ts
-import ts3 from "typescript";
+// src/dev/watchAndCompile/watchAndBundle.ts
+import { readFileSync } from "fs";
+import { createRequire } from "module";
+import { extname, join } from "path";
+import chokidar from "chokidar";
+import * as esbuild from "esbuild";
+function getPackageName(specifier) {
+  const segments = specifier.split("/");
+  return specifier.startsWith("@") ? segments.slice(0, 2).join("/") : segments[0];
+}
+function nodeExternalCompatibilityPlugin() {
+  const requireFromApp = createRequire(join(process.cwd(), "package.json"));
+  return {
+    name: "orion-node-external-compatibility",
+    setup(build3) {
+      build3.onResolve({ filter: /^[^./].*\.json$/ }, (args) => {
+        try {
+          return { path: requireFromApp.resolve(args.path) };
+        } catch {
+          return void 0;
+        }
+      });
+      build3.onResolve({ filter: /^[^./]/ }, (args) => {
+        const packageName = getPackageName(args.path);
+        if (args.path === packageName || extname(args.path)) return void 0;
+        try {
+          const packageJsonPath = requireFromApp.resolve(`${packageName}/package.json`);
+          const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf8"));
+          if (packageJson.exports) return void 0;
+          const resolvedExtension = extname(requireFromApp.resolve(args.path));
+          if (!resolvedExtension) return void 0;
+          return { path: `${args.path}${resolvedExtension}`, external: true };
+        } catch {
+          return void 0;
+        }
+      });
+    }
+  };
+}
+async function watchAndBundle(runner, options, onFilesChanged) {
+  let hasSuccessfulBuild = false;
+  let buildStartedAt = Date.now();
+  let rebuildInProgress = false;
+  let rebuildRequested = false;
+  let rebuildTimer;
+  const context2 = await esbuild.context({
+    entryPoints: ["./app/index.ts"],
+    outfile: devBuildPath,
+    tsconfig: "./tsconfig.json",
+    format: "esm",
+    platform: "node",
+    bundle: true,
+    target: "node22",
+    sourcemap: true,
+    packages: "external",
+    plugins: [
+      nodeExternalCompatibilityPlugin(),
+      {
+        name: "orion-dev-restart",
+        setup(build3) {
+          build3.onStart(() => {
+            buildStartedAt = Date.now();
+          });
+          build3.onEnd((result) => {
+            if (result.errors.length > 0) {
+              runner.stop();
+              return;
+            }
+            console.log(`=> Application bundled in ${Date.now() - buildStartedAt}ms`);
+            if (hasSuccessfulBuild && options.node) {
+              runner.restart();
+            } else if (!hasSuccessfulBuild) {
+              hasSuccessfulBuild = true;
+              runner.start();
+            } else {
+              runner.start();
+            }
+          });
+        }
+      }
+    ]
+  });
+  const rebuild = async () => {
+    if (rebuildInProgress) {
+      rebuildRequested = true;
+      return;
+    }
+    rebuildInProgress = true;
+    do {
+      rebuildRequested = false;
+      try {
+        await context2.rebuild();
+      } catch {
+      }
+    } while (rebuildRequested);
+    rebuildInProgress = false;
+  };
+  await rebuild();
+  const watcher = chokidar.watch(["./app", "./tsconfig.json"], { ignoreInitial: true });
+  watcher.on("all", () => {
+    onFilesChanged == null ? void 0 : onFilesChanged();
+    clearTimeout(rebuildTimer);
+    rebuildTimer = setTimeout(rebuild, 20);
+  });
+  watcher.on("error", (error) => console.error(`Unable to watch application files: ${error.message}`));
+  return { context: context2, watcher };
+}
+
+// src/dev/watchAndCompile/watchAndTypecheck.ts
+import { spawn as spawn2 } from "child_process";
 
 // src/dev/watchAndCompile/getConfigPath.ts
-import ts from "typescript";
+import { existsSync } from "fs";
+import { dirname, join as join2 } from "path";
 
 // src/dev/watchAndCompile/ensureConfigComplies.ts
 import { parse, stringify } from "comment-json";
@@ -181,11 +292,15 @@ function ensureConfigComplies(configPath) {
   try {
     const configJSON = readFile(configPath);
     const config = parse(configJSON);
+    const { baseUrl: _baseUrl, ...compilerOptions } = config.compilerOptions ?? {};
     const newConfig = {
       ...config,
       compilerOptions: {
-        ...config.compilerOptions,
-        baseUrl: "./",
+        ...compilerOptions,
+        paths: {
+          "*": ["./*"],
+          ...compilerOptions.paths
+        },
         noEmit: true
       }
     };
@@ -202,9 +317,19 @@ function ensureConfigComplies(configPath) {
 }
 
 // src/dev/watchAndCompile/getConfigPath.ts
+function findConfigFile(startDirectory, fileName) {
+  let directory = startDirectory;
+  while (true) {
+    const candidate = join2(directory, fileName);
+    if (existsSync(candidate)) return candidate;
+    const parent = dirname(directory);
+    if (parent === directory) return void 0;
+    directory = parent;
+  }
+}
 function getConfigPath() {
   const appBasePath = process.cwd();
-  const configPath = ts.findConfigFile(appBasePath, ts.sys.fileExists, "tsconfig.server.json") || ts.findConfigFile(appBasePath, ts.sys.fileExists, "tsconfig.json");
+  const configPath = findConfigFile(appBasePath, "tsconfig.server.json") || findConfigFile(appBasePath, "tsconfig.json");
   if (!configPath) {
     throw new Error("Could not find a valid 'tsconfig.json'.");
   }
@@ -212,106 +337,106 @@ function getConfigPath() {
   return configPath;
 }
 
-// src/dev/watchAndCompile/reports.ts
-import ts2 from "typescript";
-var format = {
-  getCanonicalFileName: (fileName) => fileName,
-  getCurrentDirectory: () => process.cwd(),
-  getNewLine: () => ts2.sys.newLine
-};
-function reportDiagnostic(diagnostic) {
-  console.log(ts2.formatDiagnosticsWithColorAndContext([diagnostic], format));
-}
-
-// src/dev/watchAndCompile/getHost.ts
-import chalk3 from "chalk";
-function getHost(runner) {
-  let isStopped = true;
-  const reportWatchStatusChanged = (diagnostic) => {
-    if (diagnostic.category !== 3) return;
-    if (diagnostic.code === 6031 || diagnostic.code === 6032) {
-      return;
-    }
-    if (diagnostic.code === 6193) {
-      runner.stop();
-      isStopped = true;
+// src/dev/watchAndCompile/watchAndTypecheck.ts
+function watchAndTypecheck(runner) {
+  const configPath = getConfigPath();
+  let checkInProgress = false;
+  let checkRequested = false;
+  const runCheck = () => {
+    if (checkInProgress) {
+      checkRequested = true;
       return;
     }
-    if (diagnostic.code === 6194) {
-      if (/^Found .+ errors?/.test(diagnostic.messageText.toString())) {
-        if (!diagnostic.messageText.toString().includes("Found 0 errors.")) {
-          runner.stop();
-          isStopped = true;
-          return;
-        }
+    checkInProgress = true;
+    const startedAt = Date.now();
+    const checker = spawn2("tsc", ["--noEmit", "--project", configPath], {
+      env: process.env,
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    let output = "";
+    let spawnError;
+    checker.stdout.on("data", (chunk) => {
+      output += chunk.toString();
+    });
+    checker.stderr.on("data", (chunk) => {
+      output += chunk.toString();
+    });
+    checker.on("error", (error) => {
+      spawnError = error;
+    });
+    checker.on("close", (code) => {
+      checkInProgress = false;
+      if (checkRequested) {
+        checkRequested = false;
+        runCheck();
+        return;
       }
-      if (isStopped) {
-        isStopped = false;
+      if (spawnError) {
+        runner.stop();
+        console.error(`Unable to run TypeScript: ${spawnError.message}`);
+        return;
+      }
+      const duration = Date.now() - startedAt;
+      if (code === 0) {
+        console.log(`=> TypeScript checked in ${duration}ms`);
         runner.start();
+        return;
       }
-      return;
-    }
-    console.log(chalk3.bold(`=> ${diagnostic.messageText} [${diagnostic.code}]`));
+      if (output.trim()) console.error(output.trimEnd());
+      console.error(`=> TypeScript found errors in ${duration}ms`);
+      runner.stop();
+    });
   };
-  const configPath = getConfigPath();
-  const createProgram = ts3.createEmitAndSemanticDiagnosticsBuilderProgram;
-  const host = ts3.createWatchCompilerHost(
-    configPath,
-    {},
-    ts3.sys,
-    createProgram,
-    reportDiagnostic,
-    reportWatchStatusChanged
-  );
-  return host;
+  return runCheck;
 }
 
 // src/dev/watchAndCompile/writeEnvFile.ts
 import { writeDtsFileFromConfigFile } from "@orion-js/env";
-import chalk4 from "chalk";
-import chokidar from "chokidar";
+import chalk3 from "chalk";
+import chokidar2 from "chokidar";
 var envFilePath = process.env.ORION_ENV_FILE_PATH;
 var dtsFilePath = "./app/env.d.ts";
 var watchEnvFile = async (runner) => {
   if (!envFilePath) return;
   writeDtsFileFromConfigFile(envFilePath, dtsFilePath);
-  chokidar.watch(envFilePath, { ignoreInitial: true }).on("change", async () => {
-    console.log(chalk4.bold("=> Environment file changed. Restarting..."));
+  chokidar2.watch(envFilePath, { ignoreInitial: true }).on("change", async () => {
+    console.log(chalk3.bold("=> Environment file changed. Restarting..."));
     writeDtsFileFromConfigFile(envFilePath, dtsFilePath);
     runner.restart();
   });
 };
 
 // src/dev/watchAndCompile/index.ts
-async function watchAndCompile(runner) {
+async function watchAndCompile(runner, options) {
   await cleanDirectory();
-  const host = getHost(runner);
-  ts4.createWatchProgram(host);
+  const requestTypecheck = options.typecheck ? watchAndTypecheck(runner) : void 0;
+  await watchAndBundle(runner, options, requestTypecheck);
+  requestTypecheck == null ? void 0 : requestTypecheck();
   watchEnvFile(runner);
 }
 
 // src/dev/index.ts
 async function dev_default(options, command) {
-  console.log(chalk5.bold(`
-Orionjs App ${chalk5.green(chalk5.bold("V4"))} Dev mode 
+  console.log(chalk4.bold(`
+Orionjs App ${chalk4.green(chalk4.bold("V4"))} Dev mode 
 `));
   const runner = getRunner(options, command);
-  watchAndCompile(runner);
+  await watchAndCompile(runner, options);
 }
 
 // src/prod/index.ts
-import chalk9 from "chalk";
+import chalk8 from "chalk";
 
 // src/build/index.ts
-import chalk8 from "chalk";
+import chalk7 from "chalk";
 
 // src/build/build.ts
-import chalk6 from "chalk";
-import * as esbuild from "esbuild";
+import chalk5 from "chalk";
+import * as esbuild2 from "esbuild";
 async function build2(options) {
   const { output } = options;
   console.log(`Building with esbuild to ${output}`);
-  await esbuild.build({
+  await esbuild2.build({
     entryPoints: ["./app/index.ts"],
     tsconfig: "./tsconfig.json",
     format: "esm",
@@ -324,11 +449,11 @@ async function build2(options) {
     minify: true,
     packages: "external"
   });
-  console.log(chalk6.green.bold("Build successful"));
+  console.log(chalk5.green.bold("Build successful"));
 }
 
 // src/build/checkTs.ts
-import chalk7 from "chalk";
+import chalk6 from "chalk";
 import { exec as exec2 } from "child_process";
 import { promisify } from "util";
 var execPromise = promisify(exec2);
@@ -343,9 +468,9 @@ async function checkTs() {
       gid: process.getgid(),
       uid: process.getuid()
     });
-    console.log(chalk7.green.bold("TypeScript check passed"));
+    console.log(chalk6.green.bold("TypeScript check passed"));
   } catch (error) {
-    console.log(chalk7.red.bold("TypeScript compilation failed"));
+    console.log(chalk6.red.bold("TypeScript compilation failed"));
     console.log(error.stderr || error.stdout || error.message);
     process.exit(1);
   }
@@ -353,23 +478,23 @@ async function checkTs() {
 
 // src/build/index.ts
 async function build_default(options) {
-  console.log(chalk8.bold(`Building Orionjs App ${chalk8.green(chalk8.bold("V4"))}...`));
+  console.log(chalk7.bold(`Building Orionjs App ${chalk7.green(chalk7.bold("V4"))}...`));
   if (!options.output) {
     options.output = "./build";
   }
   await cleanDirectory(options.output);
   await checkTs();
   await build2(options);
-  console.log(chalk8.bold("Build completed"));
+  console.log(chalk7.bold("Build completed"));
 }
 
 // src/prod/runProd.ts
-import { spawn as spawn2 } from "child_process";
+import { spawn as spawn3 } from "child_process";
 function runProd(options, command) {
   if (options.node) {
     const indexPath = `${options.path}/index.js`;
     const args2 = ["--import=tsx", ...command.args, indexPath];
-    spawn2("node", args2, {
+    spawn3("node", args2, {
       env: {
         NODE_ENV: "production",
         ...process.env
@@ -383,7 +508,7 @@ function runProd(options, command) {
     return;
   }
   const args = [...command.args, "./app/index.ts"];
-  spawn2("bun", args, {
+  spawn3("bun", args, {
     env: {
       NODE_ENV: "production",
       ...process.env
@@ -398,8 +523,8 @@ function runProd(options, command) {
 
 // src/prod/index.ts
 async function prod_default(options, command) {
-  console.log(chalk9.bold(`
-Orionjs App ${chalk9.green(chalk9.bold("V4"))} Prod mode
+  console.log(chalk8.bold(`
+Orionjs App ${chalk8.green(chalk8.bold("V4"))} Prod mode
 `));
   if (options.node) {
     if (!options.path) {
@@ -411,28 +536,28 @@ Orionjs App ${chalk9.green(chalk9.bold("V4"))} Prod mode
 }
 
 // src/handleErrors.ts
-import chalk10 from "chalk";
+import chalk9 from "chalk";
 process.on("unhandledRejection", (error) => {
   if (error.codeFrame) {
-    console.error(chalk10.red(error.message));
+    console.error(chalk9.red(error.message));
     console.log(error.codeFrame);
   } else {
-    console.error(chalk10.red(error.message), chalk10.red("Unhandled promise rejection"));
+    console.error(chalk9.red(error.message), chalk9.red("Unhandled promise rejection"));
   }
 }).on("uncaughtException", (error) => {
-  console.error(chalk10.red(error.message));
+  console.error(chalk9.red(error.message));
   process.exit(1);
 });
 
 // src/version.ts
-import { readFileSync } from "fs";
-import { dirname, resolve } from "path";
+import { readFileSync as readFileSync2 } from "fs";
+import { dirname as dirname2, resolve } from "path";
 import { fileURLToPath } from "url";
 function getVersion() {
   try {
-    const dir = dirname(fileURLToPath(import.meta.url));
+    const dir = dirname2(fileURLToPath(import.meta.url));
     const pkgPath = resolve(dir, "..", "package.json");
-    const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
+    const pkg = JSON.parse(readFileSync2(pkgPath, "utf-8"));
     return pkg.version;
   } catch {
     return "unknown";
@@ -444,10 +569,10 @@ var version_default = getVersion();
 import "dotenv/config";
 
 // src/check/index.ts
-import chalk12 from "chalk";
+import chalk11 from "chalk";
 
 // src/check/checkTs.ts
-import chalk11 from "chalk";
+import chalk10 from "chalk";
 import { execSync } from "child_process";
 function checkTs2() {
   try {
@@ -461,22 +586,22 @@ function checkTs2() {
       stdio: "inherit"
     });
   } catch {
-    console.log(chalk11.red.bold("TypeScript compilation failed"));
+    console.log(chalk10.red.bold("TypeScript compilation failed"));
     process.exit(1);
   }
 }
 
 // src/check/index.ts
 async function check_default() {
-  console.log(chalk12.bold(`Orionjs App ${chalk12.green(chalk12.bold("V4"))}
+  console.log(chalk11.bold(`Orionjs App ${chalk11.green(chalk11.bold("V4"))}
 `));
   console.log("Checking typescript...");
   checkTs2();
-  console.log(chalk12.bold.green("Check passed\n"));
+  console.log(chalk11.bold.green("Check passed\n"));
 }
 
 // src/info.ts
-import chalk13 from "chalk";
+import chalk12 from "chalk";
 import { execSync as execSync2 } from "child_process";
 function detectRuntime() {
   const runtimes = [];
@@ -489,21 +614,21 @@ function detectRuntime() {
   return runtimes.join(", ");
 }
 function info() {
-  console.log(`Orion CLI v${version_default} \u2014 Available runtimes: ${chalk13.bold(detectRuntime())}`);
-  console.log(`Default runtime: ${chalk13.bold("Bun")} (use --node flag to switch to Node.js)`);
+  console.log(`Orion CLI v${version_default} \u2014 Available runtimes: ${chalk12.bold(detectRuntime())}`);
+  console.log(`Default runtime: ${chalk12.bold("Bun")} (use --node flag to switch to Node.js)`);
 }
 
 // src/repl/index.ts
-import { readFileSync as readFileSync2 } from "fs";
+import { readFileSync as readFileSync3 } from "fs";
 import { resolve as resolve2 } from "path";
-import chalk14 from "chalk";
+import chalk13 from "chalk";
 function resolvePort(options) {
   if (options.port) {
     return Number(options.port);
   }
   try {
     const portFile = resolve2(process.cwd(), ".orion/port");
-    const port = readFileSync2(portFile, "utf-8").trim();
+    const port = readFileSync3(portFile, "utf-8").trim();
     return Number(port);
   } catch {
   }
@@ -516,7 +641,7 @@ async function repl(options) {
   var _a;
   const expression = options.expression;
   if (!expression) {
-    console.error(chalk14.red('Error: expression is required. Use -e "<expression>"'));
+    console.error(chalk13.red('Error: expression is required. Use -e "<expression>"'));
     process.exit(1);
   }
   const port = resolvePort(options);
@@ -528,9 +653,9 @@ async function repl(options) {
     });
     const data = await response.json();
     if (!data.success) {
-      console.error(chalk14.red(`Error: ${data.error}`));
+      console.error(chalk13.red(`Error: ${data.error}`));
       if (data.stack) {
-        console.error(chalk14.dim(data.stack));
+        console.error(chalk13.dim(data.stack));
       }
       process.exit(1);
     }
@@ -540,14 +665,15 @@ async function repl(options) {
       );
     }
   } catch (error) {
-    if (error.code === "ECONNREFUSED" || ((_a = error.cause) == null ? void 0 : _a.code) === "ECONNREFUSED") {
+    const nodeError = error;
+    if (nodeError.code === "ECONNREFUSED" || ((_a = nodeError.cause) == null ? void 0 : _a.code) === "ECONNREFUSED") {
       console.error(
-        chalk14.red(
+        chalk13.red(
           `Could not connect to dev server on port ${port}. Make sure "orion dev --repl" is running.`
         )
       );
     } else {
-      console.error(chalk14.red(`Error: ${error.message}`));
+      console.error(chalk13.red(`Error: ${nodeError.message}`));
     }
     process.exit(1);
   }
@@ -559,10 +685,10 @@ var run = (action) => async (...args) => {
   try {
     await action(...args);
   } catch (e) {
-    console.error(chalk15.red(`Error: ${e.message}`));
+    console.error(chalk14.red(`Error: ${e.message}`));
   }
 };
-program.command("dev").description("Run the Orionjs app in development mode").option("--node", "Use Node.js runtime instead of Bun").option("--repl", "Enable REPL endpoint for orion repl").allowUnknownOption().action(run(dev_default));
+program.command("dev").description("Run the Orionjs app in development mode").option("--node", "Use Node.js runtime instead of Bun").option("--repl", "Enable REPL endpoint for orion repl").option("--no-typecheck", "Disable continuous TypeScript diagnostics").allowUnknownOption().action(run(dev_default));
 program.command("check").description("Runs a typescript check").action(run(check_default));
 program.command("build").description("Build the Orionjs app for production").option("--output [path]", "Path of the output file").action(run(build_default));
 program.command("prod").allowUnknownOption().option("--node", "Use Node.js runtime instead of Bun").option(