sumak 0.0.4 → 0.0.6

package/dist/builder/eb.mjs

@@ -0,0 +1,641 @@
+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)));
+	}
+	
+	notLike(pattern) {
+		return wrap(binOp("NOT LIKE", this._node, rawLit(pattern)));
+	}
+	
+	ilike(pattern) {
+		return wrap(binOp("ILIKE", this._node, rawLit(pattern)));
+	}
+	
+	notIlike(pattern) {
+		return wrap(binOp("NOT ILIKE", 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
+		});
+	}
+	
+	notBetween(low, high) {
+		return wrap({
+			type: "between",
+			expr: this._node,
+			low: autoParam(low),
+			high: autoParam(high),
+			negated: true
+		});
+	}
+	
+	betweenSymmetric(low, high) {
+		return wrap({
+			type: "between",
+			expr: this._node,
+			low: autoParam(low),
+			high: autoParam(high),
+			negated: false,
+			symmetric: true
+		});
+	}
+	
+	inSubquery(query) {
+		return wrap({
+			type: "in",
+			expr: this._node,
+			values: query,
+			negated: false
+		});
+	}
+	
+	notInSubquery(query) {
+		return wrap({
+			type: "in",
+			expr: this._node,
+			values: query,
+			negated: true
+		});
+	}
+	
+	eqExpr(value) {
+		return wrap(binOp("=", this._node, value.node));
+	}
+	
+	neqExpr(value) {
+		return wrap(binOp("!=", this._node, value.node));
+	}
+	
+	gtExpr(value) {
+		return wrap(binOp(">", this._node, value.node));
+	}
+	
+	gteExpr(value) {
+		return wrap(binOp(">=", this._node, value.node));
+	}
+	
+	ltExpr(value) {
+		return wrap(binOp("<", this._node, value.node));
+	}
+	
+	lteExpr(value) {
+		return wrap(binOp("<=", this._node, value.node));
+	}
+	
+	isDistinctFrom(value) {
+		return wrap(binOp("IS DISTINCT FROM", this._node, autoParam(value)));
+	}
+	
+	isNotDistinctFrom(value) {
+		return wrap(binOp("IS NOT DISTINCT FROM", this._node, autoParam(value)));
+	}
+	
+	eqCol(other) {
+		return wrap(binOp("=", this._node, other._node));
+	}
+	
+	neqCol(other) {
+		return wrap(binOp("!=", this._node, other._node));
+	}
+	
+	gtCol(other) {
+		return wrap(binOp(">", this._node, other._node));
+	}
+	
+	ltCol(other) {
+		return wrap(binOp("<", this._node, other._node));
+	}
+	
+	gteCol(other) {
+		return wrap(binOp(">=", this._node, other._node));
+	}
+	
+	lteCol(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(...exprs) {
+	if (exprs.length === 0) return wrap(rawLit(true));
+	if (exprs.length === 1) return exprs[0];
+	return exprs.reduce((acc, expr) => wrap(rawAnd(acc.node, expr.node)));
+}
+
+export function or(...exprs) {
+	if (exprs.length === 0) return wrap(rawLit(false));
+	if (exprs.length === 1) return exprs[0];
+	return exprs.reduce((acc, expr) => wrap(rawOr(acc.node, expr.node)));
+}
+
+export function val(value) {
+	return wrap(rawLit(value));
+}
+
+export function rawExpr(sql, params = []) {
+	return wrap({
+		type: "raw",
+		sql,
+		params
+	});
+}
+
+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 sumDistinct(expr) {
+	const node = {
+		type: "function_call",
+		name: "SUM",
+		args: [expr.node],
+		distinct: true
+	};
+	return wrap(node);
+}
+
+export function avg(expr) {
+	return wrap(rawFn("AVG", [expr.node]));
+}
+
+export function avgDistinct(expr) {
+	const node = {
+		type: "function_call",
+		name: "AVG",
+		args: [expr.node],
+		distinct: true
+	};
+	return wrap(node);
+}
+
+export function min(expr) {
+	return wrap(rawFn("MIN", [expr.node]));
+}
+
+export function max(expr) {
+	return wrap(rawFn("MAX", [expr.node]));
+}
+
+export function coalesce(...args) {
+	return wrap(rawFn("COALESCE", args.map((a) => a.node)));
+}
+
+export function not(expr) {
+	return wrap(rawNot(expr.node));
+}
+
+export function add(a, b) {
+	return wrap(binOp("+", a.node, b.node));
+}
+
+export function sub(a, b) {
+	return wrap(binOp("-", a.node, b.node));
+}
+
+export function mul(a, b) {
+	return wrap(binOp("*", a.node, b.node));
+}
+
+export function div(a, b) {
+	return wrap(binOp("/", a.node, b.node));
+}
+
+export function mod(a, b) {
+	return wrap(binOp("%", a.node, b.node));
+}
+
+export function neg(expr) {
+	return wrap({
+		type: "unary_op",
+		op: "-",
+		operand: expr.node,
+		position: "prefix"
+	});
+}
+
+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);
+	}
+	groups(start, end) {
+		return this._withFrame("GROUPS", 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 jsonAgg(expr) {
+	return wrap(rawFn("JSON_AGG", [expr.node]));
+}
+
+export function toJson(expr) {
+	return wrap(rawFn("TO_JSON", [expr.node]));
+}
+
+export function jsonBuildObject(...pairs) {
+	const args = [];
+	for (const [key, val] of pairs) {
+		args.push(rawLit(key));
+		args.push(val.node);
+	}
+	return wrap(rawFn("JSON_BUILD_OBJECT", args));
+}
+
+
+export function arrayContains(arr, values) {
+	return wrap(binOp("@>", arr.node, values.node));
+}
+
+export function arrayContainedBy(arr, values) {
+	return wrap(binOp("<@", arr.node, values.node));
+}
+
+export function arrayOverlaps(arr, values) {
+	return wrap(binOp("&&", arr.node, values.node));
+}
+
+export function floor(expr) {
+	return wrap(rawFn("FLOOR", [expr.node]));
+}
+
+export function stringAgg(expr, delimiter, orderBy) {
+	const node = {
+		type: "function_call",
+		name: "STRING_AGG",
+		args: [expr.node, rawLit(delimiter)],
+		orderBy: orderBy?.map((o) => ({
+			expr: o.expr.node,
+			direction: o.direction ?? "ASC"
+		}))
+	};
+	return wrap(node);
+}
+
+export function arrayAgg(expr, orderBy) {
+	const node = {
+		type: "function_call",
+		name: "ARRAY_AGG",
+		args: [expr.node],
+		orderBy: orderBy?.map((o) => ({
+			expr: o.expr.node,
+			direction: o.direction ?? "ASC"
+		}))
+	};
+	return wrap(node);
+}
+
+export function aggOrderBy(agg, orderBy) {
+	const fnNode = agg.node;
+	return wrap({
+		...fnNode,
+		orderBy: orderBy.map((o) => ({
+			expr: o.expr.node,
+			direction: o.direction ?? "ASC"
+		}))
+	});
+}
+
+export function tuple(...exprs) {
+	const node = {
+		type: "tuple",
+		elements: exprs.map((e) => e.node)
+	};
+	return wrap(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;