autotel-devtools 21.0.1 → 23.0.0

package/dist/parse-BRlosZft.cjs

@@ -0,0 +1,642 @@
+
+//#region src/query/compile.ts
+/** The escape character for LIKE patterns; also escaped within them. */
+const LIKE_ESCAPE = "\\";
+function compileWhere(node, schema) {
+	const params = [];
+	return {
+		sql: emit(node, schema, params),
+		params
+	};
+}
+function emit(node, schema, params) {
+	switch (node.type) {
+		case "all": return "1";
+		case "and":
+		case "or": {
+			const left = emit(node.left, schema, params);
+			const right = emit(node.right, schema, params);
+			return `(${left} ${node.type === "and" ? "AND" : "OR"} ${right})`;
+		}
+		case "freeText": {
+			const pattern = likePattern(node.text, "contains");
+			const clauses = schema.freeTextColumns.map((field) => {
+				params.push(pattern);
+				return `${targetSql(field, schema, params, { pathAlreadyPushed: false })} LIKE ? ESCAPE '${LIKE_ESCAPE}'`;
+			});
+			if (clauses.length === 0) return "1";
+			if (clauses.length === 1) return clauses[0];
+			return `(${clauses.join(" OR ")})`;
+		}
+		case "comparison": return emitComparison(node.field, node.op, node.value, schema, params);
+	}
+}
+/**
+* SQL for the left-hand side of a comparison.
+*
+* A known field becomes a quoted column identifier taken from the schema. An
+* unknown one becomes `json_extract(<attrs>, ?)` with the JSON path bound as a
+* parameter — so an arbitrary attribute key is queryable without ever being
+* concatenated into SQL.
+*
+* The parameter ordering is fiddly and deliberate: the path parameter must be
+* pushed *before* the value parameter, because it appears earlier in the
+* emitted SQL.
+*/
+function targetSql(field, schema, params, opts) {
+	const known = schema.columns[field];
+	if (known) return quoteIdent(known.column);
+	if (!opts.pathAlreadyPushed) params.push(jsonPath(field));
+	return `json_extract(${quoteIdent(schema.attributesColumn)}, ?)`;
+}
+function emitComparison(field, op, value, schema, params) {
+	const related = schema.related?.[field];
+	if (related) {
+		const predicate = applyOperator(`rel.${quoteIdent(related.column)}`, op, value, params);
+		return `EXISTS (SELECT 1 FROM ${quoteIdent(related.table)} rel WHERE ${related.joinSql} AND ${predicate})`;
+	}
+	const isAttribute = !schema.columns[field];
+	if (isAttribute && op === "=" && value.type !== "null" && schema.attributeIndex) {
+		params.push(schema.attributeIndex.signal, field, JSON.stringify(jsonScalar(value)));
+		return `EXISTS (SELECT 1 FROM ${quoteIdent(schema.attributeIndex.table)} ai WHERE ai.signal = ? AND ai.entity_id = ${schema.attributeIndex.entitySql} AND ai.key = ? AND ai.value_json = ?)`;
+	}
+	if (isAttribute) params.push(jsonPath(field));
+	return applyOperator(targetSql(field, schema, params, { pathAlreadyPushed: isAttribute }), op, value, params);
+}
+/**
+* The operator half of a comparison, against an already-built target
+* expression. Split out so a child-table field can reuse it inside an EXISTS.
+*/
+function applyOperator(target, op, value, params) {
+	if (value.type === "null") {
+		if (op === "=") return `${target} IS NULL`;
+		if (op === "!=") return `${target} IS NOT NULL`;
+	}
+	switch (op) {
+		case "=":
+		case "!=":
+		case ">":
+		case "<":
+		case ">=":
+		case "<=":
+			params.push(scalar(value));
+			return `${target} ${op} ?`;
+		case "CONTAINS":
+		case "NOT CONTAINS":
+		case "^":
+		case "$": {
+			const mode = op === "^" ? "prefix" : op === "$" ? "suffix" : "contains";
+			params.push(likePattern(String(scalar(value) ?? ""), mode));
+			return `${target} ${op === "NOT CONTAINS" ? "NOT LIKE" : "LIKE"} ? ESCAPE '${LIKE_ESCAPE}'`;
+		}
+		case "REGEXP":
+		case "NOT REGEXP":
+			params.push(String(scalar(value) ?? ""));
+			return `${target} ${op} ?`;
+		case "IN":
+		case "NOT IN": {
+			const elements = value.type === "array" ? value.values : [value];
+			if (elements.length === 0) return op === "IN" ? "0" : "1";
+			for (const element of elements) params.push(scalar(element));
+			return `${target} ${op} (${elements.map(() => "?").join(", ")})`;
+		}
+	}
+}
+function jsonScalar(value) {
+	if (value.type === "array") return value.values.map(jsonScalar);
+	if (value.type === "null") return null;
+	if (value.type === "boolean") return value.value;
+	return value.value;
+}
+/** The bindable value for a scalar node. Arrays never reach here. */
+function scalar(value) {
+	switch (value.type) {
+		case "string": return value.value;
+		case "number": return value.value;
+		case "boolean": return value.value ? 1 : 0;
+		case "null": return null;
+		case "array": return JSON.stringify(value.values);
+	}
+}
+/**
+* A JSON path for an attribute key.
+*
+* The key is wrapped in double quotes so dots inside it (`http.status_code`)
+* are one key rather than a nested path, and embedded quotes and backslashes
+* are escaped so the path itself stays well-formed. This string is *bound as a
+* parameter*, never concatenated into SQL — the escaping here protects the JSON
+* path grammar, not the SQL.
+*/
+function jsonPath(key) {
+	return `$."${key.replace(/\\/g, "\\\\").replace(/"/g, "\\\"")}"`;
+}
+/**
+* Build a LIKE pattern, escaping the wildcards LIKE would otherwise honour.
+*
+* Someone searching for `100%` or `user_id` means those characters literally;
+* without escaping, `%` matches anything and `_` matches any single character,
+* and the search quietly returns far too much.
+*/
+function likePattern(text, mode) {
+	const escaped = text.replace(/\\/g, `${LIKE_ESCAPE}\\`).replace(/%/g, `${LIKE_ESCAPE}%`).replace(/_/g, `${LIKE_ESCAPE}_`);
+	if (mode === "prefix") return `${escaped}%`;
+	if (mode === "suffix") return `%${escaped}`;
+	return `%${escaped}%`;
+}
+/**
+* Quote a SQL identifier.
+*
+* Identifiers only ever come from a `SignalSchema` the caller authored, so this
+* is defence in depth rather than the primary control — but a schema built from
+* config one day should not become an injection vector.
+*/
+function quoteIdent(name) {
+	return `"${name.replace(/"/g, "\"\"")}"`;
+}
+
+//#endregion
+//#region src/query/ast.ts
+/**
+* Every operator the language accepts.
+*
+* Sigils and keywords are two spellings of one set — `=~` and `REGEXP` produce
+* the same node — so downstream code branches on one canonical value.
+*/
+const OPERATORS = {
+	"=": {
+		label: "equals",
+		kind: "comparison"
+	},
+	"!=": {
+		label: "does not equal",
+		kind: "comparison"
+	},
+	">": {
+		label: "greater than",
+		kind: "ordered"
+	},
+	"<": {
+		label: "less than",
+		kind: "ordered"
+	},
+	">=": {
+		label: "greater than or equal",
+		kind: "ordered"
+	},
+	"<=": {
+		label: "less than or equal",
+		kind: "ordered"
+	},
+	"^": {
+		label: "starts with",
+		kind: "text"
+	},
+	$: {
+		label: "ends with",
+		kind: "text"
+	},
+	CONTAINS: {
+		label: "contains",
+		kind: "text"
+	},
+	"NOT CONTAINS": {
+		label: "does not contain",
+		kind: "text"
+	},
+	REGEXP: {
+		label: "matches regex",
+		kind: "text"
+	},
+	"NOT REGEXP": {
+		label: "does not match regex",
+		kind: "text"
+	},
+	IN: {
+		label: "is one of",
+		kind: "set"
+	},
+	"NOT IN": {
+		label: "is not one of",
+		kind: "set"
+	}
+};
+/** Sigil spellings that map onto a keyword operator. */
+const SIGIL_ALIASES = {
+	"=~": "REGEXP",
+	"!~": "NOT REGEXP"
+};
+
+//#endregion
+//#region src/query/tokenize.ts
+/**
+* Characters a bare word may contain.
+*
+* Deliberately wide: attribute keys in the wild carry dots, slashes, colons and
+* dashes (`http.status_code`, `GET /users`, `db.system`), and requiring quotes
+* around every one of them would make the common query the awkward one. The
+* exclusions are the characters the grammar itself needs.
+*/
+const WORD_RE = /[^\s()[\],=!<>^$"']/;
+/** Multi-character sigils are tested before single-character ones. */
+const SIGILS = [
+	">=",
+	"<=",
+	"!=",
+	"=~",
+	"!~",
+	"=",
+	">",
+	"<",
+	"^",
+	"$"
+];
+function tokenize(input) {
+	const tokens = [];
+	let i = 0;
+	const push = (type, value, from, to, terminated = true) => tokens.push({
+		type,
+		value,
+		from,
+		to,
+		terminated
+	});
+	while (i < input.length) {
+		const ch = input[i];
+		if (/\s/.test(ch)) {
+			i++;
+			continue;
+		}
+		const punctuation = {
+			"(": "lparen",
+			")": "rparen",
+			"[": "lbracket",
+			"]": "rbracket",
+			",": "comma"
+		};
+		if (punctuation[ch]) {
+			push(punctuation[ch], ch, i, i + 1);
+			i++;
+			continue;
+		}
+		if (ch === "\"" || ch === "'") {
+			const start = i;
+			const quote = ch;
+			i++;
+			let value = "";
+			let terminated = false;
+			while (i < input.length) {
+				if (input[i] === "\\" && i + 1 < input.length) {
+					value += input[i + 1];
+					i += 2;
+					continue;
+				}
+				if (input[i] === quote) {
+					i++;
+					terminated = true;
+					break;
+				}
+				value += input[i];
+				i++;
+			}
+			push("string", value, start, i, terminated);
+			continue;
+		}
+		const sigil = SIGILS.find((s) => input.startsWith(s, i));
+		if (sigil) {
+			push("sigil", sigil, i, i + sigil.length);
+			i += sigil.length;
+			continue;
+		}
+		const start = i;
+		while (i < input.length && WORD_RE.test(input[i])) i++;
+		if (i === start) i++;
+		push("word", input.slice(start, i), start, i);
+	}
+	return tokens;
+}
+
+//#endregion
+//#region src/query/parse.ts
+/**
+* Recursive-descent parser for the telemetry query language.
+*
+* Grammar, loosest binding first:
+*
+*   query      := or?
+*   or         := and (OR and)*
+*   and        := condition ((AND)? condition)*     -- juxtaposition means AND
+*   condition  := "(" or ")" | comparison | freeText
+*   comparison := field operator value
+*   value      := string | number | boolean | null | array
+*   array      := "[" (value ("," value)*)? "]"
+*
+* Juxtaposition binding as AND is deliberate: `service = api duration > 100` is
+* what people type, and rejecting it to demand the keyword buys nothing.
+*
+* Errors are collected with source ranges rather than thrown on the first
+* problem, so a half-typed query can still be linted in the editor.
+*/
+const BOOLEAN_KEYWORDS = /* @__PURE__ */ new Set(["and", "or"]);
+const NULL_LITERALS = /* @__PURE__ */ new Set(["null", "nil"]);
+/** Keyword operators, lower-cased, mapped to their canonical spelling. */
+const KEYWORD_OPERATORS = /* @__PURE__ */ new Map([
+	["contains", "CONTAINS"],
+	["regexp", "REGEXP"],
+	["in", "IN"]
+]);
+function parse(input) {
+	const tokens = tokenize(input);
+	const errors = [];
+	/** Range used when a problem is found past the last token. */
+	const endRange = () => ({
+		from: tokens.length ? tokens[tokens.length - 1].to : 0,
+		to: input.length
+	});
+	let pos = 0;
+	const peek = (offset = 0) => tokens[pos + offset];
+	const next = () => tokens[pos++];
+	const fail = (message, range) => errors.push({
+		message,
+		range
+	});
+	/** Lower-cased text of a `word` token, or undefined for any other token. */
+	const wordAt = (offset = 0) => {
+		const token = peek(offset);
+		return token?.type === "word" ? token.value.toLowerCase() : void 0;
+	};
+	const isBooleanKeyword = (offset = 0) => {
+		const word = wordAt(offset);
+		return word !== void 0 && BOOLEAN_KEYWORDS.has(word);
+	};
+	function span(from, to) {
+		return {
+			from: from.from,
+			to: to.to
+		};
+	}
+	function parseValue() {
+		const token = next();
+		if (!token) {
+			fail("Expected a value", endRange());
+			return;
+		}
+		if (token.type === "string") {
+			if (!token.terminated) fail("Unterminated quoted string", {
+				from: token.from,
+				to: token.to
+			});
+			return {
+				type: "string",
+				value: token.value
+			};
+		}
+		if (token.type === "lbracket") {
+			const values = [];
+			if (peek()?.type === "rbracket") {
+				next();
+				return {
+					type: "array",
+					values
+				};
+			}
+			for (;;) {
+				const element = parseValue();
+				if (!element) return {
+					type: "array",
+					values
+				};
+				values.push(element);
+				const separator = peek();
+				if (separator?.type === "comma") {
+					next();
+					continue;
+				}
+				if (separator?.type === "rbracket") {
+					next();
+					return {
+						type: "array",
+						values
+					};
+				}
+				fail("Expected \",\" or \"]\" in array", separator ?? endRange());
+				return {
+					type: "array",
+					values
+				};
+			}
+		}
+		if (token.type === "word") {
+			const lower = token.value.toLowerCase();
+			if (NULL_LITERALS.has(lower)) return { type: "null" };
+			if (lower === "true") return {
+				type: "boolean",
+				value: true
+			};
+			if (lower === "false") return {
+				type: "boolean",
+				value: false
+			};
+			const numeric = Number(token.value);
+			if (Number.isFinite(numeric)) return {
+				type: "number",
+				value: numeric
+			};
+			return {
+				type: "string",
+				value: token.value
+			};
+		}
+		fail(`Expected a value, found "${token.value}"`, token);
+	}
+	/**
+	* Read an operator at the cursor, or undefined if there isn't one.
+	*
+	* Handles all three spellings: a sigil (`>=`), a keyword (`CONTAINS`), and a
+	* two-word negation (`NOT IN`).
+	*/
+	function parseOperator() {
+		const token = peek();
+		if (!token) return void 0;
+		if (token.type === "sigil") {
+			next();
+			return SIGIL_ALIASES[token.value] ?? token.value;
+		}
+		if (token.type !== "word") return void 0;
+		const lower = token.value.toLowerCase();
+		if (lower === "not") {
+			const following = wordAt(1);
+			const base = following ? KEYWORD_OPERATORS.get(following) : void 0;
+			if (base) {
+				next();
+				next();
+				return `NOT ${base}`;
+			}
+			return;
+		}
+		const keyword = KEYWORD_OPERATORS.get(lower);
+		if (keyword) {
+			next();
+			return keyword;
+		}
+	}
+	function parseCondition() {
+		const token = peek();
+		if (!token) {
+			fail("Expected a condition", endRange());
+			return;
+		}
+		if (token.type === "lparen") {
+			next();
+			const inner = parseOr();
+			const closing = peek();
+			if (closing?.type === "rparen") next();
+			else fail("Unclosed parenthesis — expected \")\"", closing ?? endRange());
+			return inner;
+		}
+		if (token.type === "word" || token.type === "string") {
+			const savedPos = pos;
+			next();
+			const op = parseOperator();
+			if (op) {
+				const value = parseValue();
+				if (!value) return void 0;
+				const previous = tokens[pos - 1];
+				return {
+					type: "comparison",
+					field: token.value,
+					op,
+					value,
+					range: span(token, previous ?? token)
+				};
+			}
+			pos = savedPos;
+			next();
+			if (token.type === "string" && !token.terminated) fail("Unterminated quoted string", {
+				from: token.from,
+				to: token.to
+			});
+			return {
+				type: "freeText",
+				text: token.value,
+				range: {
+					from: token.from,
+					to: token.to
+				}
+			};
+		}
+		fail(`Unexpected "${token.value}"`, token);
+		next();
+	}
+	/** True when the cursor sits on something that could begin a condition. */
+	function atConditionStart() {
+		const token = peek();
+		if (!token) return false;
+		if (token.type === "rparen" || token.type === "rbracket") return false;
+		if (token.type === "comma") return false;
+		return !isBooleanKeyword();
+	}
+	function parseAnd() {
+		let left = parseCondition();
+		if (!left) return void 0;
+		for (;;) {
+			if (wordAt() === "and") {
+				next();
+				const right = parseCondition();
+				if (!right) return left;
+				left = {
+					type: "and",
+					left,
+					right,
+					range: nodeSpan(left, right)
+				};
+				continue;
+			}
+			if (atConditionStart()) {
+				const right = parseCondition();
+				if (!right) return left;
+				left = {
+					type: "and",
+					left,
+					right,
+					range: nodeSpan(left, right)
+				};
+				continue;
+			}
+			return left;
+		}
+	}
+	function parseOr() {
+		let left = parseAnd();
+		if (!left) return void 0;
+		while (wordAt() === "or") {
+			next();
+			const right = parseAnd();
+			if (!right) return left;
+			left = {
+				type: "or",
+				left,
+				right,
+				range: nodeSpan(left, right)
+			};
+		}
+		return left;
+	}
+	if (tokens.length === 0) return {
+		ok: true,
+		node: { type: "all" }
+	};
+	const node = parseOr();
+	const leftover = peek();
+	if (leftover) fail(`Unexpected "${leftover.value}"`, leftover);
+	if (errors.length > 0 || !node) return {
+		ok: false,
+		errors: errors.length > 0 ? errors : [{
+			message: "Invalid query",
+			range: endRange()
+		}]
+	};
+	return {
+		ok: true,
+		node
+	};
+}
+/** Source range covering two nodes, tolerating the range-less `all` node. */
+function nodeSpan(left, right) {
+	const from = "range" in left ? left.range.from : 0;
+	return {
+		from,
+		to: "range" in right ? right.range.to : from
+	};
+}
+
+//#endregion
+Object.defineProperty(exports, 'OPERATORS', {
+  enumerable: true,
+  get: function () {
+    return OPERATORS;
+  }
+});
+Object.defineProperty(exports, 'SIGIL_ALIASES', {
+  enumerable: true,
+  get: function () {
+    return SIGIL_ALIASES;
+  }
+});
+Object.defineProperty(exports, 'compileWhere', {
+  enumerable: true,
+  get: function () {
+    return compileWhere;
+  }
+});
+Object.defineProperty(exports, 'parse', {
+  enumerable: true,
+  get: function () {
+    return parse;
+  }
+});
+Object.defineProperty(exports, 'tokenize', {
+  enumerable: true,
+  get: function () {
+    return tokenize;
+  }
+});