@dudousxd/nestjs-codegen 0.5.1 → 0.6.0

package/CHANGELOG.md

@@ -1,5 +1,19 @@
 # @dudousxd/nestjs-codegen
 
+## 0.6.0
+
+### Minor Changes
+
+- ece130c: Fix: resolve `@Filterable({ entity })` entities imported from external npm packages so the route is still classified as a filter route. Previously, when a filter's entity (e.g. a MikroORM entity from `@dudousxd/nestjs-durable-store-mikro-orm`) was imported from `node_modules` rather than an in-repo `*.entity.ts`, the discovery type resolver returned no candidates for the bare module specifier and bailed — degrading the route to a plain bodyless route (`body: never; filterFields: never`, no `queryOptions`) and breaking the generated client (`x.queryOptions is not a function`).
+
+  The type resolver now falls back to the TypeScript compiler's own module resolution (`getModuleSpecifierSourceFile()`) for bare node_modules specifiers, locating the package's `.d.ts` declaration file and enumerating the entity's columns from it. External-package filter entities now get the same full `filterFields` union + `body: FilterQueryResult` + TanStack `queryOptions` helper as in-repo entities.
+
+## 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

package/dist/cli/main.cjs

@@ -2270,7 +2270,6 @@ function resolveImportedType(name, sourceFile, project) {
     if (!namedImport) continue;
     const moduleSpecifier = importDecl.getModuleSpecifierValue();
     const candidates = resolveModuleSpecifier(moduleSpecifier, sourceFile, project);
-    if (candidates.length === 0) continue;
     for (const candidate of candidates) {
       let importedFile = project.getSourceFile(candidate);
       if (!importedFile) {
@@ -2285,9 +2284,25 @@ function resolveImportedType(name, sourceFile, project) {
       const viaReExport = resolveReExportedType(name, importedFile, project, /* @__PURE__ */ new Set());
       if (viaReExport) return viaReExport;
     }
+    if (candidates.length === 0) {
+      const viaCompiler = resolveBareSpecifierType(name, importDecl, project);
+      if (viaCompiler) return viaCompiler;
+    }
   }
   return resolveReExportedType(name, sourceFile, project, /* @__PURE__ */ new Set());
 }
+function resolveBareSpecifierType(name, importDecl, project) {
+  let target;
+  try {
+    target = importDecl.getModuleSpecifierSourceFile();
+  } catch {
+    return null;
+  }
+  if (!target) return null;
+  const direct = findTypeInFile(name, target);
+  if (direct) return direct;
+  return resolveReExportedType(name, target, project, /* @__PURE__ */ new Set());
+}
 function resolveReExportedType(name, file, project, seen) {
   const filePath = file.getFilePath();
   if (seen.has(filePath)) return null;
@@ -2571,37 +2586,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);
@@ -4457,7 +4463,7 @@ async function watch(config, onChange) {
 }
 
 // src/index.ts
-var VERSION = "0.5.1";
+var VERSION = "0.6.0";
 
 // src/cli/codegen.ts
 async function runCodegen(opts = {}) {