@dudousxd/nestjs-codegen 0.18.0 → 0.19.0

package/CHANGELOG.md

@@ -1,5 +1,55 @@
 # @dudousxd/nestjs-codegen
 
+## 0.19.0
+
+### Minor Changes
+
+- 8ffea16: Discover controller factories called through a property, and warn — loudly —
+  when a factory heritage clause cannot be followed at all.
+
+  A controller whose base came from anything other than a bare function name
+  contributed ZERO routes to the generated client:
+
+  ```ts
+  class A extends tables.createTableController(Entity, {}) {} // namespace import
+  class B extends TableFactory.create(Entity, {}) {} // static method
+  class C extends factories.table(Entity, {}) {} // re-export object
+  ```
+
+  Discovery required the callee of the factory call to be an `Identifier`, so each
+  of these resolved to nothing — and unlike the earlier filter gaps, this does not
+  mutilate a route's contract, it deletes the whole controller. `tsc` green,
+  codegen green, no warning: the first sign is a client call that does not exist.
+
+  The callee is now resolved through its name node, which covers a namespace import
+  (`ns.factory(...)`), a static method (`Factory.create(...)`) and a property of a
+  re-export object (`factories.table(...)`, including the `{ createTableController }`
+  shorthand). Bare identifiers are unchanged. A callee with no name node — an
+  element access (`factories['table'](...)`) or a callee that is itself a call
+  (`makeFactory()(Entity)`) — would mean evaluating the program to name the
+  function, so it stays unresolved.
+
+  Unresolved is no longer silent. A `@Controller`-decorated class whose heritage is
+  a factory-shaped CALL that discovery cannot follow now prints one line naming the
+  file, the class, the callee and what it costs:
+
+  ```
+  [nestjs-codegen/fast] SearchUtilsController in /src/utils/search.controller.ts
+  extends makeTableController()(...) but its callee is not a name that can be
+  resolved statically — it contributes NO routes to the generated client.
+  ```
+
+  Scoped tightly on purpose: it is a warning and never a throw, and it stays quiet
+  for `extends SomeBaseClass` (not a call) and for any class without `@Controller`
+  (extending a call expression is ordinary code). So the next unsupported shape
+  costs a line on stderr instead of a day.
+
+  `MixinBinding.factoryName` now carries the resolved DECLARATION's name rather
+  than the call-site text — a qualified `tables.createTableController` would never
+  match the by-name lookup consumers do inside `factoryFilePath`. Identical for
+  every existing bare-identifier call site, bar an import alias, where the
+  declaration name is the one that resolves.
+
 ## 0.18.0
 
 ### Minor Changes

package/dist/cli/main.cjs

@@ -3491,10 +3491,46 @@ function resolveReturnedClass(factoryDecl) {
   }
   return void 0;
 }
+function factoryCalleeName(call) {
+  const callee = unwrapExpression(call.getExpression());
+  if (import_ts_morph6.Node.isIdentifier(callee)) return callee;
+  if (import_ts_morph6.Node.isPropertyAccessExpression(callee)) {
+    const name = callee.getNameNode();
+    return import_ts_morph6.Node.isIdentifier(name) ? name : void 0;
+  }
+  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));
+  const name = factoryCalleeName(call);
+  return name ? resolveFactoryFromName(name, /* @__PURE__ */ new Set()) : void 0;
+}
+function resolveFactoryFromName(name, seen) {
+  if (seen.has(name)) return void 0;
+  seen.add(name);
+  const decls = name.getDefinitions().map((d) => d.getDeclarationNode()).filter((n) => n !== void 0);
+  for (const decl of decls) {
+    if (import_ts_morph6.Node.isFunctionDeclaration(decl) || import_ts_morph6.Node.isMethodDeclaration(decl)) return decl;
+    if (import_ts_morph6.Node.isPropertyAssignment(decl)) {
+      const init = decl.getInitializer();
+      const inner = init ? unwrapExpression(init) : void 0;
+      if (inner && import_ts_morph6.Node.isIdentifier(inner)) {
+        const resolved = resolveFactoryFromName(inner, seen);
+        if (resolved) return resolved;
+      }
+      continue;
+    }
+    if (import_ts_morph6.Node.isShorthandPropertyAssignment(decl)) {
+      const nameNode = decl.getNameNode();
+      const resolved = import_ts_morph6.Node.isIdentifier(nameNode) ? resolveFactoryFromName(nameNode, seen) : void 0;
+      if (resolved) return resolved;
+    }
+  }
+  return void 0;
+}
+function warnUnresolvedFactory(cls, calleeText, reason) {
+  console.warn(
+    `[nestjs-codegen/fast] ${cls.getName() ?? "<anonymous class>"} in ${cls.getSourceFile().getFilePath()} extends ${calleeText}(...) but ${reason} \u2014 it contributes NO routes to the generated client. Resolvable factory callees: a name (\`factory(...)\`), a namespace or object property (\`ns.factory(...)\`), or a static method (\`Factory.create(...)\`), each resolving to a function or method declaration that returns a class.`
+  );
 }
 function resolveFactoryStaticClass(node) {
   if (!import_ts_morph6.Node.isPropertyAccessExpression(node)) return void 0;
@@ -3516,12 +3552,26 @@ function resolveFactoryStaticClass(node) {
 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 isController = cls.getDecorator("Controller") !== void 0;
+  const calleeText = expr.getExpression().getText();
   const factoryDecl = resolveFactoryDeclaration(expr);
-  if (!factoryDecl) return void 0;
+  if (!factoryDecl) {
+    if (isController) {
+      warnUnresolvedFactory(
+        cls,
+        calleeText,
+        factoryCalleeName(expr) ? "its callee does not resolve to a function or method declaration" : "its callee is not a name that can be resolved statically"
+      );
+    }
+    return void 0;
+  }
   const returnedClass = resolveReturnedClass(factoryDecl);
-  if (!returnedClass) return void 0;
+  if (!returnedClass) {
+    if (isController) {
+      warnUnresolvedFactory(cls, calleeText, "that factory does not return a class declaration");
+    }
+    return void 0;
+  }
   const classArgs = [];
   const namedClassArgs = {};
   for (const arg of expr.getArguments()) {
@@ -3539,7 +3589,12 @@ function resolveInheritedMethods(cls) {
   }
   return {
     methods: returnedClass.getMethods(),
-    factoryName: callee.getText(),
+    // 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
+    // the two coincide (bar an import alias, where the declaration name is the
+    // one that resolves anyway).
+    factoryName: factoryDecl.getName() ?? calleeText,
     factoryFilePath: factoryDecl.getSourceFile().getFilePath(),
     classArgs,
     namedClassArgs
@@ -5083,7 +5138,7 @@ async function watch(config, onChange, options = {}) {
 }
 
 // src/index.ts
-var VERSION = "0.18.0";
+var VERSION = "0.19.0";
 
 // src/cli/codegen.ts
 async function runCodegen(opts = {}) {