@nage-api/data 1.0.0-beta.2

package/dist/module/data.module.d.ts

@@ -0,0 +1,67 @@
+/**
+ * `NageDataModule` (PLAN.md §7.3, §14.1).
+ *
+ * `forRoot` publishes the unit of work and the health probe a driver supplies;
+ * `forFeature` registers one repository per model under the token from
+ * `@nage-api/core`. Application services inject the token, drivers provide it, and
+ * neither imports the other — which is what makes the engine a scaffold-time
+ * choice instead of a runtime branch.
+ */
+import { type DynamicModule } from '@nestjs/common';
+import type { DataSourceHealth, Id, RepositoryPort, UnitOfWork } from '@nage-api/contracts';
+export interface DataModuleOptions {
+    /** Transaction boundary implemented by the selected driver. */
+    readonly unitOfWork: UnitOfWork;
+    /** Connection probe feeding `/health/ready`. */
+    readonly health?: DataSourceHealth;
+}
+/** One model's registration: a name and the repository serving it. */
+export interface ModelRegistration<TEntity extends {
+    id: Id;
+}> {
+    readonly model: string;
+    readonly repository: RepositoryPort<TEntity>;
+}
+declare const erasedEntity: unique symbol;
+/**
+ * A registration whose entity type has been erased.
+ *
+ * `forFeature` takes several models at once, and TypeScript cannot spell "an
+ * array whose elements are each independently generic". This used to be typed
+ * `readonly ModelRegistration<never>[]`, which reads like the erased form but is
+ * inhabited by nothing — `RepositoryPort<never>` accepts no repository, so the
+ * method could not be called at all. The first real caller (a generated app)
+ * found that immediately.
+ *
+ * The brand is what keeps the erasure honest: an object literal cannot satisfy
+ * it, so every registration goes through `registerModel`, where the entity type
+ * *is* checked.
+ */
+export interface ErasedModelRegistration {
+    readonly model: string;
+    readonly repository: unknown;
+    readonly [erasedEntity]: true;
+}
+/**
+ * Pair a model name with the repository serving it, for `forFeature`.
+ *
+ * ```ts
+ * NageDataModule.forFeature([registerModel('Product', productRepository)])
+ * ```
+ */
+export declare function registerModel<TEntity extends {
+    id: Id;
+}>(model: string, repository: RepositoryPort<TEntity>): ErasedModelRegistration;
+export declare class NageDataModule {
+    static forRoot(options: DataModuleOptions): DynamicModule;
+    /**
+     * Register repositories for a feature module.
+     *
+     * ```ts
+     * @Module({ imports: [NageDataModule.forFeature([registerModel('Product', repository)])] })
+     * ```
+     */
+    static forFeature(registrations: readonly ErasedModelRegistration[]): DynamicModule;
+}
+export {};
+//# sourceMappingURL=data.module.d.ts.map

package/dist/module/data.module.js

@@ -0,0 +1,71 @@
+"use strict";
+/**
+ * `NageDataModule` (PLAN.md §7.3, §14.1).
+ *
+ * `forRoot` publishes the unit of work and the health probe a driver supplies;
+ * `forFeature` registers one repository per model under the token from
+ * `@nage-api/core`. Application services inject the token, drivers provide it, and
+ * neither imports the other — which is what makes the engine a scaffold-time
+ * choice instead of a runtime branch.
+ */
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var NageDataModule_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NageDataModule = void 0;
+exports.registerModel = registerModel;
+const common_1 = require("@nestjs/common");
+const core_1 = require("@nage-api/core");
+const tokens_js_1 = require("../tokens.js");
+const core_2 = require("@nage-api/core");
+/**
+ * Pair a model name with the repository serving it, for `forFeature`.
+ *
+ * ```ts
+ * NageDataModule.forFeature([registerModel('Product', productRepository)])
+ * ```
+ */
+function registerModel(model, repository) {
+    // The one cast, here rather than in every caller: the module only ever hands
+    // the repository to `useValue`, so nothing downstream needs the entity type.
+    return { model, repository };
+}
+let NageDataModule = NageDataModule_1 = class NageDataModule {
+    static forRoot(options) {
+        const providers = [{ provide: core_2.NAGE_UNIT_OF_WORK, useValue: options.unitOfWork }];
+        const exports = [core_2.NAGE_UNIT_OF_WORK];
+        if (options.health !== undefined) {
+            providers.push({ provide: tokens_js_1.NAGE_DATA_HEALTH, useValue: options.health });
+            exports.push(tokens_js_1.NAGE_DATA_HEALTH);
+        }
+        return { module: NageDataModule_1, providers, exports };
+    }
+    /**
+     * Register repositories for a feature module.
+     *
+     * ```ts
+     * @Module({ imports: [NageDataModule.forFeature([registerModel('Product', repository)])] })
+     * ```
+     */
+    static forFeature(registrations) {
+        const providers = registrations.map((registration) => ({
+            provide: (0, core_1.repositoryToken)(registration.model),
+            useValue: registration.repository,
+        }));
+        return {
+            module: NageDataModule_1,
+            providers,
+            exports: providers.map((provider) => provider.provide),
+        };
+    }
+};
+exports.NageDataModule = NageDataModule;
+exports.NageDataModule = NageDataModule = NageDataModule_1 = __decorate([
+    (0, common_1.Global)(),
+    (0, common_1.Module)({})
+], NageDataModule);
+//# sourceMappingURL=data.module.js.map

package/dist/query/parse-query.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Validate client input against a model's query policy (PLAN.md §12, §16.2).
+ *
+ * This is the gate between an HTTP query string and a driver. Everything that
+ * crosses it has been checked against an allow-list; anything else is rejected
+ * with `INVALID_QUERY` rather than silently dropped, so a caller learns that a
+ * field is not filterable instead of quietly receiving unfiltered results.
+ */
+import type { Query, QueryPolicy, Sort, Where } from '@nage-api/contracts';
+/** Raw, untrusted query input — typically `request.query`. */
+export type RawQuery = Record<string, unknown>;
+/**
+ * Enforce the page-size ceiling.
+ *
+ * `limit: -1` — the legacy way to ask for everything — has no representation
+ * here: a non-positive limit is rejected, and anything above the model's
+ * ceiling is refused rather than silently clamped, so a client that asked for
+ * 100 000 rows finds out instead of believing it got them.
+ */
+export declare function resolvePagination<TEntity>(query: {
+    readonly offset?: unknown;
+    readonly limit?: unknown;
+}, policy: QueryPolicy<TEntity>): {
+    offset: number;
+    limit: number;
+};
+/** Validate a `where` clause against the filterable fields and operator allow-list. */
+export declare function parseWhere<TEntity>(raw: unknown, policy: QueryPolicy<TEntity>, depth?: number): Where<TEntity>;
+/** Validate sort instructions; accepts `-price` shorthand as well as tuples. */
+export declare function parseSort<TEntity>(raw: unknown, policy: QueryPolicy<TEntity>): Sort<TEntity>;
+/**
+ * Validate a raw query against a model's policy.
+ *
+ * @throws InvalidQueryError for anything outside the allow-lists
+ * @throws QueryLimitExceededError when the page size exceeds the ceiling
+ */
+export declare function parseQuery<TEntity>(raw: RawQuery, policy: QueryPolicy<TEntity>): Query<TEntity>;
+//# sourceMappingURL=parse-query.d.ts.map

package/dist/query/parse-query.js

@@ -0,0 +1,285 @@
+"use strict";
+/**
+ * Validate client input against a model's query policy (PLAN.md §12, §16.2).
+ *
+ * This is the gate between an HTTP query string and a driver. Everything that
+ * crosses it has been checked against an allow-list; anything else is rejected
+ * with `INVALID_QUERY` rather than silently dropped, so a caller learns that a
+ * field is not filterable instead of quietly receiving unfiltered results.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolvePagination = resolvePagination;
+exports.parseWhere = parseWhere;
+exports.parseSort = parseSort;
+exports.parseQuery = parseQuery;
+const core_1 = require("@nage-api/core");
+const LOGICAL_KEYS = new Set(['and', 'or', 'not']);
+const SORT_DIRECTIONS = new Set(['asc', 'desc']);
+function reject(message, meta = {}) {
+    throw new core_1.InvalidQueryError({ message, meta });
+}
+function isPlainObject(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+/**
+ * Refuse a clause whose prototype the client replaced.
+ *
+ * `{"__proto__": {...}}` sets the prototype instead of adding an own property in
+ * every parser that honours the key, so `Object.entries` reports an empty clause
+ * and the allow-list waves it through — the caller asked to filter and silently
+ * received the unfiltered collection, with the attacker's payload still riding
+ * on the object handed to the driver. Checking own keys against the allow-list
+ * cannot see this; only the prototype can. A null prototype is the hardened
+ * shape and stays welcome.
+ */
+function rejectTamperedPrototype(value, label) {
+    const prototype = Object.getPrototypeOf(value);
+    if (prototype !== Object.prototype && prototype !== null) {
+        reject(`${label} must not carry a modified prototype`);
+    }
+}
+/**
+ * Enforce the page-size ceiling.
+ *
+ * `limit: -1` — the legacy way to ask for everything — has no representation
+ * here: a non-positive limit is rejected, and anything above the model's
+ * ceiling is refused rather than silently clamped, so a client that asked for
+ * 100 000 rows finds out instead of believing it got them.
+ */
+function resolvePagination(query, policy) {
+    const offset = query.offset === undefined ? 0 : toInteger(query.offset, 'offset');
+    if (offset < 0)
+        reject('offset must not be negative', { offset });
+    if (query.limit === undefined)
+        return { offset, limit: policy.defaultLimit };
+    const limit = toInteger(query.limit, 'limit');
+    if (limit <= 0) {
+        reject('limit must be a positive number; use cursor pagination for large exports', { limit });
+    }
+    if (limit > policy.maxLimit) {
+        throw new core_1.QueryLimitExceededError(policy.maxLimit, { meta: { requested: limit } });
+    }
+    return { offset, limit };
+}
+/** The keys whose values the DSL expects to arrive already parsed into objects. */
+const STRUCTURED_KEYS = ['where', 'sort', 'select', 'scope', 'populate', 'search'];
+/**
+ * Refuse a query whose bracket syntax was never parsed.
+ *
+ * Express 5's default `query parser` is `simple`, under which
+ * `?where[status]=active` arrives as the single flat key `'where[status]'`
+ * instead of `{ where: { status: 'active' } }`. Every structured key then looks
+ * absent, and a request that asked to filter returns the **unfiltered**
+ * collection with a 200 — indistinguishable, to the client, from a filter that
+ * matched everything.
+ *
+ * Ignoring an unrecognised top-level key is right in general (a query string
+ * carries analytics parameters and the like), so the check is narrow: a key that
+ * begins with one of the DSL's own names followed by `[` can only mean a
+ * misconfigured parser, and saying so is far better than answering as if no
+ * filter had been requested. `@nage-api/core`'s `enableQueryDsl` is the fix.
+ */
+function rejectUnparsedBrackets(raw) {
+    for (const key of Object.keys(raw)) {
+        const bracket = key.indexOf('[');
+        if (bracket <= 0)
+            continue;
+        if (STRUCTURED_KEYS.includes(key.slice(0, bracket))) {
+            reject(`Query key "${key}" arrived unparsed; the HTTP query parser is not configured for bracket syntax`, { key, hint: 'Call enableQueryDsl(app), which bootstrap() already does.' });
+        }
+    }
+}
+function toInteger(value, field) {
+    const parsed = typeof value === 'number' ? value : Number(value);
+    if (!Number.isInteger(parsed))
+        reject(`${field} must be an integer`, { [field]: value });
+    return parsed;
+}
+/** Validate a `where` clause against the filterable fields and operator allow-list. */
+function parseWhere(raw, policy, depth = 0) {
+    if (!isPlainObject(raw))
+        reject('where must be an object');
+    rejectTamperedPrototype(raw, 'where');
+    if (depth > 5)
+        reject('where is nested too deeply', { maxDepth: 5 });
+    const filterable = new Set(policy.filterable);
+    const operators = new Set(policy.operators);
+    const result = {};
+    for (const [key, value] of Object.entries(raw)) {
+        if (LOGICAL_KEYS.has(key)) {
+            result[key] =
+                key === 'not'
+                    ? parseWhere(value, policy, depth + 1)
+                    : asArray(value, key).map((entry) => parseWhere(entry, policy, depth + 1));
+            continue;
+        }
+        if (!filterable.has(key)) {
+            // Naming the allowed fields turns a 400 into something a developer can
+            // act on without reading the source.
+            reject(`Field "${key}" is not filterable`, {
+                field: key,
+                filterable: [...filterable],
+            });
+        }
+        result[key] = isPlainObject(value) ? parseCondition(key, value, operators) : value;
+    }
+    return result;
+}
+function asArray(value, key) {
+    if (!Array.isArray(value))
+        reject(`"${key}" must be an array of conditions`);
+    return value;
+}
+function parseCondition(field, raw, operators) {
+    // An empty condition matches every row, so the same trick applied one level
+    // down turns a filter into a no-op rather than an error.
+    rejectTamperedPrototype(raw, `condition on "${field}"`);
+    const condition = {};
+    for (const [operator, operand] of Object.entries(raw)) {
+        if (!operators.has(operator)) {
+            reject(`Operator "${operator}" is not allowed on "${field}"`, {
+                field,
+                operator,
+                allowed: [...operators],
+            });
+        }
+        if ((operator === 'in' || operator === 'nin') && !Array.isArray(operand)) {
+            reject(`Operator "${operator}" expects an array`, { field, operator });
+        }
+        if (operator === 'between' && (!Array.isArray(operand) || operand.length !== 2)) {
+            reject('Operator "between" expects exactly two values', { field });
+        }
+        condition[operator] = operand;
+    }
+    return condition;
+}
+/** Validate sort instructions; accepts `-price` shorthand as well as tuples. */
+function parseSort(raw, policy) {
+    const sortable = new Set(policy.sortable);
+    const entries = [];
+    const push = (field, direction) => {
+        if (!sortable.has(field)) {
+            reject(`Field "${field}" is not sortable`, { field, sortable: [...sortable] });
+        }
+        entries.push([field, direction]);
+    };
+    const parseToken = (token) => {
+        // `-created_at` is the shorthand every list UI already sends.
+        if (token.startsWith('-'))
+            push(token.slice(1), 'desc');
+        else
+            push(token, 'asc');
+    };
+    if (typeof raw === 'string') {
+        for (const token of raw.split(',')) {
+            const trimmed = token.trim();
+            if (trimmed.length > 0)
+                parseToken(trimmed);
+        }
+    }
+    else if (Array.isArray(raw)) {
+        for (const entry of raw) {
+            if (typeof entry === 'string') {
+                parseToken(entry.trim());
+                continue;
+            }
+            if (!Array.isArray(entry) || entry.length !== 2)
+                reject('sort entries must be [field, direction]');
+            const [field, direction] = entry;
+            if (typeof field !== 'string' || typeof direction !== 'string') {
+                reject('sort entries must be [field, direction]');
+            }
+            if (!SORT_DIRECTIONS.has(direction)) {
+                reject(`"${direction}" is not a sort direction`, { direction });
+            }
+            push(field, direction);
+        }
+    }
+    else {
+        reject('sort must be a string or an array');
+    }
+    return entries;
+}
+function parseStringList(raw, field) {
+    if (typeof raw === 'string') {
+        return raw
+            .split(',')
+            .map((entry) => entry.trim())
+            .filter((entry) => entry.length > 0);
+    }
+    if (Array.isArray(raw) && raw.every((entry) => typeof entry === 'string')) {
+        return raw;
+    }
+    return reject(`${field} must be a string or an array of strings`);
+}
+function parseAllowedList(raw, allowed, field, label) {
+    const requested = parseStringList(raw, field);
+    const permitted = new Set(allowed);
+    for (const entry of requested) {
+        if (!permitted.has(entry)) {
+            reject(`"${entry}" is not ${label}`, { field: entry, allowed: [...permitted] });
+        }
+    }
+    return requested;
+}
+/**
+ * Validate a raw query against a model's policy.
+ *
+ * @throws InvalidQueryError for anything outside the allow-lists
+ * @throws QueryLimitExceededError when the page size exceeds the ceiling
+ */
+function parseQuery(raw, policy) {
+    rejectUnparsedBrackets(raw);
+    const { offset, limit } = resolvePagination(raw, policy);
+    const query = { offset, limit };
+    if (raw['where'] !== undefined)
+        query['where'] = parseWhere(raw['where'], policy);
+    if (raw['sort'] !== undefined)
+        query['sort'] = parseSort(raw['sort'], policy);
+    if (raw['select'] !== undefined) {
+        query['select'] = parseAllowedList(raw['select'], policy.selectable, 'select', 'selectable');
+    }
+    if (raw['scope'] !== undefined) {
+        query['scope'] = parseAllowedList(raw['scope'], policy.scopes, 'scope', 'a known scope');
+    }
+    if (raw['populate'] !== undefined) {
+        const populate = parseAllowedList(raw['populate'], policy.populatable, 'populate', 'populatable');
+        for (const relation of populate) {
+            const depth = relation.split('.').length;
+            if (depth > policy.maxPopulateDepth) {
+                reject(`populate "${relation}" is nested deeper than ${policy.maxPopulateDepth}`, {
+                    relation,
+                    maxPopulateDepth: policy.maxPopulateDepth,
+                });
+            }
+        }
+        query['populate'] = populate;
+    }
+    if (raw['search'] !== undefined)
+        query['search'] = parseSearch(raw['search'], policy);
+    if (raw['withDeleted'] !== undefined) {
+        query['withDeleted'] = raw['withDeleted'] === true || raw['withDeleted'] === 'true';
+    }
+    if (raw['cursor'] !== undefined) {
+        if (typeof raw['cursor'] !== 'string')
+            reject('cursor must be a string');
+        query['cursor'] = raw['cursor'];
+    }
+    return query;
+}
+function parseSearch(raw, policy) {
+    if (policy.searchable.length === 0) {
+        reject('This model does not support search', { searchable: [] });
+    }
+    if (typeof raw === 'string')
+        return { term: raw };
+    if (!isPlainObject(raw) || typeof raw['term'] !== 'string') {
+        reject('search must be a string or { term, fields }');
+    }
+    const term = raw['term'];
+    if (raw['fields'] === undefined)
+        return { term };
+    const fields = parseAllowedList(raw['fields'], policy.searchable, 'search.fields', 'searchable');
+    return { term, fields };
+}
+//# sourceMappingURL=parse-query.js.map

package/dist/query/policy.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Per-model query policy (PLAN.md §12, §14.2).
+ *
+ * The legacy DSL forwarded client-supplied `$`-operators straight to the ORM and
+ * honoured `limit: -1`. The DSL survives — it is the framework's most productive
+ * idea — but a model now declares exactly which fields and operators a client
+ * may reach, and every query is validated against that declaration before it
+ * reaches a driver.
+ *
+ * Nothing is filterable by default. A policy is a statement of what is exposed,
+ * not a list of exceptions.
+ */
+import type { ComparisonOperator, FieldName, QueryPolicy } from '@nage-api/contracts';
+/** Operators safe to expose on any model. */
+export declare const DEFAULT_OPERATORS: readonly ComparisonOperator[];
+export declare const DEFAULT_MAX_LIMIT = 100;
+export declare const DEFAULT_LIMIT = 25;
+export declare const DEFAULT_MAX_POPULATE_DEPTH = 2;
+/** What a model has to state; everything else has a safe default. */
+export interface QueryPolicyInput<TEntity> {
+    readonly filterable?: readonly FieldName<TEntity>[];
+    readonly sortable?: readonly FieldName<TEntity>[];
+    readonly selectable?: readonly FieldName<TEntity>[];
+    readonly searchable?: readonly FieldName<TEntity>[];
+    readonly populatable?: readonly string[];
+    readonly scopes?: readonly string[];
+    readonly operators?: readonly ComparisonOperator[];
+    readonly maxLimit?: number;
+    readonly defaultLimit?: number;
+    readonly maxPopulateDepth?: number;
+}
+/**
+ * Build a policy.
+ *
+ * ```ts
+ * const productPolicy = defineQueryPolicy<Product>({
+ *   filterable: ['name', 'price', 'archived'],
+ *   sortable: ['name', 'price', 'created_at'],
+ *   searchable: ['name'],
+ *   maxLimit: 200,
+ * });
+ * ```
+ */
+export declare function defineQueryPolicy<TEntity>(input?: QueryPolicyInput<TEntity>): QueryPolicy<TEntity>;
+/**
+ * Policy for internal callers: everything the entity has, nothing hidden.
+ *
+ * For server-side code that composes its own queries — never for a policy
+ * applied to client input.
+ */
+export declare function trustedQueryPolicy<TEntity>(fields: readonly FieldName<TEntity>[], maxLimit?: number): QueryPolicy<TEntity>;
+//# sourceMappingURL=policy.d.ts.map

package/dist/query/policy.js

@@ -0,0 +1,80 @@
+"use strict";
+/**
+ * Per-model query policy (PLAN.md §12, §14.2).
+ *
+ * The legacy DSL forwarded client-supplied `$`-operators straight to the ORM and
+ * honoured `limit: -1`. The DSL survives — it is the framework's most productive
+ * idea — but a model now declares exactly which fields and operators a client
+ * may reach, and every query is validated against that declaration before it
+ * reaches a driver.
+ *
+ * Nothing is filterable by default. A policy is a statement of what is exposed,
+ * not a list of exceptions.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_MAX_POPULATE_DEPTH = exports.DEFAULT_LIMIT = exports.DEFAULT_MAX_LIMIT = exports.DEFAULT_OPERATORS = void 0;
+exports.defineQueryPolicy = defineQueryPolicy;
+exports.trustedQueryPolicy = trustedQueryPolicy;
+/** Operators safe to expose on any model. */
+exports.DEFAULT_OPERATORS = [
+    'eq',
+    'ne',
+    'gt',
+    'gte',
+    'lt',
+    'lte',
+    'in',
+    'nin',
+    'like',
+    'ilike',
+    'between',
+    'isNull',
+];
+exports.DEFAULT_MAX_LIMIT = 100;
+exports.DEFAULT_LIMIT = 25;
+exports.DEFAULT_MAX_POPULATE_DEPTH = 2;
+/**
+ * Build a policy.
+ *
+ * ```ts
+ * const productPolicy = defineQueryPolicy<Product>({
+ *   filterable: ['name', 'price', 'archived'],
+ *   sortable: ['name', 'price', 'created_at'],
+ *   searchable: ['name'],
+ *   maxLimit: 200,
+ * });
+ * ```
+ */
+function defineQueryPolicy(input = {}) {
+    const maxLimit = input.maxLimit ?? exports.DEFAULT_MAX_LIMIT;
+    return {
+        filterable: input.filterable ?? [],
+        sortable: input.sortable ?? [],
+        selectable: input.selectable ?? [],
+        searchable: input.searchable ?? [],
+        populatable: input.populatable ?? [],
+        scopes: input.scopes ?? [],
+        operators: input.operators ?? exports.DEFAULT_OPERATORS,
+        maxLimit,
+        // A default page larger than the ceiling would be incoherent.
+        defaultLimit: Math.min(input.defaultLimit ?? exports.DEFAULT_LIMIT, maxLimit),
+        maxPopulateDepth: input.maxPopulateDepth ?? exports.DEFAULT_MAX_POPULATE_DEPTH,
+    };
+}
+/**
+ * Policy for internal callers: everything the entity has, nothing hidden.
+ *
+ * For server-side code that composes its own queries — never for a policy
+ * applied to client input.
+ */
+function trustedQueryPolicy(fields, maxLimit = 1000) {
+    return defineQueryPolicy({
+        filterable: fields,
+        sortable: fields,
+        selectable: fields,
+        searchable: fields,
+        maxLimit,
+        defaultLimit: Math.min(exports.DEFAULT_LIMIT, maxLimit),
+    });
+}
+//# sourceMappingURL=policy.js.map

package/dist/query/where-matcher.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Evaluate a `Where` clause against a plain object.
+ *
+ * Used by the in-memory driver, and by tests that need to reason about the DSL
+ * without a database. SQL and Mongo drivers translate the same clause into
+ * their own dialect instead — the semantics here are the reference the shared
+ * conformance suite pins down.
+ */
+import type { UnknownRecord, Where } from '@nage-api/contracts';
+/** Does `record` satisfy `where`? An empty clause matches everything. */
+export declare function matchesWhere<TEntity extends UnknownRecord>(record: TEntity, where: Where<TEntity> | undefined): boolean;
+//# sourceMappingURL=where-matcher.d.ts.map