sumak 0.0.4 → 0.0.5

package/dist/builder/typed-select.mjs

@@ -0,0 +1,217 @@
+import { unwrap } from "../ast/typed-expression.mjs";
+import { createColumnProxies, resetParams } from "./eb.mjs";
+import { SelectBuilder } from "./select.mjs";
+
+export class TypedSelectBuilder {
+	
+	_builder;
+	_table;
+	constructor(builder, table) {
+		this._builder = builder;
+		this._table = table ?? "";
+	}
+	
+	select(...cols) {
+		return new TypedSelectBuilder(this._builder.columns(...cols), this._table);
+	}
+	
+	selectAll() {
+		return new TypedSelectBuilder(this._builder.allColumns(), this._table);
+	}
+	
+	selectExpr(expr, alias) {
+		const node = unwrap(expr);
+		const aliased = aliasExpr(node, alias);
+		return new TypedSelectBuilder(this._builder.columns(aliased), this._table);
+	}
+	
+	distinct() {
+		return new TypedSelectBuilder(this._builder.distinct(), this._table);
+	}
+	
+	distinctOn(...cols) {
+		return new TypedSelectBuilder(this._builder.distinctOn(...cols), this._table);
+	}
+	
+	where(exprOrCallback) {
+		if (typeof exprOrCallback === "function") {
+			resetParams();
+			const cols = createColumnProxies(this._table);
+			const result = exprOrCallback(cols);
+			return new TypedSelectBuilder(this._builder.where(unwrap(result)), this._table);
+		}
+		return new TypedSelectBuilder(this._builder.where(unwrap(exprOrCallback)), this._table);
+	}
+	
+	innerJoin(table, onOrCallback) {
+		const on = resolveJoinOn(onOrCallback, this._table, table);
+		return new TypedSelectBuilder(this._builder.innerJoin(table, unwrap(on)), this._table);
+	}
+	
+	leftJoin(table, onOrCallback) {
+		const on = resolveJoinOn(onOrCallback, this._table, table);
+		return new TypedSelectBuilder(this._builder.leftJoin(table, unwrap(on)), this._table);
+	}
+	
+	rightJoin(table, onOrCallback) {
+		const on = resolveJoinOn(onOrCallback, this._table, table);
+		return new TypedSelectBuilder(this._builder.rightJoin(table, unwrap(on)), this._table);
+	}
+	
+	groupBy(...cols) {
+		return new TypedSelectBuilder(this._builder.groupBy(...cols), this._table);
+	}
+	
+	having(exprOrCallback) {
+		if (typeof exprOrCallback === "function") {
+			resetParams();
+			const cols = createColumnProxies(this._table);
+			const result = exprOrCallback(cols);
+			return new TypedSelectBuilder(this._builder.having(unwrap(result)), this._table);
+		}
+		return new TypedSelectBuilder(this._builder.having(unwrap(exprOrCallback)), this._table);
+	}
+	
+	orderBy(col, direction = "ASC", nulls) {
+		return new TypedSelectBuilder(this._builder.orderBy(col, direction, nulls), this._table);
+	}
+	
+	limit(n) {
+		return new TypedSelectBuilder(this._builder.limit({
+			type: "literal",
+			value: n
+		}), this._table);
+	}
+	
+	offset(n) {
+		return new TypedSelectBuilder(this._builder.offset({
+			type: "literal",
+			value: n
+		}), this._table);
+	}
+	
+	forSystemTime(clause) {
+		return new TypedSelectBuilder(this._builder.forSystemTime(clause), this._table);
+	}
+	
+	forUpdate() {
+		return new TypedSelectBuilder(this._builder.forUpdate(), this._table);
+	}
+	
+	forShare() {
+		return new TypedSelectBuilder(this._builder.forShare(), this._table);
+	}
+	
+	forNoKeyUpdate() {
+		return new TypedSelectBuilder(this._builder.forNoKeyUpdate(), this._table);
+	}
+	
+	forKeyShare() {
+		return new TypedSelectBuilder(this._builder.forKeyShare(), this._table);
+	}
+	
+	skipLocked() {
+		return new TypedSelectBuilder(this._builder.skipLocked(), this._table);
+	}
+	
+	noWait() {
+		return new TypedSelectBuilder(this._builder.noWait(), this._table);
+	}
+	
+	with(name, query, recursive = false) {
+		return new TypedSelectBuilder(this._builder.with(name, query, recursive), this._table);
+	}
+	
+	union(query) {
+		return new TypedSelectBuilder(this._builder.union(query.build()), this._table);
+	}
+	
+	unionAll(query) {
+		return new TypedSelectBuilder(this._builder.unionAll(query.build()), this._table);
+	}
+	
+	intersect(query) {
+		return new TypedSelectBuilder(this._builder.intersect(query.build()), this._table);
+	}
+	
+	intersectAll(query) {
+		return new TypedSelectBuilder(this._builder.intersectAll(query.build()), this._table);
+	}
+	
+	except(query) {
+		return new TypedSelectBuilder(this._builder.except(query.build()), this._table);
+	}
+	
+	exceptAll(query) {
+		return new TypedSelectBuilder(this._builder.exceptAll(query.build()), this._table);
+	}
+	
+	fullJoin(table, onOrCallback) {
+		const on = resolveJoinOn(onOrCallback, this._table, table);
+		return new TypedSelectBuilder(this._builder.join("FULL", table, unwrap(on)), this._table);
+	}
+	
+	crossJoin(table) {
+		return new TypedSelectBuilder(this._builder.join("CROSS", table), this._table);
+	}
+	
+	$if(condition, fn) {
+		if (condition) {
+			return fn(this);
+		}
+		return this;
+	}
+	
+	build() {
+		return this._builder.build();
+	}
+	
+	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: (printer) => printer.print(explainNode)
+		};
+	}
+}
+import { Col } from "./eb.mjs";
+function createJoinProxies(_leftTable, _rightTable) {
+	return new Proxy({}, { get(_target, tableName) {
+		return new Proxy({}, { get(_t2, colName) {
+			return new Col(colName, tableName);
+		} });
+	} });
+}
+function aliasExpr(node, alias) {
+	
+	if (node.type === "column_ref" || node.type === "function_call" || node.type === "json_access" || node.type === "window_function") {
+		return {
+			...node,
+			alias
+		};
+	}
+	
+	const aliased = {
+		type: "aliased_expr",
+		expr: node,
+		alias
+	};
+	return aliased;
+}
+function resolveJoinOn(onOrCallback, leftTable, rightTable) {
+	if (typeof onOrCallback === "function") {
+		const proxies = createJoinProxies(leftTable, rightTable);
+		return onOrCallback(proxies);
+	}
+	return onOrCallback;
+}

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

@@ -0,0 +1,55 @@
+import type { SelectNode, UpdateNode } from "../ast/nodes.mjs";
+import type { Expression } from "../ast/typed-expression.mjs";
+import type { Printer } from "../printer/types.mjs";
+import type { SelectRow, Updateable } from "../schema/types.mjs";
+import type { CompiledQuery } from "../types.mjs";
+import type { WhereCallback } from "./eb.mjs";
+import { UpdateBuilder } from "./update.mjs";
+/**
+* Type-safe UPDATE query builder.
+*/
+export declare class TypedUpdateBuilder<
+	DB,
+	TB extends keyof DB
+> {
+	private _paramIdx;
+	constructor(table: TB & string, paramIdx?: number);
+	/**
+	* SET columns from an object. All keys optional (Updateable).
+	*/
+	set(values: Updateable<DB[TB]>): TypedUpdateBuilder<DB, TB>;
+	/**
+	* SET a single column with an expression.
+	*/
+	setExpr(column: keyof DB[TB] & string, value: Expression<any>): TypedUpdateBuilder<DB, TB>;
+	/**
+	* WHERE — callback or raw Expression.
+	*/
+	where(exprOrCallback: Expression<boolean> | WhereCallback<DB, TB>): TypedUpdateBuilder<DB, TB>;
+	private get _table();
+	/**
+	* RETURNING specific columns.
+	*/
+	returning<K extends keyof DB[TB] & string>(...cols: K[]): TypedUpdateReturningBuilder<DB, TB, Pick<SelectRow<DB, TB>, K>>;
+	/**
+	* RETURNING all columns.
+	*/
+	returningAll(): TypedUpdateReturningBuilder<DB, TB, SelectRow<DB, TB>>;
+	/** FROM clause (for UPDATE ... FROM ... WHERE joins). */
+	from<T extends keyof DB & string>(table: T): TypedUpdateBuilder<DB, TB>;
+	/** WITH (CTE) */
+	with(name: string, query: SelectNode, recursive?: boolean): TypedUpdateBuilder<DB, TB>;
+	/** Conditionally apply a transformation. */
+	$if(condition: boolean, fn: (qb: TypedUpdateBuilder<DB, TB>) => TypedUpdateBuilder<DB, TB>): TypedUpdateBuilder<DB, TB>;
+	build(): UpdateNode;
+	compile(printer: Printer): CompiledQuery;
+}
+export declare class TypedUpdateReturningBuilder<
+	DB,
+	_TB extends keyof DB,
+	_R
+> {
+	constructor(builder: UpdateBuilder);
+	build(): UpdateNode;
+	compile(printer: Printer): CompiledQuery;
+}

package/dist/builder/typed-update.mjs

@@ -0,0 +1,102 @@
+import { param, star } from "../ast/expression.mjs";
+import { unwrap } from "../ast/typed-expression.mjs";
+import { createColumnProxies, resetParams } from "./eb.mjs";
+import { UpdateBuilder } from "./update.mjs";
+
+export class TypedUpdateBuilder {
+	
+	_builder;
+	_paramIdx;
+	constructor(table, paramIdx = 0) {
+		this._builder = new UpdateBuilder().table(table);
+		this._paramIdx = paramIdx;
+	}
+	
+	_with(builder, paramIdx) {
+		const t = new TypedUpdateBuilder("");
+		t._builder = builder;
+		t._paramIdx = paramIdx;
+		return t;
+	}
+	
+	set(values) {
+		let builder = this._builder;
+		let idx = this._paramIdx;
+		for (const [col, val] of Object.entries(values)) {
+			if (val !== undefined) {
+				builder = builder.set(col, param(idx, val));
+				idx++;
+			}
+		}
+		return this._with(builder, idx);
+	}
+	
+	setExpr(column, value) {
+		return this._with(this._builder.set(column, unwrap(value)), this._paramIdx);
+	}
+	
+	where(exprOrCallback) {
+		if (typeof exprOrCallback === "function") {
+			resetParams();
+			const cols = createColumnProxies(this._table);
+			const result = exprOrCallback(cols);
+			return this._with(this._builder.where(unwrap(result)), this._paramIdx);
+		}
+		return this._with(this._builder.where(unwrap(exprOrCallback)), this._paramIdx);
+	}
+	get _table() {
+		return this._builder.build().table.name;
+	}
+	
+	returning(...cols) {
+		const exprs = cols.map((c) => ({
+			type: "column_ref",
+			column: c
+		}));
+		return new TypedUpdateReturningBuilder(new UpdateBuilder({
+			...this._builder.build(),
+			returning: exprs
+		}));
+	}
+	
+	returningAll() {
+		return new TypedUpdateReturningBuilder(new UpdateBuilder({
+			...this._builder.build(),
+			returning: [star()]
+		}));
+	}
+	
+	from(table) {
+		return this._with(this._builder.from(table), this._paramIdx);
+	}
+	
+	with(name, query, recursive = false) {
+		return this._with(this._builder.with(name, query, recursive), this._paramIdx);
+	}
+	
+	$if(condition, fn) {
+		if (condition) {
+			return fn(this);
+		}
+		return this;
+	}
+	build() {
+		return this._builder.build();
+	}
+	compile(printer) {
+		return printer.print(this.build());
+	}
+}
+export class TypedUpdateReturningBuilder {
+	
+	_builder;
+	constructor(builder) {
+		this._builder = builder;
+	}
+	build() {
+		return this._builder.build();
+	}
+	compile(printer) {
+		return printer.print(this.build());
+	}
+}

package/dist/builder/update.d.mts

@@ -0,0 +1,18 @@
+import type { ExpressionNode, SelectNode, TableRefNode, UpdateNode } from "../ast/nodes.mjs";
+import type { JoinType } from "../types.mjs";
+export declare class UpdateBuilder {
+	private node;
+	constructor(node?: UpdateNode);
+	table(table: string | TableRefNode): UpdateBuilder;
+	set(column: string, value: ExpressionNode): UpdateBuilder;
+	where(expr: ExpressionNode): UpdateBuilder;
+	from(table: string | TableRefNode): UpdateBuilder;
+	/** Generic JOIN (MySQL pattern: UPDATE t JOIN other ON ... SET ...) */
+	join(type: JoinType, table: string | TableRefNode, on?: ExpressionNode): UpdateBuilder;
+	innerJoin(table: string | TableRefNode, on: ExpressionNode): UpdateBuilder;
+	leftJoin(table: string | TableRefNode, on: ExpressionNode): UpdateBuilder;
+	returning(...exprs: ExpressionNode[]): UpdateBuilder;
+	with(name: string, query: SelectNode, recursive?: boolean): UpdateBuilder;
+	build(): UpdateNode;
+}
+export declare function update(table: string | TableRefNode): UpdateBuilder;

package/dist/builder/update.mjs

@@ -0,0 +1,102 @@
+import { createUpdateNode } from "../ast/nodes.mjs";
+export class UpdateBuilder {
+	node;
+	constructor(node) {
+		this.node = node ?? createUpdateNode({
+			type: "table_ref",
+			name: ""
+		});
+	}
+	table(table) {
+		const ref = typeof table === "string" ? {
+			type: "table_ref",
+			name: table
+		} : table;
+		return new UpdateBuilder({
+			...this.node,
+			table: ref
+		});
+	}
+	set(column, value) {
+		return new UpdateBuilder({
+			...this.node,
+			set: [...this.node.set, {
+				column,
+				value
+			}]
+		});
+	}
+	where(expr) {
+		if (this.node.where) {
+			return new UpdateBuilder({
+				...this.node,
+				where: {
+					type: "binary_op",
+					op: "AND",
+					left: this.node.where,
+					right: expr
+				}
+			});
+		}
+		return new UpdateBuilder({
+			...this.node,
+			where: expr
+		});
+	}
+	from(table) {
+		const ref = typeof table === "string" ? {
+			type: "table_ref",
+			name: table
+		} : table;
+		return new UpdateBuilder({
+			...this.node,
+			from: ref
+		});
+	}
+	
+	join(type, table, on) {
+		const tableRef = typeof table === "string" ? {
+			type: "table_ref",
+			name: table
+		} : table;
+		const join = {
+			type: "join",
+			joinType: type,
+			table: tableRef,
+			on
+		};
+		return new UpdateBuilder({
+			...this.node,
+			joins: [...this.node.joins, join]
+		});
+	}
+	innerJoin(table, on) {
+		return this.join("INNER", table, on);
+	}
+	leftJoin(table, on) {
+		return this.join("LEFT", table, on);
+	}
+	returning(...exprs) {
+		return new UpdateBuilder({
+			...this.node,
+			returning: [...this.node.returning, ...exprs]
+		});
+	}
+	with(name, query, recursive = false) {
+		const cte = {
+			name,
+			query,
+			recursive
+		};
+		return new UpdateBuilder({
+			...this.node,
+			ctes: [...this.node.ctes, cte]
+		});
+	}
+	build() {
+		return { ...this.node };
+	}
+}
+export function update(table) {
+	return new UpdateBuilder().table(table);
+}

package/dist/dialect/mssql.d.mts

@@ -0,0 +1,2 @@
+import type { Dialect } from "./types.mjs";
+export declare function mssqlDialect(): Dialect;

package/dist/dialect/mssql.mjs

@@ -0,0 +1,9 @@
+import { MssqlPrinter } from "../printer/mssql.mjs";
+export function mssqlDialect() {
+	return {
+		name: "mssql",
+		createPrinter() {
+			return new MssqlPrinter();
+		}
+	};
+}

package/dist/dialect/mysql.d.mts

@@ -0,0 +1,2 @@
+import type { Dialect } from "./types.mjs";
+export declare function mysqlDialect(): Dialect;

package/dist/dialect/mysql.mjs

@@ -0,0 +1,9 @@
+import { MysqlPrinter } from "../printer/mysql.mjs";
+export function mysqlDialect() {
+	return {
+		name: "mysql",
+		createPrinter() {
+			return new MysqlPrinter();
+		}
+	};
+}

package/dist/dialect/pg.d.mts

@@ -0,0 +1,2 @@
+import type { Dialect } from "./types.mjs";
+export declare function pgDialect(): Dialect;

package/dist/dialect/pg.mjs

@@ -0,0 +1,9 @@
+import { PgPrinter } from "../printer/pg.mjs";
+export function pgDialect() {
+	return {
+		name: "pg",
+		createPrinter() {
+			return new PgPrinter();
+		}
+	};
+}

package/dist/dialect/sqlite.d.mts

@@ -0,0 +1,2 @@
+import type { Dialect } from "./types.mjs";
+export declare function sqliteDialect(): Dialect;

package/dist/dialect/sqlite.mjs

@@ -0,0 +1,9 @@
+import { SqlitePrinter } from "../printer/sqlite.mjs";
+export function sqliteDialect() {
+	return {
+		name: "sqlite",
+		createPrinter() {
+			return new SqlitePrinter();
+		}
+	};
+}

package/dist/dialect/types.d.mts

@@ -0,0 +1,6 @@
+import type { Printer } from "../printer/types.mjs";
+import type { SQLDialect } from "../types.mjs";
+export interface Dialect {
+	name: SQLDialect;
+	createPrinter(): Printer;
+}

package/dist/dialect/types.mjs

@@ -0,0 +1 @@
+export {};

package/dist/errors.d.mts

@@ -0,0 +1,12 @@
+export declare class SumakError extends Error {
+	constructor(message: string);
+}
+export declare class InvalidExpressionError extends SumakError {
+	constructor(message: string);
+}
+export declare class UnsupportedDialectFeatureError extends SumakError {
+	constructor(dialect: string, feature: string);
+}
+export declare class EmptyQueryError extends SumakError {
+	constructor(queryType: string);
+}

package/dist/errors.mjs

@@ -0,0 +1,24 @@
+export class SumakError extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "SumakError";
+	}
+}
+export class InvalidExpressionError extends SumakError {
+	constructor(message) {
+		super(message);
+		this.name = "InvalidExpressionError";
+	}
+}
+export class UnsupportedDialectFeatureError extends SumakError {
+	constructor(dialect, feature) {
+		super(`${feature} is not supported in ${dialect}`);
+		this.name = "UnsupportedDialectFeatureError";
+	}
+}
+export class EmptyQueryError extends SumakError {
+	constructor(queryType) {
+		super(`Cannot build ${queryType}: missing required clauses`);
+		this.name = "EmptyQueryError";
+	}
+}