@dudousxd/nestjs-codegen 0.14.2 → 0.15.0

package/dist/nest/index.d.cts

@@ -1,5 +1,6 @@
-import { DynamicModule, OnApplicationBootstrap, OnModuleDestroy } from '@nestjs/common';
-import { U as UserConfig } from '../index-DT8SgPxp.cjs';
+import * as _nestjs_common from '@nestjs/common';
+import { DynamicModule, OnApplicationBootstrap, OnModuleDestroy, ExecutionContext } from '@nestjs/common';
+import { U as UserConfig } from '../index-CjIDPMsV.cjs';
 import 'ts-morph';
 
 /**
@@ -82,4 +83,56 @@ declare class NestjsCodegenModule {
     static forRoot(options?: CodegenModuleOptions): DynamicModule;
 }
 
-export { CODEGEN_MODULE_OPTIONS, type CodegenModuleOptions, NestjsCodegenModule, NestjsCodegenService, shouldRun };
+/**
+ * Normalize a raw query value — `string | string[] | undefined | null` (and, for
+ * back-compat with the comma-joined wire format, a comma-separated string) — into
+ * a clean `string[]`.
+ *
+ * Why this exists: Express (and therefore Nest's default query parser) hands back a
+ * **bare `string`** when a querystring key carries exactly one value (`?ids=a`), and a
+ * `string[]` only when it carries two or more (`?ids=a&ids=b`). `ParseArrayPipe` rejects
+ * the single-value form, so the *common* case (one item selected) 400s while the
+ * multi-value case passes — an inverted footgun. This helper accepts every shape:
+ *
+ * - `undefined` / `null`                 → `[]`
+ * - `'a'`            (single value)      → `['a']`
+ * - `['a', 'b']`     (repeated param)    → `['a', 'b']`
+ * - `'a,b'`          (comma-joined wire) → `['a', 'b']`  (see `@dudousxd/nestjs-client`
+ *                                          `arrayFormat: 'comma'`, the client default)
+ *
+ * Empty/whitespace-only entries are dropped. The comma-split is a compatibility fallback:
+ * once the client sends `arrayFormat: 'repeat'` (`?ids=a&ids=b`), it degrades to a no-op
+ * and only the single-value bare-string case still needs normalizing.
+ *
+ * Exported standalone so it can back a `class-transformer` `@Transform` on a DTO field
+ * (`@Transform(({ value }) => toStringList(value))`) as well as the {@link QueryList}
+ * param decorator.
+ */
+declare function toStringList(raw: unknown): string[];
+/**
+ * Resolve a `string[]` from a request's query param `key` via {@link toStringList}.
+ * The seam the {@link QueryList} decorator is built on — exported so callers can reuse
+ * the exact resolution in a bespoke `createParamDecorator`. Returns `[]` when no `key`
+ * is given (a param decorator cannot infer the target property name).
+ */
+declare function resolveQueryList(key: string | undefined, ctx: ExecutionContext): string[];
+/**
+ * Param decorator that reads an array query param safely, always yielding a clean
+ * `string[]` regardless of whether the client sent one value, many, or a comma-joined
+ * string. Use it instead of `@Query(key, ParseArrayPipe)` for *optional* array query
+ * params:
+ *
+ * ```ts
+ * @Get()
+ * list(@QueryList('baseIds') baseIds: string[]) {
+ *   // baseIds is always a clean string[] — [] when the param is absent,
+ *   // ['a'] for ?baseIds=a, ['a','b'] for ?baseIds=a&baseIds=b or ?baseIds=a,b
+ * }
+ * ```
+ *
+ * See {@link toStringList} for the exact normalization and the single-value footgun it
+ * closes.
+ */
+declare const QueryList: (...dataOrPipes: (string | _nestjs_common.PipeTransform<any, any> | _nestjs_common.Type<_nestjs_common.PipeTransform<any, any>> | undefined)[]) => ParameterDecorator;
+
+export { CODEGEN_MODULE_OPTIONS, type CodegenModuleOptions, NestjsCodegenModule, NestjsCodegenService, QueryList, resolveQueryList, shouldRun, toStringList };

package/dist/nest/index.d.ts

@@ -1,5 +1,6 @@
-import { DynamicModule, OnApplicationBootstrap, OnModuleDestroy } from '@nestjs/common';
-import { U as UserConfig } from '../index-DT8SgPxp.js';
+import * as _nestjs_common from '@nestjs/common';
+import { DynamicModule, OnApplicationBootstrap, OnModuleDestroy, ExecutionContext } from '@nestjs/common';
+import { U as UserConfig } from '../index-CjIDPMsV.js';
 import 'ts-morph';
 
 /**
@@ -82,4 +83,56 @@ declare class NestjsCodegenModule {
     static forRoot(options?: CodegenModuleOptions): DynamicModule;
 }
 
-export { CODEGEN_MODULE_OPTIONS, type CodegenModuleOptions, NestjsCodegenModule, NestjsCodegenService, shouldRun };
+/**
+ * Normalize a raw query value — `string | string[] | undefined | null` (and, for
+ * back-compat with the comma-joined wire format, a comma-separated string) — into
+ * a clean `string[]`.
+ *
+ * Why this exists: Express (and therefore Nest's default query parser) hands back a
+ * **bare `string`** when a querystring key carries exactly one value (`?ids=a`), and a
+ * `string[]` only when it carries two or more (`?ids=a&ids=b`). `ParseArrayPipe` rejects
+ * the single-value form, so the *common* case (one item selected) 400s while the
+ * multi-value case passes — an inverted footgun. This helper accepts every shape:
+ *
+ * - `undefined` / `null`                 → `[]`
+ * - `'a'`            (single value)      → `['a']`
+ * - `['a', 'b']`     (repeated param)    → `['a', 'b']`
+ * - `'a,b'`          (comma-joined wire) → `['a', 'b']`  (see `@dudousxd/nestjs-client`
+ *                                          `arrayFormat: 'comma'`, the client default)
+ *
+ * Empty/whitespace-only entries are dropped. The comma-split is a compatibility fallback:
+ * once the client sends `arrayFormat: 'repeat'` (`?ids=a&ids=b`), it degrades to a no-op
+ * and only the single-value bare-string case still needs normalizing.
+ *
+ * Exported standalone so it can back a `class-transformer` `@Transform` on a DTO field
+ * (`@Transform(({ value }) => toStringList(value))`) as well as the {@link QueryList}
+ * param decorator.
+ */
+declare function toStringList(raw: unknown): string[];
+/**
+ * Resolve a `string[]` from a request's query param `key` via {@link toStringList}.
+ * The seam the {@link QueryList} decorator is built on — exported so callers can reuse
+ * the exact resolution in a bespoke `createParamDecorator`. Returns `[]` when no `key`
+ * is given (a param decorator cannot infer the target property name).
+ */
+declare function resolveQueryList(key: string | undefined, ctx: ExecutionContext): string[];
+/**
+ * Param decorator that reads an array query param safely, always yielding a clean
+ * `string[]` regardless of whether the client sent one value, many, or a comma-joined
+ * string. Use it instead of `@Query(key, ParseArrayPipe)` for *optional* array query
+ * params:
+ *
+ * ```ts
+ * @Get()
+ * list(@QueryList('baseIds') baseIds: string[]) {
+ *   // baseIds is always a clean string[] — [] when the param is absent,
+ *   // ['a'] for ?baseIds=a, ['a','b'] for ?baseIds=a&baseIds=b or ?baseIds=a,b
+ * }
+ * ```
+ *
+ * See {@link toStringList} for the exact normalization and the single-value footgun it
+ * closes.
+ */
+declare const QueryList: (...dataOrPipes: (string | _nestjs_common.PipeTransform<any, any> | _nestjs_common.Type<_nestjs_common.PipeTransform<any, any>> | undefined)[]) => ParameterDecorator;
+
+export { CODEGEN_MODULE_OPTIONS, type CodegenModuleOptions, NestjsCodegenModule, NestjsCodegenService, QueryList, resolveQueryList, shouldRun, toStringList };

package/dist/nest/index.js

@@ -702,6 +702,9 @@ function buildErrorType(c) {
   }
   return c.contractSource.error ?? "unknown";
 }
+function filterFieldLiterals(fields) {
+  return fields?.length ? fields.map((f) => JSON.stringify(f)) : [];
+}
 function emitRouterTypeBlock(tree, indent, outDir, serialization) {
   const pad = " ".repeat(indent);
   const lines = [];
@@ -728,7 +731,8 @@ function emitRouterTypeBlock(tree, indent, outDir, serialization) {
       const params = buildParamsType(c.params);
       const safeMethod = JSON.stringify(method);
       const safeUrl = JSON.stringify(c.path);
-      const filterFields = c.contractSource.filterFields?.length ? c.contractSource.filterFields.map((f) => JSON.stringify(f)).join(" | ") : "never";
+      const filterLiterals = filterFieldLiterals(c.contractSource.filterFields);
+      const filterFields = filterLiterals.length ? filterLiterals.join(" | ") : "never";
       const stream = c.contractSource.stream ? "true" : "false";
       const binary = c.contractSource.binaryResponse ? "true" : "false";
       lines.push(
@@ -768,6 +772,7 @@ function buildRequestModel(c) {
   const TA = buildRouterTypeAccess(c.name);
   const withParams = hasPathParams(c.params);
   const { isGet, isQuery, hasBody, hasQuery } = requestShape(c.route);
+  const filterLiterals = filterFieldLiterals(c.contractSource.filterFields);
   const fields = [];
   if (withParams) fields.push(`params: ${TA}['params']`);
   if (hasQuery) fields.push(`query?: ${TA}['query']`);
@@ -797,7 +802,12 @@ function buildRequestModel(c) {
     // (`[name]` rather than `[name, undefined]`) so the bare `.queryKey()` is a
     // clean prefix that partial-matches every parametrized variant — making it
     // directly usable for `invalidateQueries`.
-    queryKeyExpr: `(input === undefined ? [${flat}] as const : [${flat}, input] as const)`
+    queryKeyExpr: `(input === undefined ? [${flat}] as const : [${flat}, input] as const)`,
+    // Runtime counterpart to the type-level `filterFields` union: the same
+    // discovered field list, emitted as a literal `[...] as const` so apps can
+    // validate a dynamic/user-supplied field string with `isFilterField(...)`
+    // instead of casting. Omitted for routes with no filter.
+    ...filterLiterals.length ? { filterFieldsExpr: `[${filterLiterals.join(", ")}] as const` } : {}
   };
 }
 function renderFetcherRequest(req, binaryResponse) {
@@ -832,9 +842,24 @@ function emitReqHelper() {
     ""
   ];
 }
+function emitFilterFieldGuard() {
+  return [
+    "/** Runtime guard: narrows `value` to one of the leaf's `filterFields` (a `readonly K[] as const`), so a dynamic field string can be passed to `.where()` without a cast. */",
+    "export function isFilterField<const K extends string>(",
+    "  fields: readonly K[],",
+    "  value: string,",
+    "): value is K {",
+    "  return (fields as readonly string[]).includes(value);",
+    "}",
+    ""
+  ];
+}
 function renderLeaf(pad, objKey, req, requestExpr, members, streamExpr) {
   const lines = [`${pad}${objKey}: (input?: ${req.inputType}) => ({`];
   lines.push(`${pad}  ...__req<${req.responseType}>(() => ${requestExpr}),`);
+  if (req.filterFieldsExpr) {
+    lines.push(`${pad}  filterFields: ${req.filterFieldsExpr},`);
+  }
   if (streamExpr) {
     lines.push(`${pad}  stream: () => ${streamExpr},`);
   }
@@ -1106,6 +1131,9 @@ function buildApiFile(routes, outDir, opts = {}) {
   lines.push("};");
   lines.push("");
   lines.push(...emitReqHelper());
+  if (contracted.some((r) => r.contract?.contractSource.filterFields?.length)) {
+    lines.push(...emitFilterFieldGuard());
+  }
   lines.push("export function createApi(fetcher: Fetcher) {");
   lines.push("  return {");
   lines.push(
@@ -4622,7 +4650,7 @@ async function watch(config, onChange, options = {}) {
 }
 
 // src/index.ts
-var VERSION = "0.14.2";
+var VERSION = "0.15.0";
 
 // src/generate-manifest.ts
 var MANIFEST_FILE = ".codegen-manifest.json";
@@ -4822,10 +4850,26 @@ var NestjsCodegenModule = class {
 NestjsCodegenModule = __decorateClass([
   Module({})
 ], NestjsCodegenModule);
+
+// src/nest/query-list.ts
+import { createParamDecorator } from "@nestjs/common";
+function toStringList(raw) {
+  if (raw === void 0 || raw === null) return [];
+  const arr = Array.isArray(raw) ? raw : String(raw).split(",");
+  return arr.map((entry) => String(entry).trim()).filter((entry) => entry.length > 0);
+}
+function resolveQueryList(key, ctx) {
+  const request = ctx.switchToHttp().getRequest();
+  return toStringList(key ? request.query?.[key] : void 0);
+}
+var QueryList = createParamDecorator(resolveQueryList);
 export {
   CODEGEN_MODULE_OPTIONS,
   NestjsCodegenModule,
   NestjsCodegenService,
-  shouldRun
+  QueryList,
+  resolveQueryList,
+  shouldRun,
+  toStringList
 };
 //# sourceMappingURL=index.js.map