@adonis-agora/filter 0.9.0 → 0.11.0

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # @adonis-agora/filter
 
+## 0.11.0
+
+### Minor Changes
+
+- [#105](https://github.com/DavideCarvalho/adonis-agora-filter/pull/105) [`72ff139`](https://github.com/DavideCarvalho/adonis-agora-filter/commit/72ff139e16c9ac05f326d490a997579ac5fb3273) Thanks [@DavideCarvalho](https://github.com/DavideCarvalho)! - Drop Node.js 20 and 22: `engines.node` is now `>=24`. Node 20 reached end-of-life on 2026-04-30, and AdonisJS 7, which these packages require as a peer, needs Node 24 or later (`@adonisjs/core` declares `engines.node >=24.0.0`). The supported lines are the ones Node still maintains that AdonisJS 7 accepts: 24 and 26, both tested in CI.
+
+## 0.10.0
+
+### Minor Changes
+
+- [#67](https://github.com/DavideCarvalho/adonis-agora-filter/pull/67) [`1dd11c3`](https://github.com/DavideCarvalho/adonis-agora-filter/commit/1dd11c3563cd015d27627808cc3e23830ed4be50) Thanks [@DavideCarvalho](https://github.com/DavideCarvalho)! - In-memory adapter at `@adonis-agora/filter/in-memory`: `defineCollection({ fields, primaryKey, relations })` declares a row source (field types incl. `'string[]'`-style arrays, virtual fields, to-one/to-many relations), and `collection.query(rows)` is a `QueryBuilderLike` the existing runner drives unchanged — `applyFilter`, `applyCursor`, `applyFilterFromRequest`, `applyCursorFromRequest` and `groupByCountFromRequest` all work over a plain array with the same parsing, allow-listing and coercion. Evaluation mirrors the SQL the Lucid adapter emits (ILIKE, three-valued NULL logic, NULLS LAST asc / FIRST desc, EXISTS for to-many paths). `filterInMemory` / `cursorInMemory` do it in one call; `InMemoryQueryError` is thrown for SQL-only features (`computed`, `fullText`, `vectorSimilarity`).
+
 ## 0.9.0
 
 ### Minor Changes

package/README.md

@@ -1,5 +1,7 @@
 # `@adonis-agora/filter`
 
+[![npm version](https://img.shields.io/npm/v/@adonis-agora/filter)](https://www.npmjs.com/package/@adonis-agora/filter) [![npm downloads](https://img.shields.io/npm/dm/@adonis-agora/filter)](https://www.npmjs.com/package/@adonis-agora/filter) [![CI](https://github.com/DavideCarvalho/adonis-agora-filter/actions/workflows/ci.yml/badge.svg?branch=master)](https://github.com/DavideCarvalho/adonis-agora-filter/actions/workflows/ci.yml) [![license](https://img.shields.io/npm/l/@adonis-agora/filter)](https://www.npmjs.com/package/@adonis-agora/filter)
+
 Server-side query filtering, sorting, and pagination for AdonisJS. Parses the
 Spatie/JSON:API query the `@adonis-agora/filter-client` builder emits, applies it to a
 Lucid query through a field allow-list, and resolves offset or keyset (cursor)
@@ -50,6 +52,21 @@ AND/OR composition. The `allowed`/`sortable`/`searchable` lists are the security
 boundary. The Lucid binding is structural (`QueryBuilderLike`) so any Lucid query
 builder works and the adapter is unit-testable.
 
+### In-memory lists
+
+`@adonis-agora/filter/in-memory` runs the same input against a plain array — an
+in-memory `QueryBuilderLike` the runner drives exactly like a Lucid query:
+
+```ts
+import { defineCollection, filterInMemory } from '@adonis-agora/filter/in-memory'
+
+const users = defineCollection<UserRow>({
+  fields: { name: 'string', age: 'number', fullName: { type: 'string', get: (u) => u.first + ' ' + u.last } },
+})
+const page = filterInMemory(users, rows, input, { allowed: ['name', 'age', 'fullName'] })
+// { data, meta: { total, perPage, currentPage, lastPage, firstPage } }
+```
+
 See the [repository README](https://github.com/DavideCarvalho/adonis-filter).
 
 ## License

package/dist/src/in_memory.d.ts

@@ -0,0 +1,268 @@
+import { type CursorPage, type CursorParams } from './cursor.js';
+import type { QueryBuilderLike } from './lucid_adapter.js';
+import type { FilterConfig, FilterFieldKind, FilterInput } from './types.js';
+/**
+ * The in-memory adapter: a {@link QueryBuilderLike} that evaluates against a plain JS array.
+ *
+ * The runner (`applyFilter`, `applyCursor`, `applyFilterFromRequest`, `groupByCountFromRequest`)
+ * does exactly what it does for a Lucid query — parse, alias-resolve, validate, allow-list, coerce —
+ * and then drives the same builder calls it would hand Lucid. This builder records those calls and
+ * evaluates them over rows instead of compiling SQL, so an in-memory listing speaks the same wire
+ * format, operators and error shapes as a database one, and a filter spec written for a model
+ * works unchanged over rows assembled in memory (several sources merged, a static catalog, a
+ * remote API page).
+ *
+ * The evaluation mirrors what Postgres does with the SQL the Lucid adapter emits — including the
+ * places that surprise people: three-valued NULL logic (a NULL value fails `notEquals`/`notIn`/
+ * `notBetween`, `NOT IN` a list holding NULL matches nothing), ILIKE for every LIKE-style operator,
+ * and NULLS LAST on ascending / NULLS FIRST on descending order.
+ */
+/** A scalar array kind — an in-memory extension; see {@link InMemoryFieldType}. */
+export type InMemoryArrayKind = 'string[]' | 'number[]' | 'boolean[]' | 'date[]';
+/**
+ * A declared field type. The scalar kinds are the lib's own {@link FilterFieldKind}; the array
+ * kinds declare a list-valued field, on which a scalar operator matches when ANY element matches
+ * and a negated operator (`notEquals`, `notIn`, `notBetween`) matches when NO element does.
+ */
+export type InMemoryFieldType = FilterFieldKind | InMemoryArrayKind;
+/** A virtual field: a value computed from the row — the in-memory counterpart of `computed`. */
+export interface InMemoryVirtualField<T> {
+    type: InMemoryFieldType;
+    get: (row: T) => unknown;
+}
+/** One entry of {@link DefineCollectionOptions.fields}: a stored field's type, or a virtual field. */
+export type InMemoryFieldDeclaration<T> = InMemoryFieldType | InMemoryVirtualField<T>;
+/** Relation cardinality. `*-to-one` reads a row (or null); `*-to-many` reads an array. */
+export type InMemoryRelationKind = 'one-to-one' | 'many-to-one' | 'one-to-many' | 'many-to-many';
+/**
+ * A relation a dotted filter path (`posts.title`) can cross. The runner turns such a path into a
+ * `whereHas`, evaluated here with EXISTS semantics: the row matches when at least one related row
+ * satisfies the nested conditions.
+ */
+export interface InMemoryRelation<T> {
+    kind: InMemoryRelationKind;
+    /** The related collection — a thunk so two collections can reference each other. */
+    target: () => InMemoryCollection<any>;
+    /** Read the related row(s) off a row. `null`/`undefined` means no related row. */
+    get: (row: T) => unknown;
+}
+/** Options for {@link defineCollection}. */
+export interface DefineCollectionOptions<T> {
+    /**
+     * The field declarations — what each field is, so filter values are compared as that kind
+     * (`'3'` equals `3` on a `number` field, `'true'` equals `true` on a `boolean`, ISO strings
+     * compare as instants on a `date`). A field that is not declared is read as an own property and
+     * compared by the kind its value has at runtime.
+     */
+    fields: Record<string, InMemoryFieldDeclaration<T>>;
+    /** The keyset tiebreaker for cursor pagination. Default `'id'`. */
+    primaryKey?: string;
+    /** Relations dotted filter paths may cross. */
+    relations?: Record<string, InMemoryRelation<T>>;
+    /**
+     * The collection's "table" name. A `distinct`/sort field qualified with it (`users.name`, the
+     * form {@link FilterConfig.table} makes projectable) reads the root field `name`.
+     */
+    name?: string;
+}
+interface ResolvedField<T> {
+    kind: FilterFieldKind;
+    array: boolean;
+    get: ((row: T) => unknown) | undefined;
+}
+/** A declared, reusable row source. Create one with {@link defineCollection}. */
+export interface InMemoryCollection<T extends object> {
+    readonly name: string | undefined;
+    readonly primaryKey: string;
+    /**
+     * The declared fields as the colocated `filterable` map `defineFilter` accepts
+     * (`defineFilter({ filterable: users.filterable })`) — array kinds map to their element kind,
+     * which is what the runner coerces a filter value to.
+     */
+    readonly filterable: Readonly<Record<string, FilterFieldKind>>;
+    /** The declared fields as {@link FilterConfig.fieldTypes}, for `applyFilter` callers. */
+    readonly fieldTypes: Readonly<Record<string, {
+        kind: FilterFieldKind;
+    }>>;
+    /** Start a query over `rows` — hand the builder to the runner like a Lucid query. */
+    query(rows: Iterable<T>): InMemoryQueryBuilder<T>;
+    /** @internal */
+    readonly $fields: Readonly<Record<string, ResolvedField<T>>>;
+    /** @internal */
+    readonly $relations: Readonly<Record<string, InMemoryRelation<T>>>;
+}
+/**
+ * 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 declare class InMemoryQueryError extends Error {
+    constructor(message: string);
+}
+/**
+ * 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 declare function defineCollection<T extends object>(options: DefineCollectionOptions<T>): InMemoryCollection<T>;
+/** The pagination meta {@link InMemoryQueryBuilder.paginate} returns — Lucid's paginator fields. */
+export interface InMemoryPageMeta {
+    total: number;
+    perPage: number;
+    currentPage: number;
+    lastPage: number;
+    firstPage: number;
+}
+/** One offset page — the shape of a serialized Lucid paginator (`{ meta, data }`). */
+export interface InMemoryPage<T> {
+    data: T[];
+    meta: InMemoryPageMeta;
+}
+/**
+ * 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 declare class InMemoryQueryBuilder<T extends object> implements QueryBuilderLike {
+    readonly collection: InMemoryCollection<T>;
+    private readonly rows;
+    private readonly clauses;
+    private readonly sorts;
+    private readonly selects;
+    private readonly groups;
+    private readonly groupSearches;
+    private distinctFields;
+    private countAlias;
+    private limitCount;
+    private offsetCount;
+    constructor(collection: InMemoryCollection<T>, rows?: readonly T[]);
+    private field;
+    /** Strip a leading `<collection name>.` qualifier. */
+    private unqualify;
+    /**
+     * 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: T, rawPath: string): unknown;
+    /** The declared kind of a path (following to-one relations), or `unknown`. */
+    private kindOf;
+    /**
+     * 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.
+     */
+    private leaf;
+    private equalsLeaf;
+    private compareLeaf;
+    private inLeaf;
+    private betweenLeaf;
+    private likeLeaf;
+    private add;
+    private group;
+    /**
+     * 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: T): boolean;
+    where(callback: (qb: QueryBuilderLike) => void): this;
+    where(column: string, value: unknown): this;
+    where(column: string, operator: string, value: unknown): this;
+    orWhere(callback: (qb: QueryBuilderLike) => void): this;
+    whereHas(relation: any, callback: (qb: QueryBuilderLike) => void): this;
+    whereNot(column: string, value: unknown): this;
+    whereIn(column: string, values: unknown[]): this;
+    whereNotIn(column: string, values: unknown[]): this;
+    whereNull(column: string): this;
+    whereNotNull(column: string): this;
+    whereBetween(column: string, range: [unknown, unknown]): this;
+    whereNotBetween(column: string, range: [unknown, unknown]): this;
+    whereILike(column: string, value: string): this;
+    orWhereILike(column: string, value: string): this;
+    orderBy(column: string, direction: 'asc' | 'desc'): 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: string, bindings?: readonly unknown[]): this;
+    orderByRaw(sql: string, _bindings?: readonly unknown[]): this;
+    distinct(...columns: string[]): this;
+    limit(count: number): this;
+    offset(n: number): this;
+    select(...columns: string[]): this;
+    count(column: string): this;
+    groupBy(...columns: string[]): this;
+    private compareRows;
+    /** Ascending comparison with NULLs sorting last (so NULLS FIRST once a desc sort negates it). */
+    private compareValues;
+    /** Filter + sort (+ distinct / projection / aggregation), before limit/offset. */
+    private evaluate;
+    /**
+     * `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).
+     */
+    private aggregate;
+    private window;
+    /**
+     * 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(): T[];
+    /** How many rows (or distinct tuples / groups) match, ignoring `limit`/`offset`. */
+    total(): number;
+    /**
+     * 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: number, perPage: number): InMemoryPage<T>;
+    /**
+     * 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.
+     */
+    then<R1 = T[], R2 = never>(onfulfilled?: ((rows: T[]) => R1 | PromiseLike<R1>) | null, onrejected?: ((reason: unknown) => R2 | PromiseLike<R2>) | null): Promise<R1 | R2>;
+}
+/**
+ * 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 declare function filterInMemory<T extends object>(collection: InMemoryCollection<T>, rows: Iterable<T>, input: FilterInput, config: FilterConfig): InMemoryPage<T>;
+/**
+ * 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 declare function cursorInMemory<T extends object>(collection: InMemoryCollection<T>, rows: Iterable<T>, input: FilterInput & CursorParams, config: FilterConfig & {
+    primaryKey?: string;
+}): CursorPage<T>;
+export {};
+//# sourceMappingURL=in_memory.d.ts.map

package/dist/src/in_memory.d.ts.map

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