@dudousxd/nestjs-codegen 0.3.0 → 0.4.1

package/dist/cli/main.js

@@ -1251,6 +1251,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;
@@ -1258,6 +1260,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) {
@@ -1331,7 +1335,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);
@@ -1766,10 +1776,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) {
@@ -1806,6 +1825,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() };
   }
@@ -1883,10 +1922,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();
@@ -1906,7 +1942,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);
@@ -2037,18 +2073,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);
@@ -2179,17 +2224,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
@@ -3459,7 +3518,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 = {}) {