@avleon/cli 0.0.47 → 0.4.0

package/dist/commands/route-list.js

@@ -0,0 +1,160 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.joinRoute = joinRoute;
+exports.runtimeRoutes = runtimeRoutes;
+exports.scanRoutes = scanRoutes;
+exports.staticRoutes = staticRoutes;
+exports.formatRoutes = formatRoutes;
+exports.routeList = routeList;
+const child_process_1 = require("child_process");
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const compiler_1 = require("../compiler");
+const errors_1 = require("../errors");
+const entry_1 = require("../utils/entry");
+const log_1 = require("../utils/log");
+const project_1 = require("../utils/project");
+function joinRoute(...parts) {
+    const joined = "/" + parts.join("/");
+    const normalized = joined.replace(/\/{2,}/g, "/");
+    return normalized.length > 1 ? normalized.replace(/\/$/, "") : normalized;
+}
+function controllerFiles(srcDir) {
+    if (!fs_1.default.existsSync(srcDir))
+        return [];
+    return fs_1.default
+        .readdirSync(srcDir, { withFileTypes: true, recursive: true })
+        .filter((e) => e.isFile() && e.name.endsWith(".controller.ts"))
+        .map((e) => path_1.default.join(e.parentPath ?? e.path, e.name))
+        .sort();
+}
+// ── Runtime: compile, require, read Avleon's route metadata ───────────────
+const MARKER = "__AVLEON_ROUTES__";
+/**
+ * Runs in a child process (so the app's import side effects cannot affect the
+ * CLI). Requires each compiled controller and reads the metadata written by
+ * `@ApiController` (symbol "icontroller:options") and `@Get`/`@Post`/...
+ * ("route:method", "route:path").
+ */
+const WORKER = `
+const files = JSON.parse(process.argv[process.argv.length - 1]);
+const out = [];
+const errors = [];
+for (const [src, compiled] of files) {
+  let mod;
+  try { mod = require(compiled); } catch (e) { errors.push(src + ": " + (e && e.message || e)); continue; }
+  if (typeof Reflect.getOwnMetadataKeys !== "function") {
+    errors.push("reflect-metadata is not loaded; is @avleon/core installed?");
+    break;
+  }
+  for (const value of Object.values(mod)) {
+    if (typeof value !== "function") continue;
+    const key = Reflect.getOwnMetadataKeys(value).find(
+      (k) => typeof k === "symbol" && k.description === "icontroller:options");
+    if (!key) continue;
+    const meta = Reflect.getOwnMetadata(key, value) || {};
+    const proto = value.prototype;
+    for (const name of Object.getOwnPropertyNames(proto)) {
+      if (name === "constructor") continue;
+      const method = Reflect.getMetadata("route:method", proto, name);
+      if (!method) continue;
+      out.push({ controllerPath: meta.path || "/", method, path: Reflect.getMetadata("route:path", proto, name) || "/",
+        controller: value.name, handler: name, file: src });
+    }
+  }
+}
+console.log(${JSON.stringify(MARKER)} + JSON.stringify({ routes: out, errors }));
+process.exit(0);
+`;
+function runtimeRoutes(root) {
+    const layout = (0, entry_1.projectLayout)(root);
+    const cacheDir = path_1.default.join(root, "node_modules", ".cache", "avleon", "route-list");
+    fs_1.default.rmSync(cacheDir, { recursive: true, force: true });
+    const compiler = new compiler_1.SwcCompiler(layout.srcDir, cacheDir, layout.compilerOptions);
+    const failures = compiler.compileAll();
+    if (failures.size) {
+        const list = [...failures].map(([f, e]) => `${path_1.default.relative(root, f)}: ${e.split("\n")[0]}`).join("\n  ");
+        throw new errors_1.CliError(`Compilation failed:\n  ${list}`);
+    }
+    const files = controllerFiles(layout.srcDir).map((f) => [path_1.default.relative(root, f), compiler.outFileFor(f)]);
+    if (!files.length)
+        return [];
+    const result = (0, child_process_1.spawnSync)(process.execPath, ["-e", WORKER, JSON.stringify(files)], {
+        cwd: root,
+        encoding: "utf8",
+        env: { ...process.env, NODE_ENV: process.env.NODE_ENV ?? "development" },
+        maxBuffer: 64 * 1024 * 1024,
+    });
+    const line = (result.stdout ?? "").split(/\r?\n/).find((l) => l.startsWith(MARKER));
+    if (!line) {
+        throw new errors_1.CliError(`Could not load controllers:\n${result.stderr || result.stdout || result.error?.message}`);
+    }
+    const { routes, errors } = JSON.parse(line.slice(MARKER.length));
+    if (errors.length) {
+        throw new errors_1.CliError(`Could not load controllers:\n  ${errors.join("\n  ")}\nTry --static to scan the source instead.`);
+    }
+    return routes.map((r) => ({
+        method: String(r.method).toUpperCase(),
+        path: joinRoute(r.controllerPath, r.path),
+        controller: r.controller,
+        handler: r.handler,
+        file: r.file.split(path_1.default.sep).join("/"),
+    }));
+}
+// ── Static: scan decorators in the source ─────────────────────────────────
+const STRING = /^\s*(['"`])((?:(?!\1).)*)\1/;
+function decoratorPath(args) {
+    if (!args)
+        return "/";
+    const literal = args.match(STRING);
+    if (literal)
+        return literal[2] || "/";
+    const objPath = args.match(/path\s*:\s*(['"`])((?:(?!\1).)*)\1/);
+    return objPath ? objPath[2] : "/";
+}
+/** Scan `@ApiController` classes and their `@Get`/`@Post`/... methods without running any code. */
+function scanRoutes(source, file) {
+    const routes = [];
+    const ctrlRe = /@ApiController\b(?:\s*\(([^)]*)\))?[\s\S]*?\bclass\s+([A-Za-z_$][\w$]*)/g;
+    const ctrls = [...source.matchAll(ctrlRe)];
+    ctrls.forEach((m, i) => {
+        const start = m.index + m[0].length;
+        const end = i + 1 < ctrls.length ? ctrls[i + 1].index : source.length;
+        const body = source.slice(start, end);
+        const base = decoratorPath(m[1]);
+        const methodRe = /@(Get|Post|Put|Patch|Delete|Options|All)\s*\(([^)]*)\)[\s\S]*?(?<![@\w$])([A-Za-z_$][\w$]*)\s*\(/g;
+        for (const r of body.matchAll(methodRe)) {
+            routes.push({
+                method: r[1].toUpperCase(),
+                path: joinRoute(base, decoratorPath(r[2])),
+                controller: m[2],
+                handler: r[3],
+                file,
+            });
+        }
+    });
+    return routes;
+}
+function staticRoutes(root) {
+    const layout = (0, entry_1.projectLayout)(root);
+    return controllerFiles(layout.srcDir).flatMap((f) => scanRoutes(fs_1.default.readFileSync(f, "utf8"), path_1.default.relative(root, f).split(path_1.default.sep).join("/")));
+}
+// ── Command ───────────────────────────────────────────────────────────────
+function formatRoutes(routes) {
+    if (!routes.length)
+        return "No routes found.";
+    const rows = routes.map((r) => [r.method, r.path, `${r.controller}.${r.handler}`]);
+    const head = ["METHOD", "PATH", "HANDLER"];
+    const widths = head.map((h, i) => Math.max(h.length, ...rows.map((row) => row[i].length)));
+    const fmt = (row) => row.map((cell, i) => cell.padEnd(widths[i])).join("  ").trimEnd();
+    return [log_1.c.bold(fmt(head)), ...rows.map(fmt)].join("\n");
+}
+function routeList(opts = {}) {
+    const root = (0, project_1.requireProjectRoot)(opts.cwd ?? process.cwd());
+    const routes = (opts.static ? staticRoutes(root) : runtimeRoutes(root)).sort((a, b) => a.path.localeCompare(b.path) || a.method.localeCompare(b.method));
+    console.log(opts.json ? JSON.stringify(routes, null, 2) : formatRoutes(routes));
+    return routes;
+}

package/dist/commands/serve.d.ts

@@ -0,0 +1,17 @@
+export type ServeOptions = {
+    cwd?: string;
+    /** Entry file (relative to the project root), overriding package.json. */
+    entry?: string;
+    /** Run `tsc --noEmit --watch` alongside the server. Default true. */
+    typeCheck?: boolean;
+    /** Milliseconds to wait for more file events before rebuilding. Default 200. */
+    debounce?: number;
+};
+/**
+ * Development server: transpiles `src/` with SWC into the output dir, copies
+ * assets, runs the entry file, and restarts it on changes to sources, assets
+ * or `.env*` files. Type errors are reported by a parallel `tsc --watch` and
+ * never block a reload; syntax errors do, and stop the running app so stale
+ * JS never keeps serving.
+ */
+export declare function serve(opts?: ServeOptions): Promise<void>;

package/dist/commands/serve.js

@@ -0,0 +1,238 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.serve = serve;
+const child_process_1 = require("child_process");
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const compiler_1 = require("../compiler");
+const errors_1 = require("../errors");
+const entry_1 = require("../utils/entry");
+const log_1 = require("../utils/log");
+const process_1 = require("../utils/process");
+const project_1 = require("../utils/project");
+const logServe = (0, log_1.tagged)("SERVE", log_1.c.cyan);
+const logApp = (0, log_1.tagged)("AVLEON", log_1.c.green);
+const logWatch = (0, log_1.tagged)("WATCH", log_1.c.yellow);
+const logErr = (category) => (0, log_1.tagged)(category, log_1.c.red);
+/**
+ * Development server: transpiles `src/` with SWC into the output dir, copies
+ * assets, runs the entry file, and restarts it on changes to sources, assets
+ * or `.env*` files. Type errors are reported by a parallel `tsc --watch` and
+ * never block a reload; syntax errors do, and stop the running app so stale
+ * JS never keeps serving.
+ */
+async function serve(opts = {}) {
+    const root = (0, project_1.requireProjectRoot)(opts.cwd ?? process.cwd());
+    const layout = (0, entry_1.projectLayout)(root);
+    const pkg = (0, project_1.readPackageJson)(root);
+    if (!fs_1.default.existsSync(layout.srcDir))
+        throw new errors_1.CliError(`Source directory ${layout.srcDir} does not exist.`);
+    const compiler = new compiler_1.SwcCompiler(layout.srcDir, layout.outDir, layout.compilerOptions);
+    const candidates = (0, entry_1.entryCandidates)(layout, pkg, opts.entry);
+    const debounceMs = opts.debounce ?? 200;
+    const failures = new Map();
+    let app = null;
+    let stopping = false;
+    let typeChecker = null;
+    const watchers = [];
+    console.log(log_1.c.bold(log_1.c.cyan("Avleon development server")));
+    logServe(`Project: ${root}`);
+    // ── Initial build ───────────────────────────────────────────────────────
+    const started = Date.now();
+    for (const [file, error] of compiler.compileAll())
+        failures.set(file, error);
+    (0, project_1.copyAssets)(layout.srcDir, layout.outDir);
+    logServe(`Compiled in ${Date.now() - started}ms`);
+    // ── App process ─────────────────────────────────────────────────────────
+    async function stopApp() {
+        if (!app)
+            return;
+        const child = app;
+        app = null;
+        stopping = true;
+        await (0, process_1.killTree)(child);
+        stopping = false;
+    }
+    function startApp() {
+        const entry = (0, entry_1.resolveEntry)(candidates, opts.entry);
+        if (!entry) {
+            logErr("AVLEON")(`No entry file found. Tried:\n  ${candidates.map((p) => path_1.default.relative(root, p)).join("\n  ")}\n` +
+                `Set "avleon": { "entry": "dist/serve.js" } or "main" in package.json, or pass --entry.`);
+            return;
+        }
+        logApp(`Starting ${path_1.default.relative(root, entry)}`);
+        const child = (0, child_process_1.spawn)(process.execPath, ["--enable-source-maps", entry], {
+            cwd: root,
+            stdio: "inherit",
+            env: { ...process.env, NODE_ENV: process.env.NODE_ENV ?? "development" },
+            ...process_1.treeSpawnOptions,
+        });
+        app = child;
+        child.on("exit", (code, signal) => {
+            if (app === child)
+                app = null;
+            if (stopping)
+                return;
+            if (code)
+                logErr("AVLEON")(`Process exited with code ${code}. Waiting for changes...`);
+            else if (signal)
+                logApp(`Process terminated by ${signal}. Waiting for changes...`);
+        });
+        child.on("error", (err) => logErr("AVLEON")(`Failed to start: ${err.message}`));
+    }
+    function reportFailures() {
+        for (const [file, error] of failures) {
+            logErr("COMPILE")(`${path_1.default.relative(root, file)}\n${error}`);
+        }
+        logErr("COMPILE")(`${failures.size} file(s) failed to compile. The app is stopped until they are fixed.`);
+    }
+    // Serialize restarts so overlapping events never race.
+    let chain = Promise.resolve();
+    const enqueue = (task) => {
+        chain = chain.then(task).catch((err) => logErr("SERVE")(String(err?.stack ?? err)));
+        return chain;
+    };
+    async function reload() {
+        await stopApp();
+        if (failures.size)
+            return reportFailures();
+        startApp();
+    }
+    // ── Change handling (debounced) ─────────────────────────────────────────
+    const pending = new Map();
+    let timer = null;
+    function onEvent(event, file) {
+        pending.set(file, event);
+        if (timer)
+            clearTimeout(timer);
+        timer = setTimeout(() => {
+            timer = null;
+            const batch = new Map(pending);
+            pending.clear();
+            enqueue(() => applyBatch(batch));
+        }, debounceMs);
+    }
+    const outPath = (file) => path_1.default.join(layout.outDir, path_1.default.relative(layout.srcDir, file));
+    const inSrc = (file) => {
+        const rel = path_1.default.relative(layout.srcDir, file);
+        return !!rel && !rel.startsWith("..") && !path_1.default.isAbsolute(rel);
+    };
+    /**
+     * Mirror one file event into the output dir. Returns true when the app
+     * should restart; test files, `.d.ts` and dotfiles are ignored.
+     */
+    function applyChange(event, file) {
+        if (path_1.default.dirname(file) === root && path_1.default.basename(file).startsWith(".env"))
+            return true;
+        if (!inSrc(file))
+            return false;
+        if (event === "unlinkDir") {
+            fs_1.default.rmSync(outPath(file), { recursive: true, force: true });
+            for (const f of failures.keys())
+                if (f.startsWith(file + path_1.default.sep))
+                    failures.delete(f);
+            return true;
+        }
+        if (event === "addDir")
+            return false;
+        if ((0, compiler_1.isTsSource)(file)) {
+            if ((0, compiler_1.isTestFile)(file))
+                return false;
+            if (event === "unlink") {
+                fs_1.default.rmSync(compiler.outFileFor(file), { force: true });
+                failures.delete(file);
+                return true;
+            }
+            const result = compiler.compileFile(file);
+            if (result.ok)
+                failures.delete(file);
+            else
+                failures.set(file, result.error);
+            return true;
+        }
+        if (!(0, project_1.isAsset)(file))
+            return false;
+        if (event === "unlink") {
+            fs_1.default.rmSync(outPath(file), { force: true });
+        }
+        else {
+            fs_1.default.mkdirSync(path_1.default.dirname(outPath(file)), { recursive: true });
+            fs_1.default.copyFileSync(file, outPath(file));
+        }
+        return true;
+    }
+    async function applyBatch(batch) {
+        let relevant = false;
+        for (const [file, event] of batch) {
+            if (applyChange(event, file)) {
+                relevant = true;
+                logWatch(`${event} ${path_1.default.relative(root, file)}`);
+            }
+        }
+        if (relevant)
+            await reload();
+    }
+    // ── Watchers ────────────────────────────────────────────────────────────
+    const chokidar = require("chokidar");
+    const srcWatcher = chokidar.watch(layout.srcDir, {
+        ignoreInitial: true,
+        awaitWriteFinish: { stabilityThreshold: 100, pollInterval: 50 },
+    });
+    const envWatcher = chokidar.watch(root, {
+        ignoreInitial: true,
+        depth: 0,
+        ignored: (p) => p !== root && !path_1.default.basename(p).startsWith(".env"),
+    });
+    for (const w of [srcWatcher, envWatcher]) {
+        w.on("all", (event, file) => onEvent(event, file));
+        w.on("error", (err) => logErr("WATCH")(String(err?.message ?? err)));
+        watchers.push(w);
+    }
+    // ── Type checking ───────────────────────────────────────────────────────
+    if (opts.typeCheck !== false) {
+        const tsc = (0, process_1.findTsc)(root);
+        if (!tsc || !layout.tsconfig) {
+            logServe(log_1.c.yellow("Type checking disabled: TypeScript or tsconfig.json not found in the project."));
+        }
+        else {
+            typeChecker = (0, child_process_1.spawn)(process.execPath, [tsc, "--noEmit", "--watch", "--preserveWatchOutput", "--pretty", "-p", layout.tsconfig], { cwd: root, stdio: ["ignore", "pipe", "pipe"], ...process_1.treeSpawnOptions });
+            const forward = (data) => {
+                for (const line of data.toString().split(/\r?\n/)) {
+                    // Skip tsc's per-cycle "Starting compilation" / "File change detected" chatter.
+                    if (!line.trim() || /Starting (incremental )?compilation|File change detected/.test(line))
+                        continue;
+                    console.log(`${log_1.c.dim("[TSC]")} ${/Found 0 errors/.test(line) ? log_1.c.green(line) : line}`);
+                }
+            };
+            typeChecker.stdout?.on("data", forward);
+            typeChecker.stderr?.on("data", forward);
+        }
+    }
+    // ── Shutdown ────────────────────────────────────────────────────────────
+    let shuttingDown = false;
+    const shutdown = async (signal) => {
+        if (shuttingDown)
+            return;
+        shuttingDown = true;
+        logServe(`Received ${signal}, shutting down...`);
+        if (timer)
+            clearTimeout(timer);
+        await Promise.allSettled(watchers.map((w) => w.close()));
+        await Promise.allSettled([stopApp(), (0, process_1.killTree)(typeChecker, 1000)]);
+        process.exit(0);
+    };
+    process.on("SIGINT", () => void shutdown("SIGINT"));
+    process.on("SIGTERM", () => void shutdown("SIGTERM"));
+    if (process.platform === "win32")
+        process.on("SIGBREAK", () => void shutdown("SIGBREAK"));
+    if (failures.size)
+        reportFailures();
+    else
+        startApp();
+    logWatch("Watching for changes. Press Ctrl+C to stop.");
+    // Keep the promise pending for the lifetime of the server.
+    await new Promise(() => { });
+}

package/dist/commands/start.d.ts

@@ -0,0 +1,10 @@
+export type StartOptions = {
+    cwd?: string;
+    entry?: string;
+};
+/**
+ * Run the compiled app from the output dir in production mode
+ * (`NODE_ENV=production` unless already set). Resolves to the app's exit code.
+ * SIGINT/SIGTERM are forwarded so the app can shut down gracefully.
+ */
+export declare function start(opts?: StartOptions): Promise<number>;

package/dist/commands/start.js

@@ -0,0 +1,43 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.start = start;
+const child_process_1 = require("child_process");
+const path_1 = __importDefault(require("path"));
+const errors_1 = require("../errors");
+const entry_1 = require("../utils/entry");
+const log_1 = require("../utils/log");
+const project_1 = require("../utils/project");
+/**
+ * Run the compiled app from the output dir in production mode
+ * (`NODE_ENV=production` unless already set). Resolves to the app's exit code.
+ * SIGINT/SIGTERM are forwarded so the app can shut down gracefully.
+ */
+async function start(opts = {}) {
+    const root = (0, project_1.requireProjectRoot)(opts.cwd ?? process.cwd());
+    const layout = (0, entry_1.projectLayout)(root, true);
+    const candidates = (0, entry_1.entryCandidates)(layout, (0, project_1.readPackageJson)(root), opts.entry);
+    const entry = (0, entry_1.resolveEntry)(candidates, opts.entry);
+    if (!entry) {
+        throw new errors_1.CliError(`No compiled entry file found (tried ${candidates.map((p) => path_1.default.relative(root, p)).join(", ")}). ` +
+            "Run `avleon build` first, or pass --entry.");
+    }
+    const env = { ...process.env, NODE_ENV: process.env.NODE_ENV ?? "production" };
+    log_1.log.info(`Starting ${path_1.default.relative(root, entry)} (NODE_ENV=${env.NODE_ENV})`);
+    return new Promise((resolve, reject) => {
+        const child = (0, child_process_1.spawn)(process.execPath, ["--enable-source-maps", entry], { cwd: root, env, stdio: "inherit" });
+        const forward = (signal) => () => child.kill(signal);
+        const onInt = forward("SIGINT");
+        const onTerm = forward("SIGTERM");
+        process.on("SIGINT", onInt);
+        process.on("SIGTERM", onTerm);
+        child.on("error", reject);
+        child.on("exit", (code, signal) => {
+            process.off("SIGINT", onInt);
+            process.off("SIGTERM", onTerm);
+            resolve(code ?? (signal === "SIGINT" || signal === "SIGTERM" ? 0 : 1));
+        });
+    });
+}

package/dist/compiler.d.ts

@@ -0,0 +1,24 @@
+export type CompileResult = {
+    ok: true;
+} | {
+    ok: false;
+    error: string;
+};
+export declare function isTestFile(file: string): boolean;
+export declare function isTsSource(file: string): boolean;
+/**
+ * Fast per-file TypeScript -> CommonJS transpiler (SWC). It does not type-check;
+ * `serve` runs `tsc --noEmit` alongside it for that. tsconfig `paths` are
+ * rewritten to relative imports at compile time, so no runtime hook is needed.
+ */
+export declare class SwcCompiler {
+    readonly srcDir: string;
+    readonly outDir: string;
+    private readonly options;
+    constructor(srcDir: string, outDir: string, compilerOptions?: Record<string, any>);
+    outFileFor(file: string): string;
+    compileFile(file: string): CompileResult;
+    /** All non-test `.ts` sources under `srcDir`. */
+    sources(): string[];
+    compileAll(): Map<string, string>;
+}

package/dist/compiler.js

@@ -0,0 +1,83 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SwcCompiler = void 0;
+exports.isTestFile = isTestFile;
+exports.isTsSource = isTsSource;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+function isTestFile(file) {
+    return /\.(test|spec)\.[cm]?[tj]s$/.test(path_1.default.basename(file));
+}
+function isTsSource(file) {
+    return /\.ts$/.test(file) && !/\.d\.ts$/.test(file);
+}
+/**
+ * Fast per-file TypeScript -> CommonJS transpiler (SWC). It does not type-check;
+ * `serve` runs `tsc --noEmit` alongside it for that. tsconfig `paths` are
+ * rewritten to relative imports at compile time, so no runtime hook is needed.
+ */
+class SwcCompiler {
+    srcDir;
+    outDir;
+    options;
+    constructor(srcDir, outDir, compilerOptions = {}) {
+        this.srcDir = srcDir;
+        this.outDir = outDir;
+        const baseUrl = compilerOptions.baseUrl ?? compilerOptions.pathsBasePath;
+        const paths = compilerOptions.paths;
+        this.options = {
+            swcrc: false,
+            configFile: false,
+            sourceMaps: "inline",
+            module: { type: "commonjs" },
+            jsc: {
+                parser: { syntax: "typescript", decorators: true },
+                target: "es2022",
+                keepClassNames: true,
+                transform: { legacyDecorator: true, decoratorMetadata: true },
+                ...(paths && baseUrl ? { baseUrl, paths } : {}),
+            },
+        };
+    }
+    outFileFor(file) {
+        return path_1.default.join(this.outDir, path_1.default.relative(this.srcDir, file)).replace(/\.ts$/, ".js");
+    }
+    compileFile(file) {
+        try {
+            // Loaded lazily: the native binding is only needed by serve and route:list.
+            const { transformFileSync } = require("@swc/core");
+            const result = transformFileSync(file, { ...this.options, filename: file });
+            const out = this.outFileFor(file);
+            fs_1.default.mkdirSync(path_1.default.dirname(out), { recursive: true });
+            fs_1.default.writeFileSync(out, result.code, "utf8");
+            return { ok: true };
+        }
+        catch (err) {
+            // Never leave stale JS behind for a file that no longer compiles.
+            fs_1.default.rmSync(this.outFileFor(file), { force: true });
+            return { ok: false, error: err instanceof Error ? err.message : String(err) };
+        }
+    }
+    /** All non-test `.ts` sources under `srcDir`. */
+    sources() {
+        if (!fs_1.default.existsSync(this.srcDir))
+            return [];
+        return fs_1.default
+            .readdirSync(this.srcDir, { withFileTypes: true, recursive: true })
+            .filter((e) => e.isFile() && isTsSource(e.name) && !isTestFile(e.name))
+            .map((e) => path_1.default.join(e.parentPath ?? e.path, e.name));
+    }
+    compileAll() {
+        const failures = new Map();
+        for (const file of this.sources()) {
+            const r = this.compileFile(file);
+            if (!r.ok)
+                failures.set(file, r.error);
+        }
+        return failures;
+    }
+}
+exports.SwcCompiler = SwcCompiler;

package/dist/errors.d.ts

@@ -0,0 +1,8 @@
+/**
+ * An expected failure: printed as a one-line message (no stack trace) and
+ * turned into a non-zero exit code by the bin entry.
+ */
+export declare class CliError extends Error {
+    readonly exitCode: number;
+    constructor(message: string, exitCode?: number);
+}

package/dist/errors.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CliError = void 0;
+/**
+ * An expected failure: printed as a one-line message (no stack trace) and
+ * turned into a non-zero exit code by the bin entry.
+ */
+class CliError extends Error {
+    exitCode;
+    constructor(message, exitCode = 1) {
+        super(message);
+        this.exitCode = exitCode;
+        this.name = "CliError";
+    }
+}
+exports.CliError = CliError;

package/dist/generators/make.d.ts

@@ -0,0 +1,24 @@
+export type MakeBaseOptions = {
+    /** Directory to start the project-root search from. Defaults to `process.cwd()`. */
+    cwd?: string;
+    force?: boolean;
+    /** Folder under `src/` to write to instead of the default one. */
+    root?: string;
+};
+export type MakeModelOptions = MakeBaseOptions & {
+    orm?: boolean;
+};
+export type MakeServiceOptions = MakeBaseOptions & {
+    resource?: boolean;
+    model?: string;
+    orm?: boolean;
+};
+export type MakeControllerOptions = MakeServiceOptions & {
+    basePath?: boolean;
+};
+export declare function makeModel(name: string, opts?: MakeModelOptions): string;
+export declare function makeService(name: string, opts?: MakeServiceOptions): string;
+export declare function makeController(name: string, opts?: MakeControllerOptions): string;
+export declare function makeConfig(name: string, opts?: MakeBaseOptions): string;
+export declare function makeMiddleware(name: string, opts?: MakeBaseOptions): string;
+export declare function makeDto(name: string, opts?: MakeBaseOptions): string;