@dudousxd/nestjs-codegen 0.3.0 → 0.4.1

package/dist/index.d.cts

@@ -1,5 +1,5 @@
-import { U as UserConfig, R as ResolvedConfig, a as RouteDescriptor, S as SchemaModule, b as ResolvedFormsConfig, V as ValidationAdapter, C as CodegenExtension, E as ExtensionContext } from './index-oH5t7x4G.cjs';
-export { A as AdapterUsage, c as ContractDescriptor, d as ContractSource, e as ControllerRef, N as NumberCheck, f as RenderContext, g as RenderedModule, h as SchemaNode, i as ScopeConfig, j as StringCheck, T as TypeRef, k as ValidationOption, r as resolveAdapter } from './index-oH5t7x4G.cjs';
+import { U as UserConfig, R as ResolvedConfig, a as RouteDescriptor, S as SchemaNode, b as SchemaModule, c as ResolvedFormsConfig, V as ValidationAdapter, C as CodegenExtension, E as ExtensionContext } from './index-DA4uySjo.cjs';
+export { A as AdapterUsage, d as ContractDescriptor, e as ContractSource, f as ControllerRef, N as NumberCheck, g as RenderContext, h as RenderedModule, i as ScopeConfig, j as StringCheck, T as TypeRef, k as ValidationOption, r as resolveAdapter } from './index-DA4uySjo.cjs';
 import { ClassDeclaration, SourceFile, Project } from 'ts-morph';
 
 declare function defineConfig(c: UserConfig): UserConfig;
@@ -73,6 +73,31 @@ declare function acquireLock(outDir: string): Promise<{
     release: () => Promise<void>;
 } | null>;
 
+/**
+ * Renders the neutral {@link SchemaNode} IR to a TypeScript *type* expression
+ * (not a validation-lib schema). Used to synthesize the hoisted structural type
+ * that annotates a recursive zod/valibot const, breaking the implicit-any
+ * inference cycle (`type X = {...}` + `const XSchema: z.ZodType<X> = ...`).
+ *
+ * References to other named schemas resolve two ways:
+ *   - a `ref`/`lazyRef` to a *recursive* schema → its type-alias name (so the
+ *     emitted `type` aliases reference each other, terminating the recursion);
+ *   - a `ref` to a *non-recursive* schema → inlined structurally (keeps the set
+ *     of emitted `type` aliases limited to exactly the recursive cluster).
+ * Inlining always terminates: every reference cycle passes through a recursive
+ * name, which is rendered by alias rather than expanded.
+ */
+
+interface TsTypeContext {
+    /** All hoisted named schemas (for inlining non-recursive refs). */
+    named: Map<string, SchemaNode>;
+    /** Names that are genuinely recursive (rendered by alias, never inlined). */
+    recursive: Set<string>;
+    /** schema const name (e.g. `ColumnFilterSchema`) → TS type-alias name. */
+    typeNameFor: (schemaName: string) => string;
+}
+declare function renderTsType(node: SchemaNode, ctx: TsTypeContext): string;
+
 /**
  * Pure-AST translation of class-validator-decorated DTO classes into the neutral
  * {@link SchemaModule} IR. Reads decorator names + literal args via ts-morph — it
@@ -139,6 +164,6 @@ interface FastDiscoveryOptions {
 }
 declare function discoverContractsFast(opts: FastDiscoveryOptions): Promise<RouteDescriptor[]>;
 
-declare const VERSION = "0.3.0";
+declare const VERSION = "0.4.1";
 
-export { CodegenError, ConfigError, type FastDiscoveryOptions, ResolvedConfig, RouteDescriptor, SchemaModule, UserConfig, VERSION, ValidationAdapter, type Watcher, acquireLock, defineConfig, discoverContractsFast, emitApi, emitForms, emitRoutes, extractSchemaFromDto, generate, loadConfig, resolveConfig, watch };
+export { CodegenError, ConfigError, type FastDiscoveryOptions, ResolvedConfig, RouteDescriptor, SchemaModule, SchemaNode, type TsTypeContext, UserConfig, VERSION, ValidationAdapter, type Watcher, acquireLock, defineConfig, discoverContractsFast, emitApi, emitForms, emitRoutes, extractSchemaFromDto, generate, loadConfig, renderTsType, resolveConfig, watch };

package/dist/index.d.ts

@@ -1,5 +1,5 @@
-import { U as UserConfig, R as ResolvedConfig, a as RouteDescriptor, S as SchemaModule, b as ResolvedFormsConfig, V as ValidationAdapter, C as CodegenExtension, E as ExtensionContext } from './index-oH5t7x4G.js';
-export { A as AdapterUsage, c as ContractDescriptor, d as ContractSource, e as ControllerRef, N as NumberCheck, f as RenderContext, g as RenderedModule, h as SchemaNode, i as ScopeConfig, j as StringCheck, T as TypeRef, k as ValidationOption, r as resolveAdapter } from './index-oH5t7x4G.js';
+import { U as UserConfig, R as ResolvedConfig, a as RouteDescriptor, S as SchemaNode, b as SchemaModule, c as ResolvedFormsConfig, V as ValidationAdapter, C as CodegenExtension, E as ExtensionContext } from './index-DA4uySjo.js';
+export { A as AdapterUsage, d as ContractDescriptor, e as ContractSource, f as ControllerRef, N as NumberCheck, g as RenderContext, h as RenderedModule, i as ScopeConfig, j as StringCheck, T as TypeRef, k as ValidationOption, r as resolveAdapter } from './index-DA4uySjo.js';
 import { ClassDeclaration, SourceFile, Project } from 'ts-morph';
 
 declare function defineConfig(c: UserConfig): UserConfig;
@@ -73,6 +73,31 @@ declare function acquireLock(outDir: string): Promise<{
     release: () => Promise<void>;
 } | null>;
 
+/**
+ * Renders the neutral {@link SchemaNode} IR to a TypeScript *type* expression
+ * (not a validation-lib schema). Used to synthesize the hoisted structural type
+ * that annotates a recursive zod/valibot const, breaking the implicit-any
+ * inference cycle (`type X = {...}` + `const XSchema: z.ZodType<X> = ...`).
+ *
+ * References to other named schemas resolve two ways:
+ *   - a `ref`/`lazyRef` to a *recursive* schema → its type-alias name (so the
+ *     emitted `type` aliases reference each other, terminating the recursion);
+ *   - a `ref` to a *non-recursive* schema → inlined structurally (keeps the set
+ *     of emitted `type` aliases limited to exactly the recursive cluster).
+ * Inlining always terminates: every reference cycle passes through a recursive
+ * name, which is rendered by alias rather than expanded.
+ */
+
+interface TsTypeContext {
+    /** All hoisted named schemas (for inlining non-recursive refs). */
+    named: Map<string, SchemaNode>;
+    /** Names that are genuinely recursive (rendered by alias, never inlined). */
+    recursive: Set<string>;
+    /** schema const name (e.g. `ColumnFilterSchema`) → TS type-alias name. */
+    typeNameFor: (schemaName: string) => string;
+}
+declare function renderTsType(node: SchemaNode, ctx: TsTypeContext): string;
+
 /**
  * Pure-AST translation of class-validator-decorated DTO classes into the neutral
  * {@link SchemaModule} IR. Reads decorator names + literal args via ts-morph — it
@@ -139,6 +164,6 @@ interface FastDiscoveryOptions {
 }
 declare function discoverContractsFast(opts: FastDiscoveryOptions): Promise<RouteDescriptor[]>;
 
-declare const VERSION = "0.3.0";
+declare const VERSION = "0.4.1";
 
-export { CodegenError, ConfigError, type FastDiscoveryOptions, ResolvedConfig, RouteDescriptor, SchemaModule, UserConfig, VERSION, ValidationAdapter, type Watcher, acquireLock, defineConfig, discoverContractsFast, emitApi, emitForms, emitRoutes, extractSchemaFromDto, generate, loadConfig, resolveConfig, watch };
+export { CodegenError, ConfigError, type FastDiscoveryOptions, ResolvedConfig, RouteDescriptor, SchemaModule, SchemaNode, type TsTypeContext, UserConfig, VERSION, ValidationAdapter, type Watcher, acquireLock, defineConfig, discoverContractsFast, emitApi, emitForms, emitRoutes, extractSchemaFromDto, generate, loadConfig, renderTsType, resolveConfig, watch };

package/dist/index.js

@@ -1256,6 +1256,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;
@@ -1263,6 +1265,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) {
@@ -1336,7 +1340,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);
@@ -1771,10 +1781,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) {
@@ -1811,6 +1830,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() };
   }
@@ -1888,10 +1927,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();
@@ -1911,7 +1947,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 && Node3.isArrayTypeNode(typeNode);
   const typeRefName = resolveTypeFactoryName(dec("Type"));
   if (has("ValidateNested") || typeRefName) {
     const childName = typeRefName ?? singularClassName(typeText);
@@ -2042,18 +2078,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);
@@ -2184,17 +2229,31 @@ import {
 } from "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
@@ -3463,8 +3522,57 @@ async function watch(config, onChange) {
   };
 }
 
+// src/ir/render-ts-type.ts
+function tsKey(name) {
+  return /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(name) ? name : JSON.stringify(name);
+}
+function renderTsType(node, ctx) {
+  switch (node.kind) {
+    case "string":
+      return "string";
+    case "number":
+      return "number";
+    case "boolean":
+      return "boolean";
+    case "date":
+      return "Date";
+    case "unknown":
+      return "unknown";
+    case "instanceof":
+      return node.ctor;
+    case "enum":
+      return node.literals.join(" | ");
+    case "literal":
+      return node.raw;
+    case "union":
+      return node.options.map((o) => renderTsType(o, ctx)).join(" | ");
+    case "array":
+      return `Array<${renderTsType(node.element, ctx)}>`;
+    case "optional":
+      return `${renderTsType(node.inner, ctx)} | undefined`;
+    case "annotated":
+      return renderTsType(node.inner, ctx);
+    case "object": {
+      if (node.fields.length === 0) return node.passthrough ? "Record<string, unknown>" : "{}";
+      const inner = node.fields.map((f) => {
+        if (f.value.kind === "optional") {
+          return `${tsKey(f.key)}?: ${renderTsType(f.value.inner, ctx)}`;
+        }
+        return `${tsKey(f.key)}: ${renderTsType(f.value, ctx)}`;
+      }).join("; ");
+      return `{ ${inner} }`;
+    }
+    case "ref":
+    case "lazyRef": {
+      if (ctx.recursive.has(node.name)) return ctx.typeNameFor(node.name);
+      const target = ctx.named.get(node.name);
+      return target ? renderTsType(target, ctx) : "unknown";
+    }
+  }
+}
+
 // src/index.ts
-var VERSION = "0.3.0";
+var VERSION = "0.4.1";
 export {
   CodegenError,
   ConfigError,
@@ -3478,6 +3586,7 @@ export {
   extractSchemaFromDto,
   generate,
   loadConfig,
+  renderTsType,
   resolveAdapter,
   resolveConfig,
   watch