@supalive/core 0.1.4 → 0.1.5

package/dist/query-CbQLjeME.js

@@ -0,0 +1,713 @@
+import { i as bytesEqual } from "./helper-zdJT5FUc.js";
+import z, { z as z$1 } from "zod";
+//#region src/db/codec.ts
+const commitTsCodec = {
+	encode: (value) => value,
+	decode: (value) => {
+		if (typeof value === "string") return BigInt(value);
+		switch (typeof value) {
+			case "string":
+			case "number":
+			case "boolean":
+			case "bigint": return BigInt(value);
+			default: throw new Error(`Unsupported commitTs type: ${typeof value}`);
+		}
+	}
+};
+const identityCodec = {
+	encode: (value) => value,
+	decode: (value) => value
+};
+const numberCodec = {
+	encode: (value) => value,
+	decode: (value) => typeof value === "string" ? Number(value) : value
+};
+const booleanCodec = {
+	encode: (value) => value,
+	decode: (value) => {
+		if (typeof value === "boolean") return value;
+		if (typeof value === "number") return value !== 0;
+		if (typeof value === "string") {
+			const normalized = value.toLowerCase();
+			return normalized === "t" || normalized === "1" || normalized === "true";
+		}
+		return Boolean(value);
+	}
+};
+const dateCodec = {
+	encode: (value) => value,
+	decode: (value) => value instanceof Date ? value : new Date(value)
+};
+function unwrapZodType(field) {
+	let current = field;
+	while (current instanceof z.ZodOptional || current instanceof z.ZodNullable || current instanceof z.ZodDefault || current instanceof z.ZodCatch || current instanceof z.ZodReadonly) current = current._def.innerType;
+	return current;
+}
+function getDefaultCodec(field) {
+	if (field instanceof z.ZodNumber) return numberCodec;
+	if (field instanceof z.ZodBoolean) return booleanCodec;
+	if (field instanceof z.ZodDate) return dateCodec;
+	return identityCodec;
+}
+function normalizeCodec(codec, zodField) {
+	const fallback = getDefaultCodec(zodField);
+	if (!codec) return fallback;
+	return {
+		encode: codec.encode ?? fallback.encode,
+		decode: codec.decode ?? fallback.decode
+	};
+}
+//#endregion
+//#region src/db/query.ts
+function jsonKeysToPath(keys) {
+	let out = "$";
+	for (const k of keys) out += `."${k.replace(/"/g, "\\\"")}"`;
+	return out;
+}
+function resolveJsonPath(opts) {
+	if (opts?.path !== void 0 && opts?.pathRaw !== void 0) throw new Error("jsonContains: pass either `path` or `pathRaw`, not both");
+	if (opts?.pathRaw !== void 0) return opts.pathRaw;
+	if (opts?.path !== void 0) return jsonKeysToPath(Array.isArray(opts.path) ? opts.path : [opts.path]);
+}
+var QueryBuilder = class {
+	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);
+	}
+};
+var SelectQueryBuilder = 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 !== void 0 && 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() {
+		return (await this.limit(1).get())[0] ?? null;
+	}
+	async exists() {
+		return await this.count() > 0;
+	}
+	static defaultCountType = z$1.coerce.number();
+	async count(parser) {
+		const predicate = this.buildPredicate() ?? {
+			kind: "leaf",
+			column: "1",
+			operator: "=",
+			value: "1"
+		};
+		const table = this.model.table;
+		const querySpec = {
+			kind: "range",
+			table,
+			tableId: this.model.tableId,
+			predicate,
+			columns: ["count"],
+			orderBy: null,
+			limit: null,
+			offset: null
+		};
+		const params = [];
+		const sql = `SELECT COUNT(*) as count FROM ${table} WHERE (${buildPredicateSql(predicate, params, this.ctx.db.sqlBuilder)})`;
+		const raw = (await this.ctx.db.query(sql, params)).rows[0]?.count ?? "0";
+		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;
+		const pendingWrite = this.ctx.internalGetWriteSet().find((w) => w.id === id && bytesEqual(w.tableId, tableId));
+		if (pendingWrite) {
+			if (pendingWrite.op === "delete") return null;
+			return this.mapRowToSchema({
+				...pendingWrite.data,
+				id,
+				commit_ts: this.ctx.beginTs
+			});
+		}
+		const computedCols = this.computedFields.map((f) => `${f.sql} as ${f.alias}`);
+		const selectPropsWithComputed = this.selectedProps.slice(0, this.selectedProps.length - this.computedFields.length);
+		const sql = `SELECT ${selectPropsWithComputed.length > 0 ? [
+			"id",
+			...selectPropsWithComputed.map((p) => this.getColumnName(p)),
+			...computedCols,
+			"commit_ts"
+		].join(", ") : "*"} FROM ${table} WHERE id = ${this.ctx.db.sqlBuilder.placeholder(1)}`;
+		const row = (await this.ctx.db.query(sql, [id])).rows[0] ?? null;
+		const expectedCommitTs = row ? BigInt(row.commit_ts) : null;
+		this.ctx.internalGetReadSet().push({
+			kind: "point",
+			table,
+			tableId,
+			id,
+			expectedCommitTs
+		});
+		return row ? this.mapRowToSchema(row) : null;
+	}
+	async get() {
+		const predicate = this.buildPredicate() ?? {
+			kind: "leaf",
+			column: "1",
+			operator: "=",
+			value: "1"
+		};
+		const table = this.model.table;
+		const tableId = this.model.tableId;
+		const querySpec = {
+			kind: "range",
+			table,
+			tableId,
+			predicate,
+			columns: this.selectedProps,
+			orderBy: this.orderByClause,
+			limit: this.limitVal,
+			offset: this.offsetVal
+		};
+		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"
+		] : "*";
+		let sql = `SELECT ${Array.from(new Set(selectColsNames).values()).join(", ")} 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);
+		this.ctx.internalGetReadSet().push({
+			...querySpec,
+			tableId
+		});
+		return result.rows.map((row) => this.mapRowToSchema(row));
+	}
+	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) {
+				if (fb.predicates.some((p) => p.kind === "or")) 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
+		};
+	}
+};
+var FilterBuilder = 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,
+			value,
+			value2
+		};
+		if (raw) leaf.raw = true;
+		this.predicates.push(leaf);
+	}
+	addJsonContains(operator, key, value, opts) {
+		const leaf = {
+			kind: "leaf",
+			column: this.getColumnName(key),
+			operator,
+			value: this.encodeJson(value, opts?.raw)
+		};
+		if (opts?.raw) leaf.raw = true;
+		const path = resolveJsonPath(opts);
+		if (path !== void 0) 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 === void 0 || value === null) return value;
+		return codec.encode(value);
+	}
+	encodeJson(value, raw) {
+		if (value === null || value === void 0) return value;
+		if (raw) return value;
+		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);
+		if (opts?.mode && Array.isArray(value)) {
+			const leaf = {
+				kind: "leaf",
+				column: col,
+				operator: "jsonHasKey",
+				value: value.map((p) => opts.raw && typeof p === "string" ? p : jsonKeysToPath(Array.isArray(p) ? p : [p])),
+				mode: opts.mode
+			};
+			this.predicates.push(leaf);
+			return this;
+		}
+		if (Array.isArray(value)) this.add(col, "jsonHasKey", jsonKeysToPath(value), void 0, true);
+		else if (opts?.raw) this.add(col, "jsonHasKey", value, void 0, true);
+		else this.add(col, "jsonHasKey", value, void 0, 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;
+	}
+};
+function buildPredicateSql(predicate, params, sql) {
+	switch (predicate.kind) {
+		case "and": return `(${predicate.children.map((c) => buildPredicateSql(c, params, sql)).join(" AND ")})`;
+		case "or": return `(${predicate.children.map((c) => buildPredicateSql(c, params, sql)).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);
+			return `${col} BETWEEN ${p1} AND ${sql.placeholder(params.length)}`;
+		}
+		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 !== void 0) {
+				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 !== void 0) {
+				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 !== void 0) {
+				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`;
+	}
+}
+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;
+			return new RegExp("^" + pattern.replace(/%/g, ".*").replace(/_/g, ".") + "$").test(haystack);
+		}
+		case "jsonContains": {
+			const candidate = decodeJsonLeafValue(leaf);
+			const target = leaf.path !== void 0 ? jsonPathExtract(val, leaf.path) : val;
+			if (target === void 0) return false;
+			return jsonContains(target, candidate);
+		}
+		case "jsonContainedBy": {
+			const candidate = decodeJsonLeafValue(leaf);
+			const target = leaf.path !== void 0 ? jsonPathExtract(val, leaf.path) : val;
+			if (target === void 0) 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 !== void 0 ? 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;
+	}
+}
+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;
+	}
+}
+function jsonContains(target, candidate) {
+	if (candidate === target) return true;
+	if (target === null || candidate === null) return target === candidate;
+	if (target === void 0 || candidate === void 0) return false;
+	const tArr = Array.isArray(target);
+	const cArr = Array.isArray(candidate);
+	const tObj = !tArr && typeof target === "object";
+	const cObj = !cArr && typeof candidate === "object";
+	if (!cArr && !cObj && tArr) return target.some((el) => jsonContains(el, candidate));
+	if (cArr && tArr) {
+		const t = target;
+		return candidate.every((c) => t.some((el) => jsonContains(el, c)));
+	}
+	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;
+}
+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 void 0;
+		const key = p.slice(2, end).replace(/\\"/g, "\"").replace(/\\\\/g, "\\");
+		if (cur === null || typeof cur !== "object" || Array.isArray(cur)) return void 0;
+		if (!(key in cur)) return void 0;
+		cur = cur[key];
+		p = p.slice(end + 1);
+	} else if (p.startsWith(".")) {
+		const m = p.slice(1).match(/^([^.[]+)/);
+		if (!m) return void 0;
+		const key = m[1];
+		if (cur === null || typeof cur !== "object" || Array.isArray(cur)) return void 0;
+		if (!(key in cur)) return void 0;
+		cur = cur[key];
+		p = p.slice(1 + key.length);
+	} else if (p.startsWith("[")) {
+		const end = p.indexOf("]");
+		if (end === -1) return void 0;
+		const idx = parseInt(p.slice(1, end), 10);
+		if (!Array.isArray(cur) || idx < 0 || idx >= cur.length) return void 0;
+		cur = cur[idx];
+		p = p.slice(end + 1);
+	} else return;
+	return cur;
+}
+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 !== void 0;
+}
+//#endregion
+export { jsonPathExtract as a, normalizeCodec as c, jsonPathExists as i, unwrapZodType as l, buildPredicateSql as n, matchesPredicate as o, jsonContains as r, commitTsCodec as s, QueryBuilder as t };
+
+//# sourceMappingURL=query-CbQLjeME.js.map