@dudousxd/nestjs-codegen 0.24.0 → 0.25.0

package/CHANGELOG.md

@@ -1,5 +1,21 @@
 # @dudousxd/nestjs-codegen
 
+## 0.25.0
+
+### Minor Changes
+
+- 595c4b1: Follow a factory-produced controller's own heritage chain, so a factory that wraps a factory contributes every level's routes.
+
+  `class C extends createTableController(...)` was resolved one level deep: discovery found the class the factory returns and read **its own methods only**. A factory whose returned class itself extends something — another factory call, or an ordinary base class — lost everything the inner level declared. The controller was not skipped, which would at least be visible; it was generated with a subset of its routes and no warning anywhere, while Nest served all of them.
+
+  That gap made the natural way to give SOME controllers an extra route unusable. Wrapping the shared factory in a second one and declaring the extra route as an ordinary `@Post('export')` method is the shape that keeps every route statically visible — the conditionality becomes which factory a controller extends — but the wrapper's own base routes disappeared from the client, so the pattern looked broken and the alternative (declaring the handler undecorated and mounting it imperatively, `Post('export')(proto, 'export', descriptor)`) is invisible to a static scan by construction.
+
+  Discovery now walks the returned class's chain to any depth, the way Nest walks the prototype chain, resolving each base through the same factory resolution or as a plain class declaration. Nearest declaration wins, so a wrapper overriding an inner route still contributes one route rather than two — matching how a derived controller's own override was already resolved against its base.
+
+  Also fixes the types of an inherited route. A route's parameter and return annotations were resolved against the CONTROLLER's file, but they are written in the file that declares the handler — the factory's. A `@Body() body: ExportRequestDto` on a factory-declared method resolved against a file that never imports `ExportRequestDto` and silently degraded to `unknown`, so the route reached the client accepting anything. They now resolve in the declaring file, which is what the filter pass already did. For a route declared on the controller itself the two files are the same and nothing changes.
+
+  Both are additive: routes and types that were missing now appear. Regenerate and expect new entries for any controller extending a wrapping factory, and real body/query/response types where an inherited route previously had `unknown`.
+
 ## 0.24.0
 
 ### Minor Changes

package/dist/cli/main.cjs

@@ -1653,6 +1653,32 @@ function resolveFactoryStaticClass(node) {
   if (!import_ts_morph5.Node.isIdentifier(inner)) return void 0;
   return inner.getDefinitions().map((d) => d.getDeclarationNode()).find((n) => n !== void 0 && import_ts_morph5.Node.isClassDeclaration(n));
 }
+function resolveBaseClass(cls) {
+  const heritage = cls.getExtends()?.getExpression();
+  if (!heritage) return void 0;
+  const call = resolveHeritageCall(heritage);
+  if (call) {
+    const factoryDecl = resolveFactoryDeclaration(call);
+    return factoryDecl ? resolveReturnedClass(factoryDecl) : void 0;
+  }
+  const expr = unwrapExpression(heritage);
+  if (!import_ts_morph5.Node.isIdentifier(expr)) return void 0;
+  return expr.getDefinitions().map((d) => d.getDeclarationNode()).find((n) => n !== void 0 && import_ts_morph5.Node.isClassDeclaration(n));
+}
+function collectMethodsThroughChain(returnedClass) {
+  const byName = /* @__PURE__ */ new Map();
+  const seen = /* @__PURE__ */ new Set();
+  let current = returnedClass;
+  while (current && !seen.has(current)) {
+    seen.add(current);
+    for (const method of current.getMethods()) {
+      const name = method.getName();
+      if (!byName.has(name)) byName.set(name, method);
+    }
+    current = resolveBaseClass(current);
+  }
+  return [...byName.values()];
+}
 function resolveInheritedMethods(cls) {
   const expr = resolveHeritageCall(cls.getExtends()?.getExpression());
   if (!expr) return void 0;
@@ -1692,7 +1718,7 @@ function resolveInheritedMethods(cls) {
     }
   }
   return {
-    methods: returnedClass.getMethods(),
+    methods: collectMethodsThroughChain(returnedClass),
     // The DECLARATION's name, not the call-site text: consumers look the factory
     // back up by name inside `factoryFilePath`, which a qualified
     // `tables.createTableController` would never match. For a bare identifier
@@ -3066,7 +3092,7 @@ function extractDtoRoute(args) {
   const methodName = method.getName();
   const classAs = readAsDecorator(cls, `class ${className}`);
   const methodAs = readAsDecorator(method, `${className}.${methodName}`);
-  const dtoContract = extractDtoContract(method, sourceFile, project, mixin, cls);
+  const dtoContract = extractDtoContract(method, method.getSourceFile(), project, mixin, cls);
   const mixinResponse = mixin ? resolveInstantiatedReturnType(cls, methodName) : void 0;
   return buildRoute({
     className,
@@ -5273,7 +5299,7 @@ async function watch(config, onChange, options = {}) {
 }
 
 // src/index.ts
-var VERSION = "0.24.0";
+var VERSION = "0.25.0";
 
 // src/cli/codegen.ts
 async function runCodegen(opts = {}) {