@dudousxd/nestjs-codegen 0.17.1 → 0.17.2

package/CHANGELOG.md

@@ -1,5 +1,27 @@
 # @dudousxd/nestjs-codegen
 
+## 0.17.2
+
+### Patch Changes
+
+- fcf816e: Resolve `@ApplyFilter(<Table>.filter)` on overridden mixin routes.
+
+  A controller that extends a factory-produced base and overrides one of its
+  routes has to re-declare `@ApplyFilter`, and the only handle on the filter the
+  factory generated internally is the static it hands back — a property access,
+  not an importable identifier. Discovery accepted identifiers only, so it skipped
+  the decorator entirely.
+
+  The failure was silent and total rather than partial: the route emitted with
+  `body: never` and `filterFields: never`, dropping the typed filter builder from
+  exactly the routes that took the override escape hatch, while `tsc` and codegen
+  both stayed green. It only surfaced downstream, as a client call that could no
+  longer be typed.
+
+  Such a property access is now resolved through the factory — const → factory
+  call → returned class → static property → the class declared in the factory
+  body.
+
 ## 0.17.1
 
 ### Patch Changes

package/dist/cli/main.cjs

@@ -2475,7 +2475,7 @@ var import_fast_glob3 = __toESM(require("fast-glob"), 1);
 var import_ts_morph10 = require("ts-morph");
 
 // src/discovery/dto-type-resolver.ts
-var import_ts_morph7 = require("ts-morph");
+var import_ts_morph8 = require("ts-morph");
 
 // src/discovery/dto-to-ir.ts
 var import_ts_morph4 = require("ts-morph");
@@ -3231,7 +3231,7 @@ function inSchemaFromDecorator(decorator) {
 }
 
 // src/discovery/filter-for.ts
-var import_ts_morph6 = require("ts-morph");
+var import_ts_morph7 = require("ts-morph");
 
 // src/discovery/filter-field-types.ts
 var import_ts_morph5 = require("ts-morph");
@@ -3450,6 +3450,123 @@ function toFilterFieldType(name, r) {
   return ft;
 }
 
+// src/discovery/heritage.ts
+var import_ts_morph6 = require("ts-morph");
+function resolveHeritageCall(node) {
+  if (!node) return void 0;
+  const expr = unwrapExpression(node);
+  if (import_ts_morph6.Node.isCallExpression(expr)) return expr;
+  if (!import_ts_morph6.Node.isIdentifier(expr)) return void 0;
+  const decl = expr.getDefinitions().map((d) => d.getDeclarationNode()).find(
+    (n) => n !== void 0 && import_ts_morph6.Node.isVariableDeclaration(n)
+  );
+  const init = decl?.getInitializer();
+  if (!init) return void 0;
+  const unwrapped = unwrapExpression(init);
+  return import_ts_morph6.Node.isCallExpression(unwrapped) ? unwrapped : void 0;
+}
+function unwrapExpression(node) {
+  let current = node;
+  while (import_ts_morph6.Node.isAsExpression(current) || import_ts_morph6.Node.isSatisfiesExpression(current) || import_ts_morph6.Node.isParenthesizedExpression(current) || import_ts_morph6.Node.isTypeAssertion(current)) {
+    current = current.getExpression();
+  }
+  return current;
+}
+function resolveReturnedClass(factoryDecl) {
+  const body = factoryDecl.getBody();
+  if (!body) return void 0;
+  const returns = body.getDescendants().filter((n) => import_ts_morph6.Node.isReturnStatement(n));
+  for (const ret of returns) {
+    const expr = ret.getExpression();
+    if (!expr) continue;
+    const inner = unwrapExpression(expr);
+    if (import_ts_morph6.Node.isClassExpression(inner)) {
+      return inner;
+    }
+    if (import_ts_morph6.Node.isIdentifier(inner)) {
+      const name = inner.getText();
+      const decl = body.getDescendants().find((n) => import_ts_morph6.Node.isClassDeclaration(n) && n.getName() === name);
+      if (decl) return decl;
+    }
+  }
+  return void 0;
+}
+function resolveFactoryDeclaration(call) {
+  const callee = call.getExpression();
+  if (!import_ts_morph6.Node.isIdentifier(callee)) return void 0;
+  return callee.getDefinitions().map((d) => d.getDeclarationNode()).find((n) => import_ts_morph6.Node.isFunctionDeclaration(n));
+}
+function resolveFactoryStaticClass(node) {
+  if (!import_ts_morph6.Node.isPropertyAccessExpression(node)) return void 0;
+  const call = resolveHeritageCall(node.getExpression());
+  if (!call) return void 0;
+  const factoryDecl = resolveFactoryDeclaration(call);
+  if (!factoryDecl) return void 0;
+  const returnedClass = resolveReturnedClass(factoryDecl);
+  if (!returnedClass) return void 0;
+  const staticProp = returnedClass.getStaticProperties().find((p) => p.getName() === node.getName());
+  if (!staticProp || !import_ts_morph6.Node.isPropertyDeclaration(staticProp)) return void 0;
+  const init = staticProp.getInitializer();
+  if (!init) return void 0;
+  const inner = unwrapExpression(init);
+  if (import_ts_morph6.Node.isClassExpression(inner)) return inner;
+  if (!import_ts_morph6.Node.isIdentifier(inner)) return void 0;
+  return inner.getDefinitions().map((d) => d.getDeclarationNode()).find((n) => n !== void 0 && import_ts_morph6.Node.isClassDeclaration(n));
+}
+function resolveInheritedMethods(cls) {
+  const expr = resolveHeritageCall(cls.getExtends()?.getExpression());
+  if (!expr) return void 0;
+  const callee = expr.getExpression();
+  if (!import_ts_morph6.Node.isIdentifier(callee)) return void 0;
+  const factoryDecl = resolveFactoryDeclaration(expr);
+  if (!factoryDecl) return void 0;
+  const returnedClass = resolveReturnedClass(factoryDecl);
+  if (!returnedClass) return void 0;
+  const classArgs = [];
+  for (const arg of expr.getArguments()) {
+    if (!import_ts_morph6.Node.isIdentifier(arg)) continue;
+    const decl = arg.getDefinitions().map((d) => d.getDeclarationNode()).find((n) => import_ts_morph6.Node.isClassDeclaration(n));
+    if (decl) {
+      classArgs.push({
+        name: decl.getName() ?? arg.getText(),
+        filePath: decl.getSourceFile().getFilePath()
+      });
+    }
+  }
+  return {
+    methods: returnedClass.getMethods(),
+    factoryName: callee.getText(),
+    factoryFilePath: factoryDecl.getSourceFile().getFilePath(),
+    classArgs
+  };
+}
+var mixinTypeProject;
+function getMixinTypeProject() {
+  mixinTypeProject ??= new import_ts_morph6.Project({
+    skipAddingFilesFromTsConfig: true,
+    compilerOptions: { strict: true }
+  });
+  return mixinTypeProject;
+}
+function clearMixinTypeProject() {
+  mixinTypeProject = void 0;
+}
+function resolveInstantiatedReturnType(cls, methodName) {
+  const filePath = cls.getSourceFile().getFilePath();
+  const className = cls.getName();
+  if (!className) return void 0;
+  const project = getMixinTypeProject();
+  const sourceFile = project.getSourceFile(filePath) ?? project.addSourceFileAtPathIfExists(filePath);
+  const typedCls = sourceFile?.getClass(className);
+  if (!typedCls) return void 0;
+  const prop = typedCls.getType().getProperty(methodName);
+  if (!prop) return void 0;
+  const returnType = prop.getTypeAtLocation(typedCls).getCallSignatures()[0]?.getReturnType();
+  if (!returnType) return void 0;
+  const unwrapped = returnType.getSymbol()?.getName() === "Promise" ? returnType.getTypeArguments()[0] ?? returnType : returnType;
+  return unwrapped.getText(typedCls);
+}
+
 // src/discovery/filter-for.ts
 function resolveMixinEntityClass(mixin, project) {
   const entityArg = mixin?.classArgs[0];
@@ -3458,7 +3575,7 @@ function resolveMixinEntityClass(mixin, project) {
   return file?.getClass(entityArg.name);
 }
 function classifyFilterForHint(typeInit) {
-  if (import_ts_morph6.Node.isStringLiteral(typeInit)) {
+  if (import_ts_morph7.Node.isStringLiteral(typeInit)) {
     switch (typeInit.getLiteralValue()) {
       case "string":
         return { kind: "string" };
@@ -3472,10 +3589,10 @@ function classifyFilterForHint(typeInit) {
         return null;
     }
   }
-  if (import_ts_morph6.Node.isArrayLiteralExpression(typeInit)) {
+  if (import_ts_morph7.Node.isArrayLiteralExpression(typeInit)) {
     const values = [];
     for (const el of typeInit.getElements()) {
-      if (!import_ts_morph6.Node.isStringLiteral(el)) return null;
+      if (!import_ts_morph7.Node.isStringLiteral(el)) return null;
       values.push(el.getLiteralValue());
     }
     if (values.length === 0) return null;
@@ -3510,11 +3627,11 @@ function extractFilterForHints(classDecl, project) {
     if (!filterForDec) continue;
     const args = filterForDec.getArguments();
     const keyArg = args[0];
-    const inputKey = keyArg && import_ts_morph6.Node.isStringLiteral(keyArg) ? keyArg.getLiteralValue() : method.getName();
+    const inputKey = keyArg && import_ts_morph7.Node.isStringLiteral(keyArg) ? keyArg.getLiteralValue() : method.getName();
     const optsArg = args[1];
-    if (optsArg && import_ts_morph6.Node.isObjectLiteralExpression(optsArg)) {
+    if (optsArg && import_ts_morph7.Node.isObjectLiteralExpression(optsArg)) {
       const typeProp = optsArg.getProperty("type");
-      if (typeProp && import_ts_morph6.Node.isPropertyAssignment(typeProp)) {
+      if (typeProp && import_ts_morph7.Node.isPropertyAssignment(typeProp)) {
         const typeInit = typeProp.getInitializer();
         if (typeInit) {
           const classified = classifyFilterForHint(typeInit);
@@ -3539,21 +3656,23 @@ function extractApplyFilterInfo(method, sourceFile, project, mixin) {
     const args = filterDecorator.getArguments();
     if (args.length === 0) continue;
     const filterClassArg = args[0];
-    if (!filterClassArg || !import_ts_morph6.Node.isIdentifier(filterClassArg)) continue;
+    if (!filterClassArg) continue;
+    const factoryStaticClass = resolveFactoryStaticClass(filterClassArg);
+    if (!factoryStaticClass && !import_ts_morph7.Node.isIdentifier(filterClassArg)) continue;
     let source = "query";
     const optionsArg = args[1];
-    if (optionsArg && import_ts_morph6.Node.isObjectLiteralExpression(optionsArg)) {
+    if (optionsArg && import_ts_morph7.Node.isObjectLiteralExpression(optionsArg)) {
       const sourceProp = optionsArg.getProperty("source");
-      if (sourceProp && import_ts_morph6.Node.isPropertyAssignment(sourceProp)) {
+      if (sourceProp && import_ts_morph7.Node.isPropertyAssignment(sourceProp)) {
         const init = sourceProp.getInitializer();
-        if (init && import_ts_morph6.Node.isStringLiteral(init) && init.getLiteralValue() === "body") {
+        if (init && import_ts_morph7.Node.isStringLiteral(init) && init.getLiteralValue() === "body") {
           source = "body";
         }
       }
     }
     const filterClassName = filterClassArg.getText();
-    const resolved = findType(filterClassName, declFile, project);
-    const classDecl = resolved?.kind === "class" ? resolved.decl : resolveLocalClassDeclaration(filterClassArg);
+    const resolved = factoryStaticClass ? void 0 : findType(filterClassName, declFile, project);
+    const classDecl = factoryStaticClass ?? (resolved?.kind === "class" ? resolved.decl : resolveLocalClassDeclaration(filterClassArg));
     if (classDecl) {
       let fieldTypes = extractClassPropertyTypes(classDecl, project);
       if (fieldTypes.length === 0) {
@@ -3609,22 +3728,22 @@ function resolveRelationEntity(prop, sourceFile, project) {
     const args = dec.getArguments();
     if (args.length === 0) continue;
     const arg = args[0];
-    if (import_ts_morph6.Node.isObjectLiteralExpression(arg)) {
+    if (import_ts_morph7.Node.isObjectLiteralExpression(arg)) {
       const entityProp = arg.getProperty("entity");
-      if (entityProp && import_ts_morph6.Node.isPropertyAssignment(entityProp)) {
+      if (entityProp && import_ts_morph7.Node.isPropertyAssignment(entityProp)) {
         const init = entityProp.getInitializer();
-        if (init && import_ts_morph6.Node.isArrowFunction(init)) {
+        if (init && import_ts_morph7.Node.isArrowFunction(init)) {
           const body = init.getBody();
-          if (import_ts_morph6.Node.isIdentifier(body)) {
+          if (import_ts_morph7.Node.isIdentifier(body)) {
             const resolved = findType(body.getText(), prop.getSourceFile(), project);
             if (resolved?.kind === "class") return resolved.decl;
           }
         }
       }
     }
-    if (import_ts_morph6.Node.isArrowFunction(arg)) {
+    if (import_ts_morph7.Node.isArrowFunction(arg)) {
       const body = arg.getBody();
-      if (import_ts_morph6.Node.isIdentifier(body)) {
+      if (import_ts_morph7.Node.isIdentifier(body)) {
         const resolved = findType(body.getText(), prop.getSourceFile(), project);
         if (resolved?.kind === "class") return resolved.decl;
       }
@@ -3643,15 +3762,15 @@ function extractClassPropertyTypes(classDecl, project) {
   return fields;
 }
 function resolveLocalClassDeclaration(identifier) {
-  if (!import_ts_morph6.Node.isIdentifier(identifier)) return void 0;
-  return identifier.getDefinitions().map((d) => d.getDeclarationNode()).find((n) => n !== void 0 && import_ts_morph6.Node.isClassDeclaration(n));
+  if (!import_ts_morph7.Node.isIdentifier(identifier)) return void 0;
+  return identifier.getDefinitions().map((d) => d.getDeclarationNode()).find((n) => n !== void 0 && import_ts_morph7.Node.isClassDeclaration(n));
 }
 function resolveDeclaredEntity(optionsArg, filterClass, project) {
-  if (!import_ts_morph6.Node.isObjectLiteralExpression(optionsArg)) return void 0;
+  if (!import_ts_morph7.Node.isObjectLiteralExpression(optionsArg)) return void 0;
   const entityProp = optionsArg.getProperty("entity");
-  if (!entityProp || !import_ts_morph6.Node.isPropertyAssignment(entityProp)) return void 0;
+  if (!entityProp || !import_ts_morph7.Node.isPropertyAssignment(entityProp)) return void 0;
   const entityInit = entityProp.getInitializer();
-  if (!entityInit || !import_ts_morph6.Node.isIdentifier(entityInit)) return void 0;
+  if (!entityInit || !import_ts_morph7.Node.isIdentifier(entityInit)) return void 0;
   const resolved = findType(entityInit.getText(), filterClass.getSourceFile(), project);
   if (!resolved || resolved.kind !== "class") return void 0;
   return resolved.decl;
@@ -3662,7 +3781,7 @@ function extractFilterableEntityFields(filterClass, project, entityOverride) {
   const args = filterableDecorator.getArguments();
   if (args.length === 0) return [];
   const optionsArg = args[0];
-  if (!import_ts_morph6.Node.isObjectLiteralExpression(optionsArg)) return [];
+  if (!import_ts_morph7.Node.isObjectLiteralExpression(optionsArg)) return [];
   const entityDecl = entityOverride ?? resolveDeclaredEntity(optionsArg, filterClass, project);
   if (!entityDecl) return [];
   const fields = collectEntityFields(
@@ -3675,17 +3794,17 @@ function extractFilterableEntityFields(filterClass, project, entityOverride) {
   const relationsDecorator = filterClass.getDecorators().find((d) => d.getName() === "Relations");
   if (relationsDecorator) {
     const relArgs = relationsDecorator.getArguments();
-    if (relArgs.length > 0 && import_ts_morph6.Node.isObjectLiteralExpression(relArgs[0])) {
+    if (relArgs.length > 0 && import_ts_morph7.Node.isObjectLiteralExpression(relArgs[0])) {
       for (const relProp of relArgs[0].getProperties()) {
-        if (!import_ts_morph6.Node.isPropertyAssignment(relProp)) continue;
+        if (!import_ts_morph7.Node.isPropertyAssignment(relProp)) continue;
         const relInit = relProp.getInitializer();
-        if (!relInit || !import_ts_morph6.Node.isObjectLiteralExpression(relInit)) continue;
+        if (!relInit || !import_ts_morph7.Node.isObjectLiteralExpression(relInit)) continue;
         const keysProp = relInit.getProperty("keys");
-        if (!keysProp || !import_ts_morph6.Node.isPropertyAssignment(keysProp)) continue;
+        if (!keysProp || !import_ts_morph7.Node.isPropertyAssignment(keysProp)) continue;
         const keysInit = keysProp.getInitializer();
-        if (!keysInit || !import_ts_morph6.Node.isArrayLiteralExpression(keysInit)) continue;
+        if (!keysInit || !import_ts_morph7.Node.isArrayLiteralExpression(keysInit)) continue;
         for (const el of keysInit.getElements()) {
-          if (import_ts_morph6.Node.isStringLiteral(el)) {
+          if (import_ts_morph7.Node.isStringLiteral(el)) {
             fields.push(toFilterFieldType(el.getLiteralValue(), { kind: "unknown" }));
           }
         }
@@ -3726,22 +3845,22 @@ var PASSTHROUGH_UTILITY = /* @__PURE__ */ new Set([
 ]);
 function resolveTypeNodeToString(typeNode, sourceFile, project, depth, subst = /* @__PURE__ */ new Map()) {
   if (depth <= 0) return "unknown";
-  if (import_ts_morph7.Node.isArrayTypeNode(typeNode)) {
+  if (import_ts_morph8.Node.isArrayTypeNode(typeNode)) {
     const elementType = typeNode.getElementTypeNode();
     return `Array<${resolveTypeNodeToString(elementType, sourceFile, project, depth, subst)}>`;
   }
-  if (import_ts_morph7.Node.isUnionTypeNode(typeNode)) {
+  if (import_ts_morph8.Node.isUnionTypeNode(typeNode)) {
     return typeNode.getTypeNodes().map((t) => resolveTypeNodeToString(t, sourceFile, project, depth, subst)).join(" | ");
   }
-  if (import_ts_morph7.Node.isIntersectionTypeNode(typeNode)) {
+  if (import_ts_morph8.Node.isIntersectionTypeNode(typeNode)) {
     return typeNode.getTypeNodes().map((t) => resolveTypeNodeToString(t, sourceFile, project, depth, subst)).join(" & ");
   }
-  if (import_ts_morph7.Node.isParenthesizedTypeNode(typeNode)) {
+  if (import_ts_morph8.Node.isParenthesizedTypeNode(typeNode)) {
     return `(${resolveTypeNodeToString(typeNode.getTypeNode(), sourceFile, project, depth, subst)})`;
   }
-  if (import_ts_morph7.Node.isTypeReference(typeNode)) {
+  if (import_ts_morph8.Node.isTypeReference(typeNode)) {
     const typeName = typeNode.getTypeName();
-    const name = import_ts_morph7.Node.isIdentifier(typeName) ? typeName.getText() : typeNode.getText();
+    const name = import_ts_morph8.Node.isIdentifier(typeName) ? typeName.getText() : typeNode.getText();
     const bound = subst.get(name);
     if (bound !== void 0) return bound;
     if (name === "string" || name === "number" || name === "boolean") return name;
@@ -3764,10 +3883,10 @@ function resolveTypeNodeToString(typeNode, sourceFile, project, depth, subst = /
     dbg("unresolvable type:", name, "in", sourceFile.getFilePath());
     return "unknown";
   }
-  if (import_ts_morph7.Node.isTypeLiteral(typeNode)) {
+  if (import_ts_morph8.Node.isTypeLiteral(typeNode)) {
     const members = [];
     for (const member of typeNode.getMembers()) {
-      if (import_ts_morph7.Node.isPropertySignature(member)) {
+      if (import_ts_morph8.Node.isPropertySignature(member)) {
         const memberTypeNode = member.getTypeNode();
         const memberType = memberTypeNode ? resolveTypeNodeToString(memberTypeNode, sourceFile, project, depth, subst) : "unknown";
         members.push(`${member.getName()}${member.hasQuestionToken() ? "?" : ""}: ${memberType}`);
@@ -3778,11 +3897,11 @@ function resolveTypeNodeToString(typeNode, sourceFile, project, depth, subst = /
     return members.length > 0 ? `{ ${members.join("; ")} }` : "{}";
   }
   const kind = typeNode.getKind();
-  if (kind === import_ts_morph7.SyntaxKind.StringKeyword) return "string";
-  if (kind === import_ts_morph7.SyntaxKind.NumberKeyword) return "number";
-  if (kind === import_ts_morph7.SyntaxKind.BooleanKeyword) return "boolean";
-  if (kind === import_ts_morph7.SyntaxKind.UnknownKeyword) return "unknown";
-  if (kind === import_ts_morph7.SyntaxKind.AnyKeyword) return "unknown";
+  if (kind === import_ts_morph8.SyntaxKind.StringKeyword) return "string";
+  if (kind === import_ts_morph8.SyntaxKind.NumberKeyword) return "number";
+  if (kind === import_ts_morph8.SyntaxKind.BooleanKeyword) return "boolean";
+  if (kind === import_ts_morph8.SyntaxKind.UnknownKeyword) return "unknown";
+  if (kind === import_ts_morph8.SyntaxKind.AnyKeyword) return "unknown";
   return typeNode.getText();
 }
 function unwrapFirstTypeArg(typeNode, sourceFile, project, depth, mode, subst = /* @__PURE__ */ new Map()) {
@@ -3867,7 +3986,7 @@ function extractQueryType(method, sourceFile, project) {
     if (!queryDecorator) continue;
     const queryArgs = queryDecorator.getArguments();
     const nameArg = queryArgs[0];
-    if (!nameArg || !import_ts_morph7.Node.isStringLiteral(nameArg)) continue;
+    if (!nameArg || !import_ts_morph8.Node.isStringLiteral(nameArg)) continue;
     const queryName = nameArg.getLiteralValue();
     const typeNode = param.getTypeNode();
     const queryType = typeNode ? resolveTypeNodeToString(typeNode, sourceFile, project, 3) : "string";
@@ -3878,8 +3997,8 @@ function extractQueryType(method, sourceFile, project) {
 function isParamOptional(param) {
   if (param.hasQuestionToken() || param.hasInitializer()) return true;
   const typeNode = param.getTypeNode();
-  if (typeNode && import_ts_morph7.Node.isUnionTypeNode(typeNode)) {
-    return typeNode.getTypeNodes().some((t) => t.getKind() === import_ts_morph7.SyntaxKind.UndefinedKeyword);
+  if (typeNode && import_ts_morph8.Node.isUnionTypeNode(typeNode)) {
+    return typeNode.getTypeNodes().some((t) => t.getKind() === import_ts_morph8.SyntaxKind.UndefinedKeyword);
   }
   return false;
 }
@@ -3891,7 +4010,7 @@ function extractParamsType(method, sourceFile, project) {
     const paramArgs = paramDecorator.getArguments();
     if (paramArgs.length === 0) continue;
     const nameArg = paramArgs[0];
-    if (!import_ts_morph7.Node.isStringLiteral(nameArg)) continue;
+    if (!import_ts_morph8.Node.isStringLiteral(nameArg)) continue;
     const paramName = nameArg.getLiteralValue();
     const typeNode = param.getTypeNode();
     const paramType = typeNode ? resolveTypeNodeToString(typeNode, sourceFile, project, 3) : "string";
@@ -3912,28 +4031,28 @@ function extractUploadedFiles(method) {
   for (const decorator of method.getDecorators()) {
     if (decorator.getName() !== "UseInterceptors") continue;
     for (const arg of decorator.getArguments()) {
-      if (!import_ts_morph7.Node.isCallExpression(arg)) continue;
+      if (!import_ts_morph8.Node.isCallExpression(arg)) continue;
       const interceptor = arg.getExpression().getText();
       const callArgs = arg.getArguments();
       const firstArg2 = callArgs[0];
       if (interceptor === "FileInterceptor") {
-        if (firstArg2 && import_ts_morph7.Node.isStringLiteral(firstArg2)) {
+        if (firstArg2 && import_ts_morph8.Node.isStringLiteral(firstArg2)) {
           entries.push(`${firstArg2.getLiteralValue()}: ${FILE}`);
           multipart = true;
         }
       } else if (interceptor === "FilesInterceptor") {
-        if (firstArg2 && import_ts_morph7.Node.isStringLiteral(firstArg2)) {
+        if (firstArg2 && import_ts_morph8.Node.isStringLiteral(firstArg2)) {
           entries.push(`${firstArg2.getLiteralValue()}: Array<${FILE}>`);
           multipart = true;
         }
       } else if (interceptor === "FileFieldsInterceptor") {
-        if (firstArg2 && import_ts_morph7.Node.isArrayLiteralExpression(firstArg2)) {
+        if (firstArg2 && import_ts_morph8.Node.isArrayLiteralExpression(firstArg2)) {
           for (const el of firstArg2.getElements()) {
-            if (!import_ts_morph7.Node.isObjectLiteralExpression(el)) continue;
+            if (!import_ts_morph8.Node.isObjectLiteralExpression(el)) continue;
             const nameProp = el.getProperty("name");
-            if (nameProp && import_ts_morph7.Node.isPropertyAssignment(nameProp)) {
+            if (nameProp && import_ts_morph8.Node.isPropertyAssignment(nameProp)) {
               const init = nameProp.getInitializer();
-              if (init && import_ts_morph7.Node.isStringLiteral(init)) {
+              if (init && import_ts_morph8.Node.isStringLiteral(init)) {
                 entries.push(`${init.getLiteralValue()}: Array<${FILE}>`);
               }
             }
@@ -3953,13 +4072,13 @@ function extractResponseType(method, sourceFile, project) {
   if (apiResponseDecorator) {
     const args = apiResponseDecorator.getArguments();
     const optsArg = args[0];
-    if (optsArg && import_ts_morph7.Node.isObjectLiteralExpression(optsArg)) {
+    if (optsArg && import_ts_morph8.Node.isObjectLiteralExpression(optsArg)) {
       for (const prop of optsArg.getProperties()) {
-        if (!import_ts_morph7.Node.isPropertyAssignment(prop)) continue;
+        if (!import_ts_morph8.Node.isPropertyAssignment(prop)) continue;
         if (prop.getName() !== "type") continue;
         const val = prop.getInitializer();
         if (!val) continue;
-        if (import_ts_morph7.Node.isArrayLiteralExpression(val)) {
+        if (import_ts_morph8.Node.isArrayLiteralExpression(val)) {
           const elements = val.getElements();
           const firstEl = elements[0];
           if (elements.length > 0 && firstEl !== void 0) {
@@ -3980,24 +4099,24 @@ function extractResponseType(method, sourceFile, project) {
 }
 function apiResponseStatus(decorator) {
   const optsArg = decorator.getArguments()[0];
-  if (!optsArg || !import_ts_morph7.Node.isObjectLiteralExpression(optsArg)) return null;
+  if (!optsArg || !import_ts_morph8.Node.isObjectLiteralExpression(optsArg)) return null;
   for (const prop of optsArg.getProperties()) {
-    if (!import_ts_morph7.Node.isPropertyAssignment(prop)) continue;
+    if (!import_ts_morph8.Node.isPropertyAssignment(prop)) continue;
     if (prop.getName() !== "status") continue;
     const val = prop.getInitializer();
-    if (val && import_ts_morph7.Node.isNumericLiteral(val)) return Number(val.getLiteralValue());
+    if (val && import_ts_morph8.Node.isNumericLiteral(val)) return Number(val.getLiteralValue());
   }
   return null;
 }
 function apiResponseTypeNode(decorator) {
   const optsArg = decorator.getArguments()[0];
-  if (!optsArg || !import_ts_morph7.Node.isObjectLiteralExpression(optsArg)) return null;
+  if (!optsArg || !import_ts_morph8.Node.isObjectLiteralExpression(optsArg)) return null;
   for (const prop of optsArg.getProperties()) {
-    if (!import_ts_morph7.Node.isPropertyAssignment(prop)) continue;
+    if (!import_ts_morph8.Node.isPropertyAssignment(prop)) continue;
     if (prop.getName() !== "type") continue;
     const val = prop.getInitializer();
     if (!val) return null;
-    if (import_ts_morph7.Node.isArrayLiteralExpression(val)) {
+    if (import_ts_morph8.Node.isArrayLiteralExpression(val)) {
       const first = val.getElements()[0];
       return first ? { node: first, isArray: true } : null;
     }
@@ -4015,7 +4134,7 @@ function extractErrorType(method, sourceFile, project) {
     const inner = resolveIdentifierToClassType(typeInfo.node, sourceFile, project, 3);
     const type = typeInfo.isArray ? `Array<${inner}>` : inner;
     let ref = null;
-    if (import_ts_morph7.Node.isIdentifier(typeInfo.node)) {
+    if (import_ts_morph8.Node.isIdentifier(typeInfo.node)) {
       const name = typeInfo.node.getText();
       const localDecl = sourceFile.getInterface(name) || sourceFile.getClass(name) || sourceFile.getTypeAlias(name);
       if (localDecl?.isExported()) {
@@ -4032,7 +4151,7 @@ function extractErrorType(method, sourceFile, project) {
   return null;
 }
 function resolveIdentifierToClassType(node, sourceFile, project, depth) {
-  if (!import_ts_morph7.Node.isIdentifier(node)) return "unknown";
+  if (!import_ts_morph8.Node.isIdentifier(node)) return "unknown";
   const name = node.getText();
   const resolved = findType(name, sourceFile, project);
   if (resolved) {
@@ -4052,9 +4171,9 @@ var STREAM_ENVELOPES = /* @__PURE__ */ new Set(["MessageEvent", "MessageEventLik
 var BINARY_RESPONSE_TYPES = /* @__PURE__ */ new Set(["StreamableFile", "Buffer"]);
 function detectBinaryResponse(method) {
   const node = unwrapNamedContainer(method.getReturnTypeNode(), /* @__PURE__ */ new Set(["Promise"]));
-  if (!node || !import_ts_morph7.Node.isTypeReference(node)) return false;
+  if (!node || !import_ts_morph8.Node.isTypeReference(node)) return false;
   const typeName = node.getTypeName();
-  const name = import_ts_morph7.Node.isIdentifier(typeName) ? typeName.getText() : "";
+  const name = import_ts_morph8.Node.isIdentifier(typeName) ? typeName.getText() : "";
   return BINARY_RESPONSE_TYPES.has(name);
 }
 function detectStreamElement(method) {
@@ -4069,9 +4188,9 @@ function detectStreamElement(method) {
   return null;
 }
 function streamContainerElement(node) {
-  if (!node || !import_ts_morph7.Node.isTypeReference(node)) return null;
+  if (!node || !import_ts_morph8.Node.isTypeReference(node)) return null;
   const typeName = node.getTypeName();
-  const name = import_ts_morph7.Node.isIdentifier(typeName) ? typeName.getText() : "";
+  const name = import_ts_morph8.Node.isIdentifier(typeName) ? typeName.getText() : "";
   if (STREAM_CONTAINERS.has(name) || STREAM_CONTAINERS_GENERATOR.has(name)) {
     return node.getTypeArguments()[0] ?? null;
   }
@@ -4081,9 +4200,9 @@ function hasAsQueryDecorator(method) {
   return method.getDecorators().some((d) => d.getName() === "AsQuery");
 }
 function unwrapNamedContainer(node, names) {
-  if (!node || !import_ts_morph7.Node.isTypeReference(node)) return node;
+  if (!node || !import_ts_morph8.Node.isTypeReference(node)) return node;
   const typeName = node.getTypeName();
-  const name = import_ts_morph7.Node.isIdentifier(typeName) ? typeName.getText() : "";
+  const name = import_ts_morph8.Node.isIdentifier(typeName) ? typeName.getText() : "";
   if (names.has(name)) {
     return node.getTypeArguments()[0] ?? node;
   }
@@ -4129,11 +4248,11 @@ function extractDtoContract(method, sourceFile, project, mixin) {
     if (apiResp) {
       const args = apiResp.getArguments();
       const optsArg = args[0];
-      if (optsArg && import_ts_morph7.Node.isObjectLiteralExpression(optsArg)) {
+      if (optsArg && import_ts_morph8.Node.isObjectLiteralExpression(optsArg)) {
         for (const prop of optsArg.getProperties()) {
-          if (import_ts_morph7.Node.isPropertyAssignment(prop) && prop.getName() === "type") {
+          if (import_ts_morph8.Node.isPropertyAssignment(prop) && prop.getName() === "type") {
             const val = prop.getInitializer();
-            if (val && import_ts_morph7.Node.isIdentifier(val)) {
+            if (val && import_ts_morph8.Node.isIdentifier(val)) {
               const name = val.getText();
               const localDecl = sourceFile.getInterface(name) || sourceFile.getClass(name) || sourceFile.getTypeAlias(name);
               if (localDecl?.isExported()) {
@@ -4201,101 +4320,6 @@ function resolveParamClass(method, decoratorName, sourceFile, project) {
   return null;
 }
 
-// src/discovery/heritage.ts
-var import_ts_morph8 = require("ts-morph");
-function resolveHeritageCall(node) {
-  if (!node) return void 0;
-  const expr = unwrapExpression(node);
-  if (import_ts_morph8.Node.isCallExpression(expr)) return expr;
-  if (!import_ts_morph8.Node.isIdentifier(expr)) return void 0;
-  const decl = expr.getDefinitions().map((d) => d.getDeclarationNode()).find(
-    (n) => n !== void 0 && import_ts_morph8.Node.isVariableDeclaration(n)
-  );
-  const init = decl?.getInitializer();
-  if (!init) return void 0;
-  const unwrapped = unwrapExpression(init);
-  return import_ts_morph8.Node.isCallExpression(unwrapped) ? unwrapped : void 0;
-}
-function unwrapExpression(node) {
-  let current = node;
-  while (import_ts_morph8.Node.isAsExpression(current) || import_ts_morph8.Node.isSatisfiesExpression(current) || import_ts_morph8.Node.isParenthesizedExpression(current) || import_ts_morph8.Node.isTypeAssertion(current)) {
-    current = current.getExpression();
-  }
-  return current;
-}
-function resolveReturnedClass(factoryDecl) {
-  const body = factoryDecl.getBody();
-  if (!body) return void 0;
-  const returns = body.getDescendants().filter((n) => import_ts_morph8.Node.isReturnStatement(n));
-  for (const ret of returns) {
-    const expr = ret.getExpression();
-    if (!expr) continue;
-    const inner = unwrapExpression(expr);
-    if (import_ts_morph8.Node.isClassExpression(inner)) {
-      return inner;
-    }
-    if (import_ts_morph8.Node.isIdentifier(inner)) {
-      const name = inner.getText();
-      const decl = body.getDescendants().find((n) => import_ts_morph8.Node.isClassDeclaration(n) && n.getName() === name);
-      if (decl) return decl;
-    }
-  }
-  return void 0;
-}
-function resolveInheritedMethods(cls) {
-  const expr = resolveHeritageCall(cls.getExtends()?.getExpression());
-  if (!expr) return void 0;
-  const callee = expr.getExpression();
-  if (!import_ts_morph8.Node.isIdentifier(callee)) return void 0;
-  const factoryDecl = callee.getDefinitions().map((d) => d.getDeclarationNode()).find((n) => import_ts_morph8.Node.isFunctionDeclaration(n));
-  if (!factoryDecl) return void 0;
-  const returnedClass = resolveReturnedClass(factoryDecl);
-  if (!returnedClass) return void 0;
-  const classArgs = [];
-  for (const arg of expr.getArguments()) {
-    if (!import_ts_morph8.Node.isIdentifier(arg)) continue;
-    const decl = arg.getDefinitions().map((d) => d.getDeclarationNode()).find((n) => import_ts_morph8.Node.isClassDeclaration(n));
-    if (decl) {
-      classArgs.push({
-        name: decl.getName() ?? arg.getText(),
-        filePath: decl.getSourceFile().getFilePath()
-      });
-    }
-  }
-  return {
-    methods: returnedClass.getMethods(),
-    factoryName: callee.getText(),
-    factoryFilePath: factoryDecl.getSourceFile().getFilePath(),
-    classArgs
-  };
-}
-var mixinTypeProject;
-function getMixinTypeProject() {
-  mixinTypeProject ??= new import_ts_morph8.Project({
-    skipAddingFilesFromTsConfig: true,
-    compilerOptions: { strict: true }
-  });
-  return mixinTypeProject;
-}
-function clearMixinTypeProject() {
-  mixinTypeProject = void 0;
-}
-function resolveInstantiatedReturnType(cls, methodName) {
-  const filePath = cls.getSourceFile().getFilePath();
-  const className = cls.getName();
-  if (!className) return void 0;
-  const project = getMixinTypeProject();
-  const sourceFile = project.getSourceFile(filePath) ?? project.addSourceFileAtPathIfExists(filePath);
-  const typedCls = sourceFile?.getClass(className);
-  if (!typedCls) return void 0;
-  const prop = typedCls.getType().getProperty(methodName);
-  if (!prop) return void 0;
-  const returnType = prop.getTypeAtLocation(typedCls).getCallSignatures()[0]?.getReturnType();
-  if (!returnType) return void 0;
-  const unwrapped = returnType.getSymbol()?.getName() === "Promise" ? returnType.getTypeArguments()[0] ?? returnType : returnType;
-  return unwrapped.getText(typedCls);
-}
-
 // src/discovery/zod-ast-to-ts.ts
 var import_ts_morph9 = require("ts-morph");
 function zodAstToTs(node) {
@@ -5029,7 +5053,7 @@ async function watch(config, onChange, options = {}) {
 }
 
 // src/index.ts
-var VERSION = "0.17.1";
+var VERSION = "0.17.2";
 
 // src/cli/codegen.ts
 async function runCodegen(opts = {}) {