sqlql 0.1.0

package/dist/index.mjs

@@ -0,0 +1,559 @@
+import { t as __exportAll } from "./chunk-DQk6qfdC.mjs";
+import nodeSqlParser from "node-sql-parser";
+
+//#region ../core/src/planning.ts
+var planning_exports = /* @__PURE__ */ __exportAll({ defineTableResolver: () => defineTableResolver });
+function defineTableResolver(resolver) {
+	return resolver;
+}
+
+//#endregion
+//#region ../core/src/index.ts
+const DEFAULT_QUERY_BEHAVIOR = {
+	filterable: "all",
+	sortable: "all",
+	maxRows: null
+};
+function defineSchema(schema) {
+	return schema;
+}
+function getTable(schema, tableName) {
+	const table = schema.tables[tableName];
+	if (!table) throw new Error(`Unknown table: ${tableName}`);
+	return table;
+}
+function resolveTableQueryBehavior(schema, tableName) {
+	const table = getTable(schema, tableName);
+	const defaults = schema.defaults?.query;
+	return {
+		filterable: table.query?.filterable ?? defaults?.filterable ?? DEFAULT_QUERY_BEHAVIOR.filterable,
+		sortable: table.query?.sortable ?? defaults?.sortable ?? DEFAULT_QUERY_BEHAVIOR.sortable,
+		maxRows: table.query?.maxRows ?? defaults?.maxRows ?? DEFAULT_QUERY_BEHAVIOR.maxRows
+	};
+}
+function defineTableMethods(methods) {
+	return methods;
+}
+function toSqlDDL(schema, options = {}) {
+	const createPrefix = options.ifNotExists ? "CREATE TABLE IF NOT EXISTS" : "CREATE TABLE";
+	const statements = [];
+	for (const [tableName, table] of Object.entries(schema.tables)) {
+		const columnEntries = Object.entries(table.columns);
+		if (columnEntries.length === 0) throw new Error(`Cannot generate DDL for table ${tableName} with no columns.`);
+		const columnsSql = columnEntries.map(([columnName, columnType]) => `  ${escapeIdentifier(columnName)} ${toSqlType(columnType)}`).join(",\n");
+		statements.push(`${createPrefix} ${escapeIdentifier(tableName)} (\n${columnsSql}\n);`);
+	}
+	return statements.join("\n\n");
+}
+function toSqlType(type) {
+	switch (type) {
+		case "text": return "TEXT";
+		case "integer": return "INTEGER";
+		case "boolean": return "BOOLEAN";
+		case "timestamp": return "TIMESTAMP";
+	}
+}
+function escapeIdentifier(name) {
+	return `"${name.replaceAll("\"", "\"\"")}"`;
+}
+
+//#endregion
+//#region ../sql/src/index.ts
+const { Parser } = nodeSqlParser;
+const parser = new Parser();
+function parseSql(query, schema) {
+	const parsed = parseSelectAst(query.text, schema);
+	const source = parsed.bindings[0];
+	if (!source) throw new Error("SELECT queries must include a FROM clause.");
+	return {
+		source: source.table,
+		selectAll: parsed.selectAll
+	};
+}
+async function query(input) {
+	const parsed = parseSelectAst(input.sql, input.schema);
+	const rootBinding = parsed.bindings[0];
+	if (!rootBinding) throw new Error("SELECT queries must include a FROM clause.");
+	for (const binding of parsed.bindings) {
+		getTable(input.schema, binding.table);
+		if (!input.methods[binding.table]) throw new Error(`No table methods registered for table: ${binding.table}`);
+	}
+	const projectionByAlias = buildProjection(parsed, input.schema);
+	const filtersByAlias = groupFiltersByAlias(parsed.filters);
+	const executionOrder = buildExecutionOrder(parsed.bindings, parsed.joinEdges, filtersByAlias);
+	const rowsByAlias = /* @__PURE__ */ new Map();
+	for (const alias of executionOrder) {
+		const binding = parsed.bindings.find((candidate) => candidate.alias === alias);
+		if (!binding) throw new Error(`Unknown alias in execution order: ${alias}`);
+		const dependencyFilters = buildDependencyFilters(alias, parsed.joinEdges, rowsByAlias);
+		const localFilters = filtersByAlias.get(alias) ?? [];
+		if (dependencyFilters.some((filter) => filter.op === "in" && filter.values.length === 0)) {
+			rowsByAlias.set(alias, []);
+			continue;
+		}
+		const defaultMaxRows = resolveTableQueryBehavior(input.schema, binding.table).maxRows;
+		const requestWhere = [...localFilters, ...dependencyFilters];
+		const requestOrderBy = parsed.bindings.length === 1 && parsed.orderBy.every((term) => term.alias === alias) ? parsed.orderBy.map((term) => ({
+			column: term.column,
+			direction: term.direction
+		})) : void 0;
+		let requestLimit = parsed.bindings.length === 1 ? parsed.limit : void 0;
+		if (requestLimit == null && defaultMaxRows != null) requestLimit = defaultMaxRows;
+		if (requestLimit != null && defaultMaxRows != null && requestLimit > defaultMaxRows) throw new Error(`Requested limit ${requestLimit} exceeds maxRows ${defaultMaxRows} for table ${binding.table}`);
+		const method = input.methods[binding.table];
+		if (!method) throw new Error(`No table methods registered for table: ${binding.table}`);
+		const projection = projectionByAlias.get(alias);
+		if (!projection) throw new Error(`Unable to resolve projection columns for alias: ${alias}`);
+		const request = {
+			table: binding.table,
+			alias,
+			select: [...projection]
+		};
+		if (requestWhere.length > 0) request.where = requestWhere;
+		if (requestOrderBy && requestOrderBy.length > 0) request.orderBy = requestOrderBy;
+		if (requestLimit != null) request.limit = requestLimit;
+		const rows = await runScan(method, request, input.context);
+		rowsByAlias.set(alias, rows);
+	}
+	let joinedRows = initializeJoinedRows(rowsByAlias, rootBinding.alias);
+	for (const join of parsed.joins) joinedRows = applyInnerJoin(joinedRows, join, rowsByAlias);
+	if (parsed.orderBy.length > 0) joinedRows = applyFinalSort(joinedRows, parsed.orderBy);
+	if (parsed.limit != null && parsed.bindings.length > 1) joinedRows = joinedRows.slice(0, parsed.limit);
+	return projectResultRows(joinedRows, parsed);
+}
+async function runScan(method, request, context) {
+	const dependencyFilters = request.where?.filter((clause) => clause.op === "in") ?? [];
+	if (dependencyFilters.length === 1 && method.lookup && dependencyFilters[0] && dependencyFilters[0].values.length > 0 && request.orderBy == null && request.limit == null) {
+		const lookup = dependencyFilters[0];
+		if (!lookup) return method.scan(request, context);
+		const nonDependencyFilters = request.where?.filter((clause) => clause !== lookup);
+		const fullLookupRequest = {
+			table: request.table,
+			key: lookup.column,
+			values: lookup.values,
+			select: request.select
+		};
+		if (request.alias) fullLookupRequest.alias = request.alias;
+		if (nonDependencyFilters && nonDependencyFilters.length > 0) fullLookupRequest.where = nonDependencyFilters;
+		return method.lookup(fullLookupRequest, context);
+	}
+	return method.scan(request, context);
+}
+function parseSelectAst(sql, _schema) {
+	const astRaw = parser.astify(sql);
+	if (Array.isArray(astRaw)) throw new Error("Only a single SQL statement is supported.");
+	const ast = astRaw;
+	if (ast.type !== "select") throw new Error("Only SELECT statements are currently supported.");
+	const rawFrom = Array.isArray(ast.from) ? ast.from : ast.from ? [ast.from] : [];
+	if (rawFrom.length === 0) throw new Error("SELECT queries must include a FROM clause.");
+	const bindings = rawFrom.map((entry, index) => {
+		if (!entry || typeof entry !== "object" || !("table" in entry)) throw new Error("Unsupported FROM clause entry.");
+		const table = entry.table;
+		const alias = entry.as;
+		if (typeof table !== "string" || table.length === 0) throw new Error("Unable to resolve table name from query.");
+		return {
+			table,
+			alias: typeof alias === "string" && alias.length > 0 ? alias : table,
+			index
+		};
+	});
+	const aliasToTable = new Map(bindings.map((binding) => [binding.alias, binding.table]));
+	const joins = [];
+	const joinEdges = [];
+	for (let i = 1; i < rawFrom.length; i += 1) {
+		const entry = rawFrom[i];
+		const joinType = typeof entry.join === "string" ? entry.join.toUpperCase() : "";
+		if (joinType !== "INNER JOIN" && joinType !== "JOIN") throw new Error(`Unsupported join type: ${String(entry.join ?? "unknown")}`);
+		const parsedJoin = parseJoinCondition(entry.on);
+		if (!aliasToTable.has(parsedJoin.leftAlias) || !aliasToTable.has(parsedJoin.rightAlias)) throw new Error("JOIN condition references an unknown table alias.");
+		const joinedAlias = typeof entry.as === "string" && entry.as.length > 0 ? entry.as : String(entry.table);
+		joins.push({
+			alias: joinedAlias,
+			join: "inner",
+			condition: parsedJoin
+		});
+		joinEdges.push(parsedJoin);
+	}
+	const whereParts = flattenAndConditions(ast.where);
+	const filters = [];
+	for (const part of whereParts) {
+		if (!part || typeof part !== "object") throw new Error("Unsupported WHERE clause.");
+		const binary = part;
+		if (binary.type !== "binary_expr") throw new Error("Only binary predicates are supported in WHERE clauses.");
+		const operator = normalizeBinaryOperator(binary.operator);
+		if (operator === "in") {
+			const colRef = toColumnRef(binary.left);
+			if (!colRef) throw new Error("IN predicates must use a column on the left-hand side.");
+			const values = parseExpressionList(binary.right);
+			filters.push({
+				alias: colRef.alias,
+				clause: {
+					op: "in",
+					column: colRef.column,
+					values
+				}
+			});
+			continue;
+		}
+		const leftCol = toColumnRef(binary.left);
+		const rightCol = toColumnRef(binary.right);
+		if (operator === "eq" && leftCol && rightCol) {
+			joinEdges.push({
+				leftAlias: leftCol.alias,
+				leftColumn: leftCol.column,
+				rightAlias: rightCol.alias,
+				rightColumn: rightCol.column
+			});
+			continue;
+		}
+		const leftLiteral = parseLiteral(binary.left);
+		const rightLiteral = parseLiteral(binary.right);
+		if (leftCol && rightLiteral !== void 0) {
+			filters.push({
+				alias: leftCol.alias,
+				clause: {
+					op: operator,
+					column: leftCol.column,
+					value: rightLiteral
+				}
+			});
+			continue;
+		}
+		if (rightCol && leftLiteral !== void 0) {
+			filters.push({
+				alias: rightCol.alias,
+				clause: {
+					op: invertOperator(operator),
+					column: rightCol.column,
+					value: leftLiteral
+				}
+			});
+			continue;
+		}
+		throw new Error("WHERE predicates must compare columns to literals (or column equality joins).");
+	}
+	const selectColumnsRaw = ast.columns;
+	const selectAll = selectColumnsRaw === "*" || Array.isArray(selectColumnsRaw) && selectColumnsRaw.length === 1 && isStarColumn(selectColumnsRaw[0]);
+	const selectColumns = [];
+	if (!selectAll) {
+		if (!Array.isArray(selectColumnsRaw)) throw new Error("Unsupported SELECT clause.");
+		for (const item of selectColumnsRaw) {
+			if (!item || typeof item !== "object") throw new Error("Unsupported SELECT item.");
+			const expr = item.expr;
+			const colRef = toColumnRef(expr);
+			if (!colRef) throw new Error("Only direct column references are currently supported in SELECT.");
+			const as = item.as;
+			selectColumns.push({
+				alias: colRef.alias,
+				column: colRef.column,
+				output: typeof as === "string" && as.length > 0 ? as : selectColumns.some((existing) => existing.column === colRef.column) ? `${colRef.alias}.${colRef.column}` : colRef.column
+			});
+		}
+	}
+	const orderBy = [];
+	if (Array.isArray(ast.orderby)) for (const item of ast.orderby) {
+		const colRef = toColumnRef(item.expr);
+		if (!colRef) throw new Error("Only column references are currently supported in ORDER BY.");
+		const rawType = item.type;
+		orderBy.push({
+			alias: colRef.alias,
+			column: colRef.column,
+			direction: rawType === "DESC" ? "desc" : "asc"
+		});
+	}
+	let limit;
+	const rawLimit = ast.limit;
+	if (rawLimit && Array.isArray(rawLimit.value) && rawLimit.value.length > 0) {
+		const first = rawLimit.value[0]?.value;
+		if (typeof first === "number") limit = first;
+		else if (typeof first === "string") {
+			const parsed = Number(first);
+			if (Number.isFinite(parsed)) limit = parsed;
+		}
+		if (limit == null) throw new Error("Unable to parse LIMIT value.");
+	}
+	if (selectAll && bindings.length > 1) throw new Error("SELECT * is only supported for single-table queries.");
+	const parsedQuery = {
+		bindings,
+		joins,
+		joinEdges: uniqueJoinEdges(joinEdges),
+		filters,
+		selectAll,
+		selectColumns,
+		orderBy
+	};
+	if (limit != null) parsedQuery.limit = limit;
+	return parsedQuery;
+}
+function buildProjection(parsed, schema) {
+	const projections = /* @__PURE__ */ new Map();
+	for (const binding of parsed.bindings) projections.set(binding.alias, /* @__PURE__ */ new Set());
+	if (parsed.selectAll) {
+		const base = parsed.bindings[0];
+		if (!base) throw new Error("SELECT queries must include a FROM clause.");
+		const allColumns = Object.keys(getTable(schema, base.table).columns);
+		for (const column of allColumns) projections.get(base.alias)?.add(column);
+	} else for (const item of parsed.selectColumns) projections.get(item.alias)?.add(item.column);
+	for (const join of parsed.joinEdges) {
+		projections.get(join.leftAlias)?.add(join.leftColumn);
+		projections.get(join.rightAlias)?.add(join.rightColumn);
+	}
+	for (const filter of parsed.filters) projections.get(filter.alias)?.add(filter.clause.column);
+	for (const term of parsed.orderBy) projections.get(term.alias)?.add(term.column);
+	for (const [alias, cols] of projections) if (cols.size === 0) {
+		const binding = parsed.bindings.find((candidate) => candidate.alias === alias);
+		if (binding) {
+			const firstColumn = Object.keys(getTable(schema, binding.table).columns)[0];
+			if (!firstColumn) throw new Error(`Table ${binding.table} has no columns.`);
+			cols.add(firstColumn);
+		}
+	}
+	return projections;
+}
+function groupFiltersByAlias(filters) {
+	const grouped = /* @__PURE__ */ new Map();
+	for (const filter of filters) {
+		const existing = grouped.get(filter.alias) ?? [];
+		existing.push(filter.clause);
+		grouped.set(filter.alias, existing);
+	}
+	return grouped;
+}
+function buildExecutionOrder(bindings, joinEdges, filtersByAlias) {
+	const score = /* @__PURE__ */ new Map();
+	for (const binding of bindings) score.set(binding.alias, filtersByAlias.get(binding.alias)?.length ?? 0);
+	const unvisited = new Set(bindings.map((binding) => binding.alias));
+	const visited = /* @__PURE__ */ new Set();
+	const order = [];
+	while (unvisited.size > 0) {
+		const candidates = [...unvisited].filter((alias) => {
+			if (visited.size === 0) return true;
+			return joinEdges.some((edge) => edge.leftAlias === alias && visited.has(edge.rightAlias) || edge.rightAlias === alias && visited.has(edge.leftAlias));
+		});
+		const pool = candidates.length > 0 ? candidates : [...unvisited];
+		pool.sort((a, b) => {
+			const aScore = score.get(a) ?? 0;
+			const bScore = score.get(b) ?? 0;
+			if (aScore !== bScore) return bScore - aScore;
+			const aIndex = bindings.find((binding) => binding.alias === a)?.index ?? 0;
+			return (bindings.find((binding) => binding.alias === b)?.index ?? 0) - aIndex;
+		});
+		const next = pool[0];
+		if (!next) break;
+		order.push(next);
+		visited.add(next);
+		unvisited.delete(next);
+	}
+	return order;
+}
+function buildDependencyFilters(alias, joinEdges, rowsByAlias) {
+	const clauses = [];
+	for (const edge of joinEdges) {
+		if (edge.leftAlias === alias && rowsByAlias.has(edge.rightAlias)) {
+			clauses.push({
+				op: "in",
+				column: edge.leftColumn,
+				values: uniqueValues(rowsByAlias.get(edge.rightAlias) ?? [], edge.rightColumn)
+			});
+			continue;
+		}
+		if (edge.rightAlias === alias && rowsByAlias.has(edge.leftAlias)) clauses.push({
+			op: "in",
+			column: edge.rightColumn,
+			values: uniqueValues(rowsByAlias.get(edge.leftAlias) ?? [], edge.leftColumn)
+		});
+	}
+	return dedupeInClauses(clauses);
+}
+function initializeJoinedRows(rowsByAlias, baseAlias) {
+	return (rowsByAlias.get(baseAlias) ?? []).map((row) => ({ [baseAlias]: row }));
+}
+function applyInnerJoin(existing, join, rowsByAlias) {
+	const rightRows = rowsByAlias.get(join.alias) ?? [];
+	const isJoinAliasLeft = join.condition.leftAlias === join.alias;
+	const joinAliasColumn = isJoinAliasLeft ? join.condition.leftColumn : join.condition.rightColumn;
+	const existingAlias = isJoinAliasLeft ? join.condition.rightAlias : join.condition.leftAlias;
+	const existingColumn = isJoinAliasLeft ? join.condition.rightColumn : join.condition.leftColumn;
+	const index = /* @__PURE__ */ new Map();
+	for (const row of rightRows) {
+		const key = row[joinAliasColumn];
+		const bucket = index.get(key) ?? [];
+		bucket.push(row);
+		index.set(key, bucket);
+	}
+	const joined = [];
+	for (const bundle of existing) {
+		const leftRow = bundle[existingAlias];
+		if (!leftRow) continue;
+		const key = leftRow[existingColumn];
+		const matches = index.get(key) ?? [];
+		for (const match of matches) joined.push({
+			...bundle,
+			[join.alias]: match
+		});
+	}
+	return joined;
+}
+function applyFinalSort(rows, orderBy) {
+	const sorted = [...rows];
+	sorted.sort((left, right) => {
+		for (const term of orderBy) {
+			const leftValue = left[term.alias]?.[term.column];
+			const rightValue = right[term.alias]?.[term.column];
+			if (leftValue === rightValue) continue;
+			const comparison = compareNullableValues(leftValue ?? null, rightValue ?? null);
+			return term.direction === "asc" ? comparison : -comparison;
+		}
+		return 0;
+	});
+	return sorted;
+}
+function projectResultRows(rows, parsed) {
+	if (parsed.selectAll) {
+		const baseAlias = parsed.bindings[0]?.alias;
+		if (!baseAlias) return [];
+		return rows.map((row) => {
+			const baseRow = row[baseAlias];
+			return baseRow ? { ...baseRow } : {};
+		});
+	}
+	return rows.map((bundle) => {
+		const out = {};
+		for (const item of parsed.selectColumns) out[item.output] = bundle[item.alias]?.[item.column] ?? null;
+		return out;
+	});
+}
+function parseJoinCondition(raw) {
+	const expr = raw;
+	if (expr?.type !== "binary_expr" || expr.operator !== "=") throw new Error("Only equality join conditions are currently supported.");
+	const left = toColumnRef(expr.left);
+	const right = toColumnRef(expr.right);
+	if (!left || !right) throw new Error("JOIN conditions must compare two columns.");
+	return {
+		leftAlias: left.alias,
+		leftColumn: left.column,
+		rightAlias: right.alias,
+		rightColumn: right.column
+	};
+}
+function flattenAndConditions(where) {
+	if (!where) return [];
+	const expr = where;
+	if (expr.type === "binary_expr" && expr.operator === "AND") return [...flattenAndConditions(expr.left), ...flattenAndConditions(expr.right)];
+	if (expr.type === "binary_expr" && expr.operator === "OR") throw new Error("OR predicates are not yet supported.");
+	return [where];
+}
+function normalizeBinaryOperator(raw) {
+	switch (raw) {
+		case "=": return "eq";
+		case "!=":
+		case "<>": return "neq";
+		case ">": return "gt";
+		case ">=": return "gte";
+		case "<": return "lt";
+		case "<=": return "lte";
+		case "IN": return "in";
+		default: throw new Error(`Unsupported operator: ${String(raw)}`);
+	}
+}
+function invertOperator(op) {
+	switch (op) {
+		case "eq": return "eq";
+		case "neq": return "neq";
+		case "gt": return "lt";
+		case "gte": return "lte";
+		case "lt": return "gt";
+		case "lte": return "gte";
+	}
+}
+function toColumnRef(raw) {
+	const expr = raw;
+	if (expr?.type !== "column_ref") return;
+	if (typeof expr.column !== "string" || expr.column.length === 0) return;
+	if (typeof expr.table !== "string" || expr.table.length === 0) throw new Error(`Ambiguous unqualified column reference: ${expr.column}`);
+	return {
+		alias: expr.table,
+		column: expr.column
+	};
+}
+function isStarColumn(raw) {
+	const expr = raw.expr;
+	return expr?.type === "column_ref" && expr.column === "*";
+}
+function parseLiteral(raw) {
+	const expr = raw;
+	switch (expr?.type) {
+		case "single_quote_string":
+		case "double_quote_string":
+		case "string": return String(expr.value ?? "");
+		case "number": {
+			const value = expr.value;
+			if (typeof value === "number") return value;
+			if (typeof value === "string") {
+				const parsed = Number(value);
+				return Number.isFinite(parsed) ? parsed : void 0;
+			}
+			return;
+		}
+		case "bool": return Boolean(expr.value);
+		case "null": return null;
+		default: return;
+	}
+}
+function parseExpressionList(raw) {
+	const expr = raw;
+	if (expr?.type !== "expr_list" || !Array.isArray(expr.value)) throw new Error("IN predicates must use literal lists.");
+	const values = expr.value.map((entry) => parseLiteral(entry));
+	if (values.some((value) => value === void 0)) throw new Error("IN predicates must contain only literal values.");
+	return values;
+}
+function uniqueJoinEdges(edges) {
+	const seen = /* @__PURE__ */ new Set();
+	const out = [];
+	for (const edge of edges) {
+		const key = `${edge.leftAlias}.${edge.leftColumn}=${edge.rightAlias}.${edge.rightColumn}`;
+		const reverseKey = `${edge.rightAlias}.${edge.rightColumn}=${edge.leftAlias}.${edge.leftColumn}`;
+		if (seen.has(key) || seen.has(reverseKey)) continue;
+		seen.add(key);
+		out.push(edge);
+	}
+	return out;
+}
+function uniqueValues(rows, column) {
+	const seen = /* @__PURE__ */ new Set();
+	const out = [];
+	for (const row of rows) {
+		const value = row[column] ?? null;
+		if (seen.has(value)) continue;
+		seen.add(value);
+		out.push(value);
+	}
+	return out;
+}
+function compareNullableValues(left, right) {
+	if (left === right) return 0;
+	if (left == null) return -1;
+	if (right == null) return 1;
+	if (typeof left === "number" && typeof right === "number") return left < right ? -1 : 1;
+	if (typeof left === "boolean" && typeof right === "boolean") return Number(left) < Number(right) ? -1 : 1;
+	return String(left) < String(right) ? -1 : 1;
+}
+function dedupeInClauses(clauses) {
+	const out = [];
+	const seen = /* @__PURE__ */ new Set();
+	for (const clause of clauses) {
+		if (clause.op !== "in") {
+			out.push(clause);
+			continue;
+		}
+		const key = `${clause.column}:${JSON.stringify(clause.values)}`;
+		if (seen.has(key)) continue;
+		seen.add(key);
+		out.push(clause);
+	}
+	return out;
+}
+
+//#endregion
+export { DEFAULT_QUERY_BEHAVIOR, defineSchema, defineTableMethods, getTable, parseSql, planning_exports as planning, query, resolveTableQueryBehavior, toSqlDDL };
+//# sourceMappingURL=index.mjs.map