sumak 0.0.5 → 0.0.7

package/dist/builder/eb.mjs

@@ -35,6 +35,18 @@ export class Col {
 		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",
@@ -79,13 +91,122 @@ export class Col {
 		});
 	}
 	
+	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);
 	}
+	
+	cast(dataType) {
+		return wrap(rawCast(this._node, dataType));
+	}
+	
+	asc() {
+		return {
+			expr: wrap(this._node),
+			direction: "ASC"
+		};
+	}
+	
+	desc() {
+		return {
+			expr: wrap(this._node),
+			direction: "DESC"
+		};
+	}
 }
 
 let _paramIdx = 0;
@@ -114,18 +235,30 @@ export function createColumnProxies(_table) {
 }
 
 
-export function and(left, right) {
-	return wrap(rawAnd(left.node, right.node));
+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(left, right) {
-	return wrap(rawOr(left.node, right.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)));
 }
@@ -148,10 +281,30 @@ 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]));
 }
@@ -160,14 +313,50 @@ 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 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 subqueryExpr(query) {
+	return wrap({
+		type: "subquery",
+		query
+	});
+}
+
 export function exists(query) {
 	return wrap(rawExists(query));
 }
@@ -280,6 +469,9 @@ export class WindowBuilder {
 	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();
@@ -386,10 +578,85 @@ 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({

package/dist/builder/select.d.mts

@@ -9,10 +9,14 @@ export declare class SelectBuilder {
 	distinctOn(...exprs: (string | ExpressionNode)[]): SelectBuilder;
 	from(table: string | TableRefNode | SubqueryNode, alias?: string): SelectBuilder;
 	where(expr: ExpressionNode): SelectBuilder;
+	orWhere(expr: ExpressionNode): SelectBuilder;
 	join(type: JoinType, table: string | TableRefNode, on?: ExpressionNode, alias?: string): SelectBuilder;
 	innerJoin(table: string | TableRefNode, on: ExpressionNode, alias?: string): SelectBuilder;
 	leftJoin(table: string | TableRefNode, on: ExpressionNode, alias?: string): SelectBuilder;
 	rightJoin(table: string | TableRefNode, on: ExpressionNode, alias?: string): SelectBuilder;
+	innerJoinLateral(subquery: SubqueryNode, on: ExpressionNode): SelectBuilder;
+	leftJoinLateral(subquery: SubqueryNode, on: ExpressionNode): SelectBuilder;
+	crossJoinLateral(subquery: SubqueryNode): SelectBuilder;
 	groupBy(...exprs: (string | ExpressionNode)[]): SelectBuilder;
 	having(expr: ExpressionNode): SelectBuilder;
 	orderBy(expr: string | ExpressionNode, direction?: OrderDirection, nulls?: "FIRST" | "LAST"): SelectBuilder;

package/dist/builder/select.mjs

@@ -75,6 +75,23 @@ export class SelectBuilder {
 			where: expr
 		});
 	}
+	orWhere(expr) {
+		if (this.node.where) {
+			return new SelectBuilder({
+				...this.node,
+				where: {
+					type: "binary_op",
+					op: "OR",
+					left: this.node.where,
+					right: expr
+				}
+			});
+		}
+		return new SelectBuilder({
+			...this.node,
+			where: expr
+		});
+	}
 	join(type, table, on, alias) {
 		const tableRef = typeof table === "string" ? {
 			type: "table_ref",
@@ -101,6 +118,44 @@ export class SelectBuilder {
 	rightJoin(table, on, alias) {
 		return this.join("RIGHT", table, on, alias);
 	}
+	innerJoinLateral(subquery, on) {
+		const join = {
+			type: "join",
+			joinType: "INNER",
+			table: subquery,
+			on,
+			lateral: true
+		};
+		return new SelectBuilder({
+			...this.node,
+			joins: [...this.node.joins, join]
+		});
+	}
+	leftJoinLateral(subquery, on) {
+		const join = {
+			type: "join",
+			joinType: "LEFT",
+			table: subquery,
+			on,
+			lateral: true
+		};
+		return new SelectBuilder({
+			...this.node,
+			joins: [...this.node.joins, join]
+		});
+	}
+	crossJoinLateral(subquery) {
+		const join = {
+			type: "join",
+			joinType: "CROSS",
+			table: subquery,
+			lateral: true
+		};
+		return new SelectBuilder({
+			...this.node,
+			joins: [...this.node.joins, join]
+		});
+	}
 	groupBy(...exprs) {
 		const nodes = exprs.map((e) => typeof e === "string" ? col(e) : e);
 		return new SelectBuilder({

package/dist/builder/typed-delete.d.mts

@@ -17,6 +17,12 @@ export declare class TypedDeleteBuilder<
 	* WHERE — callback or raw Expression.
 	*/
 	where(exprOrCallback: Expression<boolean> | WhereCallback<DB, TB>): TypedDeleteBuilder<DB, TB>;
+	/** USING clause (PG: DELETE FROM t USING other WHERE ...) */
+	using<T extends keyof DB & string>(table: T): TypedDeleteBuilder<DB, TB>;
+	/** INNER JOIN for DELETE (MySQL pattern) */
+	innerJoin(table: string, on: Expression<boolean>): TypedDeleteBuilder<DB, TB>;
+	/** LEFT JOIN for DELETE */
+	leftJoin(table: string, on: Expression<boolean>): TypedDeleteBuilder<DB, TB>;
 	/**
 	* RETURNING specific columns.
 	*/
@@ -31,6 +37,14 @@ export declare class TypedDeleteBuilder<
 	$if(condition: boolean, fn: (qb: TypedDeleteBuilder<DB, TB>) => TypedDeleteBuilder<DB, TB>): TypedDeleteBuilder<DB, TB>;
 	build(): DeleteNode;
 	compile(printer: Printer): CompiledQuery;
+	/** EXPLAIN this query. */
+	explain(options?: {
+		analyze?: boolean;
+		format?: "TEXT" | "JSON" | "YAML" | "XML";
+	}): {
+		build(): import("../ast/nodes.ts").ExplainNode;
+		compile(printer: Printer): CompiledQuery;
+	};
 }
 export declare class TypedDeleteReturningBuilder<
 	DB,

package/dist/builder/typed-delete.mjs

@@ -27,6 +27,18 @@ export class TypedDeleteBuilder {
 		return this._with(this._builder.where(unwrap(exprOrCallback)));
 	}
 	
+	using(table) {
+		return this._with(this._builder.using(table));
+	}
+	
+	innerJoin(table, on) {
+		return this._with(this._builder.innerJoin(table, unwrap(on)));
+	}
+	
+	leftJoin(table, on) {
+		return this._with(this._builder.leftJoin(table, unwrap(on)));
+	}
+	
 	returning(...cols) {
 		const exprs = cols.map((c) => ({
 			type: "column_ref",
@@ -61,6 +73,20 @@ export class TypedDeleteBuilder {
 	compile(printer) {
 		return printer.print(this.build());
 	}
+	
+	explain(options) {
+		const node = this.build();
+		const explainNode = {
+			type: "explain",
+			statement: node,
+			analyze: options?.analyze,
+			format: options?.format
+		};
+		return {
+			build: () => explainNode,
+			compile: (p) => p.print(explainNode)
+		};
+	}
 }
 export class TypedDeleteReturningBuilder {
 	

package/dist/builder/typed-insert.d.mts

@@ -18,10 +18,18 @@ export declare class TypedInsertBuilder<
 	*/
 	values(row: Insertable<DB[TB]>): TypedInsertBuilder<DB, TB>;
 	/**
+	* Insert multiple rows at once.
+	*/
+	valuesMany(rows: Insertable<DB[TB]>[]): TypedInsertBuilder<DB, TB>;
+	/**
 	* RETURNING specific columns.
 	*/
 	returning<K extends keyof DB[TB] & string>(...cols: K[]): TypedInsertReturningBuilder<DB, TB, Pick<SelectRow<DB, TB>, K>>;
 	/**
+	* RETURNING with expression and alias.
+	*/
+	returningExpr<Alias extends string>(expr: Expression<any>, alias: Alias): TypedInsertReturningBuilder<DB, TB, SelectRow<DB, TB> & Record<Alias, any>>;
+	/**
 	* RETURNING all columns.
 	*/
 	returningAll(): TypedInsertReturningBuilder<DB, TB, SelectRow<DB, TB>>;
@@ -30,12 +38,20 @@ export declare class TypedInsertBuilder<
 	*/
 	onConflictDoNothing(...columns: (keyof DB[TB] & string)[]): TypedInsertBuilder<DB, TB>;
 	/**
-	* ON CONFLICT DO UPDATE.
+	* ON CONFLICT DO UPDATE — with Expression values.
 	*/
 	onConflictDoUpdate(columns: (keyof DB[TB] & string)[], set: {
 		column: keyof DB[TB] & string;
 		value: Expression<any>;
 	}[]): TypedInsertBuilder<DB, TB>;
+	/**
+	* ON CONFLICT DO UPDATE — with plain object (auto-parameterized).
+	*
+	* ```ts
+	* .onConflictDoUpdateSet(["email"], { name: "Alice Updated" })
+	* ```
+	*/
+	onConflictDoUpdateSet(columns: (keyof DB[TB] & string)[], values: Partial<Insertable<DB[TB]>>): TypedInsertBuilder<DB, TB>;
 	/** ON CONFLICT ON CONSTRAINT name DO NOTHING */
 	onConflictConstraintDoNothing(constraint: string): TypedInsertBuilder<DB, TB>;
 	/** ON CONFLICT ON CONSTRAINT name DO UPDATE SET ... */
@@ -62,6 +78,14 @@ export declare class TypedInsertBuilder<
 	$if(condition: boolean, fn: (qb: TypedInsertBuilder<DB, TB>) => TypedInsertBuilder<DB, TB>): TypedInsertBuilder<DB, TB>;
 	build(): InsertNode;
 	compile(printer: Printer): CompiledQuery;
+	/** EXPLAIN this query. */
+	explain(options?: {
+		analyze?: boolean;
+		format?: "TEXT" | "JSON" | "YAML" | "XML";
+	}): {
+		build(): import("../ast/nodes.ts").ExplainNode;
+		compile(printer: Printer): CompiledQuery;
+	};
 }
 export declare class TypedInsertReturningBuilder<
 	DB,

package/dist/builder/typed-insert.mjs

@@ -39,6 +39,14 @@ export class TypedInsertBuilder {
 		return this._withBuilder(builder, this._paramIdx);
 	}
 	
+	valuesMany(rows) {
+		let current = this;
+		for (const row of rows) {
+			current = current.values(row);
+		}
+		return current;
+	}
+	
 	returning(...cols) {
 		const exprs = cols.map((c) => ({
 			type: "column_ref",
@@ -51,6 +59,20 @@ export class TypedInsertBuilder {
 		return new TypedInsertReturningBuilder(builder);
 	}
 	
+	returningExpr(expr, alias) {
+		const node = unwrap(expr);
+		const aliased = {
+			type: "aliased_expr",
+			expr: node,
+			alias
+		};
+		const builder = new InsertBuilder({
+			...this._builder.build(),
+			returning: [...this._builder.build().returning, aliased]
+		}, this._paramIdx);
+		return new TypedInsertReturningBuilder(builder);
+	}
+	
 	returningAll() {
 		const builder = new InsertBuilder({
 			...this._builder.build(),
@@ -70,6 +92,21 @@ export class TypedInsertBuilder {
 		}))), this._paramIdx);
 	}
 	
+	onConflictDoUpdateSet(columns, values) {
+		const set = [];
+		let idx = this._paramIdx;
+		for (const [col, val] of Object.entries(values)) {
+			if (val !== undefined) {
+				set.push({
+					column: col,
+					value: param(idx, val)
+				});
+				idx++;
+			}
+		}
+		return this._withBuilder(this._builder.onConflictDoUpdate(columns, set), idx);
+	}
+	
 	onConflictConstraintDoNothing(constraint) {
 		return this._withBuilder(this._builder.onConflictConstraintDoNothing(constraint), this._paramIdx);
 	}
@@ -120,6 +157,20 @@ export class TypedInsertBuilder {
 	compile(printer) {
 		return printer.print(this.build());
 	}
+	
+	explain(options) {
+		const node = this.build();
+		const explainNode = {
+			type: "explain",
+			statement: node,
+			analyze: options?.analyze,
+			format: options?.format
+		};
+		return {
+			build: () => explainNode,
+			compile: (p) => p.print(explainNode)
+		};
+	}
 }
 export class TypedInsertReturningBuilder {