@adonis-agora/filter 0.9.0 → 0.11.0

package/dist/src/in_memory.js

@@ -0,0 +1,759 @@
+import { buildCursorPage, } from './cursor.js';
+import { applyCursor, applyFilter } from './runner.js';
+/**
+ * Thrown when the runner asks the in-memory builder for something only SQL can do: a raw
+ * predicate or ordering (policy `computed` fields, `fullText`, `vectorSimilarity`) — declare a
+ * virtual field instead — or a relation/field path the collection does not declare.
+ */
+export class InMemoryQueryError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'InMemoryQueryError';
+    }
+}
+const ARRAY_KINDS = {
+    'string[]': 'string',
+    'number[]': 'number',
+    'boolean[]': 'boolean',
+    'date[]': 'date',
+};
+function resolveType(type) {
+    const element = ARRAY_KINDS[type];
+    return element ? { kind: element, array: true } : { kind: type, array: false };
+}
+/**
+ * Declare a collection: its fields (and their types), virtual fields, primary key and relations.
+ *
+ * ```ts
+ * const posts = defineCollection<Post>({ fields: { id: 'number', title: 'string' } })
+ * const users = defineCollection<User>({
+ *   fields: {
+ *     id: 'number',
+ *     name: 'string',
+ *     age: 'number',
+ *     tags: 'string[]',
+ *     fullName: { type: 'string', get: (u) => `${u.first} ${u.last}` },
+ *   },
+ *   relations: { posts: { kind: 'one-to-many', target: () => posts, get: (u) => u.posts } },
+ * })
+ *
+ * const qb = users.query(rows)
+ * const { page, size } = applyFilter(qb, input, { allowed: ['name', 'posts.title'] })
+ * return qb.paginate(page, size)
+ * ```
+ */
+export function defineCollection(options) {
+    const fields = Object.create(null);
+    const filterable = {};
+    const fieldTypes = {};
+    for (const [name, declaration] of Object.entries(options.fields)) {
+        const virtual = typeof declaration === 'object' ? declaration : undefined;
+        const { kind, array } = resolveType(virtual ? virtual.type : declaration);
+        fields[name] = { kind, array, get: virtual?.get };
+        filterable[name] = kind;
+        fieldTypes[name] = { kind };
+    }
+    const relations = Object.create(null);
+    for (const [name, relation] of Object.entries(options.relations ?? {})) {
+        relations[name] = relation;
+    }
+    const collection = {
+        name: options.name,
+        primaryKey: options.primaryKey ?? 'id',
+        filterable,
+        fieldTypes,
+        $fields: fields,
+        $relations: relations,
+        query: (rows) => new InMemoryQueryBuilder(collection, [...rows]),
+    };
+    return collection;
+}
+function isNil(value) {
+    return value === null || value === undefined;
+}
+function hasToMillis(value) {
+    return (typeof value === 'object' &&
+        value !== null &&
+        typeof value.toMillis === 'function');
+}
+/** The kind a runtime value has — used for undeclared (`unknown`/`json`) fields. */
+function inferKind(value) {
+    if (typeof value === 'number' || typeof value === 'bigint')
+        return 'number';
+    if (typeof value === 'boolean')
+        return 'boolean';
+    if (typeof value === 'string')
+        return 'string';
+    if (value instanceof Date || hasToMillis(value))
+        return 'date';
+    return 'json';
+}
+/**
+ * Normalize a value to a comparable primitive of `kind`, the way Postgres casts a bound literal to
+ * the column type. `undefined` means "cannot be cast" — the comparison is then false, where
+ * Postgres would have rejected the query outright.
+ */
+function normalize(value, kind) {
+    if (isNil(value))
+        return undefined;
+    switch (kind) {
+        case 'number': {
+            if (typeof value === 'number')
+                return Number.isFinite(value) ? value : undefined;
+            if (typeof value === 'bigint')
+                return Number(value);
+            if (typeof value === 'string' && value.trim() !== '') {
+                const n = Number(value.trim());
+                return Number.isFinite(n) ? n : undefined;
+            }
+            return undefined;
+        }
+        case 'boolean': {
+            if (typeof value === 'boolean')
+                return value;
+            if (value === 1 || value === 0)
+                return value === 1;
+            if (typeof value === 'string') {
+                const v = value.trim().toLowerCase();
+                if (v === 'true' || v === '1')
+                    return true;
+                if (v === 'false' || v === '0')
+                    return false;
+            }
+            return undefined;
+        }
+        case 'date': {
+            if (value instanceof Date) {
+                const t = value.getTime();
+                return Number.isNaN(t) ? undefined : t;
+            }
+            if (hasToMillis(value))
+                return value.toMillis();
+            if (typeof value === 'number')
+                return Number.isFinite(value) ? value : undefined;
+            if (typeof value === 'string') {
+                const t = Date.parse(value);
+                return Number.isNaN(t) ? undefined : t;
+            }
+            return undefined;
+        }
+        case 'string':
+            return typeof value === 'string' ? value : stringify(value);
+        default:
+            // json / unknown: structural equality only.
+            return typeof value === 'object' ? JSON.stringify(value) : value;
+    }
+}
+/** Text form of a value — what a LIKE on a non-text column matches against. */
+function stringify(value) {
+    if (typeof value === 'string')
+        return value;
+    if (value instanceof Date)
+        return value.toISOString();
+    if (hasToMillis(value))
+        return new Date(value.toMillis()).toISOString();
+    if (typeof value === 'object' && value !== null)
+        return JSON.stringify(value);
+    return String(value);
+}
+/**
+ * Compare a row value to a comparand under `kind` (`json`/`unknown` → the row value's own kind).
+ * `undefined` when either side cannot be cast or the kind has no ordering.
+ */
+function compare(rowValue, comparand, declared) {
+    const kind = declared === 'json' || declared === 'unknown' ? inferKind(rowValue) : declared;
+    const a = normalize(rowValue, kind);
+    const b = normalize(comparand, kind);
+    if (a === undefined || b === undefined)
+        return undefined;
+    if (typeof a === 'number' && typeof b === 'number')
+        return a - b;
+    if (typeof a === 'boolean' && typeof b === 'boolean')
+        return Number(a) - Number(b);
+    if (typeof a === 'string' && typeof b === 'string') {
+        // Code-unit order — Postgres' "C" collation. Deterministic and locale-free, which a keyset
+        // cursor needs: the seek predicate and the ORDER BY must agree on every pair of values.
+        return a < b ? -1 : a > b ? 1 : 0;
+    }
+    return a === b ? 0 : undefined;
+}
+/** Compile a LIKE pattern (backslash escapes, `%`, `_`) into an anchored RegExp. */
+function likeToRegExp(pattern, caseInsensitive) {
+    let source = '';
+    for (let i = 0; i < pattern.length; i++) {
+        const ch = pattern[i];
+        if (ch === '\\' && i + 1 < pattern.length) {
+            source += escapeRegExp(pattern[++i]);
+        }
+        else if (ch === '%') {
+            source += '.*';
+        }
+        else if (ch === '_') {
+            source += '.';
+        }
+        else {
+            source += escapeRegExp(ch);
+        }
+    }
+    return new RegExp(`^${source}$`, caseInsensitive ? 'is' : 's');
+}
+function escapeRegExp(ch) {
+    return ch.replace(/[.*+?^${}()|[\]\\/]/g, '\\$&');
+}
+/** Relation targets normalized to a list (a to-one relation yields zero or one row). */
+function relatedRows(value) {
+    if (isNil(value))
+        return [];
+    if (Array.isArray(value))
+        return value.filter((v) => !isNil(v));
+    return [value];
+}
+/** Parse a `expr AS alias` select/count argument. */
+function parseAlias(expression) {
+    const match = /^\s*(.+?)\s+as\s+([A-Za-z_][A-Za-z0-9_]*)\s*$/i.exec(expression);
+    return match
+        ? { expr: match[1].trim(), alias: match[2] }
+        : { expr: expression.trim(), alias: expression.trim() };
+}
+/** The raw predicate the group-by-count search emits — the only raw SQL this adapter understands. */
+const GROUP_SEARCH_SQL = /^\s*LOWER\(\?\?\)\s+LIKE\s+\?\s*$/i;
+/**
+ * A {@link QueryBuilderLike} over an array. Created by {@link InMemoryCollection.query}; hand it to
+ * any runner entry point exactly as you would a Lucid query, then read the result with
+ * {@link all}, {@link paginate}, or by awaiting it (it is thenable, like a Lucid query — which is
+ * what lets `groupByCountFromRequest` run over it unchanged).
+ */
+export class InMemoryQueryBuilder {
+    collection;
+    rows;
+    clauses = [];
+    sorts = [];
+    selects = [];
+    groups = [];
+    groupSearches = [];
+    distinctFields = [];
+    countAlias;
+    limitCount;
+    offsetCount;
+    constructor(collection, rows = []) {
+        this.collection = collection;
+        this.rows = rows;
+    }
+    // -- field access -----------------------------------------------------------------------------
+    field(name) {
+        return this.collection.$fields[name];
+    }
+    /** Strip a leading `<collection name>.` qualifier. */
+    unqualify(path) {
+        const name = this.collection.name;
+        return name !== undefined && path.startsWith(`${name}.`) ? path.slice(name.length + 1) : path;
+    }
+    /**
+     * Read a (possibly dotted) path off a row. A dotted path crosses a to-one relation; crossing a
+     * to-many relation is ambiguous outside a `whereHas` (which the runner uses for filters) and is
+     * rejected.
+     */
+    read(row, rawPath) {
+        const path = this.unqualify(rawPath);
+        const dot = path.indexOf('.');
+        if (dot === -1) {
+            const declared = this.field(path);
+            if (declared?.get)
+                return declared.get(row);
+            return Object.hasOwn(row, path) ? row[path] : undefined;
+        }
+        const head = path.slice(0, dot);
+        const relation = this.collection.$relations[head];
+        if (!relation) {
+            throw new InMemoryQueryError(`"${rawPath}" crosses "${head}", which is not a relation declared on this collection.`);
+        }
+        if (relation.kind === 'one-to-many' || relation.kind === 'many-to-many') {
+            throw new InMemoryQueryError(`"${rawPath}" reads through the to-many relation "${head}" — only a filter (EXISTS) can cross it.`);
+        }
+        const related = relatedRows(relation.get(row))[0];
+        if (related === undefined)
+            return undefined;
+        return relation
+            .target()
+            .query([])
+            .read(related, path.slice(dot + 1));
+    }
+    /** The declared kind of a path (following to-one relations), or `unknown`. */
+    kindOf(rawPath) {
+        const path = this.unqualify(rawPath);
+        const dot = path.indexOf('.');
+        if (dot === -1)
+            return this.field(path) ?? { kind: 'unknown', array: false };
+        const relation = this.collection.$relations[path.slice(0, dot)];
+        if (!relation)
+            return { kind: 'unknown', array: false };
+        return relation
+            .target()
+            .query([])
+            .kindOf(path.slice(dot + 1));
+    }
+    /**
+     * Build a leaf predicate. `match` tests one non-null element; `negated` flips the element-level
+     * result into "no element matches" — with SQL's rule that a NULL value (or an uncastable
+     * comparison) satisfies neither a condition nor its negation.
+     */
+    leaf(path, match, negated = false) {
+        const { kind, array } = this.kindOf(path);
+        return (row) => {
+            const value = this.read(row, path);
+            if (isNil(value))
+                return false;
+            if (array || (Array.isArray(value) && (kind === 'unknown' || kind === 'json'))) {
+                const elements = (Array.isArray(value) ? value : [value]).filter((e) => !isNil(e));
+                const results = elements.map((e) => match(e, kind));
+                if (negated)
+                    return results.every((r) => r === false);
+                return results.some((r) => r === true);
+            }
+            const result = match(value, kind);
+            if (result === undefined)
+                return false;
+            return negated ? !result : result;
+        };
+    }
+    equalsLeaf(path, value, negated) {
+        return this.leaf(path, (e, kind) => {
+            const c = compare(e, value, kind);
+            return c === undefined ? undefined : c === 0;
+        }, negated);
+    }
+    compareLeaf(path, operator, value) {
+        switch (operator) {
+            case '=':
+                return isNil(value) ? () => false : this.equalsLeaf(path, value, false);
+            case '!=':
+            case '<>':
+                return isNil(value) ? () => false : this.equalsLeaf(path, value, true);
+            case '>':
+            case '>=':
+            case '<':
+            case '<=':
+                if (isNil(value))
+                    return () => false;
+                return this.leaf(path, (e, kind) => {
+                    const c = compare(e, value, kind);
+                    if (c === undefined)
+                        return undefined;
+                    if (operator === '>')
+                        return c > 0;
+                    if (operator === '>=')
+                        return c >= 0;
+                    if (operator === '<')
+                        return c < 0;
+                    return c <= 0;
+                });
+            default:
+                throw new InMemoryQueryError(`Unsupported comparison operator "${operator}".`);
+        }
+    }
+    inLeaf(path, values, negated) {
+        // SQL: `x IN ()` is false and `x NOT IN ()` is true for every row, NULLs included (knex emits
+        // 1 = 0 / 1 = 1); `x NOT IN (…, NULL)` is never true.
+        if (values.length === 0)
+            return () => negated;
+        if (negated && values.some(isNil))
+            return () => false;
+        const candidates = values.filter((v) => !isNil(v));
+        return this.leaf(path, (e, kind) => {
+            let unknown = false;
+            for (const candidate of candidates) {
+                const c = compare(e, candidate, kind);
+                if (c === 0)
+                    return true;
+                if (c === undefined)
+                    unknown = true;
+            }
+            return unknown ? undefined : false;
+        }, negated);
+    }
+    betweenLeaf(path, range, negated) {
+        const [low, high] = Array.isArray(range) ? range : [undefined, undefined];
+        if (isNil(low) || isNil(high))
+            return () => false;
+        return this.leaf(path, (e, kind) => {
+            const lo = compare(e, low, kind);
+            const hi = compare(e, high, kind);
+            if (lo === undefined || hi === undefined)
+                return undefined;
+            return lo >= 0 && hi <= 0;
+        }, negated);
+    }
+    likeLeaf(path, pattern) {
+        const regex = likeToRegExp(pattern, true);
+        return this.leaf(path, (e) => regex.test(stringify(e)));
+    }
+    add(test, or = false) {
+        this.clauses.push({ or, test });
+        return this;
+    }
+    group(callback, or) {
+        const child = new InMemoryQueryBuilder(this.collection);
+        callback(child);
+        // An empty group compiles to nothing in knex — not to an always-true/false clause.
+        if (child.clauses.length === 0)
+            return this;
+        return this.add((row) => child.matches(row), or);
+    }
+    /**
+     * Does `row` satisfy every recorded condition? Clauses chain left to right the way knex joins
+     * them — `a AND b OR c` — so AND binds tighter than OR, exactly as the emitted SQL would.
+     */
+    matches(row) {
+        let result = false;
+        let segment = true;
+        this.clauses.forEach((clause, index) => {
+            if (clause.or && index > 0) {
+                result ||= segment;
+                segment = true;
+            }
+            segment &&= clause.test(row);
+        });
+        return this.clauses.length === 0 ? true : result || segment;
+    }
+    where(...args) {
+        if (typeof args[0] === 'function') {
+            return this.group(args[0], false);
+        }
+        const column = args[0];
+        if (args.length >= 3)
+            return this.add(this.compareLeaf(column, String(args[1]), args[2]));
+        // knex compiles `where(col, null)` to `col IS NULL`.
+        if (isNil(args[1]))
+            return this.whereNull(column);
+        return this.add(this.equalsLeaf(column, args[1], false));
+    }
+    orWhere(callback) {
+        return this.group(callback, true);
+    }
+    // biome-ignore lint/suspicious/noExplicitAny: matches QueryBuilderLike.whereHas (see its docblock).
+    whereHas(relation, callback) {
+        const name = String(relation);
+        const declared = this.collection.$relations[name];
+        if (!declared) {
+            throw new InMemoryQueryError(`"${name}" is not a relation declared on this collection.`);
+        }
+        const child = new InMemoryQueryBuilder(declared.target());
+        callback(child);
+        return this.add((row) => relatedRows(declared.get(row)).some((r) => child.matches(r)));
+    }
+    whereNot(column, value) {
+        if (isNil(value))
+            return this.whereNotNull(column);
+        return this.add(this.equalsLeaf(column, value, true));
+    }
+    whereIn(column, values) {
+        return this.add(this.inLeaf(column, Array.isArray(values) ? values : [values], false));
+    }
+    whereNotIn(column, values) {
+        return this.add(this.inLeaf(column, Array.isArray(values) ? values : [values], true));
+    }
+    whereNull(column) {
+        return this.add((row) => isNil(this.read(row, column)));
+    }
+    whereNotNull(column) {
+        return this.add((row) => !isNil(this.read(row, column)));
+    }
+    whereBetween(column, range) {
+        return this.add(this.betweenLeaf(column, range, false));
+    }
+    whereNotBetween(column, range) {
+        return this.add(this.betweenLeaf(column, range, true));
+    }
+    whereILike(column, value) {
+        return this.add(this.likeLeaf(column, value));
+    }
+    orWhereILike(column, value) {
+        return this.add(this.likeLeaf(column, value), true);
+    }
+    orderBy(column, direction) {
+        this.sorts.push({ field: column, direction: direction === 'desc' ? 'desc' : 'asc' });
+        return this;
+    }
+    /**
+     * Only the group-by-count search predicate (`LOWER(??) LIKE ?`) is understood; any other raw
+     * SQL — a policy's `computed` fields, `fullText`, `vectorSimilarity` — throws
+     * {@link InMemoryQueryError}. Declare a virtual field on the collection instead of `computed`.
+     */
+    whereRaw(sql, bindings = []) {
+        if (GROUP_SEARCH_SQL.test(sql) && typeof bindings[0] === 'string') {
+            const field = bindings[0];
+            const pattern = likeToRegExp(String(bindings[1] ?? ''), false);
+            this.groupSearches.push({ field, pattern });
+            return this.add(this.leaf(field, (e) => pattern.test(stringify(e).toLowerCase())), false);
+        }
+        throw new InMemoryQueryError(`The in-memory adapter cannot evaluate raw SQL (${JSON.stringify(sql)}). Policy \`computed\` fields, \`fullText\` and \`vectorSimilarity\` are SQL-only — declare a virtual field on the collection instead.`);
+    }
+    orderByRaw(sql, _bindings = []) {
+        throw new InMemoryQueryError(`The in-memory adapter cannot order by raw SQL (${JSON.stringify(sql)}). Declare a virtual field on the collection and sort on it instead.`);
+    }
+    distinct(...columns) {
+        this.distinctFields = columns;
+        return this;
+    }
+    limit(count) {
+        this.limitCount = Math.max(0, count);
+        return this;
+    }
+    offset(n) {
+        this.offsetCount = Math.max(0, n);
+        return this;
+    }
+    select(...columns) {
+        for (const column of columns)
+            this.selects.push(parseAlias(column));
+        return this;
+    }
+    count(column) {
+        const { expr, alias } = parseAlias(column);
+        if (expr !== '*') {
+            throw new InMemoryQueryError(`Only count('*') is supported in memory, got "${column}".`);
+        }
+        this.countAlias = alias;
+        return this;
+    }
+    groupBy(...columns) {
+        this.groups.push(...columns);
+        return this;
+    }
+    // -- execution --------------------------------------------------------------------------------
+    compareRows(a, b) {
+        for (const { field, direction } of this.sorts) {
+            const c = this.compareValues(this.read(a, field), this.read(b, field), this.kindOf(field).kind);
+            if (c !== 0)
+                return direction === 'desc' ? -c : c;
+        }
+        return 0;
+    }
+    /** Ascending comparison with NULLs sorting last (so NULLS FIRST once a desc sort negates it). */
+    compareValues(a, b, kind) {
+        if (isNil(a))
+            return isNil(b) ? 0 : 1;
+        if (isNil(b))
+            return -1;
+        return compare(a, b, kind) ?? 0;
+    }
+    /** Filter + sort (+ distinct / projection / aggregation), before limit/offset. */
+    evaluate() {
+        const matched = this.rows.filter((row) => this.matches(row));
+        if (this.groups.length > 0)
+            return this.aggregate(matched);
+        const sorted = this.sorts.length > 0 ? [...matched].sort((a, b) => this.compareRows(a, b)) : matched;
+        if (this.distinctFields.length > 0) {
+            const seen = new Set();
+            const out = [];
+            for (const row of sorted) {
+                const projected = {};
+                const key = [];
+                for (const field of this.distinctFields) {
+                    const value = this.read(row, field);
+                    projected[this.unqualify(field)] = value;
+                    key.push(normalize(value, this.kindOf(field).kind) ?? null);
+                }
+                const k = JSON.stringify(key);
+                if (!seen.has(k)) {
+                    seen.add(k);
+                    out.push(projected);
+                }
+            }
+            return out;
+        }
+        if (this.selects.length > 0) {
+            return sorted.map((row) => {
+                const projected = {};
+                for (const { expr, alias } of this.selects)
+                    projected[alias] = this.read(row, expr);
+                return projected;
+            });
+        }
+        return sorted;
+    }
+    /**
+     * `GROUP BY` over the matched rows. An array-typed grouping field is unnested — each element is
+     * its own group — which is what a tag picker wants (Postgres would group whole arrays).
+     */
+    aggregate(rows) {
+        const columns = this.groups;
+        const groups = new Map();
+        const single = columns.length === 1 ? columns[0] : undefined;
+        const unnest = single !== undefined && this.kindOf(single).array;
+        const searches = this.groupSearches.filter((s) => s.field === single);
+        for (const row of rows) {
+            const tuples = [];
+            if (unnest) {
+                const value = this.read(row, single);
+                const elements = Array.isArray(value) ? value : isNil(value) ? [null] : [value];
+                for (const element of elements) {
+                    if (searches.every((s) => !isNil(element) && s.pattern.test(stringify(element).toLowerCase()))) {
+                        tuples.push([element]);
+                    }
+                }
+            }
+            else {
+                tuples.push(columns.map((c) => this.read(row, c)));
+            }
+            for (const values of tuples) {
+                const key = JSON.stringify(values.map((v, i) => normalize(v, this.kindOf(columns[i]).kind) ?? null));
+                const group = groups.get(key);
+                if (group)
+                    group.count++;
+                else
+                    groups.set(key, { values, count: 1 });
+            }
+        }
+        const outputs = [...groups.values()].map(({ values, count }) => {
+            const row = {};
+            const selects = this.selects.length > 0 ? this.selects : columns.map((c) => ({ expr: c, alias: c }));
+            for (const { expr, alias } of selects) {
+                const index = columns.indexOf(expr);
+                if (index === -1) {
+                    throw new InMemoryQueryError(`"${expr}" is selected but not grouped by.`);
+                }
+                row[alias] = values[index];
+            }
+            if (this.countAlias !== undefined)
+                row[this.countAlias] = count;
+            return { row, values, count };
+        });
+        outputs.sort((a, b) => {
+            for (const { field, direction } of this.sorts) {
+                let c;
+                if (field === this.countAlias) {
+                    c = a.count - b.count;
+                }
+                else {
+                    const index = columns.indexOf(field);
+                    const aliasIndex = this.selects.findIndex((s) => s.alias === field);
+                    const i = index !== -1
+                        ? index
+                        : aliasIndex !== -1
+                            ? columns.indexOf(this.selects[aliasIndex].expr)
+                            : -1;
+                    if (i === -1)
+                        throw new InMemoryQueryError(`Cannot order grouped rows by "${field}".`);
+                    c = this.compareValues(a.values[i], b.values[i], this.kindOf(columns[i]).kind);
+                }
+                if (c !== 0)
+                    return direction === 'desc' ? -c : c;
+            }
+            return 0;
+        });
+        return outputs.map((o) => o.row);
+    }
+    window(rows) {
+        const start = this.offsetCount ?? 0;
+        const end = this.limitCount === undefined ? undefined : start + this.limitCount;
+        return rows.slice(start, end);
+    }
+    /**
+     * Execute: the matching rows in order, honouring `limit`/`offset` (which is what a cursor page
+     * sets). Under a `distinct`, a `select` or a `groupBy`, the rows are projection objects — just
+     * as a Lucid query returns them.
+     */
+    all() {
+        return this.window(this.evaluate());
+    }
+    /** How many rows (or distinct tuples / groups) match, ignoring `limit`/`offset`. */
+    total() {
+        return this.evaluate().length;
+    }
+    /**
+     * One offset page — the in-memory `query.paginate(page, size)`. Feed it the `{ page, size }`
+     * the runner resolved (clamped and defaulted), never raw request values.
+     */
+    paginate(page, perPage) {
+        const size = Math.max(1, Math.floor(perPage));
+        const current = Math.max(1, Math.floor(page));
+        const rows = this.evaluate();
+        const total = rows.length;
+        return {
+            data: rows.slice((current - 1) * size, current * size),
+            meta: {
+                total,
+                perPage: size,
+                currentPage: current,
+                lastPage: Math.max(1, Math.ceil(total / size)),
+                firstPage: 1,
+            },
+        };
+    }
+    /**
+     * Thenable, like a Lucid query: `await qb` resolves to {@link all}. This is what lets helpers
+     * that execute a builder by awaiting it (`groupByCountFromRequest`) run over an array.
+     */
+    // biome-ignore lint/suspicious/noThenProperty: deliberately thenable, mirroring Lucid's query builders.
+    then(onfulfilled, onrejected) {
+        return new Promise((resolve) => resolve(this.all())).then(onfulfilled, onrejected);
+    }
+}
+// ---------------------------------------------------------------------------------------------
+// One-call helpers
+// ---------------------------------------------------------------------------------------------
+/**
+ * Filter, search, sort and offset-paginate `rows` in one call: {@link applyFilter} over a fresh
+ * builder, then {@link InMemoryQueryBuilder.paginate} with the resolved page. A `distinct` request
+ * pages the distinct tuples instead of rows.
+ *
+ * ```ts
+ * const page = filterInMemory(users, rows, parseFilterRequest(ctx.request.qs()), {
+ *   allowed: ['name', 'age', 'posts.title'],
+ *   searchable: ['name'],
+ *   fieldTypes: users.fieldTypes,
+ * })
+ * // → { data, meta: { total, perPage, currentPage, lastPage, firstPage } }
+ * ```
+ */
+export function filterInMemory(collection, rows, input, config) {
+    const qb = collection.query(rows);
+    const { page, size } = applyFilter(qb, input, config);
+    return qb.paginate(page, size);
+}
+/**
+ * The keyset (cursor) counterpart of {@link filterInMemory}: {@link applyCursor} over a fresh
+ * builder (the primary key defaults to the collection's), then `buildCursorPage`. Keyset values
+ * are read through the collection, so a virtual field or a to-one relation path works as a cursor
+ * sort field.
+ */
+export function cursorInMemory(collection, rows, input, config) {
+    const qb = collection.query(rows);
+    const cursorConfig = {
+        ...config,
+        primaryKey: config.primaryKey ?? collection.primaryKey,
+    };
+    const resolved = applyCursor(qb, input, cursorConfig);
+    const fetched = qb.all();
+    // buildCursorPage reads keyset values as plain properties; stand each row in with an object
+    // carrying its keyset values (virtual fields and relation paths resolved), then map back.
+    const originals = new Map();
+    const keyed = fetched.map((row) => {
+        const values = resolved.keyset.map((k) => qb.read(row, k.field));
+        const stand = {};
+        resolved.keyset.forEach((k, i) => {
+            setPath(stand, k.field, values[i]);
+        });
+        originals.set(stand, row);
+        return stand;
+    });
+    const page = buildCursorPage(keyed, resolved);
+    return { ...page, items: page.items.map((stand) => originals.get(stand)) };
+}
+function setPath(target, path, value) {
+    const segments = path.split('.');
+    let node = target;
+    for (const segment of segments.slice(0, -1)) {
+        const next = node[segment];
+        if (typeof next === 'object' && next !== null)
+            node = next;
+        else {
+            const created = {};
+            node[segment] = created;
+            node = created;
+        }
+    }
+    node[segments[segments.length - 1]] = value;
+}
+//# sourceMappingURL=in_memory.js.map