@dudousxd/nestjs-codegen 0.3.0 → 0.4.1

package/CHANGELOG.md

@@ -1,5 +1,38 @@
 # @dudousxd/nestjs-codegen
 
+## 0.4.1
+
+### Patch Changes
+
+- 6a6be24: perf: memoize type and enum resolution during generation — per-`Project` `WeakMap` caches for `findType`, `resolveTypeRef`'s named-symbol arm, and `resolveEnumValues`, so a type referenced N times is resolved once. Keyed by `Project` so each (watch) run gets a fresh cache; generated output is byte-identical.
+
+## 0.4.0
+
+### Minor Changes
+
+- ed04cdc: Validate recursive DTOs instead of degrading them to `unknown`.
+
+  Self/mutually-recursive `@ValidateNested` DTOs (e.g. a `ColumnFilter` whose `and`/`or`
+  reference `ColumnFilter[]`) used to be degraded to `unknown` with a warning, dropping all
+  client-side validation for that field. They are now expanded with a real lazy schema:
+
+  - **zod / valibot** hoist a structural TS `type` alias and annotate the recursive const
+    (`z.ZodType<T>` / `v.GenericSchema<T>`) so the implicit-any self-reference cycle is broken;
+    the recursion site uses `z.lazy` / `v.lazy`.
+  - **arktype** uses the native `this` keyword for self-recursion. Mutual recursion (A ↔ B)
+    cannot be expressed per-schema without a scope, so the back-edge schema still degrades to
+    `unknown` with a clear warning — use the zod or valibot adapter for full validation there.
+
+  The over-deep nesting guard is now reported separately ("nesting too deep") instead of being
+  mislabelled as recursion. The raw-zod `defineContract` path is unchanged.
+
+### Patch Changes
+
+- ed04cdc: Fix array detection for union types. A property typed `unknown | unknown[]` (or any
+  union whose text happens to end in `[]`) was mistakenly treated as an array and wrapped
+  in `z.array(...)`. Array detection now uses the AST (`ArrayTypeNode`) instead of a
+  `.endsWith('[]')` text check, so only genuine `T[]` properties become arrays.
+
 ## 0.3.0
 
 ### Minor Changes

package/dist/cli/main.cjs

@@ -1285,6 +1285,8 @@ function buildFormsFileWithAdapter(routes, outDir, adapter, config) {
   }
   const { globalSchemas, renamesByEntry } = planNestedSchemas(entries);
   const irNamed = /* @__PURE__ */ new Map();
+  const irTypeAliases = /* @__PURE__ */ new Map();
+  const irAnnotations = /* @__PURE__ */ new Map();
   const decls = [];
   const mapEntries = [];
   let used = false;
@@ -1292,6 +1294,8 @@ function buildFormsFileWithAdapter(routes, outDir, adapter, config) {
     if (src.schema) {
       const r = adapter.renderModule(src.schema);
       for (const [n, t] of r.namedNestedSchemas) irNamed.set(n, t);
+      if (r.namedTypeAliases) for (const [n, t] of r.namedTypeAliases) irTypeAliases.set(n, t);
+      if (r.namedAnnotations) for (const [n, a] of r.namedAnnotations) irAnnotations.set(n, a);
       return { text: r.schemaText };
     }
     if (src.zodText) {
@@ -1365,7 +1369,13 @@ function buildFormsFileWithAdapter(routes, outDir, adapter, config) {
   for (const [n, t] of irNamed) if (!allNested.has(n)) allNested.set(n, t);
   if (allNested.size > 0) {
     lines.push("// Hoisted nested schemas (shared across endpoints).");
-    for (const [n, t] of allNested) lines.push(`const ${n} = ${t};`);
+    for (const [n, alias] of irTypeAliases) {
+      if (allNested.has(n)) lines.push(`${alias};`);
+    }
+    for (const [n, t] of allNested) {
+      const annotation = irAnnotations.get(n);
+      lines.push(`const ${n}${annotation ? `: ${annotation}` : ""} = ${t};`);
+    }
     lines.push("");
   }
   lines.push(...decls);
@@ -1790,10 +1800,19 @@ function followModuleForType(name, moduleSpecifier, fromFile, project, seen) {
   }
   return null;
 }
+var _findTypeCache = /* @__PURE__ */ new WeakMap();
 function findType(name, sourceFile, project) {
+  let byKey = _findTypeCache.get(project);
+  if (byKey === void 0) {
+    byKey = /* @__PURE__ */ new Map();
+    _findTypeCache.set(project, byKey);
+  }
+  const key = `${sourceFile.getFilePath()}\0${name}`;
+  if (byKey.has(key)) return byKey.get(key) ?? null;
   const local = findTypeInFile(name, sourceFile);
-  if (local) return local;
-  return resolveImportedType(name, sourceFile, project);
+  const result = local ?? resolveImportedType(name, sourceFile, project);
+  byKey.set(key, result);
+  return result;
 }
 var _NON_REF_NAMES = /* @__PURE__ */ new Set(["string", "number", "boolean", "void", "unknown", "any", "Date"]);
 function _localDeclForKinds(name, file, kinds) {
@@ -1830,6 +1849,26 @@ function resolveTypeRef(nodeOrName, sourceFile, project, opts) {
     if (_NON_REF_NAMES.has(refName)) return null;
     name = refName;
   }
+  return _resolveNamedRef(name, sourceFile, project, opts);
+}
+var _resolveNamedRefCache = /* @__PURE__ */ new WeakMap();
+function _resolveNamedRef(name, sourceFile, project, opts) {
+  let byKey = _resolveNamedRefCache.get(project);
+  if (byKey === void 0) {
+    byKey = /* @__PURE__ */ new Map();
+    _resolveNamedRefCache.set(project, byKey);
+  }
+  const kindsKey = [...opts.kinds].sort().join(",");
+  const key = `${sourceFile.getFilePath()}\0${name}\0${kindsKey}\0${opts.allowBareSpecifier ? 1 : 0}`;
+  if (byKey.has(key)) {
+    const cached = byKey.get(key) ?? null;
+    return cached ? { ...cached } : null;
+  }
+  const computed = _computeNamedRef(name, sourceFile, project, opts);
+  byKey.set(key, computed);
+  return computed ? { ...computed } : null;
+}
+function _computeNamedRef(name, sourceFile, project, opts) {
   if (_localDeclForKinds(name, sourceFile, opts.kinds)) {
     return { name, filePath: sourceFile.getFilePath() };
   }
@@ -1907,10 +1946,7 @@ function extractSchemaFromDto(classDecl, sourceFile, project) {
     depth: 0
   };
   const root = buildObject(classDecl, sourceFile, ctx);
-  for (const schemaName of ctx.recursiveSchemas) {
-    ctx.named.set(schemaName, { kind: "unknown", note: "recursive type \u2014 not expanded" });
-  }
-  return { root, named: ctx.named, warnings: ctx.warnings };
+  return { root, named: ctx.named, warnings: ctx.warnings, recursive: ctx.recursiveSchemas };
 }
 function buildObject(classDecl, classFile, ctx) {
   const props = classDecl.getProperties();
@@ -1930,7 +1966,7 @@ function buildProperty(prop, classFile, ctx) {
   const dec = (n) => decorators.get(n);
   const typeNode = prop.getTypeNode();
   const typeText = typeNode?.getText() ?? "unknown";
-  const isArrayType = !!typeNode && typeNode.getText().endsWith("[]");
+  const isArrayType = !!typeNode && import_ts_morph4.Node.isArrayTypeNode(typeNode);
   const typeRefName = resolveTypeFactoryName(dec("Type"));
   if (has("ValidateNested") || typeRefName) {
     const childName = typeRefName ?? singularClassName(typeText);
@@ -2061,18 +2097,27 @@ function baseFromType(typeText, isArrayType) {
   }
 }
 function buildNestedReference(className, fromFile, ctx) {
-  if (ctx.visiting.has(className) || ctx.depth >= 8) {
+  if (ctx.visiting.has(className)) {
     const reserved = ctx.emittedClasses.get(className) ?? aliasFor(className, ctx);
     ctx.emittedClasses.set(className, reserved);
     ctx.recursiveSchemas.add(reserved);
     if (!ctx.warnedDecorators.has(`recursive:${reserved}`)) {
       ctx.warnedDecorators.add(`recursive:${reserved}`);
-      const msg = `${className} is a recursive type and was not expanded; the generated schema uses unknown for it.`;
+      const msg = `${className} is a recursive type; the generated schema validates it via a lazy self-reference.`;
       ctx.warnings.push(msg);
       console.warn(`[nestjs-codegen] ${msg}`);
     }
     return { kind: "lazyRef", name: reserved };
   }
+  if (ctx.depth >= 8) {
+    if (!ctx.warnedDecorators.has(`deep:${className}`)) {
+      ctx.warnedDecorators.add(`deep:${className}`);
+      const msg = `${className} nesting is too deep to expand; the generated schema uses unknown for it.`;
+      ctx.warnings.push(msg);
+      console.warn(`[nestjs-codegen] ${msg}`);
+    }
+    return { kind: "unknown", note: "nesting too deep \u2014 not expanded" };
+  }
   const existing = ctx.emittedClasses.get(className);
   if (existing) return { kind: "ref", name: existing };
   const schemaName = aliasFor(className, ctx);
@@ -2198,17 +2243,31 @@ var import_ts_morph6 = require("ts-morph");
 var import_ts_morph5 = require("ts-morph");
 
 // src/discovery/enum-resolution.ts
+var _enumCache = /* @__PURE__ */ new WeakMap();
 function resolveEnumValues(name, sourceFile, project) {
+  let byKey = _enumCache.get(project);
+  if (byKey === void 0) {
+    byKey = /* @__PURE__ */ new Map();
+    _enumCache.set(project, byKey);
+  }
+  const key = `${sourceFile.getFilePath()}\0${name}`;
+  if (byKey.has(key)) {
+    const cached = byKey.get(key) ?? null;
+    return cached ? { values: [...cached.values], numeric: cached.numeric } : null;
+  }
   const resolved = findType(name, sourceFile, project);
-  if (!resolved || resolved.kind !== "enum") return null;
-  let numeric = true;
-  const values = resolved.members.map((m) => {
-    const parsed = JSON.parse(m);
-    if (typeof parsed === "string") numeric = false;
-    return String(parsed);
-  });
-  if (values.length === 0) return null;
-  return { values, numeric };
+  let result = null;
+  if (resolved && resolved.kind === "enum") {
+    let numeric = true;
+    const values = resolved.members.map((m) => {
+      const parsed = JSON.parse(m);
+      if (typeof parsed === "string") numeric = false;
+      return String(parsed);
+    });
+    if (values.length > 0) result = { values, numeric };
+  }
+  byKey.set(key, result);
+  return result ? { values: [...result.values], numeric: result.numeric } : null;
 }
 
 // src/discovery/filter-field-types.ts
@@ -3478,7 +3537,7 @@ async function watch(config, onChange) {
 }
 
 // src/index.ts
-var VERSION = "0.3.0";
+var VERSION = "0.4.1";
 
 // src/cli/codegen.ts
 async function runCodegen(opts = {}) {