@dudousxd/nestjs-codegen 0.17.0 → 0.17.1

package/CHANGELOG.md

@@ -1,5 +1,28 @@
 # @dudousxd/nestjs-codegen
 
+## 0.17.1
+
+### Patch Changes
+
+- Support mixin controllers that OVERRIDE an inherited route.
+
+  Two gaps made the override pattern undiscoverable, so a subclass that customised
+  one route silently lost every route it did not override:
+
+  - **Heritage by identifier.** Discovery required a literal call expression
+    (`extends factory(Entity)`). But an override has to name the factory's products
+    in its own decorators (e.g. `@ApplyFilter(SomeTable.filter)`) and cannot
+    reference itself at decoration time, so the factory call must be bound to a
+    const first — `extends SomeTable`. That form now resolves through the const's
+    initialiser.
+  - **Override deduplication.** The derived class's own method now shadows the
+    inherited one of the same name. Emitting both produced two routes with the same
+    name (tripping the collision check); dropping the inherited siblings would have
+    lost the routes the subclass left alone.
+
+  An overriding method also keeps the route's mixin binding, so its `filterFields`
+  still resolve from the call-site entity.
+
 ## 0.17.0
 
 ### Minor Changes

package/dist/cli/main.cjs

@@ -4203,6 +4203,19 @@ function resolveParamClass(method, decoratorName, sourceFile, project) {
 
 // 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)) {
@@ -4230,8 +4243,8 @@ function resolveReturnedClass(factoryDecl) {
   return void 0;
 }
 function resolveInheritedMethods(cls) {
-  const expr = cls.getExtends()?.getExpression();
-  if (!expr || !import_ts_morph8.Node.isCallExpression(expr)) return void 0;
+  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));
@@ -4786,9 +4799,11 @@ function extractFromSourceFile(sourceFile, project) {
       factoryFilePath: inherited.factoryFilePath,
       classArgs: inherited.classArgs
     } : void 0;
+    const ownMethods = cls.getMethods();
+    const ownNames = new Set(ownMethods.map((m) => m.getName()));
     const methods = [
-      ...cls.getMethods().map((method) => ({ method })),
-      ...(inherited?.methods ?? []).map((method) => ({ method, mixin: mixinBinding }))
+      ...ownMethods.map((method) => ({ method, mixin: mixinBinding })),
+      ...(inherited?.methods ?? []).filter((method) => !ownNames.has(method.getName())).map((method) => ({ method, mixin: mixinBinding }))
     ];
     for (const { method, mixin } of methods) {
       const verb = resolveVerb(method);
@@ -5014,7 +5029,7 @@ async function watch(config, onChange, options = {}) {
 }
 
 // src/index.ts
-var VERSION = "0.17.0";
+var VERSION = "0.17.1";
 
 // src/cli/codegen.ts
 async function runCodegen(opts = {}) {