@supalive/core 0.1.3 → 0.1.5

package/dist/src/db/query.js

@@ -1,790 +0,0 @@
-import { z } from "zod";
-import { normalizeCodec } from "./codec";
-import { bytesEqual } from "./bytes";
-// Escape and join a key path into a JSON path expression usable by both
-// PG (`jsonb_path_exists`) and MySQL (`JSON_CONTAINS_PATH`):
-//   ["a", "b.c"] → `$."a"."b.c"`
-function jsonKeysToPath(keys) {
-    let out = "$";
-    for (const k of keys) {
-        out += `."${k.replace(/"/g, '\\"')}"`;
-    }
-    return out;
-}
-// Resolve the `path` / `pathRaw` option pair down to a single jsonpath
-// expression. Returns a string in `$."..."` form for structured `path`,
-// or the caller's `pathRaw` verbatim. Returns `undefined` when neither is
-// set. Throws when both are supplied.
-function resolveJsonPath(opts) {
-    if (opts?.path !== undefined && opts?.pathRaw !== undefined) {
-        throw new Error("jsonContains: pass either `path` or `pathRaw`, not both");
-    }
-    if (opts?.pathRaw !== undefined)
-        return opts.pathRaw;
-    if (opts?.path !== undefined) {
-        const arr = Array.isArray(opts.path) ? opts.path : [opts.path];
-        return jsonKeysToPath(arr);
-    }
-    return undefined;
-}
-export class QueryBuilder {
-    ctx;
-    model;
-    constructor(ctx, model) {
-        this.ctx = ctx;
-        this.model = model;
-    }
-    getColumnName(key) {
-        return this.model.columns[key] ?? key;
-    }
-    select(...columns) {
-        const selectedProps = (columns.length > 0 ? columns : Object.keys(this.model.columns));
-        return new SelectQueryBuilder(this.ctx, this.model, [], null, null, null, selectedProps);
-    }
-}
-class SelectQueryBuilder {
-    ctx;
-    model;
-    filters = [];
-    orderByClause = null;
-    limitVal = null;
-    offsetVal = null;
-    selectedProps = [];
-    computedFields = [];
-    constructor(ctx, model, filters = [], orderByClause = null, limitVal = null, offsetVal = null, selectedProps = [], computedFields = []) {
-        this.ctx = ctx;
-        this.model = model;
-        this.filters = filters;
-        this.orderByClause = orderByClause;
-        this.limitVal = limitVal;
-        this.offsetVal = offsetVal;
-        this.selectedProps = selectedProps;
-        this.computedFields = computedFields;
-    }
-    getColumnName(key) {
-        return this.model.columns[key] ?? key;
-    }
-    getPropertyName(column) {
-        return this.model.reverseColumns[column] ?? this.computedFields.find(f => f.alias === column)?.field ?? column;
-    }
-    mapRowToSchema(row) {
-        const result = {};
-        for (const [col, value] of Object.entries(row)) {
-            const prop = this.getPropertyName(col);
-            const codec = this.model.codecs[prop] ?? this.computedFields.find((f) => f.alias === col)?.codec;
-            result[prop] = codec?.decode && value !== undefined && value !== null ? codec.decode(value) : value;
-        }
-        return result;
-    }
-    where(filterFn) {
-        this.filters.push(filterFn);
-        return this;
-    }
-    orderBy(column, direction = "asc") {
-        this.orderByClause = `${this.getColumnName(column)} ${direction}`;
-        return this;
-    }
-    limit(n) {
-        this.limitVal = n;
-        return this;
-    }
-    offset(n) {
-        this.offsetVal = n;
-        return this;
-    }
-    computed(config) {
-        const computed = {
-            field: config.field,
-            sql: config.sql,
-            alias: config.alias ?? config.field,
-            codec: normalizeCodec(config.codec, config.type),
-        };
-        this.computedFields.push(computed);
-        return new SelectQueryBuilder(this.ctx, this.model, this.filters, this.orderByClause, this.limitVal, this.offsetVal, [...this.selectedProps, config.field], this.computedFields);
-    }
-    async first() {
-        const rows = await this.limit(1).get();
-        return (rows[0] ?? null);
-    }
-    async exists() {
-        return await this.count() > 0;
-    }
-    static defaultCountType = z.coerce.number();
-    async count(parser) {
-        const predicate = this.buildPredicate() ?? { kind: "leaf", column: "1", operator: "=", value: "1" };
-        const table = this.model.table;
-        // Build query spec for read tracking (without totalTs)
-        const querySpec = {
-            kind: "range",
-            table: table,
-            tableId: this.model.tableId,
-            predicate: predicate,
-            columns: ["count"],
-            orderBy: null,
-            limit: null,
-            offset: null,
-        };
-        // Execute query
-        const params = [];
-        const whereSql = buildPredicateSql(predicate, params, this.ctx.db.sqlBuilder);
-        const sql = `SELECT COUNT(*) as count FROM ${table} WHERE (${whereSql})`;
-        const result = await this.ctx.db.query(sql, params);
-        const raw = result.rows[0]?.count ?? "0";
-        // Record read with totalTs for OCC validation
-        this.ctx.internalGetReadSet().push({
-            ...querySpec,
-            tableId: this.model.tableId,
-        });
-        if (parser) {
-            return parser.parse(raw);
-        }
-        else {
-            return SelectQueryBuilder.defaultCountType.parse(raw);
-        }
-    }
-    async find(id) {
-        if (this.filters.length > 0) {
-            throw new Error(`Cannot use find() after where() - find() is meant for primary key lookups without additional filters`);
-        }
-        const table = this.model.table;
-        const tableId = this.model.tableId;
-        // Check pending writes first
-        const pendingWrite = this.ctx.internalGetWriteSet().find(w => w.id === id && bytesEqual(w.tableId, tableId));
-        if (pendingWrite) {
-            if (pendingWrite.op === "delete") {
-                // Don't cache pending writes, just return
-                return null;
-            }
-            const row = this.mapRowToSchema({ ...pendingWrite.data, id, commit_ts: this.ctx.beginTs });
-            return row;
-        }
-        const computedCols = this.computedFields.map(f => `${f.sql} as ${f.alias}`);
-        const selectPropsWithComputed = this.selectedProps.slice(0, this.selectedProps.length - this.computedFields.length);
-        const selectCols = selectPropsWithComputed.length > 0
-            ? ["id", ...selectPropsWithComputed.map(p => this.getColumnName(p)), ...computedCols, "commit_ts"].join(", ")
-            : "*";
-        const sql = `SELECT ${selectCols} FROM ${table} WHERE id = ${this.ctx.db.sqlBuilder.placeholder(1)}`;
-        const result = await this.ctx.db.query(sql, [id]);
-        const row = result.rows[0] ?? null;
-        // Capture commit_ts as the per-row OCC fingerprint. `null` means
-        // "no row at read time" — a later concurrent insert with this id
-        // becomes a conflict at commit time.
-        const expectedCommitTs = row ? BigInt(row.commit_ts) : null;
-        this.ctx.internalGetReadSet().push({
-            kind: "point",
-            table,
-            tableId,
-            id,
-            expectedCommitTs,
-        });
-        const mappedRow = row ? this.mapRowToSchema(row) : null;
-        return mappedRow;
-    }
-    async get() {
-        const predicate = this.buildPredicate() ?? { kind: "leaf", column: "1", operator: "=", value: "1" };
-        const table = this.model.table;
-        const tableId = this.model.tableId;
-        // Build query spec for read tracking (without totalTs)
-        const querySpec = {
-            kind: "range",
-            table: table,
-            tableId: tableId,
-            predicate: predicate,
-            columns: this.selectedProps,
-            orderBy: this.orderByClause,
-            limit: this.limitVal,
-            offset: this.offsetVal,
-        };
-        // Execute query
-        const params = [];
-        const whereSql = buildPredicateSql(predicate, params, this.ctx.db.sqlBuilder);
-        const computedCols = this.computedFields.map(f => `${f.sql} as ${f.alias}`);
-        const selectPropsWithComputed = this.selectedProps.slice(0, this.selectedProps.length - this.computedFields.length);
-        const selectColsNames = selectPropsWithComputed.length > 0
-            ? ["id", ...selectPropsWithComputed.map(p => this.getColumnName(p)), ...computedCols, "commit_ts"]
-            : "*";
-        const selectCols = Array.from(new Set(selectColsNames).values()).join(", ");
-        let sql = `SELECT ${selectCols} FROM ${table} WHERE (${whereSql})`;
-        if (this.orderByClause) {
-            sql += ` ORDER BY ${this.orderByClause}`;
-        }
-        if (this.limitVal !== null) {
-            sql += ` LIMIT ${this.limitVal}`;
-        }
-        if (this.offsetVal !== null) {
-            sql += ` OFFSET ${this.offsetVal}`;
-        }
-        const result = await this.ctx.db.query(sql, params);
-        // Record read with totalTs for OCC validation
-        this.ctx.internalGetReadSet().push({
-            ...querySpec,
-            tableId: tableId,
-        });
-        const rows = result.rows.map(row => this.mapRowToSchema(row));
-        return rows;
-    }
-    buildPredicate() {
-        if (this.filters.length === 0)
-            return null;
-        const predicates = [];
-        const fb = new FilterBuilder(this.model.columns, this.model.codecs);
-        for (const filterFn of this.filters) {
-            filterFn(fb);
-            if (fb.predicates.length > 0) {
-                const hasOr = fb.predicates.some(p => p.kind === "or");
-                if (hasOr) {
-                    predicates.push(...fb.predicates);
-                }
-                else {
-                    predicates.push({ kind: "and", children: fb.predicates });
-                }
-                fb.predicates = [];
-            }
-        }
-        if (predicates.length === 0)
-            return null;
-        if (predicates.length === 1)
-            return predicates[0] ?? null;
-        return { kind: "and", children: predicates };
-    }
-}
-// ─── Filter Builder ──────────────────────────────────────────────────────────────
-class FilterBuilder {
-    columns;
-    codecs;
-    predicates = [];
-    constructor(columns, codecs) {
-        this.columns = columns;
-        this.codecs = codecs;
-    }
-    add(column, operator, value, value2, raw) {
-        const leaf = { kind: "leaf", column, operator: operator, value, value2 };
-        if (raw)
-            leaf.raw = true;
-        this.predicates.push(leaf);
-    }
-    addJsonContains(operator, key, value, opts) {
-        const col = this.getColumnName(key);
-        const leaf = {
-            kind: "leaf",
-            column: col,
-            operator: operator,
-            value: this.encodeJson(value, opts?.raw),
-        };
-        if (opts?.raw)
-            leaf.raw = true;
-        const path = resolveJsonPath(opts);
-        if (path !== undefined)
-            leaf.path = path;
-        this.predicates.push(leaf);
-    }
-    getColumnName(key) {
-        return this.columns[key] ?? key;
-    }
-    encode(key, value) {
-        const codec = this.codecs[key];
-        if (!codec?.encode || value === undefined || value === null)
-            return value;
-        return codec.encode(value);
-    }
-    encodeJson(value, raw) {
-        if (value === null || value === undefined)
-            return value;
-        // raw=true: caller has already produced the dialect-native form
-        // (typically a JSON-encoded string or a path expression). Pass through.
-        if (raw)
-            return value;
-        // Otherwise serialize the JS value to a JSON literal so the SQL
-        // emitter can hand a single text param to the driver.
-        return JSON.stringify(value);
-    }
-    eq(key, value) {
-        this.add(this.getColumnName(key), "=", this.encode(key, value));
-        return this;
-    }
-    neq(key, value) {
-        this.add(this.getColumnName(key), "!=", this.encode(key, value));
-        return this;
-    }
-    gt(key, value) {
-        this.add(this.getColumnName(key), ">", this.encode(key, value));
-        return this;
-    }
-    gte(key, value) {
-        this.add(this.getColumnName(key), ">=", this.encode(key, value));
-        return this;
-    }
-    lt(key, value) {
-        this.add(this.getColumnName(key), "<", this.encode(key, value));
-        return this;
-    }
-    lte(key, value) {
-        this.add(this.getColumnName(key), "<=", this.encode(key, value));
-        return this;
-    }
-    like(key, pattern) {
-        this.add(this.getColumnName(key), "like", this.encode(key, pattern));
-        return this;
-    }
-    ilike(key, pattern) {
-        this.add(this.getColumnName(key), "ilike", this.encode(key, pattern));
-        return this;
-    }
-    contains(key, value) {
-        this.add(this.getColumnName(key), "contains", this.encode(key, value));
-        return this;
-    }
-    icontains(key, value) {
-        this.add(this.getColumnName(key), "icontains", this.encode(key, value));
-        return this;
-    }
-    /**
-     * JSON containment. Targets a JSON/JSONB column and asserts the document
-     * contains the given candidate (object-key subset for objects,
-     * element-subset for arrays — see dialect-specific docs for edge cases).
-     * Pass `{ raw: true }` if `value` is already a JSON-encoded string.
-     * Pass `{ path: ... }` to scope the check to a sub-document of the
-     * target (jsonb_path_query_first on PG, JSON_CONTAINS path arg on MySQL).
-     */
-    jsonContains(key, value, opts) {
-        this.addJsonContains("jsonContains", key, value, opts);
-        return this;
-    }
-    /** Inverse of {@link jsonContains}: column is contained in the given value. */
-    jsonContainedBy(key, value, opts) {
-        this.addJsonContains("jsonContainedBy", key, value, opts);
-        return this;
-    }
-    jsonHasKey(key, value, opts) {
-        const col = this.getColumnName(key);
-        // Multi-path mode: array of (string|string[]) entries with explicit mode.
-        if (opts?.mode && Array.isArray(value)) {
-            const paths = value.map((p) => opts.raw && typeof p === "string" ? p : jsonKeysToPath(Array.isArray(p) ? p : [p]));
-            const leaf = {
-                kind: "leaf",
-                column: col,
-                operator: "jsonHasKey",
-                value: paths,
-                mode: opts.mode,
-            };
-            this.predicates.push(leaf);
-            return this;
-        }
-        // Single-key/path mode.
-        if (Array.isArray(value)) {
-            this.add(col, "jsonHasKey", jsonKeysToPath(value), undefined, true);
-        }
-        else if (opts?.raw) {
-            this.add(col, "jsonHasKey", value, undefined, true);
-        }
-        else {
-            this.add(col, "jsonHasKey", value, undefined, false);
-        }
-        return this;
-    }
-    /**
-     * Array element containment: target column is a JSON array; the given
-     * `value` (any JSON-encodable type) must appear as one of its elements.
-     * Pass `{ raw: true }` if `value` is already a JSON-encoded string.
-     * Pass `{ path: ... }` to scope the check to a sub-array of the column.
-     */
-    jsonArrayContains(key, value, opts) {
-        this.addJsonContains("jsonArrayContains", key, value, opts);
-        return this;
-    }
-    between(key, lo, hi) {
-        this.add(this.getColumnName(key), "between", this.encode(key, lo), this.encode(key, hi));
-        return this;
-    }
-    isNull(key) {
-        this.add(this.getColumnName(key), "isNull", null);
-        return this;
-    }
-    notNull(key) {
-        this.add(this.getColumnName(key), "isNotNull", null);
-        return this;
-    }
-    /**
-     * Compose an OR clause. Each callback fills a fresh sub-FilterBuilder
-     * with predicates that are AND-ed together within that branch; the
-     * branches themselves are OR-ed. Example:
-     *   f.or([
-     *     b => b.eq("tag", "a"),
-     *     b => b.eq("tag", "b").gt("qty", 3),  // (tag=b AND qty>3)
-     *   ])
-     * produces  (tag=a) OR (tag=b AND qty>3).
-     */
-    or(branches) {
-        const children = [];
-        for (const fn of branches) {
-            const sub = new FilterBuilder(this.columns, this.codecs);
-            fn(sub);
-            if (sub.predicates.length === 1) {
-                children.push(sub.predicates[0]);
-            }
-            else if (sub.predicates.length > 1) {
-                children.push({ kind: "and", children: sub.predicates });
-            }
-        }
-        if (children.length > 0) {
-            this.predicates.push({ kind: "or", children });
-        }
-        return this;
-    }
-}
-export function buildPredicateSql(predicate, params, sql) {
-    switch (predicate.kind) {
-        case "and": {
-            const parts = predicate.children.map((c) => buildPredicateSql(c, params, sql));
-            return `(${parts.join(" AND ")})`;
-        }
-        case "or": {
-            const parts = predicate.children.map((c) => buildPredicateSql(c, params, sql));
-            return `(${parts.join(" OR ")})`;
-        }
-        case "leaf": {
-            return buildLeafSql(predicate, params, sql);
-        }
-    }
-}
-function buildLeafSql(leaf, params, sql) {
-    const col = leaf.column;
-    switch (leaf.operator) {
-        case "=":
-        case "!=":
-        case ">":
-        case ">=":
-        case "<":
-        case "<=": {
-            params.push(leaf.value);
-            return `${col} ${leaf.operator} ${sql.placeholder(params.length)}`;
-        }
-        case "between": {
-            params.push(leaf.value);
-            const p1 = sql.placeholder(params.length);
-            params.push(leaf.value2);
-            const p2 = sql.placeholder(params.length);
-            return `${col} BETWEEN ${p1} AND ${p2}`;
-        }
-        case "like": {
-            params.push(leaf.value);
-            return `${col} LIKE ${sql.placeholder(params.length)}`;
-        }
-        case "ilike": {
-            params.push(leaf.value);
-            return sql.ilike(col, params.length);
-        }
-        case "contains": {
-            params.push(`%${leaf.value}%`);
-            return `${col} LIKE ${sql.placeholder(params.length)}`;
-        }
-        case "icontains": {
-            params.push(`%${leaf.value}%`);
-            return sql.icontains(col, params.length);
-        }
-        case "jsonContains": {
-            params.push(leaf.value);
-            const valIdx = params.length;
-            let pathIndex;
-            if (leaf.path !== undefined) {
-                params.push(leaf.path);
-                pathIndex = params.length;
-            }
-            return sql.jsonContains(col, valIdx, { raw: leaf.raw, pathIndex });
-        }
-        case "jsonContainedBy": {
-            params.push(leaf.value);
-            const valIdx = params.length;
-            let pathIndex;
-            if (leaf.path !== undefined) {
-                params.push(leaf.path);
-                pathIndex = params.length;
-            }
-            return sql.jsonContainedBy(col, valIdx, { raw: leaf.raw, pathIndex });
-        }
-        case "jsonHasKey": {
-            if (leaf.mode && Array.isArray(leaf.value)) {
-                const paths = leaf.value;
-                const startIdx = params.length + 1;
-                for (const p of paths)
-                    params.push(p);
-                return sql.jsonHasKey(col, startIdx, {
-                    raw: true,
-                    mode: leaf.mode,
-                    pathCount: paths.length,
-                });
-            }
-            params.push(leaf.value);
-            return sql.jsonHasKey(col, params.length, { raw: leaf.raw });
-        }
-        case "jsonArrayContains": {
-            params.push(leaf.value);
-            const valIdx = params.length;
-            let pathIndex;
-            if (leaf.path !== undefined) {
-                params.push(leaf.path);
-                pathIndex = params.length;
-            }
-            return sql.jsonArrayContains(col, valIdx, { raw: leaf.raw, pathIndex });
-        }
-        case "isNull": return `${col} IS NULL`;
-        case "isNotNull": return `${col} IS NOT NULL`;
-    }
-}
-export function matchesPredicate(row, predicate) {
-    switch (predicate.kind) {
-        case "and": return predicate.children.every((c) => matchesPredicate(row, c));
-        case "or": return predicate.children.some((c) => matchesPredicate(row, c));
-        case "leaf": return matchesLeaf(row, predicate);
-    }
-}
-function matchesLeaf(row, leaf) {
-    const val = row[leaf.column];
-    switch (leaf.operator) {
-        case "=": return val === leaf.value;
-        case "!=": return val !== leaf.value;
-        case ">": return val > leaf.value;
-        case ">=": return val >= leaf.value;
-        case "<": return val < leaf.value;
-        case "<=": return val <= leaf.value;
-        case "between":
-            return val >= leaf.value &&
-                val <= leaf.value2;
-        case "like":
-        case "contains":
-        case "ilike":
-        case "icontains": {
-            if (typeof val !== "string" || typeof leaf.value !== "string")
-                return false;
-            const haystack = (leaf.operator === "ilike" || leaf.operator === "icontains")
-                ? val.toLowerCase()
-                : val;
-            const raw = leaf.value;
-            const needle = (leaf.operator === "ilike" || leaf.operator === "icontains")
-                ? raw.toLowerCase()
-                : raw;
-            const pattern = (leaf.operator === "contains" || leaf.operator === "icontains")
-                ? `%${needle}%`
-                : needle;
-            const regex = new RegExp("^" + pattern.replace(/%/g, ".*").replace(/_/g, ".") + "$");
-            return regex.test(haystack);
-        }
-        case "jsonContains": {
-            const candidate = decodeJsonLeafValue(leaf);
-            const target = leaf.path !== undefined ? jsonPathExtract(val, leaf.path) : val;
-            if (target === undefined)
-                return false;
-            return jsonContains(target, candidate);
-        }
-        case "jsonContainedBy": {
-            const candidate = decodeJsonLeafValue(leaf);
-            const target = leaf.path !== undefined ? jsonPathExtract(val, leaf.path) : val;
-            if (target === undefined)
-                return false;
-            return jsonContains(candidate, target);
-        }
-        case "jsonHasKey": {
-            if (leaf.mode && Array.isArray(leaf.value)) {
-                const paths = leaf.value;
-                if (paths.length === 0)
-                    return false;
-                return leaf.mode === "all"
-                    ? paths.every((p) => jsonPathExists(val, p))
-                    : paths.some((p) => jsonPathExists(val, p));
-            }
-            if (leaf.raw) {
-                return jsonPathExists(val, leaf.value);
-            }
-            const key = leaf.value;
-            if (val === null || typeof val !== "object")
-                return false;
-            if (Array.isArray(val))
-                return val.includes(key);
-            return key in val;
-        }
-        case "jsonArrayContains": {
-            const candidate = decodeJsonLeafValue(leaf);
-            const target = leaf.path !== undefined ? jsonPathExtract(val, leaf.path) : val;
-            if (!Array.isArray(target))
-                return false;
-            return target.some((el) => jsonContains(el, candidate));
-        }
-        case "isNull":
-            return val === null;
-        case "isNotNull":
-            return val !== null;
-        default:
-            return false;
-    }
-}
-// When raw=true the leaf.value is a JSON-encoded string; decode for in-memory
-// comparison. Otherwise the value is the original JS value as passed.
-function decodeJsonLeafValue(leaf) {
-    if (!leaf.raw)
-        return leaf.value;
-    if (typeof leaf.value !== "string")
-        return leaf.value;
-    try {
-        return JSON.parse(leaf.value);
-    }
-    catch {
-        return leaf.value;
-    }
-}
-// PG `@>` / MySQL `JSON_CONTAINS` semantics. Recursive containment:
-//   - scalars: strict equality
-//   - object: every candidate key matches target's value recursively
-//   - array: every candidate element is contained in some target element
-//   - scalar candidate vs array target: candidate equals some element
-export function jsonContains(target, candidate) {
-    if (candidate === target)
-        return true;
-    if (target === null || candidate === null)
-        return target === candidate;
-    if (target === undefined || candidate === undefined)
-        return false;
-    const tArr = Array.isArray(target);
-    const cArr = Array.isArray(candidate);
-    const tObj = !tArr && typeof target === "object";
-    const cObj = !cArr && typeof candidate === "object";
-    // Scalar candidate in array target.
-    if (!cArr && !cObj && tArr) {
-        return target.some((el) => jsonContains(el, candidate));
-    }
-    // Both arrays: every candidate element matches some target element.
-    if (cArr && tArr) {
-        const t = target;
-        return candidate.every((c) => t.some((el) => jsonContains(el, c)));
-    }
-    // Both objects.
-    if (cObj && tObj) {
-        const t = target;
-        const c = candidate;
-        for (const k of Object.keys(c)) {
-            if (!(k in t))
-                return false;
-            if (!jsonContains(t[k], c[k]))
-                return false;
-        }
-        return true;
-    }
-    return false;
-}
-// Walk the JSON path and return the value at it, or `undefined` if any
-// segment is missing or unresolvable. Same syntax subset as
-// {@link jsonPathExists}.
-export function jsonPathExtract(val, path) {
-    let p = path;
-    if (p.startsWith("$"))
-        p = p.slice(1);
-    let cur = val;
-    while (p.length > 0) {
-        if (p.startsWith('."')) {
-            let end = 2;
-            while (end < p.length) {
-                if (p[end] === "\\" && end + 1 < p.length) {
-                    end += 2;
-                    continue;
-                }
-                if (p[end] === '"')
-                    break;
-                end++;
-            }
-            if (end >= p.length)
-                return undefined;
-            const key = p.slice(2, end).replace(/\\"/g, '"').replace(/\\\\/g, "\\");
-            if (cur === null || typeof cur !== "object" || Array.isArray(cur))
-                return undefined;
-            if (!(key in cur))
-                return undefined;
-            cur = cur[key];
-            p = p.slice(end + 1);
-        }
-        else if (p.startsWith(".")) {
-            const m = p.slice(1).match(/^([^.[]+)/);
-            if (!m)
-                return undefined;
-            const key = m[1];
-            if (cur === null || typeof cur !== "object" || Array.isArray(cur))
-                return undefined;
-            if (!(key in cur))
-                return undefined;
-            cur = cur[key];
-            p = p.slice(1 + key.length);
-        }
-        else if (p.startsWith("[")) {
-            const end = p.indexOf("]");
-            if (end === -1)
-                return undefined;
-            const idx = parseInt(p.slice(1, end), 10);
-            if (!Array.isArray(cur) || idx < 0 || idx >= cur.length)
-                return undefined;
-            cur = cur[idx];
-            p = p.slice(end + 1);
-        }
-        else {
-            return undefined;
-        }
-    }
-    return cur;
-}
-// Best-effort JSON path evaluator for the in-memory predicate match.
-// Supports the path syntax this module emits (`$."key"."nested"`) plus the
-// common shorthands `$.key` and `$.key[0]`. Anything more exotic (filters,
-// wildcards) returns false — DB will still evaluate it correctly server-side.
-export function jsonPathExists(val, path) {
-    let p = path;
-    if (p.startsWith("$"))
-        p = p.slice(1);
-    let cur = val;
-    while (p.length > 0) {
-        if (p.startsWith('."')) {
-            let end = 2;
-            while (end < p.length) {
-                if (p[end] === "\\" && end + 1 < p.length) {
-                    end += 2;
-                    continue;
-                }
-                if (p[end] === '"')
-                    break;
-                end++;
-            }
-            if (end >= p.length)
-                return false;
-            const key = p.slice(2, end).replace(/\\"/g, '"').replace(/\\\\/g, "\\");
-            if (cur === null || typeof cur !== "object" || Array.isArray(cur))
-                return false;
-            if (!(key in cur))
-                return false;
-            cur = cur[key];
-            p = p.slice(end + 1);
-        }
-        else if (p.startsWith(".")) {
-            const m = p.slice(1).match(/^([^.[]+)/);
-            if (!m)
-                return false;
-            const key = m[1];
-            if (cur === null || typeof cur !== "object" || Array.isArray(cur))
-                return false;
-            if (!(key in cur))
-                return false;
-            cur = cur[key];
-            p = p.slice(1 + key.length);
-        }
-        else if (p.startsWith("[")) {
-            const end = p.indexOf("]");
-            if (end === -1)
-                return false;
-            const idx = parseInt(p.slice(1, end), 10);
-            if (!Array.isArray(cur) || idx < 0 || idx >= cur.length)
-                return false;
-            cur = cur[idx];
-            p = p.slice(end + 1);
-        }
-        else {
-            return false;
-        }
-    }
-    return cur !== undefined;
-}
-//# sourceMappingURL=query.js.map