@dudousxd/nestjs-filter 1.24.0 → 1.28.0

package/dist/runner.d.ts

@@ -1,8 +1,8 @@
 import { type Type } from '@nestjs/common';
 import { ModuleRef } from '@nestjs/core';
-import type { FilterAdapter } from './adapter/adapter.js';
+import type { FieldExtent, FilterAdapter } from './adapter/adapter.js';
 import type { ContextAccessor } from './context-accessor.js';
-import type { ComputedSource, CursorPage, EntityDescription, FilterContext, FilterModuleOptions, GroupByCountResult, SortItem } from './types.js';
+import type { ComputedSource, CursorPage, EntityDescription, FieldHistogram, FilterContext, FilterModuleOptions, GroupByCountResult, SortItem } from './types.js';
 /**
  * One resolved entry of the computed-field registry: the dev-provided SQL
  * `source` plus the runtime flags carried by the declaration (the inline
@@ -163,6 +163,7 @@ export declare class FilterRunner {
     private applyProjectedComputed;
     apply<F extends object, Q>(FilterClass: Type<F>, input: unknown, qb: Q, context?: FilterContext, internal?: {
         native?: boolean;
+        distinctOrder?: boolean | undefined;
     }): Promise<Q>;
     private resolveFilter;
     private runSetup;
@@ -280,6 +281,15 @@ export declare class FilterRunner {
     applyDynamic<Q>(entity: Type<unknown>, input: unknown, qb: Q, context?: FilterContext, internal?: {
         skipSortAndPagination?: boolean;
         native?: boolean;
+        distinctOrder?: boolean | undefined;
+        /**
+         * Marks `paginate.size` as server-authored, lifting the module-level
+         * `maxPageSize` ceiling for this call only. See
+         * {@link FilterRunner.resolvePageSize}. Dynamic mode has no filter class
+         * and no route decorator, so — like `distinctOrder` — the per-call flag
+         * is the only way in.
+         */
+        trustedPageSize?: boolean;
     }): Promise<Q>;
     /**
      * Runs a dynamic query and **executes** it, returning the page of rows plus
@@ -293,10 +303,19 @@ export declare class FilterRunner {
      *
      * Requires an adapter implementing `getResultAndCount` (and `populate` for
      * to-many includes). `applyDynamic` is unchanged; this is additive.
+     *
+     * `opts.trustedPageSize` declares that `paginate.size` was written by the
+     * server, not received from a client, and lifts the module-level
+     * `maxPageSize` ceiling for this call — see
+     * {@link FilterRunner.resolvePageSize}. This is the entry point exports and
+     * batch jobs use, so it is where the escape hatch is needed; without it they
+     * abandon `paginate` for hand-built `limit`/`offset` and lose everything
+     * else this method does.
      */
     findAndCount<E>(entity: Type<E>, input: unknown, opts?: {
         qb?: unknown;
         context?: FilterContext;
+        trustedPageSize?: boolean;
     }): Promise<{
         rows: E[];
         total: number;
@@ -359,6 +378,269 @@ export declare class FilterRunner {
      * group-by-count rather than emitting a divide-by-zero or nonsensical width.
      */
     private parseGroupByCount;
+    /**
+     * **Field extent**: the `MIN`/`MAX` of the requested field(s) over the rows
+     * the active `where`/`search` select — what a range control (numeric slider,
+     * date-range calendar) needs before it can place its endpoints. Reads the
+     * `extent` structured key (`{ extent: ['price', 'createdAt'] }`, or the
+     * comma-separated string a GET route carries, parsed exactly like `distinct`).
+     *
+     * Unlike {@link groupByCount} this is NOT terminal — it measures the same
+     * filtered set the rows come from, so a route answers with rows AND extent
+     * from two builders. Sort/pagination/distinct/select are not part of the
+     * question and are not applied (`skipSortAndPagination`).
+     *
+     * **Why this lives in the runner and not in the route.** Reading
+     * `@Body('extent')` and handing it straight to `adapter.fieldExtent` bypasses
+     * the filter class's field governance: `static distinct` narrowing, the
+     * entity-metadata check that rejects a bare relation or an unknown
+     * identifier, and the alias remapping every other key gets. That is not an
+     * injection hole — the adapter resolves names through ORM metadata — but it
+     * IS a surface leak: a caller could measure a column the filter class
+     * deliberately does not expose. Routing every requested field through
+     * {@link validateDistinct} here closes it, and it is also the only place
+     * that can tell a computed alias from a typo (see below).
+     *
+     * **Allowlist.** The same one `distinct` uses: the filter class's static
+     * `distinct` list when `opts.filterClass` declares one, else the entity's
+     * columns via adapter metadata. `distinct` and `extent` answer the same
+     * question about a column — what values can this control offer — so a class
+     * that has already narrowed which columns a control may read must narrow
+     * this too, or `extent` becomes the way around that narrowing.
+     *
+     * **Disallowed/unknown fields are DROPPED**, and the request still answers
+     * for the fields that survived — matching `distinct` (which drops an invalid
+     * projected field rather than failing the query) rather than `groupByCount`
+     * (which always rejects, because there the field IS the whole query). Under
+     * the ambient `throwOnInvalid` policy the drop becomes a
+     * `BadRequestException`, again as `distinct`. A dropped field is simply
+     * absent from the result, which the `fieldExtent` contract already defines as
+     * "not measured" — the caller cannot tell it apart from a field the adapter
+     * could not resolve, and does not need to.
+     *
+     * **Computed members** route as `{ alias, source }` rather than a bare name,
+     * mirroring {@link groupByCount}'s grouping field: the adapter measures the
+     * dev-provided expression instead of resolving a column that does not exist.
+     * The registry comes from `opts.filterClass` when given, else from
+     * `@Filterable` metadata on the entity itself. Computed aliases bypass column
+     * validation — dev-declared, never client input — exactly like computed
+     * sort/distinct.
+     *
+     * Requires an adapter implementing the optional `fieldExtent` method; when
+     * absent, a clear error is thrown rather than a silent empty answer, which a
+     * range control would render as a collapsed (0, 0) span.
+     *
+     * @returns One entry per measured field keyed by field name (or computed
+     *   alias). `{}` when the request named no extent fields at all.
+     */
+    fieldExtent<E>(entity: Type<E>, input: unknown, opts?: {
+        qb?: unknown;
+        context?: FilterContext;
+        filterClass?: Type<object>;
+    }): Promise<Record<string, FieldExtent>>;
+    /**
+     * Resolves ONE requested field to the shape an adapter measurement takes: the
+     * `{ alias, source }` pair of a computed member, or the validated column
+     * name. `null` when it is neither.
+     *
+     * Shared by {@link fieldExtent} and {@link fieldHistogram} so both obey the
+     * same allowlist, and so the one judgement nothing outside the runner can
+     * make — computed alias, or typo? both are strings no column matches — is
+     * made once. What the two callers differ on is only what `null` MEANS (a
+     * dropped field there, a rejected request here), which is why that decision
+     * stays with them.
+     *
+     * Validation runs with `throwOnInvalid: false` unconditionally: the caller
+     * words its own rejection for the key the client actually sent, rather than
+     * surfacing `Invalid distinct field` for a request that never said `distinct`.
+     */
+    private resolveMeasurableField;
+    /**
+     * A fresh builder carrying the request's WHERE/search and nothing else — the
+     * scope every measurement in this file asks its question over.
+     *
+     * `skipSortAndPagination` is the load-bearing part: an aggregate over a
+     * LIMITed builder answers for a page and looks exactly like an answer for the
+     * set, and an ORDER BY on a column an aggregate SELECT no longer projects is
+     * MySQL error 3065.
+     */
+    private buildFilteredQb;
+    /**
+     * The static `distinct` allowlist declared on a filter class, if any — the
+     * one {@link applyProjection} gates the DISTINCT projection with, reused by
+     * {@link fieldExtent} so both reads of a column obey the same narrowing.
+     *
+     * Read defensively rather than through a cast: `static distinct` is a plain
+     * class property no type checks, so a class can carry anything under that
+     * name. A non-array (or a list holding non-strings) yields `undefined`/the
+     * string entries, which degrades to entity-metadata validation instead of
+     * silently comparing field names against garbage and refusing everything.
+     */
+    private resolveDistinctAllowlist;
+    /**
+     * **Field histogram**: one numeric field's extent AND its bucketed
+     * distribution over the same filtered set — the two halves of a faceted range
+     * control, from one request. Reads the `histogram` structured key
+     * (`{ histogram: { field: 'price', buckets: 20 } }`).
+     *
+     * **Why this is a method and not two calls in a route.** The halves already
+     * exist — {@link fieldExtent} places a slider's endpoints,
+     * {@link FilterAdapter.groupByCount}'s bucketed variant draws the
+     * distribution behind them — but they are circular for the caller: the
+     * bucketed variant needs a WIDTH, and a width that is not derived from the
+     * data is either arbitrary (a hardcoded 1000 that yields two bars on one
+     * filter and four hundred on the next) or requires the extent the caller is
+     * asking for in the same breath. Nobody can break that cycle from outside:
+     * you must measure, then divide. So the runner measures, then divides.
+     *
+     * **Two round trips, and it cannot be one.** The width is a function of the
+     * first query's OUTPUT, so the second query's text does not exist until the
+     * first has returned. Folding them into one statement means either a
+     * correlated `(SELECT MAX(col)) - (SELECT MIN(col))` inside the bucket
+     * expression — the same scan twice, once per row-group, to avoid a round trip
+     * — or window functions the adapter contract does not have. Two plain
+     * aggregate queries over an indexable column is the cheaper shape, and it
+     * keeps this a composition of capabilities adapters already implement.
+     *
+     * **Not on the adapter contract, deliberately.** Every optional method added
+     * to `FilterAdapter` is a cost each adapter author pays forever, and this one
+     * would buy nothing: it is arithmetic between two existing calls, identical
+     * for every ORM. An adapter implementing `fieldExtent` and `groupByCount`
+     * gets this for free, and one implementing neither is told which is missing.
+     *
+     * **No `opts.qb`**, unlike its neighbours. Two passes need two builders — the
+     * first is consumed by an aggregate SELECT — and a single caller-supplied
+     * builder can only serve one of them. Silently creating a fresh builder for
+     * the second pass would drop whatever pre-scoping the caller put on theirs,
+     * so the distribution would describe a WIDER set than the extent: a chart
+     * with bars outside its own axis, and nothing to make it obvious.
+     *
+     * Field governance is {@link fieldExtent}'s, through the same
+     * {@link resolveMeasurableField}: alias remapping, the filter class's static
+     * `distinct` allowlist (else entity metadata), and computed members routed as
+     * `{ alias, source }`. The one divergence is what an invalid field means —
+     * rejected here, as in {@link groupByCount}, because the field IS the query
+     * and there is no partial answer to fall back to.
+     *
+     * **Dates are refused, not bucketed.** `fieldExtent` supports DATE columns on
+     * purpose, but bucketing is `FLOOR(value / width)`, and a date divided by a
+     * number is nonsense that no database announces: MySQL coerces the column to
+     * `20240131` and buckets THAT, which produces plausible-looking bars over an
+     * axis that skips two thirds of every year. See {@link assertBucketable}.
+     *
+     * @returns `{ min, max, bucketWidth, buckets }` — null ends and an empty
+     *   bucket list when no row in scope carries a value.
+     */
+    fieldHistogram<E>(entity: Type<E>, input: unknown, opts?: {
+        context?: FilterContext;
+        filterClass?: Type<object>;
+    }): Promise<FieldHistogram>;
+    /**
+     * Parses the raw `histogram` block into a canonical `{ field, buckets }`.
+     * `null` when no usable `field` is present — the caller rejects, since a
+     * histogram of nothing has no meaningful empty answer.
+     *
+     * `buckets` accepts a numeric string as well as a number: on a GET route
+     * `?histogram[buckets]=20` arrives as text, and rejecting it there while
+     * accepting `20` from a POST body would make the two transports disagree
+     * about the same request. Anything unusable (absent, zero, negative, NaN,
+     * an object) degrades to the default rather than 400ing: it is a rendering
+     * hint, and a request that says nothing about bar count still has an answer.
+     */
+    private parseHistogram;
+    /**
+     * Refuses a field whose column type cannot survive `FLOOR(value / width)`,
+     * BEFORE either query runs.
+     *
+     * A DATE column is the case this exists for. `fieldExtent` supports dates
+     * deliberately (a calendar sizes itself from one), so `extent` and
+     * `histogram` accept the same field names right up to this point — and the
+     * failure mode without the check is not an error but a wrong answer: MySQL
+     * coerces a date to `20240131` before dividing, so the query succeeds and
+     * returns bars over an axis where two thirds of every year does not exist.
+     *
+     * Only ROOT-column metadata can answer this, so anything it cannot type — a
+     * relation path, a JSON sub-path, a computed source — passes here and is
+     * caught by {@link toBucketableNumber} once the extent comes back with actual
+     * values. Refusing everything untypeable instead would reject `author.age`,
+     * which `where`, `sort` and `distinct` all accept.
+     */
+    private assertBucketable;
+    /**
+     * Coerces one measured extent end to the number the width arithmetic needs,
+     * or `null` for "no row carries a value".
+     *
+     * Not a `typeof value === 'number'` check, in either direction:
+     *
+     *  - a DECIMAL column hydrates to a STRING on mysql2 and pg, so the strict
+     *    check would refuse the most ordinary histogram there is — a price;
+     *  - `Number(new Date())` is a finite epoch, so a bare numeric coercion would
+     *    wave a date extent straight through into `FLOOR(ms / width)`. Dates are
+     *    therefore tested for FIRST, by identity, not by what they coerce to.
+     *
+     * This is the net under {@link assertBucketable}, which only sees root-column
+     * metadata: a computed source, a relation path or a JSON sub-path is typed by
+     * nothing until its value arrives here.
+     */
+    private toBucketableNumber;
+    /**
+     * Derives a bucket width from the measured span and the desired bar count,
+     * snapped to the nearest 1/2/5 × 10ⁿ step.
+     *
+     * The raw `span / desired` is the arithmetically correct width and the wrong
+     * answer for a control. Two reasons, both visible to a user:
+     *
+     *  - buckets are anchored at multiples of the width (`FLOOR(col / w) * w`,
+     *    which the adapter capability defines and which is what lets the grouping
+     *    be one expression), so an ugly width means ugly edges: a span of
+     *    499–128000 over 10 gives 12750.1, and axis labels at 12750.1, 25500.2,
+     *    38250.3;
+     *  - a raw width changes on every row inserted, so the bars re-partition and
+     *    visibly jump whenever the filtered set shifts slightly. A snapped width
+     *    holds still across a range of spans, which is the hysteresis a facet
+     *    that redraws on every keystroke needs.
+     *
+     * Snapped to the NEAREST step in log space (the √2 / √10 / √50 thresholds),
+     * not upward: rounding up turns a span of 101 over 10 buckets into a width of
+     * 20 and six bars, which is a worse lie about the request than eleven bars.
+     * The count therefore lands within about √2 of `desired` in either direction
+     * — `buckets` is a target, and the returned `bucketWidth` is authoritative.
+     *
+     * `span` is strictly positive here: the `min === max` case never reaches this.
+     */
+    private niceBucketWidth;
+    /**
+     * Turns the adapter's sparse `{ value, count }` groups into the contiguous
+     * ascending bucket list a chart draws.
+     *
+     * Three things the raw groups get wrong for this purpose:
+     *
+     *  - **Nulls.** A row whose column is null groups under `FLOOR(NULL / w)`,
+     *    which is NULL — and `Number(null)` is 0, so passing the groups through
+     *    unfiltered plants a phantom bar at zero holding every null row.
+     *  - **Order.** `GROUP BY` has no defined output order. A histogram is a
+     *    sequence, and bars drawn in the order MySQL happened to hash them are
+     *    not a distribution.
+     *  - **Gaps.** Empty buckets produce no group at all, so a sparse list renders
+     *    as evenly spaced bars that lie about where the data sits. They are
+     *    filled with zero-count entries, which is bounded work: the bucket count
+     *    is `span / width`, and the width came from a clamped desired count.
+     *
+     * Groups are matched to buckets by INDEX rather than by comparing the
+     * returned `value` to a computed edge: for a width like 0.1 the database's
+     * `FLOOR(x / 0.1) * 0.1` and this code's `i * 0.1` differ in the last bits,
+     * and an equality match would silently drop those buckets to zero.
+     */
+    private assembleBuckets;
+    /**
+     * Rounds a bucket edge to the decimal precision its width implies. Every edge
+     * is an exact multiple of a 1/2/5 × 10ⁿ width, so this cannot move one onto a
+     * different bucket — it only sheds the binary-float residue that otherwise
+     * labels an axis `0.30000000000000004`. Skipped entirely for widths outside
+     * `toFixed`'s useful range, where rounding would destroy information rather
+     * than tidy it.
+     */
+    private snapEdge;
     /**
      * Runs a dynamic query with **keyset (cursor) pagination** and executes it,
      * returning a stable, non-overlapping page plus opaque forward/backward
@@ -377,10 +659,18 @@ export declare class FilterRunner {
      * Requires an adapter implementing `getResult`, `getPrimaryKey`,
      * `applyKeysetPagination` and `applyKeysetOrderAndLimit`. Additive — does not
      * change `apply`/`applyDynamic`/`findAndCount`.
+     *
+     * `opts.trustedPageSize` lifts the module-level `maxPageSize` ceiling off
+     * `first`/`last` for this call — same meaning as on {@link findAndCount},
+     * and it belongs here for the same reason: keyset paging is the pagination a
+     * long server-side walk SHOULD use (it is stable under concurrent writes),
+     * so capping it would leave the recommended export path as the one that
+     * cannot opt out.
      */
     findPage<E>(entity: Type<E>, input: unknown, opts?: {
         qb?: unknown;
         context?: FilterContext;
+        trustedPageSize?: boolean;
     }): Promise<CursorPage<E>>;
     /** Flips every keyset column's direction (for backward cursor paging). */
     private reverseKeyset;
@@ -393,8 +683,37 @@ export declare class FilterRunner {
      * Drops `where` column-filter clauses whose field is not a known scalar
      * column, relation, or dotted relation path on the entity — so a client
      * filter on an absent column (e.g. a base-scope `baseId` on a base-less
-     * table) is silently ignored instead of crashing the ORM. Recurses AND/OR.
-     * No-op (pass-through) when the adapter exposes no metadata.
+     * table) is dropped instead of crashing the ORM. Recurses AND/OR.
+     *
+     * The grammar check (`validateColumnFilters` → `isValidFieldPath`) only
+     * proves the field name is SQL-SAFE, not that it EXISTS: `ghostColumn`
+     * satisfies the pattern, sails through the operator allowlist, and blows up
+     * inside the ORM. That surfaces as a 500 for the consumer, and as a mid-run
+     * failure for a background job — both worse than not applying a constraint
+     * the entity cannot express in the first place.
+     *
+     * **Policy knob: `throwOnInvalid`, not `onUnknownKey`.** Three reasons, in
+     * order of weight: (1) `FilterModuleOptions.throwOnInvalid` is already
+     * DOCUMENTED as covering "unknown `where` columns" — static mode was simply
+     * never wired to it; (2) `applyDynamic` already routes this same function
+     * through `throwOnInvalid`, so choosing the other knob would recreate, in a
+     * new place, the very static-vs-dynamic asymmetry this fix closes; (3)
+     * `throwOnInvalid` is overridable per-`@Filterable`, while `onUnknownKey` is
+     * module-global — and whether a stray `where` column is a client bug or a
+     * tolerated legacy payload is a per-endpoint judgement. `onUnknownKey` keeps
+     * its own scope: keys of the STRUCTURED filter object, which are dispatch
+     * targets (`@FilterFor` / auto-field / relation), not column references.
+     *
+     * Default (`throwOnInvalid: false`) is drop-with-a-warning rather than a
+     * 400: it is the change that stops the crash without turning requests that
+     * work today into errors, and the warning names the field so the drop is
+     * observable rather than silent. Mirrors
+     * {@link pruneBlacklistedColumnFilters}, which made the same call.
+     *
+     * Falls back to accept-all (with a warning) when the adapter exposes no
+     * metadata — the same graceful degradation `resolveAutoFields` uses, so an
+     * adapter that cannot introspect keeps its pre-fix behavior instead of
+     * having every `where` clause dropped.
      */
     private pruneUnknownColumnFilters;
     /**
@@ -504,13 +823,46 @@ export declare class FilterRunner {
      * option. Returns undefined when neither is set.
      */
     private resolveDefaultSort;
+    /**
+     * Resolves the effective `distinctOrder`: the ROUTE's own
+     * `@ApplyFilter({ distinctOrder })` wins over the filter class's
+     * `@Filterable({ distinctOrder })`, and absent both it is off.
+     *
+     * There is deliberately no module-level knob. Whether a `SELECT DISTINCT`
+     * wants an ORDER BY is a property of the endpoint reading it — one filter
+     * class typically serves a rows route that orders itself and a distinct route
+     * that does not — so an app-wide switch would be answering a question at the
+     * wrong altitude, and silently, for queries whose cost it cannot see.
+     *
+     * Off unless asked for, for the same reason: ordering a projection the caller
+     * never asked to order is a clause this library would be inventing, and on a
+     * large distinct with no index on the projected column that clause is a
+     * filesort nobody signed up for. See {@link FilterableOptions.distinctOrder}.
+     */
+    private resolveDistinctOrder;
     private handleUnknownKey;
+    /**
+     * Narrows an already-structured sort element. The `direction` check is the
+     * strict part: an unrecognised direction is dropped rather than coerced,
+     * because guessing `asc` for a client that asked for something else silently
+     * returns the wrong page of a paginated result.
+     */
+    private isSortItem;
+    /**
+     * Parses one `"-field"` / `"field"` token into a {@link SortItem}, or
+     * `undefined` when there is no field left after trimming (`""`, `"  "`,
+     * a bare `"-"`). Shared by both string shapes so a token means the same
+     * thing whether it arrived inside `"a,-b"` or as `["a", "-b"]`.
+     */
+    private parseSortToken;
     /**
      * Parses raw sort input into an array of SortItem objects.
      *
      * Supports:
      * - String: `"-createdAt,name"` → `[{ field: 'createdAt', direction: 'desc' }, { field: 'name', direction: 'asc' }]`
+     * - Array of tokens: `["-createdAt", "name"]` — same token rules as the string form
      * - Array of SortItem objects: passed through as-is
+     * - Arrays mixing the two: each element is read by its own type
      * - Falsy values: returns empty array
      *
      * Minus prefix = desc, no prefix = asc (JSON:API convention).
@@ -569,7 +921,32 @@ export declare class FilterRunner {
     /**
      * Applies offset or cursor pagination to the query builder.
      * Cursor pagination logs a warning (not yet implemented).
+     *
+     * `trusted` bypasses the `maxPageSize` ceiling — see
+     * {@link FilterRunner.resolvePageSize}.
      */
     private applyPagination;
+    /**
+     * Resolves the effective page size from a requested one.
+     *
+     * `maxPageSize` is a MODULE-level ceiling, so one number has to answer two
+     * different questions, and the right answers disagree. For a size that came
+     * off an HTTP request the ceiling is the whole point: it is what stops a
+     * client asking for a million rows. For a size that came from the server's
+     * own code — an export writing a CSV, a scheduled report, a batch job — the
+     * ceiling is not protection, it is a silent wrong answer: the runner is
+     * handed `size: 10_000`, returns 100 rows, and the export loop reads
+     * `100 < 10_000` as "table exhausted" and writes a truncated file with no
+     * error anywhere.
+     *
+     * The runner cannot tell the two apart by looking at the number, so the CALL
+     * SITE says which it is. `trusted` means "this size is server-authored, not
+     * client input" — the one fact the caller knows and the runner never can.
+     *
+     * The minimum of 1 still applies either way: that is not a safety cap but a
+     * correctness one (a `LIMIT 0` or a negative limit is not a page), and
+     * trusting the caller's intent does not make `size: -5` mean anything.
+     */
+    private resolvePageSize;
 }
 //# sourceMappingURL=runner.d.ts.map

package/dist/runner.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"runner.d.ts","sourceRoot":"","sources":["../src/runner.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"runner.d.ts","sourceRoot":"","sources":["../src/runner.ts"],"names":[],"mappings":"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"}