@dudousxd/nestjs-codegen 0.18.0 → 0.20.0

package/dist/nest/index.cjs

@@ -3308,10 +3308,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;
@@ -3333,12 +3369,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()) {
@@ -3356,7 +3406,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
@@ -3415,10 +3470,15 @@ function resolveInstantiatedReturnType(cls, methodName) {
 
 // src/discovery/filter-for.ts
 function resolveMixinEntityClass(mixin, project) {
-  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);
+  return resolveClassRef(mixin?.namedClassArgs?.entity ?? mixin?.classArgs[0], project);
+}
+function resolveMixinFilterClass(mixin, project) {
+  return resolveClassRef(mixin?.namedClassArgs?.filter, project);
+}
+function resolveClassRef(ref, project) {
+  if (!ref) return void 0;
+  const file = project.getSourceFile(ref.filePath) ?? project.addSourceFileAtPathIfExists(ref.filePath);
+  return file?.getClass(ref.name);
 }
 function classifyFilterForHint(typeInit) {
   if (import_ts_morph7.Node.isStringLiteral(typeInit)) {
@@ -3518,31 +3578,55 @@ function extractApplyFilterInfo(method, sourceFile, project, mixin) {
     }
     const filterClassName = filterClassArg.getText();
     const resolved = factoryStaticClass ? void 0 : findType(filterClassName, declFile, project);
-    const classDecl = factoryStaticClass ?? (resolved?.kind === "class" ? resolved.decl : resolveLocalClassDeclaration(filterClassArg));
-    if (classDecl) {
-      let fieldTypes = extractClassPropertyTypes(classDecl, project);
-      if (fieldTypes.length === 0) {
-        fieldTypes = extractFilterableEntityFields(classDecl, project, mixinEntity);
-      }
-      const filterForHints = extractFilterForHints(classDecl, project);
-      if (filterForHints.size > 0) {
-        const byName = new Map(fieldTypes.map((f) => [f.name, f]));
-        for (const [key, classified] of filterForHints) {
-          byName.set(key, toFilterFieldType(key, classified));
-        }
-        fieldTypes = [...byName.values()];
-      }
-      if (fieldTypes.length === 0) return null;
-      const fieldNames = fieldTypes.map((f) => f.name);
+    const declaredClass = factoryStaticClass ?? (resolved?.kind === "class" ? resolved.decl : resolveLocalClassDeclaration(filterClassArg));
+    const ownRoute = !mixin || declFile.getFilePath() !== mixin.factoryFilePath;
+    const namedByRoute = ownRoute && import_ts_morph7.Node.isIdentifier(filterClassArg) ? declaredClass : void 0;
+    for (const candidate of orderFilterCandidates({
+      namedByRoute,
+      supplied: resolveMixinFilterClass(mixin, project),
+      declared: declaredClass
+    })) {
+      const fieldTypes = collectFilterFields(candidate, project, mixinEntity);
+      if (fieldTypes.length === 0) continue;
       return {
-        fieldNames,
+        fieldNames: fieldTypes.map((f) => f.name),
         fieldTypes,
         source
       };
     }
+    if (declaredClass) return null;
   }
   return null;
 }
+function orderFilterCandidates(sources) {
+  const ordered = [];
+  const seen = /* @__PURE__ */ new Set();
+  const push = (decl, preferDeclaredEntity) => {
+    if (!decl || seen.has(decl)) return;
+    seen.add(decl);
+    ordered.push({ decl, preferDeclaredEntity });
+  };
+  push(sources.namedByRoute, true);
+  push(sources.supplied, true);
+  push(sources.declared, false);
+  return ordered;
+}
+function collectFilterFields(candidate, project, mixinEntity) {
+  const { decl, preferDeclaredEntity } = candidate;
+  let fieldTypes = extractClassPropertyTypes(decl, project);
+  if (fieldTypes.length === 0) {
+    fieldTypes = extractFilterableEntityFields(decl, project, mixinEntity, preferDeclaredEntity);
+  }
+  const filterForHints = extractFilterForHints(decl, project);
+  if (filterForHints.size > 0) {
+    const byName = new Map(fieldTypes.map((f) => [f.name, f]));
+    for (const [key, classified] of filterForHints) {
+      byName.set(key, toFilterFieldType(key, classified));
+    }
+    fieldTypes = [...byName.values()];
+  }
+  return fieldTypes;
+}
 var RELATION_DECORATORS = /* @__PURE__ */ new Set(["OneToMany", "ManyToOne", "ManyToMany", "OneToOne"]);
 function collectEntityFields(entityDecl, sourceFile, project, prefix, visited) {
   const entityName = entityDecl.getName() ?? "";
@@ -3621,21 +3705,53 @@ function resolveDeclaredEntity(optionsArg, filterClass, project) {
   if (!resolved || resolved.kind !== "class") return void 0;
   return resolved.decl;
 }
-function extractFilterableEntityFields(filterClass, project, entityOverride) {
+function readFieldNameList(optionsArg, key) {
+  if (!import_ts_morph7.Node.isObjectLiteralExpression(optionsArg)) return void 0;
+  const prop = optionsArg.getProperty(key);
+  if (!prop || !import_ts_morph7.Node.isPropertyAssignment(prop)) return void 0;
+  const init = prop.getInitializer();
+  if (!init || !import_ts_morph7.Node.isArrayLiteralExpression(init)) return void 0;
+  const names = /* @__PURE__ */ new Set();
+  for (const el of init.getElements()) {
+    if (import_ts_morph7.Node.isStringLiteral(el)) {
+      names.add(el.getLiteralValue());
+      continue;
+    }
+    if (import_ts_morph7.Node.isObjectLiteralExpression(el)) {
+      const fieldProp = el.getProperty("field");
+      if (fieldProp && import_ts_morph7.Node.isPropertyAssignment(fieldProp)) {
+        const fieldInit = fieldProp.getInitializer();
+        if (fieldInit && import_ts_morph7.Node.isStringLiteral(fieldInit)) {
+          names.add(fieldInit.getLiteralValue());
+          continue;
+        }
+      }
+    }
+    return void 0;
+  }
+  return names;
+}
+function narrowToDeclaredFields(fields, optionsArg) {
+  const allowed = readFieldNameList(optionsArg, "allowed");
+  const blocked = readFieldNameList(optionsArg, "blocked");
+  if (!allowed && !blocked) return fields;
+  return fields.filter(
+    (f) => (!allowed || allowed.has(f.name)) && !(blocked?.has(f.name) ?? false)
+  );
+}
+function extractFilterableEntityFields(filterClass, project, entityOverride, preferDeclaredEntity = false) {
   const filterableDecorator = filterClass.getDecorators().find((d) => d.getName() === "Filterable");
   if (!filterableDecorator) return [];
   const args = filterableDecorator.getArguments();
   if (args.length === 0) return [];
   const optionsArg = args[0];
   if (!import_ts_morph7.Node.isObjectLiteralExpression(optionsArg)) return [];
-  const entityDecl = entityOverride ?? resolveDeclaredEntity(optionsArg, filterClass, project);
+  const declaredEntity = resolveDeclaredEntity(optionsArg, filterClass, project);
+  const entityDecl = preferDeclaredEntity ? declaredEntity ?? entityOverride : entityOverride ?? declaredEntity;
   if (!entityDecl) return [];
-  const fields = collectEntityFields(
-    entityDecl,
-    entityDecl.getSourceFile(),
-    project,
-    "",
-    /* @__PURE__ */ new Set()
+  const fields = narrowToDeclaredFields(
+    collectEntityFields(entityDecl, entityDecl.getSourceFile(), project, "", /* @__PURE__ */ new Set()),
+    optionsArg
   );
   const relationsDecorator = filterClass.getDecorators().find((d) => d.getName() === "Relations");
   if (relationsDecorator) {
@@ -4881,7 +4997,7 @@ async function watch(config, onChange, options = {}) {
 }
 
 // src/index.ts
-var VERSION = "0.18.0";
+var VERSION = "0.20.0";
 
 // src/generate-manifest.ts
 var MANIFEST_FILE = ".codegen-manifest.json";