@dudousxd/nestjs-codegen 0.3.0 → 0.4.0

package/CHANGELOG.md

@@ -1,5 +1,32 @@
 # @dudousxd/nestjs-codegen
 
+## 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);
@@ -1907,10 +1917,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 +1937,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 +2068,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);
@@ -3478,7 +3494,7 @@ async function watch(config, onChange) {
 }
 
 // src/index.ts
-var VERSION = "0.3.0";
+var VERSION = "0.4.0";
 
 // src/cli/codegen.ts
 async function runCodegen(opts = {}) {