sumak 0.0.4 → 0.0.5

package/dist/printer/base.mjs

@@ -0,0 +1,450 @@
+import { quoteIdentifier, quoteTableRef } from "../utils/identifier.mjs";
+import { formatParam } from "../utils/param.mjs";
+export class BasePrinter {
+	params = [];
+	dialect;
+	constructor(dialect) {
+		this.dialect = dialect;
+	}
+	print(node) {
+		this.params = [];
+		const sql = this.printNode(node);
+		return {
+			sql,
+			params: [...this.params]
+		};
+	}
+	printNode(node) {
+		switch (node.type) {
+			case "select": return this.printSelect(node);
+			case "insert": return this.printInsert(node);
+			case "update": return this.printUpdate(node);
+			case "delete": return this.printDelete(node);
+			case "merge": return this.printMerge(node);
+			case "explain": return this.printExplain(node);
+			default: return this.printExpression(node);
+		}
+	}
+	printSelect(node) {
+		const parts = [];
+		if (node.ctes.length > 0) {
+			parts.push(this.printCTEs(node.ctes));
+		}
+		parts.push("SELECT");
+		if (node.distinctOn && node.distinctOn.length > 0) {
+			parts.push(`DISTINCT ON (${node.distinctOn.map((e) => this.printExpression(e)).join(", ")})`);
+		} else if (node.distinct) {
+			parts.push("DISTINCT");
+		}
+		if (node.columns.length === 0) {
+			parts.push("*");
+		} else {
+			parts.push(node.columns.map((c) => this.printExpression(c)).join(", "));
+		}
+		if (node.from) {
+			parts.push("FROM");
+			if (node.from.type === "subquery") {
+				parts.push(this.printSubquery(node.from));
+			} else {
+				parts.push(this.printTableRef(node.from));
+			}
+		}
+		for (const join of node.joins) {
+			parts.push(this.printJoin(join));
+		}
+		if (node.where) {
+			parts.push("WHERE", this.printExpression(node.where));
+		}
+		if (node.groupBy.length > 0) {
+			parts.push("GROUP BY", node.groupBy.map((g) => this.printExpression(g)).join(", "));
+		}
+		if (node.having) {
+			parts.push("HAVING", this.printExpression(node.having));
+		}
+		if (node.orderBy.length > 0) {
+			parts.push("ORDER BY", node.orderBy.map((o) => this.printOrderBy(o)).join(", "));
+		}
+		if (node.limit) {
+			parts.push("LIMIT", this.printExpression(node.limit));
+		}
+		if (node.offset) {
+			parts.push("OFFSET", this.printExpression(node.offset));
+		}
+		if (node.setOp) {
+			parts.push(node.setOp.op, this.printSelect(node.setOp.query));
+		}
+		if (node.lock) {
+			parts.push(`FOR ${node.lock.mode}`);
+			if (node.lock.noWait) {
+				parts.push("NOWAIT");
+			} else if (node.lock.skipLocked) {
+				parts.push("SKIP LOCKED");
+			}
+		}
+		return parts.join(" ");
+	}
+	printInsert(node) {
+		const parts = [];
+		if (node.ctes.length > 0) {
+			parts.push(this.printCTEs(node.ctes));
+		}
+		const insertKeyword = node.insertMode ?? "INSERT";
+		parts.push(`${insertKeyword} INTO`, this.printTableRef(node.table));
+		if (node.columns.length > 0) {
+			parts.push(`(${node.columns.map((c) => quoteIdentifier(c, this.dialect)).join(", ")})`);
+		}
+		if (node.defaultValues) {
+			parts.push("DEFAULT VALUES");
+		} else if (node.source) {
+			parts.push(this.printSelect(node.source));
+		} else {
+			parts.push("VALUES");
+			const rows = node.values.map((row) => `(${row.map((v) => this.printExpression(v)).join(", ")})`);
+			parts.push(rows.join(", "));
+		}
+		if (node.onConflict) {
+			parts.push(this.printOnConflict(node.onConflict));
+		}
+		if (node.returning.length > 0) {
+			parts.push("RETURNING", node.returning.map((r) => this.printExpression(r)).join(", "));
+		}
+		return parts.join(" ");
+	}
+	printOnConflict(node) {
+		const parts = ["ON CONFLICT"];
+		if (node.constraint) {
+			parts.push(`ON CONSTRAINT ${quoteIdentifier(node.constraint, this.dialect)}`);
+		} else if (node.columns.length > 0) {
+			parts.push(`(${node.columns.map((c) => quoteIdentifier(c, this.dialect)).join(", ")})`);
+		}
+		if (node.action === "nothing") {
+			parts.push("DO NOTHING");
+		} else {
+			parts.push("DO UPDATE SET");
+			const sets = node.action.set.map((s) => `${quoteIdentifier(s.column, this.dialect)} = ${this.printExpression(s.value)}`);
+			parts.push(sets.join(", "));
+		}
+		if (node.where) {
+			parts.push("WHERE", this.printExpression(node.where));
+		}
+		return parts.join(" ");
+	}
+	printUpdate(node) {
+		const parts = [];
+		if (node.ctes.length > 0) {
+			parts.push(this.printCTEs(node.ctes));
+		}
+		parts.push("UPDATE", this.printTableRef(node.table), "SET");
+		const sets = node.set.map((s) => `${quoteIdentifier(s.column, this.dialect)} = ${this.printExpression(s.value)}`);
+		parts.push(sets.join(", "));
+		for (const join of node.joins) {
+			parts.push(this.printJoin(join));
+		}
+		if (node.from) {
+			parts.push("FROM", this.printTableRef(node.from));
+		}
+		if (node.where) {
+			parts.push("WHERE", this.printExpression(node.where));
+		}
+		if (node.returning.length > 0) {
+			parts.push("RETURNING", node.returning.map((r) => this.printExpression(r)).join(", "));
+		}
+		return parts.join(" ");
+	}
+	printDelete(node) {
+		const parts = [];
+		if (node.ctes.length > 0) {
+			parts.push(this.printCTEs(node.ctes));
+		}
+		parts.push("DELETE FROM", this.printTableRef(node.table));
+		if (node.using) {
+			parts.push("USING", this.printTableRef(node.using));
+		}
+		for (const join of node.joins) {
+			parts.push(this.printJoin(join));
+		}
+		if (node.where) {
+			parts.push("WHERE", this.printExpression(node.where));
+		}
+		if (node.returning.length > 0) {
+			parts.push("RETURNING", node.returning.map((r) => this.printExpression(r)).join(", "));
+		}
+		return parts.join(" ");
+	}
+	printExpression(node) {
+		switch (node.type) {
+			case "column_ref": return this.printColumnRef(node);
+			case "literal": return this.printLiteral(node);
+			case "binary_op": return this.printBinaryOp(node);
+			case "unary_op": return this.printUnaryOp(node);
+			case "function_call": return this.printFunctionCall(node);
+			case "param": return this.printParam(node);
+			case "raw": return this.printRaw(node);
+			case "subquery": return this.printSubquery(node);
+			case "between": return this.printBetween(node);
+			case "in": return this.printIn(node);
+			case "is_null": return this.printIsNull(node);
+			case "cast": return this.printCast(node);
+			case "exists": return this.printExists(node);
+			case "star": return this.printStar(node);
+			case "case": return this.printCase(node);
+			case "json_access": return this.printJsonAccess(node);
+			case "array_expr": return this.printArrayExpr(node);
+			case "window_function": return this.printWindowFunction(node);
+			case "aliased_expr": return this.printAliasedExpr(node);
+			case "full_text_search": return this.printFullTextSearch(node);
+		}
+	}
+	printColumnRef(node) {
+		let result = node.table ? `${quoteIdentifier(node.table, this.dialect)}.${quoteIdentifier(node.column, this.dialect)}` : quoteIdentifier(node.column, this.dialect);
+		if (node.alias) {
+			result += ` AS ${quoteIdentifier(node.alias, this.dialect)}`;
+		}
+		return result;
+	}
+	printLiteral(node) {
+		if (node.value === null) return "NULL";
+		if (typeof node.value === "boolean") return node.value ? "TRUE" : "FALSE";
+		if (typeof node.value === "number") return String(node.value);
+		return `'${String(node.value).replaceAll("'", "''")}'`;
+	}
+	printBinaryOp(node) {
+		return `(${this.printExpression(node.left)} ${node.op} ${this.printExpression(node.right)})`;
+	}
+	printUnaryOp(node) {
+		if (node.position === "postfix") {
+			return `(${this.printExpression(node.operand)} ${node.op})`;
+		}
+		return `(${node.op} ${this.printExpression(node.operand)})`;
+	}
+	printFunctionCall(node) {
+		const distinctPrefix = node.distinct ? "DISTINCT " : "";
+		let result = `${node.name}(${distinctPrefix}${node.args.map((a) => this.printExpression(a)).join(", ")})`;
+		if (node.filter) {
+			result += ` FILTER (WHERE ${this.printExpression(node.filter)})`;
+		}
+		if (node.alias) {
+			result += ` AS ${quoteIdentifier(node.alias, this.dialect)}`;
+		}
+		return result;
+	}
+	printParam(node) {
+		this.params.push(node.value);
+		return formatParam(this.params.length - 1, this.dialect);
+	}
+	printRaw(node) {
+		this.params.push(...node.params);
+		return node.sql;
+	}
+	printSubquery(node) {
+		let result = `(${this.printSelect(node.query)})`;
+		if (node.alias) {
+			result += ` AS ${quoteIdentifier(node.alias, this.dialect)}`;
+		}
+		return result;
+	}
+	printBetween(node) {
+		const neg = node.negated ? "NOT " : "";
+		return `(${this.printExpression(node.expr)} ${neg}BETWEEN ${this.printExpression(node.low)} AND ${this.printExpression(node.high)})`;
+	}
+	printIn(node) {
+		const neg = node.negated ? "NOT " : "";
+		if (Array.isArray(node.values)) {
+			return `(${this.printExpression(node.expr)} ${neg}IN (${node.values.map((v) => this.printExpression(v)).join(", ")}))`;
+		}
+		return `(${this.printExpression(node.expr)} ${neg}IN (${this.printSelect(node.values)}))`;
+	}
+	printIsNull(node) {
+		const neg = node.negated ? " NOT" : "";
+		return `(${this.printExpression(node.expr)} IS${neg} NULL)`;
+	}
+	printCase(node) {
+		const parts = ["CASE"];
+		if (node.operand) {
+			parts.push(this.printExpression(node.operand));
+		}
+		for (const when of node.whens) {
+			parts.push("WHEN", this.printExpression(when.condition), "THEN", this.printExpression(when.result));
+		}
+		if (node.else_) {
+			parts.push("ELSE", this.printExpression(node.else_));
+		}
+		parts.push("END");
+		return parts.join(" ");
+	}
+	printCast(node) {
+		return `CAST(${this.printExpression(node.expr)} AS ${node.dataType})`;
+	}
+	printExists(node) {
+		const neg = node.negated ? "NOT " : "";
+		return `(${neg}EXISTS (${this.printSelect(node.query)}))`;
+	}
+	printStar(node) {
+		return node.table ? `${quoteIdentifier(node.table, this.dialect)}.*` : "*";
+	}
+	printTableRef(ref) {
+		let result = quoteTableRef(ref.name, this.dialect, ref.schema);
+		if (ref.temporal) {
+			result += ` ${this.printTemporalClause(ref.temporal)}`;
+		}
+		if (ref.alias) {
+			result += ` AS ${quoteIdentifier(ref.alias, this.dialect)}`;
+		}
+		return result;
+	}
+	printTemporalClause(clause) {
+		switch (clause.kind) {
+			case "as_of": return `FOR SYSTEM_TIME AS OF ${this.printExpression(clause.timestamp)}`;
+			case "from_to": return `FOR SYSTEM_TIME FROM ${this.printExpression(clause.start)} TO ${this.printExpression(clause.end)}`;
+			case "between": return `FOR SYSTEM_TIME BETWEEN ${this.printExpression(clause.start)} AND ${this.printExpression(clause.end)}`;
+			case "contained_in": return `FOR SYSTEM_TIME CONTAINED IN (${this.printExpression(clause.start)}, ${this.printExpression(clause.end)})`;
+			case "all": return "FOR SYSTEM_TIME ALL";
+		}
+	}
+	printJoin(node) {
+		const parts = [];
+		parts.push(`${node.joinType} JOIN`);
+		if (node.table.type === "subquery") {
+			parts.push(this.printSubquery(node.table));
+		} else {
+			parts.push(this.printTableRef(node.table));
+		}
+		if (node.on) {
+			parts.push("ON", this.printExpression(node.on));
+		}
+		return parts.join(" ");
+	}
+	printOrderBy(node) {
+		let result = `${this.printExpression(node.expr)} ${node.direction}`;
+		if (node.nulls) {
+			result += ` NULLS ${node.nulls}`;
+		}
+		return result;
+	}
+	printCTEs(ctes) {
+		const hasRecursive = ctes.some((c) => c.recursive);
+		const prefix = hasRecursive ? "WITH RECURSIVE" : "WITH";
+		const cteParts = ctes.map((c) => `${quoteIdentifier(c.name, this.dialect)} AS (${this.printSelect(c.query)})`);
+		return `${prefix} ${cteParts.join(", ")}`;
+	}
+	printJsonAccess(node) {
+		let result = `${this.printExpression(node.expr)}${node.operator}${this.printLiteral({
+			type: "literal",
+			value: node.path
+		})}`;
+		if (node.alias) {
+			result += ` AS ${quoteIdentifier(node.alias, this.dialect)}`;
+		}
+		return result;
+	}
+	printArrayExpr(node) {
+		return `ARRAY[${node.elements.map((e) => this.printExpression(e)).join(", ")}]`;
+	}
+	printWindowFunction(node) {
+		const parts = [];
+		parts.push(this.printFunctionCall(node.fn));
+		parts.push("OVER");
+		const overParts = [];
+		if (node.partitionBy.length > 0) {
+			overParts.push(`PARTITION BY ${node.partitionBy.map((p) => this.printExpression(p)).join(", ")}`);
+		}
+		if (node.orderBy.length > 0) {
+			overParts.push(`ORDER BY ${node.orderBy.map((o) => this.printOrderBy(o)).join(", ")}`);
+		}
+		if (node.frame) {
+			overParts.push(this.printFrameSpec(node.frame));
+		}
+		parts.push(`(${overParts.join(" ")})`);
+		if (node.alias) {
+			parts.push("AS", quoteIdentifier(node.alias, this.dialect));
+		}
+		return parts.join(" ");
+	}
+	printFrameSpec(frame) {
+		const start = this.printFrameBound(frame.start);
+		if (frame.end) {
+			return `${frame.kind} BETWEEN ${start} AND ${this.printFrameBound(frame.end)}`;
+		}
+		return `${frame.kind} ${start}`;
+	}
+	printFrameBound(bound) {
+		switch (bound.type) {
+			case "unbounded_preceding": return "UNBOUNDED PRECEDING";
+			case "preceding": return `${bound.value} PRECEDING`;
+			case "current_row": return "CURRENT ROW";
+			case "following": return `${bound.value} FOLLOWING`;
+			case "unbounded_following": return "UNBOUNDED FOLLOWING";
+		}
+	}
+	printMerge(node) {
+		const parts = [];
+		if (node.ctes.length > 0) {
+			parts.push(this.printCTEs(node.ctes));
+		}
+		parts.push("MERGE INTO", this.printTableRef(node.target));
+		parts.push("USING");
+		if (node.source.type === "subquery") {
+			parts.push(this.printSubquery(node.source));
+		} else {
+			parts.push(this.printTableRef(node.source));
+		}
+		parts.push("AS", quoteIdentifier(node.sourceAlias, this.dialect));
+		parts.push("ON", this.printExpression(node.on));
+		for (const when of node.whens) {
+			if (when.type === "matched") {
+				parts.push(this.printMergeWhenMatched(when));
+			} else {
+				parts.push(this.printMergeWhenNotMatched(when));
+			}
+		}
+		return parts.join(" ");
+	}
+	printMergeWhenMatched(when) {
+		const parts = ["WHEN MATCHED"];
+		if (when.condition) {
+			parts.push("AND", this.printExpression(when.condition));
+		}
+		if (when.action === "delete") {
+			parts.push("THEN DELETE");
+		} else {
+			parts.push("THEN UPDATE SET");
+			const sets = (when.set ?? []).map((s) => `${quoteIdentifier(s.column, this.dialect)} = ${this.printExpression(s.value)}`);
+			parts.push(sets.join(", "));
+		}
+		return parts.join(" ");
+	}
+	printMergeWhenNotMatched(when) {
+		const parts = ["WHEN NOT MATCHED"];
+		if (when.condition) {
+			parts.push("AND", this.printExpression(when.condition));
+		}
+		parts.push("THEN INSERT");
+		parts.push(`(${when.columns.map((c) => quoteIdentifier(c, this.dialect)).join(", ")})`);
+		parts.push(`VALUES (${when.values.map((v) => this.printExpression(v)).join(", ")})`);
+		return parts.join(" ");
+	}
+	printAliasedExpr(node) {
+		return `${this.printExpression(node.expr)} AS ${quoteIdentifier(node.alias, this.dialect)}`;
+	}
+	printExplain(node) {
+		const parts = ["EXPLAIN"];
+		if (node.analyze) {
+			parts.push("ANALYZE");
+		}
+		if (node.format) {
+			parts.push(`(FORMAT ${node.format})`);
+		}
+		parts.push(this.printNode(node.statement));
+		return parts.join(" ");
+	}
+	printFullTextSearch(node) {
+		
+		const cols = node.columns.map((c) => this.printExpression(c)).join(" || ' ' || ");
+		const lang = node.language ? `'${node.language}', ` : "";
+		let result = `(to_tsvector(${lang}${cols}) @@ to_tsquery(${lang}${this.printExpression(node.query)}))`;
+		if (node.alias) {
+			result += ` AS ${quoteIdentifier(node.alias, this.dialect)}`;
+		}
+		return result;
+	}
+}

package/dist/printer/document.d.mts

@@ -0,0 +1,45 @@
+/**
+* Wadler-style pretty printer document algebra.
+*
+* Based on "A prettier printer" (Wadler 1998) and "Strictly Pretty" (Lindig 2000).
+* Used to format SQL output with width-sensitive line breaking.
+*/
+export type Doc = {
+	tag: "empty";
+} | {
+	tag: "text";
+	text: string;
+} | {
+	tag: "line";
+} | {
+	tag: "nest";
+	indent: number;
+	doc: Doc;
+} | {
+	tag: "group";
+	doc: Doc;
+} | {
+	tag: "concat";
+	docs: Doc[];
+};
+export declare function empty(): Doc;
+export declare function text(s: string): Doc;
+/** A line break. In flat mode, renders as a single space. */
+export declare function line(): Doc;
+/** Increase indentation for the nested document. */
+export declare function nest(indent: number, doc: Doc): Doc;
+/** Try to render flat; if too wide, break lines. */
+export declare function group(doc: Doc): Doc;
+/** Concatenate documents. */
+export declare function concat(...docs: Doc[]): Doc;
+/** Join documents with a separator. */
+export declare function join(sep: Doc, docs: Doc[]): Doc;
+/** Convenience: text + line */
+export declare function textLine(s: string): Doc;
+/**
+* Render a document to a string.
+*
+* Uses Wadler/Lindig's algorithm: maintain a stack of (indent, mode, doc) triples.
+* mode = "flat" (try single line) or "break" (use line breaks).
+*/
+export declare function render(doc: Doc, width?: number): string;

package/dist/printer/document.mjs

@@ -0,0 +1,153 @@
+export function empty() {
+	return { tag: "empty" };
+}
+export function text(s) {
+	return {
+		tag: "text",
+		text: s
+	};
+}
+
+export function line() {
+	return { tag: "line" };
+}
+
+export function nest(indent, doc) {
+	return {
+		tag: "nest",
+		indent,
+		doc
+	};
+}
+
+export function group(doc) {
+	return {
+		tag: "group",
+		doc
+	};
+}
+
+export function concat(...docs) {
+	const filtered = docs.filter((d) => d.tag !== "empty");
+	if (filtered.length === 0) return empty();
+	if (filtered.length === 1) return filtered[0];
+	return {
+		tag: "concat",
+		docs: filtered
+	};
+}
+
+export function join(sep, docs) {
+	if (docs.length === 0) return empty();
+	const result = [];
+	for (let i = 0; i < docs.length; i++) {
+		if (i > 0) result.push(sep);
+		result.push(docs[i]);
+	}
+	return concat(...result);
+}
+
+export function textLine(s) {
+	return concat(text(s), line());
+}
+
+export function render(doc, width = 80) {
+	let output = "";
+	let col = 0;
+	const stack = [[
+		0,
+		"break",
+		doc
+	]];
+	while (stack.length > 0) {
+		const [indent, mode, d] = stack.pop();
+		switch (d.tag) {
+			case "empty": break;
+			case "text":
+				output += d.text;
+				col += d.text.length;
+				break;
+			case "line":
+				if (mode === "flat") {
+					output += " ";
+					col += 1;
+				} else {
+					output += "\n" + " ".repeat(indent);
+					col = indent;
+				}
+				break;
+			case "nest":
+				stack.push([
+					indent + d.indent,
+					mode,
+					d.doc
+				]);
+				break;
+			case "group":
+				if (mode === "flat") {
+					stack.push([
+						indent,
+						"flat",
+						d.doc
+					]);
+				} else {
+					
+					const flat = measureFlat(d.doc);
+					if (flat !== null && col + flat <= width) {
+						stack.push([
+							indent,
+							"flat",
+							d.doc
+						]);
+					} else {
+						stack.push([
+							indent,
+							"break",
+							d.doc
+						]);
+					}
+				}
+				break;
+			case "concat":
+				
+				for (let i = d.docs.length - 1; i >= 0; i--) {
+					stack.push([
+						indent,
+						mode,
+						d.docs[i]
+					]);
+				}
+				break;
+		}
+	}
+	return output;
+}
+
+function measureFlat(doc) {
+	let width = 0;
+	const stack = [doc];
+	while (stack.length > 0) {
+		const d = stack.pop();
+		switch (d.tag) {
+			case "empty": break;
+			case "text":
+				width += d.text.length;
+				break;
+			case "line":
+				width += 1;
+				break;
+			case "nest":
+				stack.push(d.doc);
+				break;
+			case "group":
+				stack.push(d.doc);
+				break;
+			case "concat":
+				for (let i = d.docs.length - 1; i >= 0; i--) {
+					stack.push(d.docs[i]);
+				}
+				break;
+		}
+	}
+	return width;
+}

package/dist/printer/formatter.d.mts

@@ -0,0 +1,5 @@
+export interface FormatOptions {
+	indent?: string;
+	uppercase?: boolean;
+}
+export declare function formatSQL(sql: string, options?: FormatOptions): string;