sumak 0.0.3 → 0.0.5

package/dist/builder/eb.mjs

@@ -0,0 +1,399 @@
+import { col as rawCol, lit as rawLit, param as rawParam, and as rawAnd, or as rawOr, fn as rawFn, star as rawStar, exists as rawExists, cast as rawCast, not as rawNot } from "../ast/expression.mjs";
+
+export class Col {
+	
+	_node;
+	constructor(column, table) {
+		this._node = rawCol(column, table);
+	}
+	
+	eq(value) {
+		return wrap(binOp("=", this._node, autoParam(value)));
+	}
+	
+	neq(value) {
+		return wrap(binOp("!=", this._node, autoParam(value)));
+	}
+	
+	gt(value) {
+		return wrap(binOp(">", this._node, autoParam(value)));
+	}
+	
+	gte(value) {
+		return wrap(binOp(">=", this._node, autoParam(value)));
+	}
+	
+	lt(value) {
+		return wrap(binOp("<", this._node, autoParam(value)));
+	}
+	
+	lte(value) {
+		return wrap(binOp("<=", this._node, autoParam(value)));
+	}
+	
+	like(pattern) {
+		return wrap(binOp("LIKE", this._node, rawLit(pattern)));
+	}
+	
+	in(values) {
+		return wrap({
+			type: "in",
+			expr: this._node,
+			values: values.map((v) => autoParam(v)),
+			negated: false
+		});
+	}
+	
+	notIn(values) {
+		return wrap({
+			type: "in",
+			expr: this._node,
+			values: values.map((v) => autoParam(v)),
+			negated: true
+		});
+	}
+	
+	isNull() {
+		return wrap({
+			type: "is_null",
+			expr: this._node,
+			negated: false
+		});
+	}
+	
+	isNotNull() {
+		return wrap({
+			type: "is_null",
+			expr: this._node,
+			negated: true
+		});
+	}
+	
+	between(low, high) {
+		return wrap({
+			type: "between",
+			expr: this._node,
+			low: autoParam(low),
+			high: autoParam(high),
+			negated: false
+		});
+	}
+	
+	eqCol(other) {
+		return wrap(binOp("=", this._node, other._node));
+	}
+	
+	toExpr() {
+		return wrap(this._node);
+	}
+}
+
+let _paramIdx = 0;
+export function resetParams() {
+	_paramIdx = 0;
+}
+function autoParam(value) {
+	return rawParam(_paramIdx++, value);
+}
+function binOp(op, left, right) {
+	return {
+		type: "binary_op",
+		op,
+		left,
+		right
+	};
+}
+function wrap(node) {
+	return { node };
+}
+
+export function createColumnProxies(_table) {
+	return new Proxy({}, { get(_target, prop) {
+		return new Col(prop, undefined);
+	} });
+}
+
+
+export function and(left, right) {
+	return wrap(rawAnd(left.node, right.node));
+}
+
+export function or(left, right) {
+	return wrap(rawOr(left.node, right.node));
+}
+
+export function val(value) {
+	return wrap(rawLit(value));
+}
+
+export function sqlFn(name, ...args) {
+	return wrap(rawFn(name, args.map((a) => a.node)));
+}
+
+export function count() {
+	return wrap(rawFn("COUNT", [rawStar()]));
+}
+
+export function countDistinct(expr) {
+	const node = {
+		type: "function_call",
+		name: "COUNT",
+		args: [expr.node],
+		distinct: true
+	};
+	return wrap(node);
+}
+
+export function sum(expr) {
+	return wrap(rawFn("SUM", [expr.node]));
+}
+
+export function avg(expr) {
+	return wrap(rawFn("AVG", [expr.node]));
+}
+
+export function min(expr) {
+	return wrap(rawFn("MIN", [expr.node]));
+}
+
+export function max(expr) {
+	return wrap(rawFn("MAX", [expr.node]));
+}
+
+export function coalesce(expr, fallback) {
+	return wrap(rawFn("COALESCE", [expr.node, fallback.node]));
+}
+
+export function not(expr) {
+	return wrap(rawNot(expr.node));
+}
+
+export function exists(query) {
+	return wrap(rawExists(query));
+}
+
+export function notExists(query) {
+	return wrap(rawExists(query, true));
+}
+
+export function cast(expr, dataType) {
+	return wrap(rawCast(expr.node, dataType));
+}
+
+export function jsonRef(expr, path, operator = "->") {
+	const node = {
+		type: "json_access",
+		expr: expr.node,
+		path,
+		operator
+	};
+	return wrap(node);
+}
+
+export function textSearch(columns, query, options) {
+	const node = {
+		type: "full_text_search",
+		columns: columns.map((c) => c.node),
+		query: query.node,
+		mode: options?.mode,
+		language: options?.language
+	};
+	return wrap(node);
+}
+
+export function case_(operand) {
+	return new CaseBuilder(operand ? operand.node : undefined, []);
+}
+export class CaseBuilder {
+	
+	_operand;
+	
+	_whens;
+	
+	_else;
+	
+	constructor(operand, whens, else_) {
+		this._operand = operand;
+		this._whens = whens;
+		this._else = else_;
+	}
+	when(condition, result) {
+		return new CaseBuilder(this._operand, [...this._whens, {
+			condition: condition.node,
+			result: result.node
+		}]);
+	}
+	else_(result) {
+		return new CaseBuilder(this._operand, this._whens, result.node);
+	}
+	end() {
+		const node = {
+			type: "case",
+			operand: this._operand,
+			whens: this._whens,
+			else_: this._else
+		};
+		return wrap(node);
+	}
+}
+
+
+export function over(fn, build) {
+	const builder = build(new WindowBuilder());
+	const fnNode = fn.node;
+	const node = {
+		type: "window_function",
+		fn: fnNode,
+		partitionBy: builder._partitionBy,
+		orderBy: builder._orderBy,
+		frame: builder._frame
+	};
+	return wrap(node);
+}
+export class WindowBuilder {
+	
+	_partitionBy = [];
+	
+	_orderBy = [];
+	
+	_frame;
+	partitionBy(...columns) {
+		const b = new WindowBuilder();
+		b._partitionBy = columns.map((c) => rawCol(c));
+		b._orderBy = this._orderBy;
+		b._frame = this._frame;
+		return b;
+	}
+	orderBy(column, direction = "ASC") {
+		const b = new WindowBuilder();
+		b._partitionBy = this._partitionBy;
+		b._orderBy = [...this._orderBy, {
+			expr: rawCol(column),
+			direction
+		}];
+		b._frame = this._frame;
+		return b;
+	}
+	rows(start, end) {
+		return this._withFrame("ROWS", start, end);
+	}
+	range(start, end) {
+		return this._withFrame("RANGE", start, end);
+	}
+	
+	_withFrame(kind, start, end) {
+		const b = new WindowBuilder();
+		b._partitionBy = this._partitionBy;
+		b._orderBy = this._orderBy;
+		b._frame = {
+			kind,
+			start,
+			end
+		};
+		return b;
+	}
+}
+
+
+export function rowNumber() {
+	return wrap(rawFn("ROW_NUMBER", []));
+}
+
+export function rank() {
+	return wrap(rawFn("RANK", []));
+}
+
+export function denseRank() {
+	return wrap(rawFn("DENSE_RANK", []));
+}
+
+export function lag(expr, offset, defaultValue) {
+	const args = [expr.node];
+	if (offset !== undefined) args.push(rawLit(offset));
+	if (defaultValue !== undefined) args.push(defaultValue.node);
+	return wrap(rawFn("LAG", args));
+}
+
+export function lead(expr, offset, defaultValue) {
+	const args = [expr.node];
+	if (offset !== undefined) args.push(rawLit(offset));
+	if (defaultValue !== undefined) args.push(defaultValue.node);
+	return wrap(rawFn("LEAD", args));
+}
+
+export function ntile(n) {
+	return wrap(rawFn("NTILE", [rawLit(n)]));
+}
+
+
+export function upper(expr) {
+	return wrap(rawFn("UPPER", [expr.node]));
+}
+
+export function lower(expr) {
+	return wrap(rawFn("LOWER", [expr.node]));
+}
+
+export function concat(...args) {
+	return wrap(rawFn("CONCAT", args.map((a) => a.node)));
+}
+
+export function substring(expr, start, length) {
+	const args = [expr.node, rawLit(start)];
+	if (length !== undefined) args.push(rawLit(length));
+	return wrap(rawFn("SUBSTRING", args));
+}
+
+export function trim(expr) {
+	return wrap(rawFn("TRIM", [expr.node]));
+}
+
+export function length(expr) {
+	return wrap(rawFn("LENGTH", [expr.node]));
+}
+
+export function now() {
+	return wrap(rawFn("NOW", []));
+}
+
+export function currentTimestamp() {
+	return wrap(rawFn("CURRENT_TIMESTAMP", []));
+}
+
+export function nullif(a, b) {
+	return wrap(rawFn("NULLIF", [a.node, b.node]));
+}
+
+export function greatest(...args) {
+	return wrap(rawFn("GREATEST", args.map((a) => a.node)));
+}
+
+export function least(...args) {
+	return wrap(rawFn("LEAST", args.map((a) => a.node)));
+}
+
+export function abs(expr) {
+	return wrap(rawFn("ABS", [expr.node]));
+}
+
+export function round(expr, precision) {
+	const args = [expr.node];
+	if (precision !== undefined) args.push(rawLit(precision));
+	return wrap(rawFn("ROUND", args));
+}
+
+export function ceil(expr) {
+	return wrap(rawFn("CEIL", [expr.node]));
+}
+
+export function floor(expr) {
+	return wrap(rawFn("FLOOR", [expr.node]));
+}
+
+export function filter(agg, condition) {
+	const fnNode = agg.node;
+	return wrap({
+		...fnNode,
+		filter: condition.node
+	});
+}

package/dist/builder/expression.d.mts

@@ -0,0 +1,5 @@
+import { and, between, binOp, col, eq, exists, gt, gte, inList, isNull, like, lit, lt, lte, neq, not, or } from "../ast/expression.mjs";
+import type { ExpressionNode } from "../ast/nodes.mjs";
+export declare function resetParamCounter(): void;
+export declare function val(value: unknown): ExpressionNode;
+export { and, between, binOp, col, eq, exists, gt, gte, inList, isNull, like, lit, lt, lte, neq, not, or };

package/dist/builder/expression.mjs

@@ -0,0 +1,10 @@
+import { and, between, binOp, col, eq, exists, gt, gte, inList, isNull, like, lit, lt, lte, neq, not, or, param } from "../ast/expression.mjs";
+let paramCounter = 0;
+export function resetParamCounter() {
+	paramCounter = 0;
+}
+export function val(value) {
+	const index = paramCounter++;
+	return param(index, value);
+}
+export { and, between, binOp, col, eq, exists, gt, gte, inList, isNull, like, lit, lt, lte, neq, not, or };

package/dist/builder/insert.d.mts

@@ -0,0 +1,40 @@
+import type { ExpressionNode, InsertMode, InsertNode, SelectNode, TableRefNode } from "../ast/nodes.mjs";
+export declare class InsertBuilder {
+	private node;
+	private paramIndex;
+	constructor(node?: InsertNode, paramIndex?: number);
+	into(table: string | TableRefNode): InsertBuilder;
+	columns(...cols: string[]): InsertBuilder;
+	values(...vals: unknown[]): InsertBuilder;
+	returning(...exprs: ExpressionNode[]): InsertBuilder;
+	onConflictDoNothing(...columns: string[]): InsertBuilder;
+	onConflictDoUpdate(columns: string[], set: {
+		column: string;
+		value: ExpressionNode;
+	}[], where?: ExpressionNode): InsertBuilder;
+	/** ON CONFLICT ON CONSTRAINT name DO NOTHING */
+	onConflictConstraintDoNothing(constraint: string): InsertBuilder;
+	/** ON CONFLICT ON CONSTRAINT name DO UPDATE SET ... */
+	onConflictConstraintDoUpdate(constraint: string, set: {
+		column: string;
+		value: ExpressionNode;
+	}[], where?: ExpressionNode): InsertBuilder;
+	/** Set insert mode (SQLite: INSERT OR IGNORE, INSERT OR REPLACE, etc.) */
+	mode(mode: InsertMode): InsertBuilder;
+	/** Shorthand: INSERT OR IGNORE (SQLite) */
+	orIgnore(): InsertBuilder;
+	/** Shorthand: INSERT OR REPLACE (SQLite) */
+	orReplace(): InsertBuilder;
+	/** MySQL: ON DUPLICATE KEY UPDATE */
+	onDuplicateKeyUpdate(set: {
+		column: string;
+		value: ExpressionNode;
+	}[]): InsertBuilder;
+	/** INSERT INTO ... SELECT ... */
+	fromSelect(query: SelectNode): InsertBuilder;
+	/** INSERT INTO ... DEFAULT VALUES */
+	defaultValues(): InsertBuilder;
+	with(name: string, query: SelectNode, recursive?: boolean): InsertBuilder;
+	build(): InsertNode;
+}
+export declare function insert(table: string | TableRefNode): InsertBuilder;

package/dist/builder/insert.mjs

@@ -0,0 +1,146 @@
+import { param } from "../ast/expression.mjs";
+import { createInsertNode } from "../ast/nodes.mjs";
+export class InsertBuilder {
+	node;
+	paramIndex;
+	constructor(node, paramIndex = 0) {
+		this.node = node ?? createInsertNode({
+			type: "table_ref",
+			name: ""
+		});
+		this.paramIndex = paramIndex;
+	}
+	into(table) {
+		const ref = typeof table === "string" ? {
+			type: "table_ref",
+			name: table
+		} : table;
+		return new InsertBuilder({
+			...this.node,
+			table: ref
+		}, this.paramIndex);
+	}
+	columns(...cols) {
+		return new InsertBuilder({
+			...this.node,
+			columns: [...this.node.columns, ...cols]
+		}, this.paramIndex);
+	}
+	values(...vals) {
+		let idx = this.paramIndex;
+		const row = vals.map((v) => {
+			const p = param(idx, v);
+			idx++;
+			return p;
+		});
+		return new InsertBuilder({
+			...this.node,
+			values: [...this.node.values, row]
+		}, idx);
+	}
+	returning(...exprs) {
+		return new InsertBuilder({
+			...this.node,
+			returning: [...this.node.returning, ...exprs]
+		}, this.paramIndex);
+	}
+	onConflictDoNothing(...columns) {
+		const conflict = {
+			columns,
+			action: "nothing"
+		};
+		return new InsertBuilder({
+			...this.node,
+			onConflict: conflict
+		}, this.paramIndex);
+	}
+	onConflictDoUpdate(columns, set, where) {
+		const conflict = {
+			columns,
+			action: { set },
+			where
+		};
+		return new InsertBuilder({
+			...this.node,
+			onConflict: conflict
+		}, this.paramIndex);
+	}
+	
+	onConflictConstraintDoNothing(constraint) {
+		const conflict = {
+			columns: [],
+			constraint,
+			action: "nothing"
+		};
+		return new InsertBuilder({
+			...this.node,
+			onConflict: conflict
+		}, this.paramIndex);
+	}
+	
+	onConflictConstraintDoUpdate(constraint, set, where) {
+		const conflict = {
+			columns: [],
+			constraint,
+			action: { set },
+			where
+		};
+		return new InsertBuilder({
+			...this.node,
+			onConflict: conflict
+		}, this.paramIndex);
+	}
+	
+	mode(mode) {
+		return new InsertBuilder({
+			...this.node,
+			insertMode: mode
+		}, this.paramIndex);
+	}
+	
+	orIgnore() {
+		return this.mode("INSERT OR IGNORE");
+	}
+	
+	orReplace() {
+		return this.mode("INSERT OR REPLACE");
+	}
+	
+	onDuplicateKeyUpdate(set) {
+		return new InsertBuilder({
+			...this.node,
+			onDuplicateKeyUpdate: set
+		}, this.paramIndex);
+	}
+	
+	fromSelect(query) {
+		return new InsertBuilder({
+			...this.node,
+			source: query
+		}, this.paramIndex);
+	}
+	
+	defaultValues() {
+		return new InsertBuilder({
+			...this.node,
+			defaultValues: true
+		}, this.paramIndex);
+	}
+	with(name, query, recursive = false) {
+		const cte = {
+			name,
+			query,
+			recursive
+		};
+		return new InsertBuilder({
+			...this.node,
+			ctes: [...this.node.ctes, cte]
+		}, this.paramIndex);
+	}
+	build() {
+		return { ...this.node };
+	}
+}
+export function insert(table) {
+	return new InsertBuilder().into(table);
+}

package/dist/builder/merge.d.mts

@@ -0,0 +1,20 @@
+import type { ExpressionNode, MergeNode, MergeWhenMatched, MergeWhenNotMatched, SelectNode, SubqueryNode, TableRefNode } from "../ast/nodes.mjs";
+export declare class MergeBuilder {
+	private node;
+	private paramIndex;
+	constructor(node?: MergeNode, paramIndex?: number);
+	into(table: string | TableRefNode): MergeBuilder;
+	using(source: string | TableRefNode | SubqueryNode, alias: string): MergeBuilder;
+	on(expr: ExpressionNode): MergeBuilder;
+	whenMatched(action: MergeWhenMatched): MergeBuilder;
+	whenNotMatched(action: MergeWhenNotMatched): MergeBuilder;
+	whenMatchedUpdate(set: {
+		column: string;
+		value: ExpressionNode;
+	}[], condition?: ExpressionNode): MergeBuilder;
+	whenMatchedDelete(condition?: ExpressionNode): MergeBuilder;
+	whenNotMatchedInsert(columns: string[], values: ExpressionNode[], condition?: ExpressionNode): MergeBuilder;
+	with(name: string, query: SelectNode, recursive?: boolean): MergeBuilder;
+	build(): MergeNode;
+}
+export declare function merge(target: string | TableRefNode): MergeBuilder;

package/dist/builder/merge.mjs

@@ -0,0 +1,100 @@
+import { createMergeNode } from "../ast/nodes.mjs";
+export class MergeBuilder {
+	node;
+	paramIndex;
+	constructor(node, paramIndex = 0) {
+		this.node = node ?? createMergeNode({
+			type: "table_ref",
+			name: ""
+		}, {
+			type: "table_ref",
+			name: ""
+		}, "src", {
+			type: "literal",
+			value: true
+		});
+		this.paramIndex = paramIndex;
+	}
+	into(table) {
+		const ref = typeof table === "string" ? {
+			type: "table_ref",
+			name: table
+		} : table;
+		return new MergeBuilder({
+			...this.node,
+			target: ref
+		}, this.paramIndex);
+	}
+	using(source, alias) {
+		const src = typeof source === "string" ? {
+			type: "table_ref",
+			name: source
+		} : source;
+		return new MergeBuilder({
+			...this.node,
+			source: src,
+			sourceAlias: alias
+		}, this.paramIndex);
+	}
+	on(expr) {
+		return new MergeBuilder({
+			...this.node,
+			on: expr
+		}, this.paramIndex);
+	}
+	whenMatched(action) {
+		return new MergeBuilder({
+			...this.node,
+			whens: [...this.node.whens, action]
+		}, this.paramIndex);
+	}
+	whenNotMatched(action) {
+		return new MergeBuilder({
+			...this.node,
+			whens: [...this.node.whens, action]
+		}, this.paramIndex);
+	}
+	whenMatchedUpdate(set, condition) {
+		const when = {
+			type: "matched",
+			action: "update",
+			set,
+			condition
+		};
+		return this.whenMatched(when);
+	}
+	whenMatchedDelete(condition) {
+		const when = {
+			type: "matched",
+			action: "delete",
+			condition
+		};
+		return this.whenMatched(when);
+	}
+	whenNotMatchedInsert(columns, values, condition) {
+		const when = {
+			type: "not_matched",
+			columns,
+			values,
+			condition
+		};
+		return this.whenNotMatched(when);
+	}
+	with(name, query, recursive = false) {
+		const cte = {
+			name,
+			query,
+			recursive
+		};
+		return new MergeBuilder({
+			...this.node,
+			ctes: [...this.node.ctes, cte]
+		}, this.paramIndex);
+	}
+	build() {
+		return { ...this.node };
+	}
+}
+export function merge(target) {
+	return new MergeBuilder().into(target);
+}

package/dist/builder/raw.d.mts

@@ -0,0 +1,2 @@
+import type { RawNode } from "../ast/nodes.mjs";
+export declare function raw(sql: string, params?: unknown[]): RawNode;