@rocicorp/zero 1.10.0-canary.2 → 1.10.0-canary.21

package/out/zero-cache/src/services/change-source/pg/schema/index-predicate.js

@@ -0,0 +1,581 @@
+//#region ../zero-cache/src/services/change-source/pg/schema/index-predicate.ts
+var UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/;
+var INTEGER_RE = /^[+-]?\d+$/;
+var WHITESPACE_RE = /\s/;
+var OPERATOR_TOKEN_RE = /^(?:::|<>|!=|<=|>=|=|<|>)/;
+var UNSUPPORTED_OPERATOR_TOKEN_RE = /^(?:!~\*|!~|~\*|~)/;
+var INTEGER_TOKEN_RE = /^[+-]?\d+/;
+var WORD_TOKEN_RE = /^[A-Za-z_][A-Za-z0-9_$]*/;
+var SIMPLE_ESCAPES = {
+	b: "\b",
+	f: "\f",
+	n: "\n",
+	r: "\r",
+	t: "	",
+	v: "\v"
+};
+var UnsupportedPredicateError = class extends Error {
+	reason;
+	constructor(reason) {
+		super(reason);
+		this.reason = reason;
+	}
+};
+function translatePostgresIndexPredicate(sql, table) {
+	try {
+		const parser = new Parser(tokenize(sql));
+		const expression = parser.parse();
+		parser.expect("EOF");
+		return {
+			supported: true,
+			predicate: normalize(expression, table)
+		};
+	} catch (error) {
+		return {
+			supported: false,
+			reason: error instanceof UnsupportedPredicateError ? error.reason : "unsupported-syntax"
+		};
+	}
+}
+var Parser = class {
+	#tokens;
+	#position = 0;
+	constructor(tokens) {
+		this.#tokens = tokens;
+	}
+	parse() {
+		return this.#parseOr();
+	}
+	#parseOr() {
+		const expressions = [this.#parseAnd()];
+		while (this.#take("OR")) expressions.push(this.#parseAnd());
+		return expressions.length === 1 ? expressions[0] : {
+			type: "or",
+			expressions
+		};
+	}
+	#parseAnd() {
+		const expressions = [this.#parseNot()];
+		while (this.#take("AND")) expressions.push(this.#parseNot());
+		return expressions.length === 1 ? expressions[0] : {
+			type: "and",
+			expressions
+		};
+	}
+	#parseNot() {
+		if (this.#take("NOT")) return {
+			type: "not",
+			expression: this.#parseNot()
+		};
+		return this.#parseComparison();
+	}
+	#parseComparison() {
+		const left = this.#parseOperand();
+		if (this.#take("IS")) {
+			const not = this.#take("NOT");
+			const token = this.#tokens[this.#position++];
+			if (token?.type !== "literal" || token.literalType !== "null") throw new UnsupportedPredicateError("unsupported-operator");
+			return {
+				type: "null-test",
+				expression: left,
+				not
+			};
+		}
+		if (this.#take("IN")) {
+			this.expect("(");
+			const values = this.#parseOperandList(")");
+			this.expect(")");
+			return comparisons(left, values);
+		}
+		const op = this.#tokens[this.#position]?.type;
+		if (isComparison(op)) {
+			this.#position++;
+			if (op === "=" && this.#takeIdentifier("ANY")) return comparisons(left, this.#parseLiteralArray());
+			return {
+				type: "comparison",
+				left,
+				op,
+				right: this.#parseOperand()
+			};
+		}
+		const next = this.#tokens[this.#position];
+		if (next?.type === "identifier" && next.value.toUpperCase() === "COLLATE") throw new UnsupportedPredicateError("non-deterministic-collation");
+		if (next?.type === "unsupported" && UNSUPPORTED_OPERATOR_TOKEN_RE.test(next.value)) throw new UnsupportedPredicateError("unsupported-operator");
+		if (next?.type === "identifier" && unsupportedOperatorWords.has(next.value.toUpperCase())) throw new UnsupportedPredicateError("unsupported-operator");
+		return left;
+	}
+	#parseLiteralArray() {
+		this.expect("(");
+		this.#expectIdentifier("ARRAY");
+		this.expect("[");
+		const values = this.#parseOperandList("]");
+		this.expect("]");
+		if (this.#take("::")) {
+			this.#parseCastName();
+			this.expect("[");
+			this.expect("]");
+		}
+		this.expect(")");
+		return values;
+	}
+	#parseOperandList(end) {
+		const values = [];
+		if (this.#tokens[this.#position]?.type === end) return values;
+		values.push(this.#parseOperand());
+		while (this.#take(",")) values.push(this.#parseOperand());
+		return values;
+	}
+	#parseOperand() {
+		let expression = this.#parsePrimary();
+		while (this.#take("::")) expression = {
+			type: "cast",
+			expression,
+			cast: this.#parseCastName()
+		};
+		return expression;
+	}
+	#parsePrimary() {
+		if (this.#take("(")) {
+			const expression = this.#parseOr();
+			this.expect(")");
+			return expression;
+		}
+		const token = this.#tokens[this.#position++];
+		if (token?.type === "literal") return {
+			type: "literal",
+			value: token.value,
+			literalType: token.literalType
+		};
+		if (token?.type === "identifier") {
+			if (this.#tokens[this.#position]?.type === "(") throw new UnsupportedPredicateError("unsupported-function");
+			if (this.#tokens[this.#position]?.type === ".") throw new UnsupportedPredicateError("unsupported-syntax");
+			if (token.value.toUpperCase() === "COLLATE") throw new UnsupportedPredicateError("non-deterministic-collation");
+			return {
+				type: "column",
+				name: token.value
+			};
+		}
+		throw new UnsupportedPredicateError("unsupported-syntax");
+	}
+	#parseCastName() {
+		const first = this.#expectIdentifier();
+		const parts = [first];
+		let separator = ".";
+		while (this.#take(".")) parts.push(this.#expectIdentifier());
+		const next = this.#tokens[this.#position];
+		if (first.toLowerCase() === "character" && next?.type === "identifier" && next.value.toLowerCase() === "varying") {
+			parts.push(this.#expectIdentifier());
+			separator = " ";
+		}
+		if (this.#tokens[this.#position]?.type === "(") throw new UnsupportedPredicateError("unsupported-cast");
+		return parts.join(separator);
+	}
+	#expectIdentifier(expected) {
+		const token = this.#tokens[this.#position++];
+		if (token?.type !== "identifier" || expected !== void 0 && token.value.toUpperCase() !== expected) throw new UnsupportedPredicateError("unsupported-cast");
+		return token.value;
+	}
+	#takeIdentifier(expected) {
+		const token = this.#tokens[this.#position];
+		if (token?.type !== "identifier" || token.value.toUpperCase() !== expected) return false;
+		this.#position++;
+		return true;
+	}
+	#take(type) {
+		if (this.#tokens[this.#position]?.type !== type) return false;
+		this.#position++;
+		return true;
+	}
+	expect(type) {
+		if (!this.#take(type)) throw new UnsupportedPredicateError("unsupported-syntax");
+	}
+};
+var unsupportedOperatorWords = new Set([
+	"ALL",
+	"BETWEEN",
+	"ILIKE",
+	"LIKE",
+	"SIMILAR"
+]);
+function comparisons(left, values) {
+	if (values.length === 0) throw new UnsupportedPredicateError("unsupported-syntax");
+	const expressions = values.map((right) => ({
+		type: "comparison",
+		left,
+		op: "=",
+		right
+	}));
+	return expressions.length === 1 ? expressions[0] : {
+		type: "or",
+		expressions
+	};
+}
+function normalize(expression, table) {
+	switch (expression.type) {
+		case "and":
+		case "or": {
+			const conditions = expression.expressions.map((expr) => normalize(expr, table));
+			return {
+				type: expression.type,
+				conditions: conditions.flatMap((condition) => condition.type === expression.type ? condition.conditions : [condition])
+			};
+		}
+		case "not": {
+			const booleanColumn = resolveBareBooleanColumn(expression.expression, table);
+			if (booleanColumn) return booleanComparison(booleanColumn, false);
+			return {
+				type: "not",
+				condition: normalize(expression.expression, table)
+			};
+		}
+		case "column": {
+			const column = resolveColumn(expression, table);
+			if (column.category !== "boolean") throw new UnsupportedPredicateError("unsupported-type");
+			return booleanComparison(column.name, true);
+		}
+		case "cast": {
+			const column = resolveColumnOperand(expression, table);
+			if (column.category !== "boolean") throw new UnsupportedPredicateError("unsupported-type");
+			return booleanComparison(column.name, true);
+		}
+		case "null-test": return {
+			type: "null-test",
+			column: resolveNullTestColumn(expression.expression, table),
+			op: expression.not ? "IS NOT NULL" : "IS NULL"
+		};
+		case "comparison": return normalizeComparison(expression, table);
+		case "literal": throw new UnsupportedPredicateError("unsupported-syntax");
+	}
+}
+function resolveNullTestColumn(expression, table) {
+	if (expression.type === "cast") return resolveColumnOperand(expression, table).name;
+	if (expression.type === "column" && !table.columns[expression.name]) throw new UnsupportedPredicateError("unpublished-column");
+	if (expression.type === "column") return expression.name;
+	throw new UnsupportedPredicateError("unsupported-syntax");
+}
+function resolveBareBooleanColumn(expression, table) {
+	if (expression.type !== "column" && expression.type !== "cast") return;
+	const column = resolveColumnOperand(expression, table);
+	return column.category === "boolean" ? column.name : void 0;
+}
+function booleanComparison(column, value) {
+	return {
+		type: "comparison",
+		column,
+		op: "=",
+		value: {
+			type: "boolean",
+			value
+		}
+	};
+}
+function normalizeComparison(expression, table) {
+	const column = resolveColumnOperand(expression.left, table);
+	const op = expression.op === "!=" ? "<>" : expression.op;
+	if (column.category !== "integer" && op !== "=" && op !== "<>") throw new UnsupportedPredicateError("unsupported-operator");
+	const value = resolveLiteral(expression.right, column);
+	return {
+		type: "comparison",
+		column: column.name,
+		op,
+		value
+	};
+}
+function resolveColumnOperand(expression, table) {
+	if (expression.type === "column") return resolveColumn(expression, table);
+	if (expression.type !== "cast") throw new UnsupportedPredicateError("unsupported-syntax");
+	const column = resolveColumnOperand(expression.expression, table);
+	const cast = canonicalTypeName(expression.cast);
+	switch (column.category) {
+		case "integer": {
+			const rank = integerRank(cast);
+			if (rank === void 0 || rank < column.rank) throw new UnsupportedPredicateError("unsupported-cast");
+			return {
+				...column,
+				rank
+			};
+		}
+		case "text":
+			if (cast !== "text" && cast !== "varchar") throw new UnsupportedPredicateError("unsupported-cast");
+			return column;
+		case "boolean":
+			if (cast !== "bool") throw new UnsupportedPredicateError("unsupported-cast");
+			return column;
+		case "uuid":
+			if (cast !== "uuid") throw new UnsupportedPredicateError("unsupported-cast");
+			return column;
+		case "enum":
+			if (lastTypeName(expression.cast) !== column.enumName.toLowerCase()) throw new UnsupportedPredicateError("unsupported-cast");
+			return column;
+	}
+}
+function resolveColumn(expression, table) {
+	const spec = table.columns[expression.name];
+	if (!spec) throw new UnsupportedPredicateError("unpublished-column");
+	const dataType = canonicalTypeName(spec.dataType);
+	if (dataType === "bool") return {
+		category: "boolean",
+		name: expression.name
+	};
+	const rank = integerRank(dataType);
+	if (rank !== void 0) return {
+		category: "integer",
+		name: expression.name,
+		rank
+	};
+	if (dataType === "text" || dataType === "varchar") {
+		if (spec.collationIsDeterministic === false) throw new UnsupportedPredicateError("non-deterministic-collation");
+		return {
+			category: "text",
+			name: expression.name
+		};
+	}
+	if (dataType === "uuid") return {
+		category: "uuid",
+		name: expression.name
+	};
+	if (spec.pgTypeClass === "e") return {
+		category: "enum",
+		name: expression.name,
+		enumName: spec.dataType.toLowerCase()
+	};
+	throw new UnsupportedPredicateError("unsupported-type");
+}
+function resolveLiteral(expression, column) {
+	let literal = expression;
+	let cast;
+	while (literal.type === "cast") {
+		cast = literal.cast;
+		literal = literal.expression;
+	}
+	if (literal.type !== "literal" || literal.value === null) throw new UnsupportedPredicateError("unsupported-syntax");
+	switch (column.category) {
+		case "boolean":
+			validateLiteralCast(cast, new Set(["bool"]));
+			if (literal.literalType !== "boolean") throw new UnsupportedPredicateError("unsupported-type");
+			return {
+				type: "boolean",
+				value: literal.value
+			};
+		case "integer":
+			if (cast !== void 0) {
+				const castRank = integerRank(canonicalTypeName(cast));
+				if (castRank === void 0 || castRank > column.rank) throw new UnsupportedPredicateError("unsupported-cast");
+			}
+			if (literal.literalType !== "integer" && !(literal.literalType === "string" && cast !== void 0)) throw new UnsupportedPredicateError("unsupported-type");
+			return {
+				type: "integer",
+				value: canonicalInteger(String(literal.value), column.rank)
+			};
+		case "text":
+			validateLiteralCast(cast, new Set(["text", "varchar"]));
+			if (literal.literalType !== "string") throw new UnsupportedPredicateError("unsupported-type");
+			return {
+				type: "string",
+				value: String(literal.value)
+			};
+		case "enum":
+			if (cast !== void 0 && lastTypeName(cast) !== column.enumName.toLowerCase()) throw new UnsupportedPredicateError("unsupported-cast");
+			if (literal.literalType !== "string") throw new UnsupportedPredicateError("unsupported-type");
+			return {
+				type: "string",
+				value: String(literal.value)
+			};
+		case "uuid": {
+			validateLiteralCast(cast, new Set(["uuid"]));
+			const value = String(literal.value).toLowerCase();
+			if (literal.literalType !== "string" || !UUID_RE.test(value)) throw new UnsupportedPredicateError("unsupported-type");
+			return {
+				type: "string",
+				value
+			};
+		}
+	}
+}
+function validateLiteralCast(cast, allowed) {
+	if (cast !== void 0 && !allowed.has(canonicalTypeName(cast))) throw new UnsupportedPredicateError("unsupported-cast");
+}
+function canonicalInteger(value, rank) {
+	if (!INTEGER_RE.test(value)) throw new UnsupportedPredicateError("unsupported-type");
+	let integer;
+	try {
+		integer = BigInt(value);
+	} catch {
+		throw new UnsupportedPredicateError("unsupported-type");
+	}
+	const bounds = [
+		[-32768n, 32767n],
+		[-2147483648n, 2147483647n],
+		[-9223372036854775808n, 9223372036854775807n]
+	];
+	if (integer < bounds[rank][0] || integer > bounds[rank][1]) throw new UnsupportedPredicateError("unsupported-type");
+	return integer.toString();
+}
+function canonicalTypeName(type) {
+	const name = lastTypeName(type).replace(/\s+/g, " ");
+	switch (name) {
+		case "boolean": return "bool";
+		case "smallint": return "int2";
+		case "integer": return "int4";
+		case "bigint": return "int8";
+		case "character varying": return "varchar";
+		default: return name;
+	}
+}
+function lastTypeName(type) {
+	return type.split(".").at(-1)?.toLowerCase() ?? "";
+}
+function integerRank(type) {
+	switch (type) {
+		case "int2": return 0;
+		case "int4": return 1;
+		case "int8": return 2;
+		default: return;
+	}
+}
+function isComparison(type) {
+	return type === "=" || type === "<>" || type === "!=" || type === "<" || type === "<=" || type === ">" || type === ">=";
+}
+function tokenize(sql) {
+	const tokens = [];
+	for (let i = 0; i < sql.length;) {
+		const char = sql[i];
+		if (WHITESPACE_RE.test(char)) {
+			i++;
+			continue;
+		}
+		if (char === "\"") {
+			const result = readQuoted(sql, i, "\"", false);
+			tokens.push({
+				type: "identifier",
+				value: result.value
+			});
+			i = result.end;
+			continue;
+		}
+		const escapeString = (char === "E" || char === "e") && sql[i + 1] === "'";
+		if (char === "'" || escapeString) {
+			const result = readQuoted(sql, i + (escapeString ? 1 : 0), "'", escapeString);
+			tokens.push({
+				type: "literal",
+				literalType: "string",
+				value: result.value
+			});
+			i = result.end;
+			continue;
+		}
+		const operator = OPERATOR_TOKEN_RE.exec(sql.slice(i))?.[0];
+		if (operator) {
+			tokens.push({ type: operator });
+			i += operator.length;
+			continue;
+		}
+		const unsupportedOperator = UNSUPPORTED_OPERATOR_TOKEN_RE.exec(sql.slice(i))?.[0];
+		if (unsupportedOperator) {
+			tokens.push({
+				type: "unsupported",
+				value: unsupportedOperator
+			});
+			i += unsupportedOperator.length;
+			continue;
+		}
+		if (char === "(" || char === ")" || char === "[" || char === "]" || char === "," || char === ".") {
+			tokens.push({ type: char });
+			i++;
+			continue;
+		}
+		const integer = INTEGER_TOKEN_RE.exec(sql.slice(i))?.[0];
+		if (integer) {
+			tokens.push({
+				type: "literal",
+				literalType: "integer",
+				value: integer
+			});
+			i += integer.length;
+			continue;
+		}
+		const word = WORD_TOKEN_RE.exec(sql.slice(i))?.[0];
+		if (word) {
+			const keyword = word.toUpperCase();
+			if (unsupportedOperatorWords.has(keyword)) throw new UnsupportedPredicateError("unsupported-operator");
+			if (keyword === "TRUE" || keyword === "FALSE") tokens.push({
+				type: "literal",
+				literalType: "boolean",
+				value: keyword === "TRUE"
+			});
+			else if (keyword === "NULL") tokens.push({
+				type: "literal",
+				literalType: "null",
+				value: null
+			});
+			else if (keyword === "AND" || keyword === "OR" || keyword === "NOT" || keyword === "IN" || keyword === "IS") tokens.push({ type: keyword });
+			else tokens.push({
+				type: "identifier",
+				value: word.toLowerCase()
+			});
+			i += word.length;
+			continue;
+		}
+		tokens.push({
+			type: "unsupported",
+			value: char
+		});
+		i++;
+	}
+	tokens.push({ type: "EOF" });
+	return tokens;
+}
+function readQuoted(sql, start, quote, escapes) {
+	let value = "";
+	for (let i = start + 1; i < sql.length; i++) {
+		const char = sql[i];
+		if (char === quote) if (sql[i + 1] === quote) {
+			value += quote;
+			i++;
+		} else return {
+			value,
+			end: i + 1
+		};
+		else if (escapes && char === "\\") {
+			const escape = sql[++i];
+			if (escape === void 0) throw new UnsupportedPredicateError("unsupported-syntax");
+			if (escape === "x") {
+				const hex = readEscapeDigits(sql, i + 1, 2, 16, 1);
+				value += String.fromCharCode(hex.value);
+				i = hex.end - 1;
+			} else if (escape === "u" || escape === "U") {
+				const hex = readEscapeDigits(sql, i + 1, escape === "u" ? 4 : 8, 16);
+				try {
+					value += String.fromCodePoint(hex.value);
+				} catch {
+					throw new UnsupportedPredicateError("unsupported-syntax");
+				}
+				i = hex.end - 1;
+			} else if (escape >= "0" && escape <= "7") {
+				let octal = escape;
+				while (octal.length < 3 && sql[i + 1] !== void 0 && sql[i + 1] >= "0" && sql[i + 1] <= "7") octal += sql[++i];
+				value += String.fromCharCode(Number.parseInt(octal, 8));
+			} else if (escape === "\n") {} else if (escape === "\r" && sql[i + 1] === "\n") i++;
+			else value += SIMPLE_ESCAPES[escape] ?? escape;
+		} else value += char;
+	}
+	throw new UnsupportedPredicateError("unsupported-syntax");
+}
+function readEscapeDigits(sql, start, length, radix, minLength = length) {
+	let end = start;
+	while (end < start + length) {
+		const digit = sql[end];
+		if (digit === void 0 || !(digit >= "0" && digit <= "9" || digit.toLowerCase() >= "a" && digit.toLowerCase() <= "f")) break;
+		end++;
+	}
+	const digits = sql.slice(start, end);
+	if (digits.length < minLength) throw new UnsupportedPredicateError("unsupported-syntax");
+	return {
+		value: Number.parseInt(digits, radix),
+		end
+	};
+}
+//#endregion
+export { translatePostgresIndexPredicate };
+
+//# sourceMappingURL=index-predicate.js.map

package/out/zero-cache/src/services/change-source/pg/schema/index-predicate.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index-predicate.js","names":["#tokens","#parseOr","#parseAnd","#take","#parseNot","#parseComparison","#parseOperand","#position","#parseOperandList","#takeIdentifier","#parseLiteralArray","#expectIdentifier","#parseCastName","#parsePrimary"],"sources":["../../../../../../../../zero-cache/src/services/change-source/pg/schema/index-predicate.ts"],"sourcesContent":["import * as PostgresTypeClass from '../../../../db/postgres-type-class-enum.ts';\nimport type {\n  IndexPredicate,\n  IndexPredicateValue,\n  PublishedTableSpec,\n} from '../../../../db/specs.ts';\n\nconst UUID_RE =\n  /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/;\nconst INTEGER_RE = /^[+-]?\\d+$/;\nconst WHITESPACE_RE = /\\s/;\nconst OPERATOR_TOKEN_RE = /^(?:::|<>|!=|<=|>=|=|<|>)/;\nconst UNSUPPORTED_OPERATOR_TOKEN_RE = /^(?:!~\\*|!~|~\\*|~)/;\nconst INTEGER_TOKEN_RE = /^[+-]?\\d+/;\nconst WORD_TOKEN_RE = /^[A-Za-z_][A-Za-z0-9_$]*/;\nconst SIMPLE_ESCAPES: Readonly<Record<string, string>> = {\n  b: '\\b',\n  f: '\\f',\n  n: '\\n',\n  r: '\\r',\n  t: '\\t',\n  v: '\\v',\n};\n\nexport const unsupportedPredicateReasons = [\n  'unpublished-column',\n  'unsupported-type',\n  'unsupported-operator',\n  'unsupported-function',\n  'unsupported-cast',\n  'unsupported-syntax',\n  'non-deterministic-collation',\n] as const;\n\nexport type UnsupportedPredicateReason =\n  (typeof unsupportedPredicateReasons)[number];\n\nexport type PredicateTranslation =\n  | {readonly supported: true; readonly predicate: IndexPredicate}\n  | {readonly supported: false; readonly reason: UnsupportedPredicateReason};\n\ntype PredicateColumnSpec = PublishedTableSpec['columns'][string] & {\n  readonly collationIsDeterministic?: boolean | null | undefined;\n};\n\ntype PredicateTableSpec = Omit<PublishedTableSpec, 'columns'> & {\n  readonly columns: Readonly<Record<string, PredicateColumnSpec>>;\n};\n\ntype Expr =\n  | {readonly type: 'column'; readonly name: string}\n  | {\n      readonly type: 'literal';\n      readonly value: boolean | string | null;\n      readonly literalType: 'boolean' | 'integer' | 'string' | 'null';\n    }\n  | {readonly type: 'cast'; readonly expression: Expr; readonly cast: string}\n  | {readonly type: 'not'; readonly expression: Expr}\n  | {\n      readonly type: 'and' | 'or';\n      readonly expressions: readonly Expr[];\n    }\n  | {\n      readonly type: 'comparison';\n      readonly left: Expr;\n      readonly op: '=' | '<>' | '!=' | '<' | '<=' | '>' | '>=';\n      readonly right: Expr;\n    }\n  | {\n      readonly type: 'null-test';\n      readonly expression: Expr;\n      readonly not: boolean;\n    };\n\ntype Token =\n  | {readonly type: 'identifier'; readonly value: string}\n  | {\n      readonly type: 'literal';\n      readonly value: boolean | string | null;\n      readonly literalType: 'boolean' | 'integer' | 'string' | 'null';\n    }\n  | {\n      readonly type:\n        | '('\n        | ')'\n        | '['\n        | ']'\n        | ','\n        | '.'\n        | '::'\n        | '='\n        | '<>'\n        | '!='\n        | '<'\n        | '<='\n        | '>'\n        | '>='\n        | 'AND'\n        | 'OR'\n        | 'NOT'\n        | 'IN'\n        | 'IS'\n        | 'EOF';\n    }\n  | {readonly type: 'unsupported'; readonly value: string};\n\nclass UnsupportedPredicateError extends Error {\n  readonly reason: UnsupportedPredicateReason;\n\n  constructor(reason: UnsupportedPredicateReason) {\n    super(reason);\n    this.reason = reason;\n  }\n}\n\nexport function translatePostgresIndexPredicate(\n  sql: string,\n  table: PredicateTableSpec,\n): PredicateTranslation {\n  try {\n    const parser = new Parser(tokenize(sql));\n    const expression = parser.parse();\n    parser.expect('EOF');\n    return {supported: true, predicate: normalize(expression, table)};\n  } catch (error) {\n    return {\n      supported: false,\n      reason:\n        error instanceof UnsupportedPredicateError\n          ? error.reason\n          : 'unsupported-syntax',\n    };\n  }\n}\n\nclass Parser {\n  readonly #tokens: readonly Token[];\n  #position = 0;\n\n  constructor(tokens: readonly Token[]) {\n    this.#tokens = tokens;\n  }\n\n  parse(): Expr {\n    return this.#parseOr();\n  }\n\n  #parseOr(): Expr {\n    const expressions = [this.#parseAnd()];\n    while (this.#take('OR')) expressions.push(this.#parseAnd());\n    return expressions.length === 1\n      ? expressions[0]\n      : {type: 'or', expressions};\n  }\n\n  #parseAnd(): Expr {\n    const expressions = [this.#parseNot()];\n    while (this.#take('AND')) expressions.push(this.#parseNot());\n    return expressions.length === 1\n      ? expressions[0]\n      : {type: 'and', expressions};\n  }\n\n  #parseNot(): Expr {\n    if (this.#take('NOT')) {\n      return {type: 'not', expression: this.#parseNot()};\n    }\n    return this.#parseComparison();\n  }\n\n  #parseComparison(): Expr {\n    const left = this.#parseOperand();\n    if (this.#take('IS')) {\n      const not = this.#take('NOT');\n      const token = this.#tokens[this.#position++];\n      if (token?.type !== 'literal' || token.literalType !== 'null') {\n        throw new UnsupportedPredicateError('unsupported-operator');\n      }\n      return {type: 'null-test', expression: left, not};\n    }\n    if (this.#take('IN')) {\n      this.expect('(');\n      const values = this.#parseOperandList(')');\n      this.expect(')');\n      return comparisons(left, values);\n    }\n    const op = this.#tokens[this.#position]?.type;\n    if (isComparison(op)) {\n      this.#position++;\n      if (op === '=' && this.#takeIdentifier('ANY')) {\n        return comparisons(left, this.#parseLiteralArray());\n      }\n      return {\n        type: 'comparison',\n        left,\n        op,\n        right: this.#parseOperand(),\n      };\n    }\n    const next = this.#tokens[this.#position];\n    if (next?.type === 'identifier' && next.value.toUpperCase() === 'COLLATE') {\n      throw new UnsupportedPredicateError('non-deterministic-collation');\n    }\n    if (\n      next?.type === 'unsupported' &&\n      UNSUPPORTED_OPERATOR_TOKEN_RE.test(next.value)\n    ) {\n      throw new UnsupportedPredicateError('unsupported-operator');\n    }\n    if (\n      next?.type === 'identifier' &&\n      unsupportedOperatorWords.has(next.value.toUpperCase())\n    ) {\n      throw new UnsupportedPredicateError('unsupported-operator');\n    }\n    return left;\n  }\n\n  #parseLiteralArray(): readonly Expr[] {\n    this.expect('(');\n    this.#expectIdentifier('ARRAY');\n    this.expect('[');\n    const values = this.#parseOperandList(']');\n    this.expect(']');\n    if (this.#take('::')) {\n      this.#parseCastName();\n      this.expect('[');\n      this.expect(']');\n    }\n    this.expect(')');\n    return values;\n  }\n\n  #parseOperandList(end: ')' | ']'): readonly Expr[] {\n    const values: Expr[] = [];\n    if (this.#tokens[this.#position]?.type === end) return values;\n    values.push(this.#parseOperand());\n    while (this.#take(',')) values.push(this.#parseOperand());\n    return values;\n  }\n\n  #parseOperand(): Expr {\n    let expression = this.#parsePrimary();\n    while (this.#take('::')) {\n      expression = {\n        type: 'cast',\n        expression,\n        cast: this.#parseCastName(),\n      };\n    }\n    return expression;\n  }\n\n  #parsePrimary(): Expr {\n    if (this.#take('(')) {\n      const expression = this.#parseOr();\n      this.expect(')');\n      return expression;\n    }\n    const token = this.#tokens[this.#position++];\n    if (token?.type === 'literal') {\n      return {\n        type: 'literal',\n        value: token.value,\n        literalType: token.literalType,\n      };\n    }\n    if (token?.type === 'identifier') {\n      if (this.#tokens[this.#position]?.type === '(') {\n        throw new UnsupportedPredicateError('unsupported-function');\n      }\n      if (this.#tokens[this.#position]?.type === '.') {\n        throw new UnsupportedPredicateError('unsupported-syntax');\n      }\n      if (token.value.toUpperCase() === 'COLLATE') {\n        throw new UnsupportedPredicateError('non-deterministic-collation');\n      }\n      return {type: 'column', name: token.value};\n    }\n    throw new UnsupportedPredicateError('unsupported-syntax');\n  }\n\n  #parseCastName(): string {\n    const first = this.#expectIdentifier();\n    const parts = [first];\n    let separator = '.';\n    while (this.#take('.')) parts.push(this.#expectIdentifier());\n    const next = this.#tokens[this.#position];\n    if (\n      first.toLowerCase() === 'character' &&\n      next?.type === 'identifier' &&\n      next.value.toLowerCase() === 'varying'\n    ) {\n      parts.push(this.#expectIdentifier());\n      separator = ' ';\n    }\n    if (this.#tokens[this.#position]?.type === '(') {\n      throw new UnsupportedPredicateError('unsupported-cast');\n    }\n    return parts.join(separator);\n  }\n\n  #expectIdentifier(expected?: string): string {\n    const token = this.#tokens[this.#position++];\n    if (\n      token?.type !== 'identifier' ||\n      (expected !== undefined && token.value.toUpperCase() !== expected)\n    ) {\n      throw new UnsupportedPredicateError('unsupported-cast');\n    }\n    return token.value;\n  }\n\n  #takeIdentifier(expected: string): boolean {\n    const token = this.#tokens[this.#position];\n    if (\n      token?.type !== 'identifier' ||\n      token.value.toUpperCase() !== expected\n    ) {\n      return false;\n    }\n    this.#position++;\n    return true;\n  }\n\n  #take(type: Token['type']): boolean {\n    if (this.#tokens[this.#position]?.type !== type) return false;\n    this.#position++;\n    return true;\n  }\n\n  expect(type: Token['type']): void {\n    if (!this.#take(type)) {\n      throw new UnsupportedPredicateError('unsupported-syntax');\n    }\n  }\n}\n\nconst unsupportedOperatorWords = new Set([\n  'ALL',\n  'BETWEEN',\n  'ILIKE',\n  'LIKE',\n  'SIMILAR',\n]);\n\nfunction comparisons(left: Expr, values: readonly Expr[]): Expr {\n  if (values.length === 0) {\n    throw new UnsupportedPredicateError('unsupported-syntax');\n  }\n  const expressions = values.map(\n    right => ({type: 'comparison', left, op: '=', right}) as const,\n  );\n  return expressions.length === 1 ? expressions[0] : {type: 'or', expressions};\n}\n\nfunction normalize(\n  expression: Expr,\n  table: PredicateTableSpec,\n): IndexPredicate {\n  switch (expression.type) {\n    case 'and':\n    case 'or': {\n      const conditions = expression.expressions.map(expr =>\n        normalize(expr, table),\n      );\n      return {\n        type: expression.type,\n        conditions: conditions.flatMap(condition =>\n          condition.type === expression.type\n            ? condition.conditions\n            : [condition],\n        ),\n      };\n    }\n    case 'not': {\n      const booleanColumn = resolveBareBooleanColumn(\n        expression.expression,\n        table,\n      );\n      if (booleanColumn) {\n        return booleanComparison(booleanColumn, false);\n      }\n      return {type: 'not', condition: normalize(expression.expression, table)};\n    }\n    case 'column': {\n      const column = resolveColumn(expression, table);\n      if (column.category !== 'boolean') {\n        throw new UnsupportedPredicateError('unsupported-type');\n      }\n      return booleanComparison(column.name, true);\n    }\n    case 'cast': {\n      const column = resolveColumnOperand(expression, table);\n      if (column.category !== 'boolean') {\n        throw new UnsupportedPredicateError('unsupported-type');\n      }\n      return booleanComparison(column.name, true);\n    }\n    case 'null-test': {\n      const column = resolveNullTestColumn(expression.expression, table);\n      return {\n        type: 'null-test',\n        column,\n        op: expression.not ? 'IS NOT NULL' : 'IS NULL',\n      };\n    }\n    case 'comparison':\n      return normalizeComparison(expression, table);\n    case 'literal':\n      throw new UnsupportedPredicateError('unsupported-syntax');\n  }\n}\n\nfunction resolveNullTestColumn(\n  expression: Expr,\n  table: PredicateTableSpec,\n): string {\n  if (expression.type === 'cast') {\n    return resolveColumnOperand(expression, table).name;\n  }\n  if (expression.type === 'column' && !table.columns[expression.name]) {\n    throw new UnsupportedPredicateError('unpublished-column');\n  }\n  if (expression.type === 'column') return expression.name;\n  throw new UnsupportedPredicateError('unsupported-syntax');\n}\n\nfunction resolveBareBooleanColumn(\n  expression: Expr,\n  table: PredicateTableSpec,\n): string | undefined {\n  if (expression.type !== 'column' && expression.type !== 'cast') {\n    return undefined;\n  }\n  const column = resolveColumnOperand(expression, table);\n  return column.category === 'boolean' ? column.name : undefined;\n}\n\nfunction booleanComparison(column: string, value: boolean): IndexPredicate {\n  return {\n    type: 'comparison',\n    column,\n    op: '=',\n    value: {type: 'boolean', value},\n  };\n}\n\ntype ColumnCategory =\n  | {readonly category: 'boolean'; readonly name: string}\n  | {\n      readonly category: 'integer';\n      readonly name: string;\n      readonly rank: 0 | 1 | 2;\n    }\n  | {readonly category: 'text'; readonly name: string}\n  | {\n      readonly category: 'enum';\n      readonly name: string;\n      readonly enumName: string;\n    }\n  | {readonly category: 'uuid'; readonly name: string};\n\nfunction normalizeComparison(\n  expression: Extract<Expr, {type: 'comparison'}>,\n  table: PredicateTableSpec,\n): IndexPredicate {\n  const column = resolveColumnOperand(expression.left, table);\n  const op = expression.op === '!=' ? '<>' : expression.op;\n  if (column.category !== 'integer' && op !== '=' && op !== '<>') {\n    throw new UnsupportedPredicateError('unsupported-operator');\n  }\n  const value = resolveLiteral(expression.right, column);\n  return {type: 'comparison', column: column.name, op, value};\n}\n\nfunction resolveColumnOperand(\n  expression: Expr,\n  table: PredicateTableSpec,\n): ColumnCategory {\n  if (expression.type === 'column') return resolveColumn(expression, table);\n  if (expression.type !== 'cast') {\n    throw new UnsupportedPredicateError('unsupported-syntax');\n  }\n  const column = resolveColumnOperand(expression.expression, table);\n  const cast = canonicalTypeName(expression.cast);\n  switch (column.category) {\n    case 'integer': {\n      const rank = integerRank(cast);\n      if (rank === undefined || rank < column.rank) {\n        throw new UnsupportedPredicateError('unsupported-cast');\n      }\n      return {...column, rank};\n    }\n    case 'text':\n      if (cast !== 'text' && cast !== 'varchar') {\n        throw new UnsupportedPredicateError('unsupported-cast');\n      }\n      return column;\n    case 'boolean':\n      if (cast !== 'bool') {\n        throw new UnsupportedPredicateError('unsupported-cast');\n      }\n      return column;\n    case 'uuid':\n      if (cast !== 'uuid') {\n        throw new UnsupportedPredicateError('unsupported-cast');\n      }\n      return column;\n    case 'enum':\n      if (lastTypeName(expression.cast) !== column.enumName.toLowerCase()) {\n        throw new UnsupportedPredicateError('unsupported-cast');\n      }\n      return column;\n  }\n}\n\nfunction resolveColumn(\n  expression: Extract<Expr, {type: 'column'}>,\n  table: PredicateTableSpec,\n): ColumnCategory {\n  const spec = table.columns[expression.name];\n  if (!spec) throw new UnsupportedPredicateError('unpublished-column');\n  const dataType = canonicalTypeName(spec.dataType);\n  if (dataType === 'bool') return {category: 'boolean', name: expression.name};\n  const rank = integerRank(dataType);\n  if (rank !== undefined) {\n    return {category: 'integer', name: expression.name, rank};\n  }\n  if (dataType === 'text' || dataType === 'varchar') {\n    if (spec.collationIsDeterministic === false) {\n      throw new UnsupportedPredicateError('non-deterministic-collation');\n    }\n    return {category: 'text', name: expression.name};\n  }\n  if (dataType === 'uuid') return {category: 'uuid', name: expression.name};\n  if (spec.pgTypeClass === PostgresTypeClass.Enum) {\n    return {\n      category: 'enum',\n      name: expression.name,\n      enumName: spec.dataType.toLowerCase(),\n    };\n  }\n  throw new UnsupportedPredicateError('unsupported-type');\n}\n\nfunction resolveLiteral(\n  expression: Expr,\n  column: ColumnCategory,\n): IndexPredicateValue {\n  let literal = expression;\n  let cast: string | undefined;\n  while (literal.type === 'cast') {\n    cast = literal.cast;\n    literal = literal.expression;\n  }\n  if (literal.type !== 'literal' || literal.value === null) {\n    throw new UnsupportedPredicateError('unsupported-syntax');\n  }\n\n  switch (column.category) {\n    case 'boolean': {\n      validateLiteralCast(cast, new Set(['bool']));\n      if (literal.literalType !== 'boolean') {\n        throw new UnsupportedPredicateError('unsupported-type');\n      }\n      return {type: 'boolean', value: literal.value as boolean};\n    }\n    case 'integer': {\n      if (cast !== undefined) {\n        const castRank = integerRank(canonicalTypeName(cast));\n        if (castRank === undefined || castRank > column.rank) {\n          throw new UnsupportedPredicateError('unsupported-cast');\n        }\n      }\n      if (\n        literal.literalType !== 'integer' &&\n        !(literal.literalType === 'string' && cast !== undefined)\n      ) {\n        throw new UnsupportedPredicateError('unsupported-type');\n      }\n      return {\n        type: 'integer',\n        value: canonicalInteger(String(literal.value), column.rank),\n      };\n    }\n    case 'text':\n      validateLiteralCast(cast, new Set(['text', 'varchar']));\n      if (literal.literalType !== 'string') {\n        throw new UnsupportedPredicateError('unsupported-type');\n      }\n      return {type: 'string', value: String(literal.value)};\n    case 'enum':\n      if (\n        cast !== undefined &&\n        lastTypeName(cast) !== column.enumName.toLowerCase()\n      ) {\n        throw new UnsupportedPredicateError('unsupported-cast');\n      }\n      if (literal.literalType !== 'string') {\n        throw new UnsupportedPredicateError('unsupported-type');\n      }\n      return {type: 'string', value: String(literal.value)};\n    case 'uuid': {\n      validateLiteralCast(cast, new Set(['uuid']));\n      const value = String(literal.value).toLowerCase();\n      if (literal.literalType !== 'string' || !UUID_RE.test(value)) {\n        throw new UnsupportedPredicateError('unsupported-type');\n      }\n      return {type: 'string', value};\n    }\n  }\n}\n\nfunction validateLiteralCast(\n  cast: string | undefined,\n  allowed: ReadonlySet<string>,\n): void {\n  if (cast !== undefined && !allowed.has(canonicalTypeName(cast))) {\n    throw new UnsupportedPredicateError('unsupported-cast');\n  }\n}\n\nfunction canonicalInteger(value: string, rank: 0 | 1 | 2): string {\n  if (!INTEGER_RE.test(value)) {\n    throw new UnsupportedPredicateError('unsupported-type');\n  }\n  let integer: bigint;\n  try {\n    integer = BigInt(value);\n  } catch {\n    throw new UnsupportedPredicateError('unsupported-type');\n  }\n  const bounds = [\n    [-32768n, 32767n],\n    [-2147483648n, 2147483647n],\n    [-9223372036854775808n, 9223372036854775807n],\n  ] as const;\n  if (integer < bounds[rank][0] || integer > bounds[rank][1]) {\n    throw new UnsupportedPredicateError('unsupported-type');\n  }\n  return integer.toString();\n}\n\nfunction canonicalTypeName(type: string): string {\n  const name = lastTypeName(type).replace(/\\s+/g, ' ');\n  switch (name) {\n    case 'boolean':\n      return 'bool';\n    case 'smallint':\n      return 'int2';\n    case 'integer':\n      return 'int4';\n    case 'bigint':\n      return 'int8';\n    case 'character varying':\n      return 'varchar';\n    default:\n      return name;\n  }\n}\n\nfunction lastTypeName(type: string): string {\n  return type.split('.').at(-1)?.toLowerCase() ?? '';\n}\n\nfunction integerRank(type: string): 0 | 1 | 2 | undefined {\n  switch (type) {\n    case 'int2':\n      return 0;\n    case 'int4':\n      return 1;\n    case 'int8':\n      return 2;\n    default:\n      return undefined;\n  }\n}\n\nfunction isComparison(\n  type: Token['type'] | undefined,\n): type is '=' | '<>' | '!=' | '<' | '<=' | '>' | '>=' {\n  return (\n    type === '=' ||\n    type === '<>' ||\n    type === '!=' ||\n    type === '<' ||\n    type === '<=' ||\n    type === '>' ||\n    type === '>='\n  );\n}\n\nfunction tokenize(sql: string): readonly Token[] {\n  const tokens: Token[] = [];\n  for (let i = 0; i < sql.length; ) {\n    const char = sql[i];\n    if (WHITESPACE_RE.test(char)) {\n      i++;\n      continue;\n    }\n    if (char === '\"') {\n      const result = readQuoted(sql, i, '\"', false);\n      tokens.push({type: 'identifier', value: result.value});\n      i = result.end;\n      continue;\n    }\n    const escapeString = (char === 'E' || char === 'e') && sql[i + 1] === \"'\";\n    if (char === \"'\" || escapeString) {\n      const result = readQuoted(\n        sql,\n        i + (escapeString ? 1 : 0),\n        \"'\",\n        escapeString,\n      );\n      tokens.push({\n        type: 'literal',\n        literalType: 'string',\n        value: result.value,\n      });\n      i = result.end;\n      continue;\n    }\n    const operator = OPERATOR_TOKEN_RE.exec(sql.slice(i))?.[0];\n    if (operator) {\n      tokens.push({\n        type: operator as '::' | '=' | '<>' | '!=' | '<' | '<=' | '>' | '>=',\n      });\n      i += operator.length;\n      continue;\n    }\n    const unsupportedOperator = UNSUPPORTED_OPERATOR_TOKEN_RE.exec(\n      sql.slice(i),\n    )?.[0];\n    if (unsupportedOperator) {\n      tokens.push({type: 'unsupported', value: unsupportedOperator});\n      i += unsupportedOperator.length;\n      continue;\n    }\n    if (\n      char === '(' ||\n      char === ')' ||\n      char === '[' ||\n      char === ']' ||\n      char === ',' ||\n      char === '.'\n    ) {\n      tokens.push({type: char});\n      i++;\n      continue;\n    }\n    const integer = INTEGER_TOKEN_RE.exec(sql.slice(i))?.[0];\n    if (integer) {\n      tokens.push({type: 'literal', literalType: 'integer', value: integer});\n      i += integer.length;\n      continue;\n    }\n    const word = WORD_TOKEN_RE.exec(sql.slice(i))?.[0];\n    if (word) {\n      const keyword = word.toUpperCase();\n      if (unsupportedOperatorWords.has(keyword)) {\n        throw new UnsupportedPredicateError('unsupported-operator');\n      }\n      if (keyword === 'TRUE' || keyword === 'FALSE') {\n        tokens.push({\n          type: 'literal',\n          literalType: 'boolean',\n          value: keyword === 'TRUE',\n        });\n      } else if (keyword === 'NULL') {\n        tokens.push({type: 'literal', literalType: 'null', value: null});\n      } else if (\n        keyword === 'AND' ||\n        keyword === 'OR' ||\n        keyword === 'NOT' ||\n        keyword === 'IN' ||\n        keyword === 'IS'\n      ) {\n        tokens.push({type: keyword});\n      } else {\n        tokens.push({type: 'identifier', value: word.toLowerCase()});\n      }\n      i += word.length;\n      continue;\n    }\n    tokens.push({type: 'unsupported', value: char});\n    i++;\n  }\n  tokens.push({type: 'EOF'});\n  return tokens;\n}\n\nfunction readQuoted(\n  sql: string,\n  start: number,\n  quote: '\"' | \"'\",\n  escapes: boolean,\n): {readonly value: string; readonly end: number} {\n  let value = '';\n  for (let i = start + 1; i < sql.length; i++) {\n    const char = sql[i];\n    if (char === quote) {\n      if (sql[i + 1] === quote) {\n        value += quote;\n        i++;\n      } else {\n        return {value, end: i + 1};\n      }\n    } else if (escapes && char === '\\\\') {\n      const escape = sql[++i];\n      if (escape === undefined) {\n        throw new UnsupportedPredicateError('unsupported-syntax');\n      }\n      if (escape === 'x') {\n        const hex = readEscapeDigits(sql, i + 1, 2, 16, 1);\n        value += String.fromCharCode(hex.value);\n        i = hex.end - 1;\n      } else if (escape === 'u' || escape === 'U') {\n        const hex = readEscapeDigits(sql, i + 1, escape === 'u' ? 4 : 8, 16);\n        try {\n          value += String.fromCodePoint(hex.value);\n        } catch {\n          throw new UnsupportedPredicateError('unsupported-syntax');\n        }\n        i = hex.end - 1;\n      } else if (escape >= '0' && escape <= '7') {\n        let octal = escape;\n        while (\n          octal.length < 3 &&\n          sql[i + 1] !== undefined &&\n          sql[i + 1] >= '0' &&\n          sql[i + 1] <= '7'\n        ) {\n          octal += sql[++i];\n        }\n        value += String.fromCharCode(Number.parseInt(octal, 8));\n      } else if (escape === '\\n') {\n        // A backslash-newline pair is a line continuation.\n      } else if (escape === '\\r' && sql[i + 1] === '\\n') {\n        i++;\n      } else {\n        value += SIMPLE_ESCAPES[escape] ?? escape;\n      }\n    } else {\n      value += char;\n    }\n  }\n  throw new UnsupportedPredicateError('unsupported-syntax');\n}\n\nfunction readEscapeDigits(\n  sql: string,\n  start: number,\n  length: number,\n  radix: 16,\n  minLength = length,\n): {readonly value: number; readonly end: number} {\n  let end = start;\n  while (end < start + length) {\n    const digit = sql[end];\n    if (\n      digit === undefined ||\n      !(\n        (digit >= '0' && digit <= '9') ||\n        (digit.toLowerCase() >= 'a' && digit.toLowerCase() <= 'f')\n      )\n    ) {\n      break;\n    }\n    end++;\n  }\n  const digits = sql.slice(start, end);\n  if (digits.length < minLength) {\n    throw new UnsupportedPredicateError('unsupported-syntax');\n  }\n  return {value: Number.parseInt(digits, radix), end};\n}\n"],"mappings":"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"}

package/out/zero-cache/src/services/change-source/pg/schema/init.d.ts

@@ -4,6 +4,6 @@ import { type ShardConfig } from '../../../../types/shards.ts';
 /**
  * Ensures that a shard is set up for initial sync.
  */
-export declare function ensureShardSchema(lc: LogContext, db: PostgresDB, shard: ShardConfig): Promise<void>;
+export declare function ensureShardSchema(lc: LogContext, db: PostgresDB, shard: ShardConfig, installPartialIndexTriggers?: boolean): Promise<void>;
 export declare const CURRENT_SCHEMA_VERSION: number;
 //# sourceMappingURL=init.d.ts.map