@dudousxd/nestjs-codegen 0.17.2 → 0.18.0

package/CHANGELOG.md

@@ -1,5 +1,31 @@
 # @dudousxd/nestjs-codegen
 
+## 0.18.0
+
+### Minor Changes
+
+- 553e503: Resolve the entity of a controller factory called with a single options object.
+
+  `class X extends createTableController({ entity: Util, dto: UtilDTO })` emitted
+  every one of its routes with `body: never` and `filterFields: never` — the typed
+  filter builder gone from the client, with `tsc` and codegen both green. Only the
+  positional form (`createTableController(Util, { dto })`) worked: discovery
+  collected call-site classes by scanning for identifier ARGUMENTS, and an object
+  literal is not one, so the entity behind the factory's generated
+  `@Filterable({ entity })` was unresolvable. Measured downstream at 22 tables
+  losing their filter builder at once.
+
+  Class-valued properties of an options-object argument are now collected too,
+  keyed by property name, and the entity resolver prefers a named `entity` over the
+  first positional argument. Both call forms work, so a codebase can migrate table
+  by table.
+
+  `MixinBinding` gains `namedClassArgs: Record<string, { name, filePath }>`
+  alongside the unchanged positional `classArgs`. The key is what identifies an
+  argument's role once there is no positional order to read it from, and consumers
+  want different properties: this package resolves `entity`, while
+  `@dudousxd/nestjs-filter-codegen` reads `filter` off the same binding.
+
 ## 0.17.2
 
 ### Patch Changes

package/dist/cli/main.cjs

@@ -3523,23 +3523,52 @@ function resolveInheritedMethods(cls) {
   const returnedClass = resolveReturnedClass(factoryDecl);
   if (!returnedClass) 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(),
     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({
@@ -3569,7 +3598,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);
@@ -4821,7 +4850,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()));
@@ -5053,7 +5083,7 @@ async function watch(config, onChange, options = {}) {
 }
 
 // src/index.ts
-var VERSION = "0.17.2";
+var VERSION = "0.18.0";
 
 // src/cli/codegen.ts
 async function runCodegen(opts = {}) {