@supalive/core 1.14.0 → 1.16.0

package/dist/query-q1ZvKrZO.js

@@ -0,0 +1,762 @@
+import { i as normalizeCodec } from "./table-id-DyrJBKAQ.js";
+import { i as bytesEqual } from "./helper-zdJT5FUc.js";
+import { z as z$1 } from "zod";
+import { SpanStatusCode, context, trace } from "@opentelemetry/api";
+//#region src/db/sqlcommenter.ts
+function comment(input) {
+	if (!input) return "";
+	if (typeof input === "string") return `/*${input}*/`;
+	const entries = Object.entries(input).filter(([_, v]) => v != null);
+	if (entries.length === 0) return "";
+	return `/*${entries.map(([k, v]) => `${encodeURIComponent(k)}='${encodeURIComponent(v)}'`).sort().join(",")}*/`;
+}
+//#endregion
+//#region src/db/db-trace.ts
+const tracer = trace.getTracer("@supalive/core");
+/**
+* Run `fn` inside a `db.<op> <table>` span when a trace is being recorded;
+* otherwise run it directly. `system` is the DB flavor (`mysql`/`postgres`).
+* Attributes follow OTel DB semantic conventions and stay low-cardinality —
+* table + operation only, never ids or parameter values.
+*/
+function traceDbCall(op, table, system, fn) {
+	const active = trace.getActiveSpan();
+	if (!active || !active.isRecording()) return fn();
+	const span = tracer.startSpan(table ? `db.${op} ${table}` : `db.${op}`, { attributes: {
+		"db.system": system,
+		"db.operation": op,
+		...table ? { "db.sql.table": table } : {}
+	} });
+	return context.with(trace.setSpan(context.active(), span), async () => {
+		try {
+			const res = await fn();
+			span.setStatus({ code: SpanStatusCode.OK });
+			return res;
+		} catch (err) {
+			if (err instanceof Error) span.recordException(err);
+			span.setStatus({ code: SpanStatusCode.ERROR });
+			throw err;
+		} finally {
+			span.end();
+		}
+	});
+}
+//#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 = [];
+	paginationClause = null;
+	orderByClause = null;
+	limitVal = null;
+	offsetVal = null;
+	selectedProps = [];
+	computedFields = [];
+	commentStr = "";
+	constructor(ctx, model, filters = [], orderByClause = null, limitVal = null, offsetVal = null, selectedProps = [], computedFields = [], commentStr = "") {
+		this.ctx = ctx;
+		this.model = model;
+		this.filters = filters;
+		this.orderByClause = orderByClause;
+		this.limitVal = limitVal;
+		this.offsetVal = offsetVal;
+		this.selectedProps = selectedProps;
+		this.computedFields = computedFields;
+		this.commentStr = commentStr;
+	}
+	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;
+	}
+	paginate(clause) {
+		this.paginationClause = clause;
+		return this;
+	}
+	orderBy(column, directionOrOptions = "ASC") {
+		const sql = this.buildOrderBySql(column, directionOrOptions);
+		if (!this.orderByClause) this.orderByClause = [];
+		this.orderByClause.push(sql);
+		return this;
+	}
+	buildOrderBySql(column, directionOrOptions = "ASC") {
+		const options = typeof directionOrOptions === "string" ? { direction: directionOrOptions } : directionOrOptions;
+		let sql = this.getColumnName(column);
+		if (options?.collate) sql += ` COLLATE ${options.collate}`;
+		sql += ` ${(options?.direction ?? "ASC").toUpperCase()}`;
+		if (this.ctx.db.dbType === "postgres") {
+			if (options?.nulls) sql += ` NULLS ${options.nulls.toUpperCase()}`;
+		}
+		return sql;
+	}
+	orderByRaw(sql) {
+		if (!this.orderByClause) this.orderByClause = [];
+		this.orderByClause.push(sql);
+		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, this.commentStr);
+	}
+	comment(input) {
+		this.commentStr = comment(input);
+		return this;
+	}
+	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(false) ?? {
+			kind: "leaf",
+			column: "1",
+			operator: "=",
+			value: "1"
+		};
+		const table = this.model.table;
+		const querySpec = {
+			kind: "range",
+			table,
+			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)})${this.commentStr ? " " + this.commentStr : ""}`;
+		const raw = (await traceDbCall("count", table, this.ctx.db.dbType, () => this.ctx.db.query(sql, params))).rows[0]?.count ?? "0";
+		this.ctx.internalGetReadSet().push({ ...querySpec });
+		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);
+		let 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)}`;
+		if (this.commentStr) sql += ` ${this.commentStr}`;
+		const row = (await traceDbCall("find", table, this.ctx.db.dbType, () => this.ctx.db.query(sql, [id]))).rows[0] ?? null;
+		const expectedCommitTs = row ? BigInt(row.commit_ts) : null;
+		this.ctx.internalGetReadSet().push({
+			kind: "point",
+			table,
+			id,
+			expectedCommitTs
+		});
+		return row ? this.mapRowToSchema(row) : null;
+	}
+	async get() {
+		const predicate = this.buildPredicate(true) ?? {
+			kind: "leaf",
+			column: "1",
+			operator: "=",
+			value: "1"
+		};
+		const table = this.model.table;
+		const querySpec = {
+			kind: "range",
+			table,
+			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})`;
+		let orderByClause;
+		const paginateClause = this.paginationClause;
+		if (paginateClause) {
+			const idField = paginateClause.idCol ?? "id";
+			const orderDir = paginateClause.direction ?? "DESC";
+			orderByClause = [this.buildOrderBySql(paginateClause.timeCol, orderDir), this.buildOrderBySql(idField, orderDir)];
+			if (this.orderByClause) orderByClause.push(...this.orderByClause);
+		} else if (this.orderByClause) orderByClause = this.orderByClause;
+		if (orderByClause) sql += ` ORDER BY ${orderByClause.join(", ")}`;
+		const limit = paginateClause?.limit ?? this.limitVal;
+		if (limit !== null) sql += ` LIMIT ${limit}`;
+		if (this.offsetVal !== null && !this.paginationClause) sql += ` OFFSET ${this.offsetVal}`;
+		if (this.commentStr) sql += ` ${this.commentStr}`;
+		const result = await traceDbCall("select", table, this.ctx.db.dbType, () => this.ctx.db.query(sql, params));
+		this.ctx.internalGetReadSet().push({ ...querySpec });
+		return result.rows.map((row) => this.mapRowToSchema(row));
+	}
+	buildPredicate(includePagination) {
+		if (this.filters.length === 0) return null;
+		const predicates = [];
+		const fb = new FilterBuilder(this.model.columns, this.model.codecs);
+		let paginateFilter;
+		const clause = this.paginationClause;
+		const cursor = clause?.cursor;
+		if (clause && cursor != null) {
+			const descending = (clause.direction ?? "DESC") === "DESC";
+			const idField = clause.idCol ?? "id";
+			paginateFilter = (f) => {
+				f.or([(f1) => {
+					return descending ? f1.lt(clause.timeCol, cursor.time) : f1.gt(clause.timeCol, cursor.time);
+				}, (f2) => {
+					const q = f2.eq(clause.timeCol, cursor.time);
+					return descending ? q.lt(idField, cursor.id) : q.gt(idField, cursor.id);
+				}]);
+			};
+		}
+		const count = this.filters.length + (paginateFilter ? 1 : 0);
+		for (let i = 0; i < count; i++) {
+			(i == this.filters.length ? paginateFilter : this.filters[i])(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;
+	}
+	/**
+	* Set membership: `key` equals any of `values` (SQL `IN`). Each value is
+	* codec-encoded like `eq`. An empty `values` matches no rows. Bound as one
+	* parameter per element, so keep the list within the driver's parameter
+	* limit (chunk very large sets at the call site).
+	*/
+	in(key, values) {
+		const col = this.getColumnName(key);
+		this.add(col, "in", values.map((v) => this.encode(key, v)));
+		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 "in": {
+			const values = leaf.value ?? [];
+			if (values.length === 0) return "1 = 0";
+			return `${col} IN (${values.map((v) => {
+				params.push(v);
+				return sql.placeholder(params.length);
+			}).join(", ")})`;
+		}
+		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 "in": return Array.isArray(leaf.value) && leaf.value.includes(val);
+		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, jsonPathExists as i, buildPredicateSql as n, matchesPredicate as o, jsonContains as r, traceDbCall as s, QueryBuilder as t };
+
+//# sourceMappingURL=query-q1ZvKrZO.js.map