ts-prorm-orm 1.1.0 → 1.2.0

package/dist/nosql/ravendb/index.d.ts

@@ -0,0 +1,138 @@
+/**
+ * RavenDB store implementation for the Prorm NoSQL layer.
+ *
+ * RavenDB is a transactional, multi-model document database with a
+ * unit-of-work session API (store/load/delete + saveChanges) and a fluent,
+ * indexed query builder. It does not fit the SQL-shaped `Dialect` interface,
+ * so this class implements the minimal `NoSqlStore` marker interface for
+ * connection lifecycle and exposes RavenDB's real session CRUD plus `query`
+ * API through a small document-CRUD convenience layer. Each operation opens
+ * its own short-lived session and commits with `saveChanges()`.
+ *
+ * Uses the official `ravendb` driver. That driver is an optional peer
+ * dependency and is loaded lazily inside `connect()` so importing this module
+ * never requires it to be installed. Tests inject a pre-built mock
+ * `DocumentStore` via `options.client`, which bypasses the lazy `require`
+ * entirely - no real driver and no network are needed.
+ */
+import { NoSqlStore } from '../store';
+/** A native `DocumentStore` handle, left untyped because the driver is an
+ * optional dependency not imported here. */
+type DocumentStore = any;
+/** One `[field, direction]` ordering term, e.g. `['createdAt', 'DESC']`. */
+export type OrderTerm = [string, 'ASC' | 'DESC'] | string;
+/** Options for {@link RavenDbStore.findAll}/{@link RavenDbStore.findOne}. */
+export interface RavenFindOptions {
+    /** Ordering terms applied in sequence. A bare string sorts ascending. */
+    order?: OrderTerm | OrderTerm[];
+    /** Maximum number of documents to return (`take`). */
+    limit?: number;
+    /** Number of leading documents to skip (`skip`, offset). */
+    offset?: number;
+}
+/** A group-aggregation request for {@link RavenDbStore.aggregate}. */
+export interface RavenAggregateOptions {
+    /** ORM `where` filter applied before grouping. */
+    where?: Record<string | symbol, unknown>;
+    /** Field(s) to group by. Omit for a single whole-collection group. */
+    groupBy?: string | string[];
+    /** Emit a `count` per group. */
+    count?: boolean;
+    /** Fields to `sum` per group, keyed by output name → source field. */
+    sum?: Record<string, string>;
+    /** Fields to `avg` per group, keyed by output name → source field. */
+    avg?: Record<string, string>;
+    /** Fields to `min` per group, keyed by output name → source field. */
+    min?: Record<string, string>;
+    /** Fields to `max` per group, keyed by output name → source field. */
+    max?: Record<string, string>;
+}
+/**
+ * Connection options for `RavenDbStore`.
+ *
+ * `urls` and `database` configure the underlying `DocumentStore`. When a
+ * pre-built `client` is supplied (e.g. in tests), `connect()` uses it directly
+ * and skips loading the `ravendb` driver.
+ */
+export interface RavenDbStoreOptions {
+    urls?: string[];
+    database?: string;
+    /** A pre-built `DocumentStore` to use instead of the driver. */
+    client?: DocumentStore;
+}
+export declare class RavenDbStore implements NoSqlStore {
+    readonly name = "ravendb";
+    readonly library = "ravendb";
+    private readonly options;
+    private store;
+    private connected;
+    constructor(options?: RavenDbStoreOptions);
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    isConnected(): boolean;
+    getClient(): DocumentStore;
+    private requireStore;
+    /** Store a document in `collection`; returns the id used. */
+    insert(collection: string, doc: Record<string, unknown>): Promise<unknown>;
+    /** Load a document by id. */
+    get(_collection: string, id: string): Promise<unknown>;
+    /** Load, merge `patch`, and save; returns the updated entity. */
+    update(_collection: string, id: string, patch: Record<string, unknown>): Promise<unknown>;
+    /** Delete a document by id. */
+    delete(_collection: string, id: string): Promise<unknown>;
+    /**
+     * Query `collection` with an ORM `where` clause. The `where` object accepts
+     * the full ORM operator surface (`Op.gt`, `Op.in`, `Op.between`, `Op.like`,
+     * `Op.and`/`Op.or`, ...), translated to native RavenDB session-query
+     * conditions - so a plain `{ field: value }` still behaves as equality, but
+     * richer queries no longer require hand-written RQL. Bare-field values are
+     * ANDed together (Op.* comparisons expand per field).
+     */
+    query(collection: string, where?: Record<string | symbol, unknown>): Promise<unknown[]>;
+    /**
+     * Fetch all documents in `collection` matching an ORM `where` clause, with
+     * optional ordering, offset (`skip`), and limit (`take`).
+     */
+    findAll<T = unknown>(collection: string, where?: Record<string | symbol, unknown>, options?: RavenFindOptions): Promise<T[]>;
+    /** Fetch the first document in `collection` matching an ORM `where` clause (respecting `order`), or `null`. */
+    findOne<T = unknown>(collection: string, where?: Record<string | symbol, unknown>, options?: Omit<RavenFindOptions, 'limit'>): Promise<T | null>;
+    /** Count documents in `collection` matching an ORM `where` clause. */
+    count(collection: string, where?: Record<string | symbol, unknown>): Promise<number>;
+    /**
+     * Store multiple documents in a single session/transaction (one
+     * `saveChanges()`). Returns the ids assigned to each document, in order.
+     */
+    bulkInsert(collection: string, docs: Record<string, unknown>[]): Promise<string[]>;
+    /**
+     * Insert-or-update by id: loads the document, merges `doc` into it if it
+     * exists, otherwise stores `doc` fresh - all in one session. Returns the id.
+     */
+    upsert(collection: string, doc: Record<string, unknown>, id?: string): Promise<string>;
+    /**
+     * Update every document in `collection` matching an ORM `where` clause,
+     * merging `patch` into each, in a single session/transaction. Returns the
+     * number of documents updated.
+     */
+    updateWhere(collection: string, where: Record<string | symbol, unknown>, patch: Record<string, unknown>): Promise<number>;
+    /**
+     * Delete every document in `collection` matching an ORM `where` clause, in a
+     * single session/transaction. Returns the number of documents deleted.
+     */
+    deleteWhere(collection: string, where: Record<string | symbol, unknown>): Promise<number>;
+    /**
+     * Grouped aggregation over `collection` (`count`/`sum`/`avg`/`min`/`max`),
+     * with an optional ORM `where` pre-filter. Computed client-side over the
+     * matched documents so callers get standard `GROUP BY`-style results without
+     * hand-writing an RQL `group by`/index. Returns one entry per group:
+     * `{ group, ...aggregates }`.
+     */
+    aggregate(collection: string, options?: RavenAggregateOptions): Promise<Array<Record<string, unknown>>>;
+    /**
+     * Run `fn` inside a single RavenDB session (unit of work), passing the
+     * session so multiple store/load/delete operations commit atomically with
+     * one `saveChanges()`. RavenDB sessions are ACID transactions, so this is
+     * the native way to make multi-document changes all-or-nothing.
+     */
+    withTransaction<T>(fn: (session: any) => Promise<T>): Promise<T>;
+}
+export default RavenDbStore;

package/dist/nosql/ravendb/index.js

@@ -19,6 +19,105 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RavenDbStore = void 0;
 const errors_1 = require("../../errors");
+const operators_1 = require("../../operators");
+const where_1 = require("./where");
+/** Whether `order` is a single `[field, direction]` tuple rather than a list of terms. */
+function isSingleOrderTerm(order) {
+    return order.length === 2 && typeof order[0] === 'string' && (order[1] === 'ASC' || order[1] === 'DESC');
+}
+/**
+ * Apply a {@link WhereNode} tree to a RavenDB session query builder `q`,
+ * emitting `whereEquals`/`whereGreaterThan`/`whereIn`/... conditions and
+ * grouping `Op.and`/`Op.or` with `openSubclause`/`closeSubclause` +
+ * `andAlso`/`orElse`. This lets callers pass ORM `where` clauses instead of
+ * hand-writing RQL.
+ */
+function applyRavenWhere(q, node) {
+    switch (node.kind) {
+        case 'true':
+            return q;
+        case 'and':
+            return applyRavenGroup(q, node.nodes, 'andAlso');
+        case 'or':
+            return applyRavenGroup(q, node.nodes, 'orElse');
+        case 'not':
+            return applyRavenWhere(q.not(), node.node);
+        case 'cmp':
+            return applyRavenCmp(q, node.field, node.op, node.value);
+    }
+}
+function applyRavenGroup(q, nodes, combinator) {
+    const meaningful = nodes.filter((n) => n.kind !== 'true');
+    if (meaningful.length === 0)
+        return q;
+    if (meaningful.length === 1)
+        return applyRavenWhere(q, meaningful[0]);
+    let out = q.openSubclause();
+    meaningful.forEach((n, i) => {
+        if (i > 0)
+            out = out[combinator]();
+        out = applyRavenWhere(out, n);
+    });
+    return out.closeSubclause();
+}
+function applyRavenCmp(q, field, op, value) {
+    switch (op) {
+        case operators_1.Op.eq:
+            return q.whereEquals(field, value);
+        case operators_1.Op.ne:
+            return q.whereNotEquals(field, value);
+        case operators_1.Op.gt:
+            return q.whereGreaterThan(field, value);
+        case operators_1.Op.gte:
+            return q.whereGreaterThanOrEqual(field, value);
+        case operators_1.Op.lt:
+            return q.whereLessThan(field, value);
+        case operators_1.Op.lte:
+            return q.whereLessThanOrEqual(field, value);
+        case operators_1.Op.in:
+            return q.whereIn(field, value);
+        case operators_1.Op.notIn:
+            return q.not().whereIn(field, value);
+        case operators_1.Op.between: {
+            const [lo, hi] = value;
+            return q.whereBetween(field, lo, hi);
+        }
+        case operators_1.Op.notBetween: {
+            const [lo, hi] = value;
+            return q.not().whereBetween(field, lo, hi);
+        }
+        case operators_1.Op.isNull:
+            return q.whereEquals(field, null);
+        case operators_1.Op.isNotNull:
+            return q.whereExists(field).andAlso().not().whereEquals(field, null);
+        case operators_1.Op.startsWith:
+            return q.whereStartsWith(field, value);
+        case operators_1.Op.endsWith:
+            return q.whereEndsWith(field, value);
+        case operators_1.Op.like:
+        case operators_1.Op.iLike:
+            return q.whereRegex(field, (0, where_1.likeToRegex)(String(value)).replace(/^\^|\$$/g, ''));
+        case operators_1.Op.notLike:
+        case operators_1.Op.notILike:
+            return q.not().whereRegex(field, (0, where_1.likeToRegex)(String(value)).replace(/^\^|\$$/g, ''));
+        case operators_1.Op.regexp:
+        case operators_1.Op.iRegexp:
+            return q.whereRegex(field, String(value));
+        case operators_1.Op.notRegexp:
+        case operators_1.Op.notIRegexp:
+            return q.not().whereRegex(field, String(value));
+        case operators_1.Op.substring:
+        case operators_1.Op.contains:
+            return q.whereRegex(field, escapeRegexRql(String(value)));
+        default:
+            throw new errors_1.DatabaseError(`RavenDB: unsupported where operator "${op.toString()}"`, {
+                code: errors_1.ErrorCodes.QUERY_ERROR,
+            });
+    }
+}
+function escapeRegexRql(s) {
+    return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
 class RavenDbStore {
     constructor(options = {}) {
         this.name = 'ravendb';
@@ -141,27 +240,242 @@ class RavenDbStore {
         }
     }
     /**
-     * Query `collection`. `filter` is a plain object whose entries become
-     * `whereEquals(field, value)` conditions on the session query. Returns all
-     * matched documents.
+     * Query `collection` with an ORM `where` clause. The `where` object accepts
+     * the full ORM operator surface (`Op.gt`, `Op.in`, `Op.between`, `Op.like`,
+     * `Op.and`/`Op.or`, ...), translated to native RavenDB session-query
+     * conditions - so a plain `{ field: value }` still behaves as equality, but
+     * richer queries no longer require hand-written RQL. Bare-field values are
+     * ANDed together (Op.* comparisons expand per field).
      */
-    async query(collection, filter = {}) {
+    async query(collection, where = {}) {
+        return this.findAll(collection, where);
+    }
+    /**
+     * Fetch all documents in `collection` matching an ORM `where` clause, with
+     * optional ordering, offset (`skip`), and limit (`take`).
+     */
+    async findAll(collection, where = {}, options = {}) {
         const store = this.requireStore();
         try {
             const session = store.openSession();
-            let q = session.query({ collection });
-            for (const [field, value] of Object.entries(filter)) {
-                q = q.whereEquals(field, value);
+            let q = applyRavenWhere(session.query({ collection }), (0, where_1.parseWhere)(where));
+            if (options.order !== undefined) {
+                const terms = Array.isArray(options.order) && !isSingleOrderTerm(options.order)
+                    ? options.order
+                    : [options.order];
+                for (const term of terms) {
+                    if (typeof term === 'string')
+                        q = q.orderBy(term);
+                    else
+                        q = term[1] === 'DESC' ? q.orderByDescending(term[0]) : q.orderBy(term[0]);
+                }
             }
+            if (typeof options.offset === 'number')
+                q = q.skip(options.offset);
+            if (typeof options.limit === 'number')
+                q = q.take(options.limit);
+            const results = await q.all();
+            return (results ?? []);
+        }
+        catch (err) {
+            throw wrapDatabaseError(err, 'RavenDB findAll failed');
+        }
+    }
+    /** Fetch the first document in `collection` matching an ORM `where` clause (respecting `order`), or `null`. */
+    async findOne(collection, where = {}, options = {}) {
+        const rows = await this.findAll(collection, where, { ...options, limit: 1 });
+        return rows.length > 0 ? rows[0] : null;
+    }
+    /** Count documents in `collection` matching an ORM `where` clause. */
+    async count(collection, where = {}) {
+        const store = this.requireStore();
+        try {
+            const session = store.openSession();
+            const q = applyRavenWhere(session.query({ collection }), (0, where_1.parseWhere)(where));
+            if (typeof q.count === 'function')
+                return await q.count();
             const results = await q.all();
-            return results ?? [];
+            return (results ?? []).length;
+        }
+        catch (err) {
+            throw wrapDatabaseError(err, 'RavenDB count failed');
+        }
+    }
+    /**
+     * Store multiple documents in a single session/transaction (one
+     * `saveChanges()`). Returns the ids assigned to each document, in order.
+     */
+    async bulkInsert(collection, docs) {
+        const store = this.requireStore();
+        try {
+            const session = store.openSession();
+            const ids = [];
+            for (const doc of docs) {
+                const id = (doc.id ?? `${collection}/${genId()}`);
+                await session.store(doc, id);
+                ids.push(id);
+            }
+            await session.saveChanges();
+            return ids;
         }
         catch (err) {
-            throw wrapDatabaseError(err, 'RavenDB query failed');
+            throw wrapDatabaseError(err, 'RavenDB bulkInsert failed');
+        }
+    }
+    /**
+     * Insert-or-update by id: loads the document, merges `doc` into it if it
+     * exists, otherwise stores `doc` fresh - all in one session. Returns the id.
+     */
+    async upsert(collection, doc, id) {
+        const store = this.requireStore();
+        try {
+            const resolvedId = (id ?? doc.id ?? `${collection}/${genId()}`);
+            const session = store.openSession();
+            const existing = await session.load(resolvedId);
+            if (existing) {
+                Object.assign(existing, doc);
+            }
+            else {
+                await session.store(doc, resolvedId);
+            }
+            await session.saveChanges();
+            return resolvedId;
+        }
+        catch (err) {
+            throw wrapDatabaseError(err, 'RavenDB upsert failed');
+        }
+    }
+    /**
+     * Update every document in `collection` matching an ORM `where` clause,
+     * merging `patch` into each, in a single session/transaction. Returns the
+     * number of documents updated.
+     */
+    async updateWhere(collection, where, patch) {
+        const store = this.requireStore();
+        try {
+            const session = store.openSession();
+            const q = applyRavenWhere(session.query({ collection }), (0, where_1.parseWhere)(where));
+            const matches = (await q.all()) ?? [];
+            for (const entity of matches) {
+                Object.assign(entity, patch);
+            }
+            await session.saveChanges();
+            return matches.length;
+        }
+        catch (err) {
+            throw wrapDatabaseError(err, 'RavenDB updateWhere failed');
+        }
+    }
+    /**
+     * Delete every document in `collection` matching an ORM `where` clause, in a
+     * single session/transaction. Returns the number of documents deleted.
+     */
+    async deleteWhere(collection, where) {
+        const store = this.requireStore();
+        try {
+            const session = store.openSession();
+            const q = applyRavenWhere(session.query({ collection }), (0, where_1.parseWhere)(where));
+            const matches = (await q.all()) ?? [];
+            for (const entity of matches) {
+                await session.delete(entity);
+            }
+            await session.saveChanges();
+            return matches.length;
+        }
+        catch (err) {
+            throw wrapDatabaseError(err, 'RavenDB deleteWhere failed');
+        }
+    }
+    /**
+     * Grouped aggregation over `collection` (`count`/`sum`/`avg`/`min`/`max`),
+     * with an optional ORM `where` pre-filter. Computed client-side over the
+     * matched documents so callers get standard `GROUP BY`-style results without
+     * hand-writing an RQL `group by`/index. Returns one entry per group:
+     * `{ group, ...aggregates }`.
+     */
+    async aggregate(collection, options = {}) {
+        const docs = await this.findAll(collection, options.where ?? {});
+        const groupFields = options.groupBy
+            ? Array.isArray(options.groupBy)
+                ? options.groupBy
+                : [options.groupBy]
+            : [];
+        const groups = new Map();
+        for (const doc of docs) {
+            const keyParts = groupFields.map((f) => getPath(doc, f));
+            const key = groupFields.length === 0 ? null : groupFields.length === 1 ? keyParts[0] : keyParts;
+            const mapKey = JSON.stringify(key ?? null);
+            const bucket = groups.get(mapKey) ?? { key, rows: [] };
+            bucket.rows.push(doc);
+            groups.set(mapKey, bucket);
+        }
+        const hasOtherAgg = !!(options.sum || options.avg || options.min || options.max);
+        const result = [];
+        for (const { key, rows } of groups.values()) {
+            const entry = { group: key };
+            if (options.count || !hasOtherAgg) {
+                entry.count = rows.length;
+            }
+            for (const [out, src] of Object.entries(options.sum ?? {}))
+                entry[out] = sumBy(rows, src);
+            for (const [out, src] of Object.entries(options.avg ?? {}))
+                entry[out] = rows.length ? sumBy(rows, src) / rows.length : null;
+            for (const [out, src] of Object.entries(options.min ?? {}))
+                entry[out] = minBy(rows, src);
+            for (const [out, src] of Object.entries(options.max ?? {}))
+                entry[out] = maxBy(rows, src);
+            result.push(entry);
+        }
+        return result;
+    }
+    /**
+     * Run `fn` inside a single RavenDB session (unit of work), passing the
+     * session so multiple store/load/delete operations commit atomically with
+     * one `saveChanges()`. RavenDB sessions are ACID transactions, so this is
+     * the native way to make multi-document changes all-or-nothing.
+     */
+    async withTransaction(fn) {
+        const store = this.requireStore();
+        const session = store.openSession();
+        try {
+            const result = await fn(session);
+            await session.saveChanges();
+            return result;
+        }
+        catch (err) {
+            throw wrapDatabaseError(err, 'RavenDB transaction failed');
         }
     }
 }
 exports.RavenDbStore = RavenDbStore;
+function getPath(obj, path) {
+    return path.split('.').reduce((acc, part) => (acc == null ? undefined : acc[part]), obj);
+}
+function sumBy(rows, field) {
+    return rows.reduce((acc, r) => acc + Number(getPath(r, field) ?? 0), 0);
+}
+function minBy(rows, field) {
+    let min;
+    for (const r of rows) {
+        const v = getPath(r, field);
+        if (v == null)
+            continue;
+        if (min === undefined || v < min)
+            min = v;
+    }
+    return min ?? null;
+}
+function maxBy(rows, field) {
+    let max;
+    for (const r of rows) {
+        const v = getPath(r, field);
+        if (v == null)
+            continue;
+        if (max === undefined || v > max)
+            max = v;
+    }
+    return max ?? null;
+}
 function genId() {
     return `${Date.now().toString(36)}${Math.random().toString(36).slice(2, 10)}`;
 }

package/dist/nosql/ravendb/where.d.ts

@@ -0,0 +1,38 @@
+/** A single field comparison, e.g. `age >= 18`. */
+export interface CmpNode {
+    kind: 'cmp';
+    field: string;
+    op: symbol;
+    value: unknown;
+}
+/** A normalized boolean tree produced by {@link parseWhere}. */
+export type WhereNode = CmpNode | {
+    kind: 'and';
+    nodes: WhereNode[];
+} | {
+    kind: 'or';
+    nodes: WhereNode[];
+} | {
+    kind: 'not';
+    node: WhereNode;
+} | {
+    kind: 'true';
+};
+/**
+ * Parse an ORM `where` object into a {@link WhereNode} tree.
+ *
+ * - String keys are field conditions: a scalar means equality, an array means
+ *   `Op.in`, and a nested `{ [Op.*]: value }` object expands to one comparison
+ *   per operator.
+ * - `Op.and`/`Op.or` take an array of sub-`where` objects; `Op.not` negates a
+ *   single sub-`where`.
+ */
+export declare function parseWhere(where: Record<string | symbol, unknown> | undefined | null): WhereNode;
+/** Escape a string for safe inclusion in a regular expression. */
+export declare function escapeRegex(s: string): string;
+/**
+ * Translate a SQL `LIKE`/`ILIKE` pattern into an anchored regular expression
+ * (`%` → `.*`, `_` → `.`), so stores that only speak regex can honor ORM
+ * `Op.like` queries without the caller hand-writing a pattern.
+ */
+export declare function likeToRegex(pattern: string, caseInsensitive?: boolean): string;

package/dist/nosql/ravendb/where.js

@@ -0,0 +1,94 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseWhere = parseWhere;
+exports.escapeRegex = escapeRegex;
+exports.likeToRegex = likeToRegex;
+/**
+ * ORM where-clause parser for the RavenDB store.
+ *
+ * Turns the ORM's `where` shape (plain-object field conditions, `Op.*`
+ * comparison symbols, and `Op.and`/`Op.or`/`Op.not` logical symbols) into a
+ * small, store-agnostic {@link WhereNode} tree that the store then renders to
+ * a RavenDB session query. This is what lets callers write standard ORM
+ * queries (`{ age: { [Op.gte]: 18 } }`) instead of hand-building ReQL row
+ * predicates.
+ */
+const operators_1 = require("../../operators");
+/** Whether `v` is a plain object carrying `Op.*` comparison symbols (e.g. `{ [Op.gt]: 5 }`). */
+function hasOpSymbols(v) {
+    return (v !== null &&
+        typeof v === 'object' &&
+        !Array.isArray(v) &&
+        Object.getOwnPropertySymbols(v).length > 0);
+}
+/**
+ * Parse an ORM `where` object into a {@link WhereNode} tree.
+ *
+ * - String keys are field conditions: a scalar means equality, an array means
+ *   `Op.in`, and a nested `{ [Op.*]: value }` object expands to one comparison
+ *   per operator.
+ * - `Op.and`/`Op.or` take an array of sub-`where` objects; `Op.not` negates a
+ *   single sub-`where`.
+ */
+function parseWhere(where) {
+    if (!where)
+        return { kind: 'true' };
+    const nodes = [];
+    for (const sym of Object.getOwnPropertySymbols(where)) {
+        const val = where[sym];
+        if (sym === operators_1.Op.and) {
+            nodes.push({ kind: 'and', nodes: asArray(val).map(parseWhere) });
+        }
+        else if (sym === operators_1.Op.or) {
+            nodes.push({ kind: 'or', nodes: asArray(val).map(parseWhere) });
+        }
+        else if (sym === operators_1.Op.not) {
+            nodes.push({ kind: 'not', node: parseWhere(val) });
+        }
+    }
+    for (const field of Object.keys(where)) {
+        const val = where[field];
+        if (hasOpSymbols(val)) {
+            for (const opSym of Object.getOwnPropertySymbols(val)) {
+                nodes.push({ kind: 'cmp', field, op: opSym, value: val[opSym] });
+            }
+            continue;
+        }
+        if (Array.isArray(val)) {
+            nodes.push({ kind: 'cmp', field, op: operators_1.Op.in, value: val });
+        }
+        else {
+            nodes.push({ kind: 'cmp', field, op: operators_1.Op.eq, value: val });
+        }
+    }
+    if (nodes.length === 0)
+        return { kind: 'true' };
+    if (nodes.length === 1)
+        return nodes[0];
+    return { kind: 'and', nodes };
+}
+function asArray(v) {
+    return (Array.isArray(v) ? v : [v]);
+}
+/** Escape a string for safe inclusion in a regular expression. */
+function escapeRegex(s) {
+    return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+/**
+ * Translate a SQL `LIKE`/`ILIKE` pattern into an anchored regular expression
+ * (`%` → `.*`, `_` → `.`), so stores that only speak regex can honor ORM
+ * `Op.like` queries without the caller hand-writing a pattern.
+ */
+function likeToRegex(pattern, caseInsensitive = false) {
+    let out = '';
+    for (let i = 0; i < pattern.length; i++) {
+        const ch = pattern[i];
+        if (ch === '%')
+            out += '.*';
+        else if (ch === '_')
+            out += '.';
+        else
+            out += escapeRegex(ch);
+    }
+    return `${caseInsensitive ? '(?i)' : ''}^${out}$`;
+}