@dudousxd/nestjs-codegen 0.5.0 → 0.5.2

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # @dudousxd/nestjs-codegen
 
+## 0.5.2
+
+### Patch Changes
+
+- f432450: Internal refactors (behavior-preserving): share `renderModule` across the zod/valibot adapters via a `createChainModuleRenderer` factory, and dedupe the nested-reference array-wrap + presence tail in `buildProperty` (`dto-to-ir`) behind a single `asField` closure.
+
+## 0.5.1
+
+### Patch Changes
+
+- 7dee3f6: perf: faster generation — `aliasFor` uses a maintained in-use-name set (O(n²)→O(1) over nested DTOs) and `planNestedSchemas` caches compiled rename regexes + uses a maintained Set for membership instead of rebuilding arrays. Generated output is byte-identical.
+
 ## 0.5.0
 
 ### Minor Changes

package/dist/cli/main.cjs

@@ -1188,18 +1188,27 @@ function refRootIdentifier(refName) {
 function hasSource(src) {
   return !!(src.schema || src.zodText || src.zodRef);
 }
+function escapeRegExp(s) {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+var wordBoundaryRegexCache = /* @__PURE__ */ new Map();
+function wordBoundaryRegex(token) {
+  let re = wordBoundaryRegexCache.get(token);
+  if (re === void 0) {
+    re = new RegExp(`\\b${escapeRegExp(token)}\\b`, "g");
+    wordBoundaryRegexCache.set(token, re);
+  }
+  return re;
+}
 function applyRenames(text, renames) {
   if (!renames || renames.size === 0) return text;
   let out = text;
   for (const [from, to] of renames) {
     if (from === to) continue;
-    out = out.replace(new RegExp(`\\b${escapeRegExp(from)}\\b`, "g"), to);
+    out = out.replace(wordBoundaryRegex(from), to);
   }
   return out;
 }
-function escapeRegExp(s) {
-  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
 function isSelfReferential(name, text) {
   return new RegExp(`\\b${escapeRegExp(name)}\\b`).test(text);
 }
@@ -1211,7 +1220,23 @@ function planNestedSchemas(entries) {
     const local = Object.entries(entry.nestedSchemas);
     if (local.length === 0) continue;
     const rename = /* @__PURE__ */ new Map();
-    for (const [name] of local) rename.set(name, name);
+    const renameValues = /* @__PURE__ */ new Set();
+    const setRename = (key, value) => {
+      const prev = rename.get(key);
+      rename.set(key, value);
+      if (prev !== void 0 && prev !== value) {
+        let stillUsed = false;
+        for (const v of rename.values()) {
+          if (v === prev) {
+            stillUsed = true;
+            break;
+          }
+        }
+        if (!stillUsed) renameValues.delete(prev);
+      }
+      renameValues.add(value);
+    };
+    for (const [name] of local) setRename(name, name);
     const textFor = (name) => {
       const raw = entry.nestedSchemas?.[name] ?? "";
       return applyRenames(raw, rename);
@@ -1229,11 +1254,11 @@ function planNestedSchemas(entries) {
         if (existing === text) continue;
         let i = 2;
         let candidate = `${name}_${i}`;
-        while (globalSchemas.has(candidate) && globalSchemas.get(candidate) !== textFor(name) || [...rename.values()].includes(candidate)) {
+        while (globalSchemas.has(candidate) && globalSchemas.get(candidate) !== textFor(name) || renameValues.has(candidate)) {
           i += 1;
           candidate = `${name}_${i}`;
         }
-        rename.set(name, candidate);
+        setRename(name, candidate);
         changed = true;
       }
     }
@@ -2518,6 +2543,7 @@ function extractSchemaFromDto(classDecl, sourceFile, project) {
     warnings: [],
     warnedDecorators: /* @__PURE__ */ new Set(),
     emittedClasses: /* @__PURE__ */ new Map(),
+    usedSchemaNames: /* @__PURE__ */ new Set(),
     visiting: /* @__PURE__ */ new Set(),
     recursiveSchemas: /* @__PURE__ */ new Set(),
     depth: 0,
@@ -2545,37 +2571,28 @@ function buildProperty(prop, classFile, ctx) {
   const typeNode = prop.getTypeNode();
   const typeText = typeNode?.getText() ?? "unknown";
   const isArrayType = !!typeNode && import_ts_morph4.Node.isArrayTypeNode(typeNode);
+  const asField = (child) => applyPresence(
+    has("IsArray") || isArrayType ? { kind: "array", element: child } : child,
+    decorators
+  );
   const discriminator = resolveDiscriminator(dec("Type"));
   if (discriminator) {
     const options = discriminator.subTypes.map(
       (name) => buildNestedReference(name, classFile, ctx)
     );
-    const unionNode = {
-      kind: "union",
-      options,
-      discriminator: discriminator.property
-    };
-    const wrapArray = has("IsArray") || isArrayType;
-    const node2 = wrapArray ? { kind: "array", element: unionNode } : unionNode;
-    return applyPresence(node2, decorators);
+    return asField({ kind: "union", options, discriminator: discriminator.property });
   }
   const propTypeParam = singularClassName(typeText);
   if (propTypeParam && ctx.typeBindings.has(propTypeParam)) {
     const bound = ctx.typeBindings.get(propTypeParam);
-    const childNode = buildNestedReference(bound, classFile, ctx);
-    const wrapArray = has("IsArray") || isArrayType;
-    const node2 = wrapArray ? { kind: "array", element: childNode } : childNode;
-    return applyPresence(node2, decorators);
+    return asField(buildNestedReference(bound, classFile, ctx));
   }
   const typeRefName = resolveTypeFactoryName(dec("Type"));
   if (has("ValidateNested") || typeRefName) {
     const typeArgs = genericTypeArgNames(typeNode);
     const childName = typeRefName ?? singularClassName(typeText);
     if (childName) {
-      const childNode = buildNestedReference(childName, classFile, ctx, typeArgs);
-      const wrapArray = has("IsArray") || isArrayType;
-      const node2 = wrapArray ? { kind: "array", element: childNode } : childNode;
-      return applyPresence(node2, decorators);
+      return asField(buildNestedReference(childName, classFile, ctx, typeArgs));
     }
   }
   let base = baseFromType(typeText, isArrayType);
@@ -2703,6 +2720,7 @@ function buildNestedReference(className, fromFile, ctx, typeArgs = []) {
   if (ctx.visiting.has(cacheKey)) {
     const reserved = ctx.emittedClasses.get(cacheKey) ?? aliasFor(schemaBase, ctx);
     ctx.emittedClasses.set(cacheKey, reserved);
+    ctx.usedSchemaNames.add(reserved);
     ctx.recursiveSchemas.add(reserved);
     if (!ctx.warnedDecorators.has(`recursive:${reserved}`)) {
       ctx.warnedDecorators.add(`recursive:${reserved}`);
@@ -2736,6 +2754,7 @@ function buildNestedReference(className, fromFile, ctx, typeArgs = []) {
   });
   for (const [k, v] of newBindings) ctx.typeBindings.set(k, v);
   ctx.emittedClasses.set(cacheKey, schemaName);
+  ctx.usedSchemaNames.add(schemaName);
   ctx.visiting.add(cacheKey);
   ctx.depth += 1;
   const childNode = buildObject(resolved.decl, resolved.file, ctx);
@@ -2743,15 +2762,14 @@ function buildNestedReference(className, fromFile, ctx, typeArgs = []) {
   ctx.visiting.delete(cacheKey);
   for (const [k] of newBindings) ctx.typeBindings.delete(k);
   ctx.named.set(schemaName, childNode);
+  ctx.usedSchemaNames.add(schemaName);
   return { kind: "ref", name: schemaName };
 }
 function aliasFor(className, ctx) {
   const baseName = `${className}Schema`;
   let candidate = baseName;
   let i = 1;
-  const used = new Set(ctx.named.keys());
-  for (const v of ctx.emittedClasses.values()) used.add(v);
-  while (used.has(candidate)) {
+  while (ctx.usedSchemaNames.has(candidate)) {
     candidate = `${baseName}_${i}`;
     i += 1;
   }
@@ -4430,7 +4448,7 @@ async function watch(config, onChange) {
 }
 
 // src/index.ts
-var VERSION = "0.5.0";
+var VERSION = "0.5.2";
 
 // src/cli/codegen.ts
 async function runCodegen(opts = {}) {