@dudousxd/nestjs-codegen 0.19.0 → 0.21.0

package/CHANGELOG.md

@@ -1,5 +1,84 @@
 # @dudousxd/nestjs-codegen
 
+## 0.21.0
+
+### Minor Changes
+
+- 71b4485: Tell an overridden route from an inherited one by the class it is declared on, not by its file
+
+  `extractApplyFilterInfo` decided whether a route was the controller's OWN by
+  comparing the method's file to the factory's (`declFile !== mixin.factoryFilePath`).
+  That is a proxy for the real question, and it breaks on the one shape where the
+  two come apart: a controller factory declared in the SAME file as a controller
+  that calls it. There, a genuine override reads as inherited, its
+  `@ApplyFilter(SomeFilter)` is mistaken for the factory talking about itself, and
+  the factory's `filter` option silently outranks the filter the override names —
+  typing the route against a filter the runtime does not use.
+
+  `extractDtoContract` now takes the `@Controller` class the route was discovered
+  on and passes it down, so the check is `method.getParent() === controllerClass`:
+  the ground truth the discovery pass already computed when it merged own and
+  inherited methods. The parameter is optional — omitting it degrades to the
+  previous file comparison, so an external caller of the exported
+  `extractDtoContract` keeps working unchanged.
+
+  This also settles a disagreement between packages. `@dudousxd/nestjs-filter-codegen`
+  asks the same question via `controllerClass.getMethod(name)` and was already
+  right about the colocated case; the two have to agree on what an override IS, not
+  merely on how to rank one, or the same route ends up described twice, differently.
+
+## 0.20.0
+
+### Minor Changes
+
+- f8da873: Describe a table's routes with the filter its factory was HANDED, not the one it
+  generated.
+
+  A factory given a hand-written filter through an option —
+  `createTableController({ entity: Wo, filter: WoFilter })` — applies `WoFilter` to
+  every route it produces, but the decorators inside the factory body can only name
+  the fallback it generates internally (`@ApplyFilter(GeneratedFilter)`; the
+  supplied class exists only at the call site). Discovery read that decorator
+  argument and nothing else, so everything emitted for those routes came from the
+  fallback:
+
+  - the hand-written filter's `@FilterFor` virtual fields were **absent** from the
+    client — filtering by them does not type-check, though the server accepts them;
+  - a filter that NARROWS with `allowed` was typed with the fallback's **wider**
+    entity-derived field set — the client is told it may filter by fields the
+    server will reject, which type-checks at the call site and fails at runtime.
+
+  The route's mixin binding already carried the call-site `filter` class. It is now
+  consulted, in this precedence (first candidate that yields a readable field set
+  wins):
+
+  1. a filter named BY IDENTIFIER in the route's own `@ApplyFilter(SomeFilter)` —
+     an overriding method is the only place a per-route statement can be made;
+  2. the factory's `filter` option;
+  3. the existing walk — `@ApplyFilter(<Const>.filter)` through the factory static,
+     a lexically-scoped local class, then a module-level lookup.
+
+  `@ApplyFilter(<Const>.filter)` sits below (2) deliberately, matching
+  `@dudousxd/nestjs-filter-codegen`: it forwards the factory's product rather than
+  naming a filter of its own, so statically it always lands on the generated
+  fallback.
+
+  Two consequences follow:
+
+  - **`allowed` / `blocked` now narrow the emitted field set.** They gate exactly
+    the auto-field set, so they are applied to the entity-derived fields;
+    `@FilterFor` keys are appended afterwards, as the runtime resolves an explicit
+    handler without consulting `allowed`.
+  - **A hand-written filter's own `@Filterable({ entity })` wins** over the
+    factory's call-site entity. The call-site entity is a repair for a GENERATED
+    filter, whose `entity` names the factory's parameter and resolves to nothing; a
+    hand-written filter names a real class, and that is the class the runtime
+    queries. It stays a fallback for when the declared entity does not resolve.
+
+  Nothing gets worse: a candidate that resolves but reads as empty (no properties,
+  no `@Filterable`, no `@FilterFor`) is skipped rather than returned, so an opaque
+  call-site filter degrades to today's result instead of to `filterFields: never`.
+
 ## 0.19.0
 
 ### Minor Changes

package/dist/cli/main.cjs

@@ -3653,10 +3653,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)) {
@@ -3731,7 +3736,7 @@ function extractFilterForHints(classDecl, project) {
   }
   return hints;
 }
-function extractApplyFilterInfo(method, sourceFile, project, mixin) {
+function extractApplyFilterInfo(method, sourceFile, project, mixin, controllerClass) {
   const declFile = method.getSourceFile();
   const mixinEntity = resolveMixinEntityClass(mixin, project);
   for (const param of method.getParameters()) {
@@ -3756,31 +3761,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 || (controllerClass ? method.getParent() === controllerClass : 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() ?? "";
@@ -3859,21 +3888,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) {
@@ -4292,9 +4353,9 @@ function unwrapNamedContainer(node, names) {
   }
   return node;
 }
-function extractDtoContract(method, sourceFile, project, mixin) {
+function extractDtoContract(method, sourceFile, project, mixin, controllerClass) {
   let body = extractBodyType(method, sourceFile, project);
-  const filterInfo = extractApplyFilterInfo(method, sourceFile, project, mixin);
+  const filterInfo = extractApplyFilterInfo(method, sourceFile, project, mixin, controllerClass);
   const query = extractQueryType(method, sourceFile, project);
   const uploads = extractUploadedFiles(method);
   const multipartBody = uploads.fields ? `{ ${uploads.fields} }` : null;
@@ -4857,7 +4918,7 @@ function extractDtoRoute(args) {
   const methodName = method.getName();
   const classAs = readAsDecorator(cls, `class ${className}`);
   const methodAs = readAsDecorator(method, `${className}.${methodName}`);
-  const dtoContract = extractDtoContract(method, sourceFile, project, mixin);
+  const dtoContract = extractDtoContract(method, sourceFile, project, mixin, cls);
   const mixinResponse = mixin ? resolveInstantiatedReturnType(cls, methodName) : void 0;
   return buildRoute({
     className,
@@ -5138,7 +5199,7 @@ async function watch(config, onChange, options = {}) {
 }
 
 // src/index.ts
-var VERSION = "0.19.0";
+var VERSION = "0.21.0";
 
 // src/cli/codegen.ts
 async function runCodegen(opts = {}) {