sumak 0.0.4 → 0.0.6

package/dist/ast/nodes.d.mts

@@ -0,0 +1,309 @@
+import type { JoinType, OrderDirection, SetOperator } from "../types.mjs";
+export type ASTNode = SelectNode | InsertNode | UpdateNode | DeleteNode | MergeNode | ExplainNode | ExpressionNode;
+export interface ExplainNode {
+	type: "explain";
+	statement: SelectNode | InsertNode | UpdateNode | DeleteNode;
+	analyze?: boolean;
+	format?: "TEXT" | "JSON" | "YAML" | "XML";
+}
+export type ExpressionNode = ColumnRefNode | LiteralNode | BinaryOpNode | UnaryOpNode | FunctionCallNode | ParamNode | RawNode | SubqueryNode | BetweenNode | InNode | IsNullNode | CaseNode | CastNode | ExistsNode | StarNode | JsonAccessNode | ArrayExprNode | WindowFunctionNode | AliasedExprNode | FullTextSearchNode | TupleNode;
+export interface ColumnRefNode {
+	type: "column_ref";
+	table?: string;
+	column: string;
+	alias?: string;
+}
+export interface LiteralNode {
+	type: "literal";
+	value: string | number | boolean | null;
+}
+export interface BinaryOpNode {
+	type: "binary_op";
+	op: string;
+	left: ExpressionNode;
+	right: ExpressionNode;
+}
+export interface UnaryOpNode {
+	type: "unary_op";
+	op: string;
+	operand: ExpressionNode;
+	position: "prefix" | "postfix";
+}
+export interface FunctionCallNode {
+	type: "function_call";
+	name: string;
+	args: ExpressionNode[];
+	distinct?: boolean;
+	filter?: ExpressionNode;
+	orderBy?: OrderByNode[];
+	alias?: string;
+}
+export interface ParamNode {
+	type: "param";
+	index: number;
+	value: unknown;
+}
+export interface RawNode {
+	type: "raw";
+	sql: string;
+	params: unknown[];
+}
+export interface SubqueryNode {
+	type: "subquery";
+	query: SelectNode;
+	alias?: string;
+}
+export interface BetweenNode {
+	type: "between";
+	expr: ExpressionNode;
+	low: ExpressionNode;
+	high: ExpressionNode;
+	negated: boolean;
+	symmetric?: boolean;
+}
+export interface InNode {
+	type: "in";
+	expr: ExpressionNode;
+	values: ExpressionNode[] | SelectNode;
+	negated: boolean;
+}
+export interface IsNullNode {
+	type: "is_null";
+	expr: ExpressionNode;
+	negated: boolean;
+}
+export interface CaseNode {
+	type: "case";
+	operand?: ExpressionNode;
+	whens: {
+		condition: ExpressionNode;
+		result: ExpressionNode;
+	}[];
+	else_?: ExpressionNode;
+}
+export interface CastNode {
+	type: "cast";
+	expr: ExpressionNode;
+	dataType: string;
+}
+export interface ExistsNode {
+	type: "exists";
+	query: SelectNode;
+	negated: boolean;
+}
+export interface StarNode {
+	type: "star";
+	table?: string;
+}
+export type FullTextSearchMode = "natural" | "boolean" | "expansion";
+export interface FullTextSearchNode {
+	type: "full_text_search";
+	columns: ExpressionNode[];
+	query: ExpressionNode;
+	mode?: FullTextSearchMode;
+	language?: string;
+	alias?: string;
+}
+export interface TupleNode {
+	type: "tuple";
+	elements: ExpressionNode[];
+}
+export interface AliasedExprNode {
+	type: "aliased_expr";
+	expr: ExpressionNode;
+	alias: string;
+}
+export type TemporalClause = {
+	kind: "as_of";
+	timestamp: ExpressionNode;
+} | {
+	kind: "from_to";
+	start: ExpressionNode;
+	end: ExpressionNode;
+} | {
+	kind: "between";
+	start: ExpressionNode;
+	end: ExpressionNode;
+} | {
+	kind: "contained_in";
+	start: ExpressionNode;
+	end: ExpressionNode;
+} | {
+	kind: "all";
+};
+export interface TableRefNode {
+	type: "table_ref";
+	name: string;
+	alias?: string;
+	schema?: string;
+	temporal?: TemporalClause;
+}
+export interface JoinNode {
+	type: "join";
+	joinType: JoinType;
+	table: TableRefNode | SubqueryNode;
+	on?: ExpressionNode;
+	lateral?: boolean;
+}
+export interface JsonAccessNode {
+	type: "json_access";
+	expr: ExpressionNode;
+	path: string;
+	operator: "->" | "->>" | "#>" | "#>>";
+	alias?: string;
+}
+export interface ArrayExprNode {
+	type: "array_expr";
+	elements: ExpressionNode[];
+}
+export type FrameKind = "ROWS" | "RANGE" | "GROUPS";
+export type FrameBound = {
+	type: "unbounded_preceding";
+} | {
+	type: "preceding";
+	value: number;
+} | {
+	type: "current_row";
+} | {
+	type: "following";
+	value: number;
+} | {
+	type: "unbounded_following";
+};
+export interface FrameSpec {
+	kind: FrameKind;
+	start: FrameBound;
+	end?: FrameBound;
+}
+export interface WindowFunctionNode {
+	type: "window_function";
+	fn: FunctionCallNode;
+	partitionBy: ExpressionNode[];
+	orderBy: OrderByNode[];
+	frame?: FrameSpec;
+	alias?: string;
+}
+export interface OrderByNode {
+	expr: ExpressionNode;
+	direction: OrderDirection;
+	nulls?: "FIRST" | "LAST";
+}
+export interface CTENode {
+	name: string;
+	query: SelectNode;
+	recursive: boolean;
+}
+export interface WindowNode {
+	partitionBy: ExpressionNode[];
+	orderBy: OrderByNode[];
+}
+export type LockMode = "UPDATE" | "SHARE" | "NO KEY UPDATE" | "KEY SHARE";
+export interface LockClause {
+	mode: LockMode;
+	skipLocked?: boolean;
+	noWait?: boolean;
+}
+export interface SelectNode {
+	type: "select";
+	distinct: boolean;
+	distinctOn?: ExpressionNode[];
+	columns: ExpressionNode[];
+	from?: TableRefNode | SubqueryNode;
+	joins: JoinNode[];
+	where?: ExpressionNode;
+	groupBy: ExpressionNode[];
+	having?: ExpressionNode;
+	orderBy: OrderByNode[];
+	limit?: ExpressionNode;
+	offset?: ExpressionNode;
+	ctes: CTENode[];
+	setOp?: {
+		op: SetOperator;
+		query: SelectNode;
+	};
+	lock?: LockClause;
+}
+export type InsertMode = "INSERT" | "INSERT OR IGNORE" | "INSERT OR REPLACE" | "INSERT OR ABORT" | "INSERT OR ROLLBACK" | "INSERT OR FAIL";
+export interface InsertNode {
+	type: "insert";
+	insertMode?: InsertMode;
+	table: TableRefNode;
+	columns: string[];
+	values: ExpressionNode[][];
+	returning: ExpressionNode[];
+	onConflict?: OnConflictNode;
+	onDuplicateKeyUpdate?: {
+		column: string;
+		value: ExpressionNode;
+	}[];
+	ctes: CTENode[];
+	source?: SelectNode;
+	defaultValues?: boolean;
+}
+export interface OnConflictNode {
+	columns: string[];
+	constraint?: string;
+	action: "nothing" | {
+		set: {
+			column: string;
+			value: ExpressionNode;
+		}[];
+	};
+	where?: ExpressionNode;
+}
+export interface UpdateNode {
+	type: "update";
+	table: TableRefNode;
+	set: {
+		column: string;
+		value: ExpressionNode;
+	}[];
+	where?: ExpressionNode;
+	returning: ExpressionNode[];
+	from?: TableRefNode;
+	joins: JoinNode[];
+	ctes: CTENode[];
+	orderBy?: OrderByNode[];
+	limit?: ExpressionNode;
+}
+export interface DeleteNode {
+	type: "delete";
+	table: TableRefNode;
+	where?: ExpressionNode;
+	returning: ExpressionNode[];
+	ctes: CTENode[];
+	using?: TableRefNode;
+	joins: JoinNode[];
+	orderBy?: OrderByNode[];
+	limit?: ExpressionNode;
+}
+export interface MergeWhenMatched {
+	type: "matched";
+	condition?: ExpressionNode;
+	action: "update" | "delete";
+	set?: {
+		column: string;
+		value: ExpressionNode;
+	}[];
+}
+export interface MergeWhenNotMatched {
+	type: "not_matched";
+	condition?: ExpressionNode;
+	columns: string[];
+	values: ExpressionNode[];
+}
+export interface MergeNode {
+	type: "merge";
+	target: TableRefNode;
+	source: TableRefNode | SubqueryNode;
+	sourceAlias: string;
+	on: ExpressionNode;
+	whens: (MergeWhenMatched | MergeWhenNotMatched)[];
+	ctes: CTENode[];
+}
+export declare function createMergeNode(target: TableRefNode, source: TableRefNode | SubqueryNode, sourceAlias: string, on: ExpressionNode): MergeNode;
+export declare function tableRef(name: string, alias?: string, schema?: string): TableRefNode;
+export declare function createSelectNode(): SelectNode;
+export declare function createInsertNode(table: TableRefNode): InsertNode;
+export declare function createUpdateNode(table: TableRefNode): UpdateNode;
+export declare function createDeleteNode(table: TableRefNode): DeleteNode;

package/dist/ast/nodes.mjs

@@ -0,0 +1,59 @@
+export function createMergeNode(target, source, sourceAlias, on) {
+	return {
+		type: "merge",
+		target,
+		source,
+		sourceAlias,
+		on,
+		whens: [],
+		ctes: []
+	};
+}
+export function tableRef(name, alias, schema) {
+	return Object.freeze({
+		type: "table_ref",
+		name,
+		alias,
+		schema
+	});
+}
+export function createSelectNode() {
+	return {
+		type: "select",
+		distinct: false,
+		columns: [],
+		joins: [],
+		groupBy: [],
+		orderBy: [],
+		ctes: []
+	};
+}
+export function createInsertNode(table) {
+	return {
+		type: "insert",
+		table,
+		columns: [],
+		values: [],
+		returning: [],
+		ctes: []
+	};
+}
+export function createUpdateNode(table) {
+	return {
+		type: "update",
+		table,
+		set: [],
+		returning: [],
+		joins: [],
+		ctes: []
+	};
+}
+export function createDeleteNode(table) {
+	return {
+		type: "delete",
+		table,
+		returning: [],
+		ctes: [],
+		joins: []
+	};
+}

package/dist/ast/transformer.d.mts

@@ -0,0 +1,10 @@
+import type { ASTNode, DeleteNode, ExpressionNode, InsertNode, MergeNode, SelectNode, UpdateNode } from "./nodes.mjs";
+export declare class ASTTransformer {
+	transform(node: ASTNode): ASTNode;
+	transformSelect(node: SelectNode): SelectNode;
+	transformInsert(node: InsertNode): InsertNode;
+	transformUpdate(node: UpdateNode): UpdateNode;
+	transformDelete(node: DeleteNode): DeleteNode;
+	transformMerge(node: MergeNode): MergeNode;
+	transformExpression(node: ExpressionNode): ExpressionNode;
+}

package/dist/ast/transformer.mjs

@@ -0,0 +1,140 @@
+export class ASTTransformer {
+	transform(node) {
+		switch (node.type) {
+			case "select": return this.transformSelect(node);
+			case "insert": return this.transformInsert(node);
+			case "update": return this.transformUpdate(node);
+			case "delete": return this.transformDelete(node);
+			case "merge": return this.transformMerge(node);
+			case "explain": return {
+				...node,
+				statement: this.transform(node.statement)
+			};
+			default: return this.transformExpression(node);
+		}
+	}
+	transformSelect(node) {
+		return {
+			...node,
+			columns: node.columns.map((c) => this.transformExpression(c)),
+			where: node.where ? this.transformExpression(node.where) : undefined,
+			having: node.having ? this.transformExpression(node.having) : undefined,
+			joins: node.joins.map((j) => ({
+				...j,
+				on: j.on ? this.transformExpression(j.on) : undefined
+			})),
+			orderBy: node.orderBy.map((o) => ({
+				...o,
+				expr: this.transformExpression(o.expr)
+			}))
+		};
+	}
+	transformInsert(node) {
+		return {
+			...node,
+			values: node.values.map((row) => row.map((v) => this.transformExpression(v)))
+		};
+	}
+	transformUpdate(node) {
+		return {
+			...node,
+			set: node.set.map((s) => ({
+				...s,
+				value: this.transformExpression(s.value)
+			})),
+			where: node.where ? this.transformExpression(node.where) : undefined
+		};
+	}
+	transformDelete(node) {
+		return {
+			...node,
+			where: node.where ? this.transformExpression(node.where) : undefined
+		};
+	}
+	transformMerge(node) {
+		return {
+			...node,
+			on: this.transformExpression(node.on),
+			whens: node.whens.map((w) => {
+				if (w.type === "matched") {
+					return {
+						...w,
+						condition: w.condition ? this.transformExpression(w.condition) : undefined,
+						set: w.set?.map((s) => ({
+							...s,
+							value: this.transformExpression(s.value)
+						}))
+					};
+				}
+				return {
+					...w,
+					condition: w.condition ? this.transformExpression(w.condition) : undefined,
+					values: w.values.map((v) => this.transformExpression(v))
+				};
+			})
+		};
+	}
+	transformExpression(node) {
+		switch (node.type) {
+			case "binary_op": return {
+				...node,
+				left: this.transformExpression(node.left),
+				right: this.transformExpression(node.right)
+			};
+			case "unary_op": return {
+				...node,
+				operand: this.transformExpression(node.operand)
+			};
+			case "function_call": return {
+				...node,
+				args: node.args.map((a) => this.transformExpression(a))
+			};
+			case "between": return {
+				...node,
+				expr: this.transformExpression(node.expr),
+				low: this.transformExpression(node.low),
+				high: this.transformExpression(node.high)
+			};
+			case "in": return {
+				...node,
+				expr: this.transformExpression(node.expr),
+				values: Array.isArray(node.values) ? node.values.map((v) => this.transformExpression(v)) : node.values
+			};
+			case "is_null": return {
+				...node,
+				expr: this.transformExpression(node.expr)
+			};
+			case "cast": return {
+				...node,
+				expr: this.transformExpression(node.expr)
+			};
+			case "json_access": return {
+				...node,
+				expr: this.transformExpression(node.expr)
+			};
+			case "array_expr": return {
+				...node,
+				elements: node.elements.map((e) => this.transformExpression(e))
+			};
+			case "window_function": return {
+				...node,
+				fn: this.transformExpression(node.fn),
+				partitionBy: node.partitionBy.map((p) => this.transformExpression(p)),
+				orderBy: node.orderBy.map((o) => ({
+					...o,
+					expr: this.transformExpression(o.expr)
+				}))
+			};
+			case "aliased_expr": return {
+				...node,
+				expr: this.transformExpression(node.expr)
+			};
+			case "full_text_search": return {
+				...node,
+				columns: node.columns.map((c) => this.transformExpression(c)),
+				query: this.transformExpression(node.query)
+			};
+			default: return node;
+		}
+	}
+}

package/dist/ast/typed-expression.d.mts

@@ -0,0 +1,37 @@
+import type { ExpressionNode } from "./nodes.mjs";
+/**
+* Type-safe expression wrapper. The T parameter tracks the expression's
+* output type at compile time. At runtime, this is just an ExpressionNode.
+*
+* The `__type` field is a phantom — it never exists at runtime.
+*/
+export interface Expression<T> {
+	readonly __type: T;
+	readonly node: ExpressionNode;
+}
+/** Unwrap an Expression to its underlying AST node */
+export declare function unwrap<T>(e: Expression<T>): ExpressionNode;
+/** Reference a column — type-safe version */
+export declare function typedCol<T>(column: string, table?: string): Expression<T>;
+/** Wrap a literal value */
+export declare function typedLit<T extends string | number | boolean | null>(value: T): Expression<T>;
+/** Wrap a parameter value */
+export declare function typedParam<T>(index: number, value: T): Expression<T>;
+export declare function typedEq<T>(left: Expression<T>, right: Expression<T>): Expression<boolean>;
+export declare function typedNeq<T>(left: Expression<T>, right: Expression<T>): Expression<boolean>;
+export declare function typedGt<T>(left: Expression<T>, right: Expression<T>): Expression<boolean>;
+export declare function typedGte<T>(left: Expression<T>, right: Expression<T>): Expression<boolean>;
+export declare function typedLt<T>(left: Expression<T>, right: Expression<T>): Expression<boolean>;
+export declare function typedLte<T>(left: Expression<T>, right: Expression<T>): Expression<boolean>;
+export declare function typedLike(left: Expression<string>, right: Expression<string>): Expression<boolean>;
+export declare function typedBetween<T>(value: Expression<T>, low: Expression<T>, high: Expression<T>): Expression<boolean>;
+export declare function typedIn<T>(value: Expression<T>, list: Expression<T>[]): Expression<boolean>;
+export declare function typedIsNull<T>(value: Expression<T>): Expression<boolean>;
+export declare function typedIsNotNull<T>(value: Expression<T>): Expression<boolean>;
+export declare function typedAnd(left: Expression<boolean>, right: Expression<boolean>): Expression<boolean>;
+export declare function typedOr(left: Expression<boolean>, right: Expression<boolean>): Expression<boolean>;
+export declare function typedNot(operand: Expression<boolean>): Expression<boolean>;
+export declare function typedAdd(left: Expression<number>, right: Expression<number>): Expression<number>;
+export declare function typedSub(left: Expression<number>, right: Expression<number>): Expression<number>;
+export declare function typedMul(left: Expression<number>, right: Expression<number>): Expression<number>;
+export declare function typedDiv(left: Expression<number>, right: Expression<number>): Expression<number>;

package/dist/ast/typed-expression.mjs

@@ -0,0 +1,77 @@
+import { and as rawAnd, between as rawBetween, binOp as rawBinOp, col as rawCol, eq as rawEq, gt as rawGt, gte as rawGte, inList as rawInList, isNull as rawIsNull, like as rawLike, lit as rawLit, lt as rawLt, lte as rawLte, neq as rawNeq, not as rawNot, or as rawOr, param as rawParam } from "./expression.mjs";
+function expr(node) {
+	return { node };
+}
+
+export function unwrap(e) {
+	return e.node;
+}
+
+export function typedCol(column, table) {
+	return expr(rawCol(column, table));
+}
+
+export function typedLit(value) {
+	return expr(rawLit(value));
+}
+
+export function typedParam(index, value) {
+	return expr(rawParam(index, value));
+}
+
+export function typedEq(left, right) {
+	return expr(rawEq(left.node, right.node));
+}
+export function typedNeq(left, right) {
+	return expr(rawNeq(left.node, right.node));
+}
+export function typedGt(left, right) {
+	return expr(rawGt(left.node, right.node));
+}
+export function typedGte(left, right) {
+	return expr(rawGte(left.node, right.node));
+}
+export function typedLt(left, right) {
+	return expr(rawLt(left.node, right.node));
+}
+export function typedLte(left, right) {
+	return expr(rawLte(left.node, right.node));
+}
+export function typedLike(left, right) {
+	return expr(rawLike(left.node, right.node));
+}
+export function typedBetween(value, low, high) {
+	return expr(rawBetween(value.node, low.node, high.node));
+}
+export function typedIn(value, list) {
+	return expr(rawInList(value.node, list.map((e) => e.node)));
+}
+export function typedIsNull(value) {
+	return expr(rawIsNull(value.node));
+}
+export function typedIsNotNull(value) {
+	return expr(rawIsNull(value.node, true));
+}
+
+export function typedAnd(left, right) {
+	return expr(rawAnd(left.node, right.node));
+}
+export function typedOr(left, right) {
+	return expr(rawOr(left.node, right.node));
+}
+export function typedNot(operand) {
+	return expr(rawNot(operand.node));
+}
+
+export function typedAdd(left, right) {
+	return expr(rawBinOp("+", left.node, right.node));
+}
+export function typedSub(left, right) {
+	return expr(rawBinOp("-", left.node, right.node));
+}
+export function typedMul(left, right) {
+	return expr(rawBinOp("*", left.node, right.node));
+}
+export function typedDiv(left, right) {
+	return expr(rawBinOp("/", left.node, right.node));
+}

package/dist/ast/visitor.d.mts

@@ -0,0 +1,13 @@
+import type { ASTNode, CTENode, DeleteNode, ExpressionNode, InsertNode, JoinNode, MergeNode, OrderByNode, SelectNode, UpdateNode } from "./nodes.mjs";
+export interface ASTVisitor<R = void> {
+	visitSelect(node: SelectNode): R;
+	visitInsert(node: InsertNode): R;
+	visitUpdate(node: UpdateNode): R;
+	visitDelete(node: DeleteNode): R;
+	visitMerge(node: MergeNode): R;
+	visitExpression(node: ExpressionNode): R;
+	visitJoin(node: JoinNode): R;
+	visitOrderBy(node: OrderByNode): R;
+	visitCTE(node: CTENode): R;
+}
+export declare function visitNode<R>(node: ASTNode, visitor: ASTVisitor<R>): R;

package/dist/ast/visitor.mjs

@@ -0,0 +1,11 @@
+export function visitNode(node, visitor) {
+	switch (node.type) {
+		case "select": return visitor.visitSelect(node);
+		case "insert": return visitor.visitInsert(node);
+		case "update": return visitor.visitUpdate(node);
+		case "delete": return visitor.visitDelete(node);
+		case "merge": return visitor.visitMerge(node);
+		case "explain": return visitNode(node.statement, visitor);
+		default: return visitor.visitExpression(node);
+	}
+}

package/dist/builder/delete.d.mts

@@ -0,0 +1,20 @@
+import type { DeleteNode, ExpressionNode, SelectNode, TableRefNode } from "../ast/nodes.mjs";
+import type { JoinType } from "../types.mjs";
+export declare class DeleteBuilder {
+	private node;
+	constructor(node?: DeleteNode);
+	from(table: string | TableRefNode): DeleteBuilder;
+	where(expr: ExpressionNode): DeleteBuilder;
+	/** USING clause (PG: DELETE FROM t USING other WHERE ...) */
+	using(table: string | TableRefNode): DeleteBuilder;
+	/** Generic JOIN (MySQL pattern: DELETE t FROM t JOIN other ON ...) */
+	join(type: JoinType, table: string | TableRefNode, on?: ExpressionNode): DeleteBuilder;
+	innerJoin(table: string | TableRefNode, on: ExpressionNode): DeleteBuilder;
+	leftJoin(table: string | TableRefNode, on: ExpressionNode): DeleteBuilder;
+	orderBy(expr: string | ExpressionNode, direction?: "ASC" | "DESC"): DeleteBuilder;
+	limit(n: ExpressionNode): DeleteBuilder;
+	returning(...exprs: ExpressionNode[]): DeleteBuilder;
+	with(name: string, query: SelectNode, recursive?: boolean): DeleteBuilder;
+	build(): DeleteNode;
+}
+export declare function deleteFrom(table: string | TableRefNode): DeleteBuilder;