@dudousxd/nestjs-codegen 0.17.2 → 0.19.0

package/dist/extension/index.d.cts

@@ -1,2 +1,2 @@
-export { m as ApiClientLayer, n as ApiHeaderContribution, o as ApiModuleDeps, C as CodegenExtension, p as EmittedFile, E as ExtensionContext, L as LeafModel, q as RequestModel, s as RequestShape, t as defineExtension, u as requestShape } from '../index-DCF9QSPY.cjs';
+export { m as ApiClientLayer, n as ApiHeaderContribution, o as ApiModuleDeps, C as CodegenExtension, p as EmittedFile, E as ExtensionContext, L as LeafModel, q as RequestModel, s as RequestShape, t as defineExtension, u as requestShape } from '../index-Dyf4ttwU.cjs';
 import 'ts-morph';

package/dist/extension/index.d.ts

@@ -1,2 +1,2 @@
-export { m as ApiClientLayer, n as ApiHeaderContribution, o as ApiModuleDeps, C as CodegenExtension, p as EmittedFile, E as ExtensionContext, L as LeafModel, q as RequestModel, s as RequestShape, t as defineExtension, u as requestShape } from '../index-DCF9QSPY.js';
+export { m as ApiClientLayer, n as ApiHeaderContribution, o as ApiModuleDeps, C as CodegenExtension, p as EmittedFile, E as ExtensionContext, L as LeafModel, q as RequestModel, s as RequestShape, t as defineExtension, u as requestShape } from '../index-Dyf4ttwU.js';
 import 'ts-morph';

package/dist/{index-DCF9QSPY.d.cts → index-Dyf4ttwU.d.cts}

@@ -550,11 +550,34 @@ interface ContractDescriptor {
 interface MixinBinding {
     factoryName: string;
     factoryFilePath: string;
-    /** Call-site arguments that resolve to a class declaration, in argument order. */
+    /**
+     * POSITIONAL call-site arguments that resolve to a class declaration, in
+     * argument order — `createTableController(Entity, { dto })` yields one entry.
+     */
     classArgs: Array<{
         name: string;
         filePath: string;
     }>;
+    /**
+     * Class-valued properties of an OPTIONS-OBJECT call-site argument, keyed by
+     * property name — `createTableController({ entity: Entity, filter: Filter })`
+     * yields `entity` and `filter`.
+     *
+     * Keyed by name rather than flattened into {@link classArgs} because the key
+     * is what identifies the argument's role: with a single object argument there
+     * is no positional order to read a role out of, and consumers want different
+     * properties. This package resolves `entity` (to derive the filter fields of a
+     * factory-generated `@Filterable({ entity })`, whose `entity` names the
+     * factory's own parameter and resolves to nothing on its own);
+     * `@dudousxd/nestjs-filter-codegen` reads `filter` off this same binding to
+     * resolve a call-site-supplied filter class. Empty for a purely positional
+     * call; both maps are populated independently, so a factory may be called
+     * either way.
+     */
+    namedClassArgs: Record<string, {
+        name: string;
+        filePath: string;
+    }>;
 }
 interface ControllerRef {
     className: string;

package/dist/{index-DCF9QSPY.d.ts → index-Dyf4ttwU.d.ts}

@@ -550,11 +550,34 @@ interface ContractDescriptor {
 interface MixinBinding {
     factoryName: string;
     factoryFilePath: string;
-    /** Call-site arguments that resolve to a class declaration, in argument order. */
+    /**
+     * POSITIONAL call-site arguments that resolve to a class declaration, in
+     * argument order — `createTableController(Entity, { dto })` yields one entry.
+     */
     classArgs: Array<{
         name: string;
         filePath: string;
     }>;
+    /**
+     * Class-valued properties of an OPTIONS-OBJECT call-site argument, keyed by
+     * property name — `createTableController({ entity: Entity, filter: Filter })`
+     * yields `entity` and `filter`.
+     *
+     * Keyed by name rather than flattened into {@link classArgs} because the key
+     * is what identifies the argument's role: with a single object argument there
+     * is no positional order to read a role out of, and consumers want different
+     * properties. This package resolves `entity` (to derive the filter fields of a
+     * factory-generated `@Filterable({ entity })`, whose `entity` names the
+     * factory's own parameter and resolves to nothing on its own);
+     * `@dudousxd/nestjs-filter-codegen` reads `filter` off this same binding to
+     * resolve a call-site-supplied filter class. Empty for a purely positional
+     * call; both maps are populated independently, so a factory may be called
+     * either way.
+     */
+    namedClassArgs: Record<string, {
+        name: string;
+        filePath: string;
+    }>;
 }
 interface ControllerRef {
     className: string;

package/dist/index.cjs

@@ -3526,10 +3526,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;
@@ -3551,30 +3587,78 @@ 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()) {
-    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()
-      });
+    const positional = resolveClassReference(arg);
+    if (positional) {
+      classArgs.push(positional);
+      continue;
+    }
+    if (!import_ts_morph6.Node.isObjectLiteralExpression(arg)) continue;
+    for (const prop of arg.getProperties()) {
+      const named = resolvePropertyClassReference(prop);
+      if (!named) continue;
+      namedClassArgs[named.key] ??= named.ref;
     }
   }
   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
+    classArgs,
+    namedClassArgs
   };
 }
+function resolveClassReference(node) {
+  const expr = unwrapExpression(node);
+  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.isClassDeclaration(n));
+  if (!decl) return void 0;
+  return {
+    name: decl.getName() ?? expr.getText(),
+    filePath: decl.getSourceFile().getFilePath()
+  };
+}
+function resolvePropertyClassReference(prop) {
+  if (import_ts_morph6.Node.isShorthandPropertyAssignment(prop)) {
+    const ref2 = resolveClassReference(prop.getNameNode());
+    return ref2 ? { key: prop.getName(), ref: ref2 } : void 0;
+  }
+  if (!import_ts_morph6.Node.isPropertyAssignment(prop)) return void 0;
+  const init = prop.getInitializer();
+  if (!init) return void 0;
+  const ref = resolveClassReference(init);
+  if (!ref) return void 0;
+  const nameNode = prop.getNameNode();
+  const key = import_ts_morph6.Node.isStringLiteral(nameNode) ? nameNode.getLiteralValue() : prop.getName();
+  return { key, ref };
+}
 var mixinTypeProject;
 function getMixinTypeProject() {
   mixinTypeProject ??= new import_ts_morph6.Project({
@@ -3604,7 +3688,7 @@ function resolveInstantiatedReturnType(cls, methodName) {
 
 // src/discovery/filter-for.ts
 function resolveMixinEntityClass(mixin, project) {
-  const entityArg = mixin?.classArgs[0];
+  const entityArg = mixin?.namedClassArgs?.entity ?? mixin?.classArgs[0];
   if (!entityArg) return void 0;
   const file = project.getSourceFile(entityArg.filePath) ?? project.addSourceFileAtPathIfExists(entityArg.filePath);
   return file?.getClass(entityArg.name);
@@ -4856,7 +4940,8 @@ function extractFromSourceFile(sourceFile, project) {
     const mixinBinding = inherited ? {
       factoryName: inherited.factoryName,
       factoryFilePath: inherited.factoryFilePath,
-      classArgs: inherited.classArgs
+      classArgs: inherited.classArgs,
+      namedClassArgs: inherited.namedClassArgs
     } : void 0;
     const ownMethods = cls.getMethods();
     const ownNames = new Set(ownMethods.map((m) => m.getName()));
@@ -5171,7 +5256,7 @@ function createChainModuleRenderer(opts) {
 }
 
 // src/index.ts
-var VERSION = "0.17.2";
+var VERSION = "0.19.0";
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   CodegenError,