@dudousxd/nestjs-codegen 0.11.0 → 0.12.0

package/dist/nest/index.d.cts

@@ -33,11 +33,21 @@ interface CodegenModuleOptions extends Omit<UserConfig, 'validation'> {
     validation?: UserConfig['validation'];
     /**
      * Master switch for the boot-time watcher. When omitted, the watcher runs in every
-     * environment EXCEPT production (`process.env.NODE_ENV === 'production'`) — codegen is a
-     * dev/CI build step, not a production-runtime concern. Set `false` to disable entirely,
-     * or `true` to force it on even in production.
+     * environment EXCEPT production — codegen is a dev/CI build step, not a
+     * production-runtime concern. Set `false` to disable entirely, or `true` to force it
+     * on even in production (overrides {@link runInProduction}).
      */
     enabled?: boolean;
+    /**
+     * Run the boot-time watcher even when `NODE_ENV` is `production`. Codegen is a
+     * dev-time concern — in production the artifacts are already built by the CLI in the
+     * build pipeline — so this defaults to `false` (skip in production). Set `true` only
+     * if you genuinely need to regenerate at production runtime. Ignored when `enabled`
+     * is set explicitly.
+     *
+     * @default false
+     */
+    runInProduction?: boolean;
     /** Project root used to resolve globs / `outDir`. Defaults to `process.cwd()`. */
     cwd?: string;
 }
@@ -45,7 +55,8 @@ interface CodegenModuleOptions extends Omit<UserConfig, 'validation'> {
 declare const CODEGEN_MODULE_OPTIONS: unique symbol;
 /**
  * Decide whether the boot-time watcher should start, given the module options and the
- * current `NODE_ENV`. Explicit `enabled` always wins; otherwise default on unless prod.
+ * current `NODE_ENV`. Explicit `enabled` always wins; otherwise default on everywhere
+ * except production, where it stays off unless `runInProduction` is set.
  */
 declare function shouldRun(options: CodegenModuleOptions, env: string | undefined): boolean;
 /**

package/dist/nest/index.d.ts

@@ -33,11 +33,21 @@ interface CodegenModuleOptions extends Omit<UserConfig, 'validation'> {
     validation?: UserConfig['validation'];
     /**
      * Master switch for the boot-time watcher. When omitted, the watcher runs in every
-     * environment EXCEPT production (`process.env.NODE_ENV === 'production'`) — codegen is a
-     * dev/CI build step, not a production-runtime concern. Set `false` to disable entirely,
-     * or `true` to force it on even in production.
+     * environment EXCEPT production — codegen is a dev/CI build step, not a
+     * production-runtime concern. Set `false` to disable entirely, or `true` to force it
+     * on even in production (overrides {@link runInProduction}).
      */
     enabled?: boolean;
+    /**
+     * Run the boot-time watcher even when `NODE_ENV` is `production`. Codegen is a
+     * dev-time concern — in production the artifacts are already built by the CLI in the
+     * build pipeline — so this defaults to `false` (skip in production). Set `true` only
+     * if you genuinely need to regenerate at production runtime. Ignored when `enabled`
+     * is set explicitly.
+     *
+     * @default false
+     */
+    runInProduction?: boolean;
     /** Project root used to resolve globs / `outDir`. Defaults to `process.cwd()`. */
     cwd?: string;
 }
@@ -45,7 +55,8 @@ interface CodegenModuleOptions extends Omit<UserConfig, 'validation'> {
 declare const CODEGEN_MODULE_OPTIONS: unique symbol;
 /**
  * Decide whether the boot-time watcher should start, given the module options and the
- * current `NODE_ENV`. Explicit `enabled` always wins; otherwise default on unless prod.
+ * current `NODE_ENV`. Explicit `enabled` always wins; otherwise default on everywhere
+ * except production, where it stays off unless `runInProduction` is set.
  */
 declare function shouldRun(options: CodegenModuleOptions, env: string | undefined): boolean;
 /**

package/dist/nest/index.js

@@ -138,8 +138,8 @@ function applyDefaults(userConfig, cwd) {
 }
 
 // src/watch/watcher.ts
-import { readFile as readFile3 } from "fs/promises";
-import { join as join15 } from "path";
+import { readFile as readFile4 } from "fs/promises";
+import { join as join16 } from "path";
 import chokidar from "chokidar";
 
 // src/discovery/contracts-fast.ts
@@ -2294,8 +2294,8 @@ function extractFromSourceFile(sourceFile, project) {
 }
 
 // src/generate.ts
-import { mkdir as mkdir9, writeFile as writeFile9 } from "fs/promises";
-import { dirname as dirname3, join as join13 } from "path";
+import { mkdir as mkdir10, writeFile as writeFile10 } from "fs/promises";
+import { dirname as dirname3, join as join15 } from "path";
 
 // src/discovery/pages.ts
 import { readFile } from "fs/promises";
@@ -4190,9 +4190,159 @@ function buildEmpty() {
   ].join("\n");
 }
 
+// src/generate-manifest.ts
+import { createHash } from "crypto";
+import { readFile as readFile3, readdir, writeFile as writeFile9 } from "fs/promises";
+import { join as join14, relative as relative6 } from "path";
+import fg3 from "fast-glob";
+
+// src/watch/lock-file.ts
+import { open } from "fs/promises";
+import { mkdir as mkdir9, readFile as readFile2, unlink } from "fs/promises";
+import { join as join13 } from "path";
+var LOCK_FILE = ".watcher.lock";
+function isProcessAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function acquireLock(outDir) {
+  await mkdir9(outDir, { recursive: true });
+  const lockPath = join13(outDir, LOCK_FILE);
+  const lockData = { pid: process.pid, startedAt: (/* @__PURE__ */ new Date()).toISOString() };
+  try {
+    const fd = await open(lockPath, "wx");
+    await fd.writeFile(`${JSON.stringify(lockData, null, 2)}
+`, "utf8");
+    await fd.close();
+  } catch (err) {
+    if (err.code === "EEXIST") {
+      try {
+        const raw = await readFile2(lockPath, "utf8");
+        const existing = JSON.parse(raw);
+        if (isProcessAlive(existing.pid)) return null;
+        await unlink(lockPath);
+        return acquireLock(outDir);
+      } catch {
+        return null;
+      }
+    }
+    return null;
+  }
+  return {
+    release: async () => {
+      try {
+        await unlink(lockPath);
+      } catch {
+      }
+    }
+  };
+}
+
+// src/index.ts
+var VERSION = "0.12.0";
+
+// src/generate-manifest.ts
+var MANIFEST_FILE = ".codegen-manifest.json";
+var LOCK_FILE2 = ".watcher.lock";
+function isManifestShape(value) {
+  if (typeof value !== "object" || value === null) return false;
+  const candidate = value;
+  if (typeof candidate.version !== "string") return false;
+  if (typeof candidate.hash !== "string") return false;
+  if (!Array.isArray(candidate.files)) return false;
+  return candidate.files.every((entry) => typeof entry === "string");
+}
+function serializeConfig(config) {
+  try {
+    return JSON.stringify(config, (_key, value) => {
+      if (typeof value === "function") return `[fn:${value.name}]${value.toString()}`;
+      return value;
+    });
+  } catch {
+    return `unserializable:${config.codegen.outDir}:${config.contracts.glob}`;
+  }
+}
+async function discoverInputFiles(config) {
+  const globs = [config.contracts.glob, config.forms.watch];
+  if (config.pages) globs.push(config.pages.glob);
+  const cwd = config.codegen.cwd;
+  const matched = await fg3(globs, { cwd, absolute: true, onlyFiles: true });
+  return [...new Set(matched)].sort();
+}
+async function computeInputsHash(config) {
+  const hash = createHash("sha256");
+  hash.update(`version:${VERSION}
+`);
+  hash.update(`config:${serializeConfig(config)}
+`);
+  const inputFiles = await discoverInputFiles(config);
+  const cwd = config.codegen.cwd;
+  for (const file of inputFiles) {
+    const contents = await readFile3(file, "utf8");
+    hash.update(`file:${relative6(cwd, file)}
+`);
+    hash.update(contents);
+    hash.update("\n");
+  }
+  return hash.digest("hex");
+}
+async function readManifest(outDir) {
+  try {
+    const raw = await readFile3(join14(outDir, MANIFEST_FILE), "utf8");
+    const parsed = JSON.parse(raw);
+    if (!isManifestShape(parsed)) return null;
+    return { version: parsed.version, hash: parsed.hash, files: parsed.files };
+  } catch {
+    return null;
+  }
+}
+async function writeManifest(outDir, manifest) {
+  await writeFile9(join14(outDir, MANIFEST_FILE), `${JSON.stringify(manifest, null, 2)}
+`, "utf8");
+}
+async function listOutputFiles(outDir) {
+  const found = [];
+  async function walk(dir) {
+    const entries = await readdir(dir, { withFileTypes: true }).catch(() => []);
+    for (const entry of entries) {
+      const abs = join14(dir, entry.name);
+      if (entry.isDirectory()) {
+        await walk(abs);
+      } else if (entry.isFile()) {
+        const rel = relative6(outDir, abs);
+        if (rel === MANIFEST_FILE || rel === LOCK_FILE2) continue;
+        found.push(rel);
+      }
+    }
+  }
+  await walk(outDir);
+  return found.sort();
+}
+async function allOutputsExist(outDir, files) {
+  const present = new Set(await listOutputFiles(outDir));
+  return files.every((file) => present.has(file));
+}
+async function isManifestFresh(outDir, manifest, inputsHash) {
+  if (manifest === null) return false;
+  if (manifest.version !== VERSION) return false;
+  if (manifest.hash !== inputsHash) return false;
+  if (manifest.files.length === 0) return false;
+  return allOutputsExist(outDir, manifest.files);
+}
+
 // src/generate.ts
 async function generate(config, inputRoutes = []) {
   setCodegenDebug(config.debug);
+  const inputsHash = await computeInputsHash(config);
+  const manifest = await readManifest(config.codegen.outDir);
+  if (await isManifestFresh(config.codegen.outDir, manifest, inputsHash)) {
+    console.log(`[nestjs-codegen] ${config.codegen.outDir} up to date, skipped`);
+    return;
+  }
   const extensions = config.extensions ?? [];
   let routes = inputRoutes;
   const ctx = createExtensionContext(config, () => routes);
@@ -4249,69 +4399,29 @@ async function generate(config, inputRoutes = []) {
   if (extensions.length > 0) {
     const extraFiles = await collectEmittedFiles(extensions, ctx);
     for (const file of extraFiles) {
-      const dest = join13(config.codegen.outDir, file.path);
-      await mkdir9(dirname3(dest), { recursive: true });
-      await writeFile9(dest, file.contents, "utf8");
+      const dest = join15(config.codegen.outDir, file.path);
+      await mkdir10(dirname3(dest), { recursive: true });
+      await writeFile10(dest, file.contents, "utf8");
     }
   }
-}
-
-// src/watch/lock-file.ts
-import { open } from "fs/promises";
-import { mkdir as mkdir10, readFile as readFile2, unlink } from "fs/promises";
-import { join as join14 } from "path";
-var LOCK_FILE = ".watcher.lock";
-function isProcessAlive(pid) {
-  try {
-    process.kill(pid, 0);
-    return true;
-  } catch {
-    return false;
-  }
-}
-async function acquireLock(outDir) {
-  await mkdir10(outDir, { recursive: true });
-  const lockPath = join14(outDir, LOCK_FILE);
-  const lockData = { pid: process.pid, startedAt: (/* @__PURE__ */ new Date()).toISOString() };
-  try {
-    const fd = await open(lockPath, "wx");
-    await fd.writeFile(`${JSON.stringify(lockData, null, 2)}
-`, "utf8");
-    await fd.close();
-  } catch (err) {
-    if (err.code === "EEXIST") {
-      try {
-        const raw = await readFile2(lockPath, "utf8");
-        const existing = JSON.parse(raw);
-        if (isProcessAlive(existing.pid)) return null;
-        await unlink(lockPath);
-        return acquireLock(outDir);
-      } catch {
-        return null;
-      }
-    }
-    return null;
-  }
-  return {
-    release: async () => {
-      try {
-        await unlink(lockPath);
-      } catch {
-      }
-    }
-  };
+  const outputFiles = await listOutputFiles(config.codegen.outDir);
+  await writeManifest(config.codegen.outDir, {
+    version: VERSION,
+    hash: inputsHash,
+    files: outputFiles
+  });
 }
 
 // src/watch/watcher.ts
 var PAGES_DEBOUNCE_MS = 150;
 var NO_OP_WATCHER = { close: async () => {
 } };
-async function watch(config, onChange) {
+async function watch(config, onChange, options = {}) {
   const lock = await acquireLock(config.codegen.outDir);
   if (lock === null) {
     let holderPid = "unknown";
     try {
-      const raw = await readFile3(join15(config.codegen.outDir, ".watcher.lock"), "utf8");
+      const raw = await readFile4(join16(config.codegen.outDir, ".watcher.lock"), "utf8");
       const data = JSON.parse(raw);
       if (data.pid !== void 0) holderPid = String(data.pid);
     } catch {
@@ -4334,22 +4444,33 @@ async function watch(config, onChange) {
     }
     return discovery;
   }
-  try {
-    const initialRoutes = (await getDiscovery()).discover();
-    lastRoutes = initialRoutes;
-    await generate(config, initialRoutes);
-  } catch (err) {
-    console.warn(
-      `[nestjs-codegen] Initial route discovery failed, falling back to pages-only: ${err instanceof Error ? err.message : String(err)}`
-    );
+  async function runInitialPass() {
     try {
-      await generate(config, lastRoutes);
-    } catch {
+      const initialRoutes = (await getDiscovery()).discover();
+      lastRoutes = initialRoutes;
+      await generate(config, initialRoutes);
+    } catch (err) {
+      console.warn(
+        `[nestjs-codegen] Initial route discovery failed, falling back to pages-only: ${err instanceof Error ? err.message : String(err)}`
+      );
+      try {
+        await generate(config, lastRoutes);
+      } catch {
+      }
     }
   }
+  if (options.deferInitialGenerate) {
+    void runInitialPass().catch((err) => {
+      console.warn(
+        `[nestjs-codegen] Background initial generate failed: ${err instanceof Error ? err.message : String(err)}`
+      );
+    });
+  } else {
+    await runInitialPass();
+  }
   let pagesDebounceTimer;
   const pagesGlob = config.pages?.glob ?? ".nestjs-codegen-no-pages";
-  const pagesWatcher = chokidar.watch(join15(config.codegen.cwd, pagesGlob), {
+  const pagesWatcher = chokidar.watch(join16(config.codegen.cwd, pagesGlob), {
     ignoreInitial: true,
     persistent: true,
     awaitWriteFinish: { stabilityThreshold: 80, pollInterval: 20 }
@@ -4376,7 +4497,7 @@ async function watch(config, onChange) {
   pagesWatcher.on("unlink", schedulePagesRegenerate);
   let contractsDebounceTimer;
   const pendingChangedPaths = /* @__PURE__ */ new Set();
-  const contractsWatcher = chokidar.watch(join15(config.codegen.cwd, config.contracts.glob), {
+  const contractsWatcher = chokidar.watch(join16(config.codegen.cwd, config.contracts.glob), {
     ignoreInitial: true,
     persistent: true,
     awaitWriteFinish: { stabilityThreshold: 80, pollInterval: 20 }
@@ -4406,7 +4527,7 @@ async function watch(config, onChange) {
   contractsWatcher.on("add", (p) => scheduleContractsRegenerate(p));
   contractsWatcher.on("change", (p) => scheduleContractsRegenerate(p));
   contractsWatcher.on("unlink", (p) => scheduleContractsRegenerate(p));
-  const formsWatcher = chokidar.watch(join15(config.codegen.cwd, config.forms.watch), {
+  const formsWatcher = chokidar.watch(join16(config.codegen.cwd, config.forms.watch), {
     ignoreInitial: true,
     persistent: true,
     awaitWriteFinish: { stabilityThreshold: 80, pollInterval: 20 }
@@ -4434,9 +4555,13 @@ async function watch(config, onChange) {
 
 // src/nest/module.ts
 var CODEGEN_MODULE_OPTIONS = Symbol("NESTJS_CODEGEN_MODULE_OPTIONS");
+function isProductionEnv(env) {
+  return (env ?? "").trim().toLowerCase() === "production";
+}
 function shouldRun(options, env) {
   if (options.enabled !== void 0) return options.enabled;
-  return env !== "production";
+  if (isProductionEnv(env)) return options.runInProduction === true;
+  return true;
 }
 var NestjsCodegenService = class {
   constructor(options) {
@@ -4445,11 +4570,21 @@ var NestjsCodegenService = class {
   logger = new Logger("NestjsCodegen");
   watcher = null;
   async onApplicationBootstrap() {
-    if (!shouldRun(this.options, process.env.NODE_ENV)) return;
-    const { enabled: _enabled, cwd, ...userConfig } = this.options;
+    if (!shouldRun(this.options, process.env.NODE_ENV)) {
+      if (this.options.enabled === void 0 && isProductionEnv(process.env.NODE_ENV)) {
+        this.logger.log("Skipped in production (set runInProduction: true to override).");
+      }
+      return;
+    }
+    const {
+      enabled: _enabled,
+      runInProduction: _runInProduction,
+      cwd,
+      ...userConfig
+    } = this.options;
     try {
       const config = resolveConfig(userConfig, cwd ?? process.cwd());
-      this.watcher = await watch(config);
+      this.watcher = await watch(config, void 0, { deferInitialGenerate: true });
       this.logger.log(`Watching ${config.contracts.glob} \u2192 ${config.codegen.outDir}`);
     } catch (err) {
       this.logger.warn(