zudojs-cli 1.1.1 → 1.2.1

package/dist/src/templates/shared/appRuntime.template.js

@@ -54,7 +54,7 @@ ${options.modules.map((m) => `    new ${m.className}(),`).join("\n")}
     const metadata = options.port === undefined
         ? ""
         : `\n      metadata: { port: ${options.port} },`;
-    return `import type { Environment } from "@zudojs/constants";
+    return `import { resolveEnvironment } from "@zudojs/constants";
 import { createContainer } from "@zudojs/container";
 import type { Module } from "@zudojs/core";
 import { createEventBus } from "@zudojs/events";
@@ -62,19 +62,6 @@ import { createLogger } from "@zudojs/logger";
 import { createRuntime, type Runtime } from "@zudojs/runtime";
 ${imports}
 
-const ENVIRONMENTS: readonly Environment[] = [
-  "development",
-  "test",
-  "staging",
-  "production",
-];
-
-/** Narrows NODE_ENV to a framework Environment without an unchecked cast. */
-function resolveEnvironment(): Environment {
-  const value = process.env["NODE_ENV"];
-  return ENVIRONMENTS.find((candidate) => candidate === value) ?? "development";
-}
-
 /**
  * Assembles the application runtime.
  *
@@ -93,6 +80,8 @@ ${registration}
     {
       applicationName: ${literal(options.applicationName)},
       applicationVersion: "0.1.0",
+      // NODE_ENV is read the same way the framework reads it: \`prod\` and
+      // \`Production\` are production, an unknown value warns once.
       environment: resolveEnvironment(),
       // Signals are handled explicitly in server.ts.
       handleSignals: false,${metadata}
@@ -105,32 +94,6 @@ ${registration}
 }
 `;
 }
-/**
- * Renders `src/server.ts`: the process entry point. Starts the runtime and
- * stops it cleanly on SIGINT/SIGTERM.
- */
-export function renderServerFile(appImportPath = "./app.js") {
-    return `import { createApp } from ${literal(appImportPath)};
-
-const runtime = createApp();
-
-await runtime.start();
-
-for (const signal of ["SIGINT", "SIGTERM"] as const) {
-  process.once(signal, () => {
-    void runtime
-      .stop()
-      .then(() => {
-        process.exit(0);
-      })
-      .catch((error: unknown) => {
-        console.error(error);
-        process.exit(1);
-      });
-  });
-}
-`;
-}
 /**
  * Renders a module class extending `BaseModule`.
  *

package/dist/src/templates/shared/dockerfile.template.d.ts

@@ -0,0 +1,28 @@
+/**
+ * zudojs-cli — Generated Dockerfiles.
+ *
+ * Shared by the microservice template and the InfrastructureGenerator so the
+ * fullstack microservice project and the standalone one build the same way.
+ */
+/** The dependency install command for a package manager inside a Dockerfile. */
+export declare function dockerInstallCommand(packageManager: string): string;
+/**
+ * A self-contained Dockerfile for one app of a microservice project. The
+ * build context is the project root; only `appPath` is copied in.
+ */
+export declare function renderAppPackageDockerfile(options: {
+    readonly appPath: string;
+    readonly port: number;
+    readonly packageManager: string;
+}): string;
+/**
+ * A Dockerfile for a workspace whose server lives in `appDirectory`. The whole
+ * workspace is installed, then only that app is built and started: the root
+ * `build` script writes `apps/*\/dist`, never a root `dist/`.
+ */
+export declare function renderWorkspaceAppDockerfile(options: {
+    readonly appDirectory: string;
+    readonly port: number;
+    readonly packageManager: string;
+}): string;
+//# sourceMappingURL=dockerfile.template.d.ts.map

package/dist/src/templates/shared/dockerfile.template.js

@@ -0,0 +1,69 @@
+/**
+ * zudojs-cli — Generated Dockerfiles.
+ *
+ * Shared by the microservice template and the InfrastructureGenerator so the
+ * fullstack microservice project and the standalone one build the same way.
+ */
+/** The dependency install command for a package manager inside a Dockerfile. */
+export function dockerInstallCommand(packageManager) {
+    // No lockfile is generated, so never `npm ci`; bare node images need
+    // corepack for pnpm/yarn; bun is not available there, so npm is used.
+    switch (packageManager) {
+        case "pnpm":
+            return "corepack enable && pnpm install";
+        case "yarn":
+            return "corepack enable && yarn install";
+        default:
+            return "npm install";
+    }
+}
+/**
+ * A self-contained Dockerfile for one app of a microservice project. The
+ * build context is the project root; only `appPath` is copied in.
+ */
+export function renderAppPackageDockerfile(options) {
+    const { appPath, port } = options;
+    return `FROM node:24-alpine AS builder
+WORKDIR /app
+COPY ${appPath}/package.json ./
+RUN ${dockerInstallCommand(options.packageManager)}
+COPY ${appPath}/tsconfig.json ./
+COPY ${appPath}/src ./src
+RUN npx tsc
+
+FROM node:24-alpine AS runtime
+WORKDIR /app
+COPY --from=builder /app/dist ./dist
+COPY --from=builder /app/node_modules ./node_modules
+COPY --from=builder /app/package.json ./
+EXPOSE ${port}
+CMD ["node", "dist/server.js"]
+`;
+}
+/**
+ * A Dockerfile for a workspace whose server lives in `appDirectory`. The whole
+ * workspace is installed, then only that app is built and started: the root
+ * `build` script writes `apps/*\/dist`, never a root `dist/`.
+ */
+export function renderWorkspaceAppDockerfile(options) {
+    const dir = options.appDirectory.replace(/^\.\/?/, "").replace(/\/$/, "");
+    const install = dockerInstallCommand(options.packageManager);
+    const runner = options.packageManager === "npm" || options.packageManager === "bun"
+        ? "npm"
+        : options.packageManager;
+    const build = dir === "" ? `${runner} run build` : `cd ${dir} && ${runner} run build`;
+    const dist = dir === "" ? "dist" : `${dir}/dist`;
+    return `FROM node:24-alpine AS builder
+WORKDIR /app
+COPY . .
+RUN ${install}
+RUN ${build}
+
+FROM node:24-alpine
+WORKDIR /app
+COPY --from=builder /app /app
+EXPOSE ${options.port}
+CMD ["node", "${dist}/server.js"]
+`;
+}
+//# sourceMappingURL=dockerfile.template.js.map

package/dist/src/templates/shared/index.d.ts

@@ -2,5 +2,7 @@
  * zudojs-cli — Shared Template Fragments
  */
 export * from "./appRuntime.template.js";
+export * from "./dockerfile.template.js";
 export * from "./pnpm.template.js";
+export * from "./server.template.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/src/templates/shared/index.js

@@ -2,5 +2,7 @@
  * zudojs-cli — Shared Template Fragments
  */
 export * from "./appRuntime.template.js";
+export * from "./dockerfile.template.js";
 export * from "./pnpm.template.js";
+export * from "./server.template.js";
 //# sourceMappingURL=index.js.map

package/dist/src/templates/shared/server.template.d.ts

@@ -0,0 +1,31 @@
+/**
+ * zudojs-cli — Generated `src/server.ts`
+ *
+ * The entry point used to call `runtime.start()` and nothing else. The
+ * runtime creates no HTTP server, so `pnpm dev` logged "ready" and exited
+ * with 0 even though `.env.example` set `PORT`, the Dockerfile exposed it
+ * and the fullstack frontend called it.
+ *
+ * The emitted server starts the runtime, then serves HTTP with
+ * `@zudojs/http` (`createHttpServer` + `createNodeHttpAdapter`) on `PORT`,
+ * answers `GET /health`, and keeps the process alive until SIGINT/SIGTERM,
+ * when it stops the HTTP server and then the runtime. `tests/
+ * generatedProject.typecheck.test.ts` type-checks this output against the
+ * current `@zudojs/*` sources.
+ */
+/** Options for {@link renderServerFile}. */
+export interface ServerFileOptions {
+    /** Port used when `PORT` is unset. Defaults to 3000. */
+    readonly defaultPort?: number;
+    /**
+     * Import path of a `HealthController` whose `check()` answers `/health`,
+     * relative to server.ts. When omitted, `/health` is answered inline.
+     */
+    readonly healthControllerImport?: string;
+}
+/**
+ * Renders `src/server.ts`: starts the runtime, serves HTTP on `PORT` with a
+ * `/health` route, and shuts both down cleanly on SIGINT/SIGTERM.
+ */
+export declare function renderServerFile(appImportPath?: string, options?: ServerFileOptions): string;
+//# sourceMappingURL=server.template.d.ts.map

package/dist/src/templates/shared/server.template.js

@@ -0,0 +1,96 @@
+/**
+ * zudojs-cli — Generated `src/server.ts`
+ *
+ * The entry point used to call `runtime.start()` and nothing else. The
+ * runtime creates no HTTP server, so `pnpm dev` logged "ready" and exited
+ * with 0 even though `.env.example` set `PORT`, the Dockerfile exposed it
+ * and the fullstack frontend called it.
+ *
+ * The emitted server starts the runtime, then serves HTTP with
+ * `@zudojs/http` (`createHttpServer` + `createNodeHttpAdapter`) on `PORT`,
+ * answers `GET /health`, and keeps the process alive until SIGINT/SIGTERM,
+ * when it stops the HTTP server and then the runtime. `tests/
+ * generatedProject.typecheck.test.ts` type-checks this output against the
+ * current `@zudojs/*` sources.
+ */
+/** Emits a string as a TypeScript string literal that cannot break out. */
+function literal(value) {
+    return JSON.stringify(value);
+}
+/**
+ * Renders `src/server.ts`: starts the runtime, serves HTTP on `PORT` with a
+ * `/health` route, and shuts both down cleanly on SIGINT/SIGTERM.
+ */
+export function renderServerFile(appImportPath = "./app.js", options = {}) {
+    const defaultPort = options.defaultPort ?? 3000;
+    const controller = options.healthControllerImport;
+    const controllerImport = controller
+        ? `import { HealthController } from ${literal(controller)};\n`
+        : "";
+    const healthBody = controller
+        ? "new HealthController().check()"
+        : `{ status: "ok", timestamp: new Date().toISOString() }`;
+    return `import {
+  createHttpServer,
+  createNodeHttpAdapter,
+  createResponseContext,
+  type HttpRequestContext,
+} from "@zudojs/http";
+
+import { createApp } from ${literal(appImportPath)};
+${controllerImport}
+const DEFAULT_PORT = ${defaultPort};
+
+/** Reads PORT, refusing values that are not a TCP port. */
+function resolvePort(): number {
+  const raw = process.env["PORT"];
+  if (raw === undefined || raw.trim() === "") return DEFAULT_PORT;
+  const port = Number(raw);
+  if (!Number.isInteger(port) || port < 0 || port > 65535) {
+    throw new Error(\`PORT must be an integer between 0 and 65535, got "\${raw}".\`);
+  }
+  return port;
+}
+
+const runtime = createApp();
+await runtime.start();
+
+const server = createHttpServer({
+  adapter: createNodeHttpAdapter({
+    host: process.env["HOST"] ?? "0.0.0.0",
+    port: resolvePort(),
+  }),
+  handler: (request: HttpRequestContext) => {
+    if (request.path === "/health") {
+      if (runtime.state !== "running") {
+        return createResponseContext({ status: 503 }).json({ status: "unavailable" });
+      }
+      return ${healthBody};
+    }
+    return createResponseContext({ status: 404 }).json({ error: "Not Found" });
+  },
+});
+
+await server.start();
+console.log(\`Listening on port \${server.address?.port ?? resolvePort()}\`);
+
+let stopping = false;
+for (const signal of ["SIGINT", "SIGTERM"] as const) {
+  process.once(signal, () => {
+    if (stopping) return;
+    stopping = true;
+    void server
+      .stop()
+      .then(() => runtime.stop())
+      .then(() => {
+        process.exit(0);
+      })
+      .catch((error: unknown) => {
+        console.error(error);
+        process.exit(1);
+      });
+  });
+}
+`;
+}
+//# sourceMappingURL=server.template.js.map

package/dist/src/utils/index.d.ts

@@ -7,4 +7,5 @@ export { writeFile, writeFileTree, mergeBarrelExport, } from "./utils.fileSystem
 export { normalizeName, toPascalCase, toCamelCase } from "./utils.name.js";
 export { detectArchitecture } from "./utils.detect.js";
 export { execCommand, runStreaming } from "./utils.exec.js";
+export { activeWriteCapture, captureWrites, findWriteConflicts, } from "./utils.writeGuard.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/src/utils/index.js

@@ -7,4 +7,5 @@ export { writeFile, writeFileTree, mergeBarrelExport, } from "./utils.fileSystem
 export { normalizeName, toPascalCase, toCamelCase } from "./utils.name.js";
 export { detectArchitecture } from "./utils.detect.js";
 export { execCommand, runStreaming } from "./utils.exec.js";
+export { activeWriteCapture, captureWrites, findWriteConflicts, } from "./utils.writeGuard.js";
 //# sourceMappingURL=index.js.map

package/dist/src/utils/utils.fileSystem.js

@@ -1,6 +1,7 @@
 import { existsSync, readFileSync } from "node:fs";
 import { mkdir, writeFile as writeFileAsync } from "node:fs/promises";
 import { dirname, join, relative } from "node:path";
+import { activeWriteCapture } from "./utils.writeGuard.js";
 function assertSafePath(basePath, filePath) {
     const resolved = join(basePath, filePath);
     const relativePath = relative(basePath, resolved);
@@ -11,6 +12,11 @@ function assertSafePath(basePath, filePath) {
 export async function writeFile(basePath, filePath, content) {
     assertSafePath(basePath, filePath);
     const fullPath = join(basePath, filePath);
+    const capture = activeWriteCapture();
+    if (capture) {
+        capture.set(fullPath, content);
+        return;
+    }
     await mkdir(dirname(fullPath), { recursive: true });
     await writeFileAsync(fullPath, content);
 }

package/dist/src/utils/utils.writeGuard.d.ts

@@ -0,0 +1,25 @@
+/**
+ * zudojs-cli — Refusing to overwrite user files.
+ *
+ * Every schematic wrote with an unconditional `writeFile`, so re-running
+ * `zudojs generate module billing` (or reusing a name by mistake) replaced
+ * hand-written `*.module.ts`, `*.service.ts` and handler files without a
+ * word. `zudojs generate` now runs the schematic once with its writes
+ * captured, checks the captured files against the disk, and only then
+ * writes. An existing file may only be left as it is or appended to (the
+ * barrel merge done by `mergeBarrelExport`); anything else is a conflict
+ * unless `--force` is passed.
+ */
+/** The capture map of the current `captureWrites` call, if any. */
+export declare function activeWriteCapture(): Map<string, string> | undefined;
+/**
+ * Runs `run` with every `writeFile`/`writeFileTree` recorded instead of
+ * written. Returns the absolute paths and contents that would be written.
+ */
+export declare function captureWrites(run: () => Promise<unknown>): Promise<ReadonlyMap<string, string>>;
+/**
+ * Lists captured files that already exist and would be changed other than
+ * by appending (paths relative to `cwd`).
+ */
+export declare function findWriteConflicts(cwd: string, files: ReadonlyMap<string, string>): string[];
+//# sourceMappingURL=utils.writeGuard.d.ts.map

package/dist/src/utils/utils.writeGuard.js

@@ -0,0 +1,46 @@
+/**
+ * zudojs-cli — Refusing to overwrite user files.
+ *
+ * Every schematic wrote with an unconditional `writeFile`, so re-running
+ * `zudojs generate module billing` (or reusing a name by mistake) replaced
+ * hand-written `*.module.ts`, `*.service.ts` and handler files without a
+ * word. `zudojs generate` now runs the schematic once with its writes
+ * captured, checks the captured files against the disk, and only then
+ * writes. An existing file may only be left as it is or appended to (the
+ * barrel merge done by `mergeBarrelExport`); anything else is a conflict
+ * unless `--force` is passed.
+ */
+import { AsyncLocalStorage } from "node:async_hooks";
+import { existsSync, readFileSync } from "node:fs";
+import { relative } from "node:path";
+const captured = new AsyncLocalStorage();
+/** The capture map of the current `captureWrites` call, if any. */
+export function activeWriteCapture() {
+    return captured.getStore();
+}
+/**
+ * Runs `run` with every `writeFile`/`writeFileTree` recorded instead of
+ * written. Returns the absolute paths and contents that would be written.
+ */
+export async function captureWrites(run) {
+    const files = new Map();
+    await captured.run(files, run);
+    return files;
+}
+/**
+ * Lists captured files that already exist and would be changed other than
+ * by appending (paths relative to `cwd`).
+ */
+export function findWriteConflicts(cwd, files) {
+    const conflicts = [];
+    for (const [path, content] of files) {
+        if (!existsSync(path))
+            continue;
+        const existing = readFileSync(path, "utf-8");
+        if (content === existing || content.startsWith(existing))
+            continue;
+        conflicts.push(relative(cwd, path));
+    }
+    return conflicts;
+}
+//# sourceMappingURL=utils.writeGuard.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zudojs-cli",
-  "version": "1.1.1",
+  "version": "1.2.1",
   "description": "Command-line interface for scaffolding, generating, and managing Zudojs framework projects.",
   "license": "MIT",
   "author": {
@@ -28,13 +28,14 @@
   ],
   "dependencies": {
     "@clack/prompts": "^1.7.0",
-    "@zudojs/config": "1.0.1",
-    "@zudojs/core": "1.1.0",
-    "@zudojs/errors": "1.0.1",
-    "@zudojs/logger": "1.1.0"
+    "@zudojs/config": "1.2.0",
+    "@zudojs/core": "1.2.1",
+    "@zudojs/errors": "1.2.0",
+    "@zudojs/logger": "1.3.0"
   },
   "devDependencies": {
     "@types/node": "^26.4.1",
+    "@zudojs/constants": "1.1.1",
     "tsx": "^4.23.12",
     "typescript": "7.0.2",
     "vitest": "^4.1.11"