sumak 0.0.7 → 0.0.9

package/dist/builder/eb.d.mts

@@ -93,7 +93,6 @@ export declare class Col<T> {
 		direction: "DESC";
 	};
 }
-export declare function resetParams(): void;
 /**
 * Create typed column proxies for a table's columns.
 *

package/dist/builder/eb.mjs

@@ -209,12 +209,8 @@ export class Col {
 	}
 }
 
-let _paramIdx = 0;
-export function resetParams() {
-	_paramIdx = 0;
-}
 function autoParam(value) {
-	return rawParam(_paramIdx++, value);
+	return rawParam(0, value);
 }
 function binOp(op, left, right) {
 	return {

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

@@ -37,6 +37,8 @@ export declare class TypedDeleteBuilder<
 	$if(condition: boolean, fn: (qb: TypedDeleteBuilder<DB, TB>) => TypedDeleteBuilder<DB, TB>): TypedDeleteBuilder<DB, TB>;
 	build(): DeleteNode;
 	compile(printer: Printer): CompiledQuery;
+	/** Compile to SQL using the dialect's printer. */
+	toSQL(): CompiledQuery;
 	/** EXPLAIN this query. */
 	explain(options?: {
 		analyze?: boolean;

package/dist/builder/typed-delete.mjs

@@ -1,11 +1,15 @@
 import { star } from "../ast/expression.mjs";
 import { unwrap } from "../ast/typed-expression.mjs";
 import { DeleteBuilder } from "./delete.mjs";
-import { createColumnProxies, resetParams } from "./eb.mjs";
+import { createColumnProxies } from "./eb.mjs";
 
 export class TypedDeleteBuilder {
 	
 	_builder;
+	
+	_printer;
+	
+	_compile;
 	constructor(table) {
 		this._builder = new DeleteBuilder().from(table);
 	}
@@ -13,12 +17,13 @@ export class TypedDeleteBuilder {
 	_with(builder) {
 		const t = new TypedDeleteBuilder("");
 		t._builder = builder;
+		t._printer = this._printer;
+		t._compile = this._compile;
 		return t;
 	}
 	
 	where(exprOrCallback) {
 		if (typeof exprOrCallback === "function") {
-			resetParams();
 			const table = this._builder.build().table.name;
 			const cols = createColumnProxies(table);
 			const result = exprOrCallback(cols);
@@ -74,6 +79,14 @@ export class TypedDeleteBuilder {
 		return printer.print(this.build());
 	}
 	
+	toSQL() {
+		if (this._compile) return this._compile(this.build());
+		if (!this._printer) {
+			throw new Error("toSQL() requires a printer. Use db.deleteFrom() or pass a printer to compile().");
+		}
+		return this._printer.print(this.build());
+	}
+	
 	explain(options) {
 		const node = this.build();
 		const explainNode = {

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

@@ -11,8 +11,7 @@ export declare class TypedInsertBuilder<
 	DB,
 	TB extends keyof DB
 > {
-	private _paramIdx;
-	constructor(table: TB & string, paramIdx?: number);
+	constructor(table: TB & string);
 	/**
 	* Insert a single row. Columns/values inferred from Insertable<DB[TB]>.
 	*/
@@ -46,10 +45,6 @@ export declare class TypedInsertBuilder<
 	}[]): 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 */
@@ -78,6 +73,8 @@ export declare class TypedInsertBuilder<
 	$if(condition: boolean, fn: (qb: TypedInsertBuilder<DB, TB>) => TypedInsertBuilder<DB, TB>): TypedInsertBuilder<DB, TB>;
 	build(): InsertNode;
 	compile(printer: Printer): CompiledQuery;
+	/** Compile to SQL using the full pipeline. */
+	toSQL(): CompiledQuery;
 	/** EXPLAIN this query. */
 	explain(options?: {
 		analyze?: boolean;

package/dist/builder/typed-insert.mjs

@@ -6,27 +6,26 @@ import { InsertBuilder } from "./insert.mjs";
 export class TypedInsertBuilder {
 	
 	_builder;
-	_paramIdx;
-	constructor(table, paramIdx = 0) {
+	
+	_printer;
+	
+	_compile;
+	constructor(table) {
 		this._builder = new InsertBuilder().into(table);
-		this._paramIdx = paramIdx;
 	}
 	
-	_withBuilder(builder, paramIdx) {
+	_withBuilder(builder) {
 		const t = new TypedInsertBuilder("");
 		t._builder = builder;
-		t._paramIdx = paramIdx;
+		t._printer = this._printer;
+		t._compile = this._compile;
 		return t;
 	}
 	
 	values(row) {
 		const entries = Object.entries(row);
 		const cols = entries.map(([k]) => k);
-		const vals = entries.map(([_, v]) => {
-			const p = param(this._paramIdx, v);
-			this._paramIdx++;
-			return p;
-		});
+		const vals = entries.map(([_, v]) => param(0, v));
 		let builder = this._builder;
 		
 		if (builder.build().columns.length === 0) {
@@ -35,8 +34,8 @@ export class TypedInsertBuilder {
 		builder = new InsertBuilder({
 			...builder.build(),
 			values: [...builder.build().values, vals]
-		}, this._paramIdx);
-		return this._withBuilder(builder, this._paramIdx);
+		});
+		return this._withBuilder(builder);
 	}
 	
 	valuesMany(rows) {
@@ -55,7 +54,7 @@ export class TypedInsertBuilder {
 		const builder = new InsertBuilder({
 			...this._builder.build(),
 			returning: exprs
-		}, this._paramIdx);
+		});
 		return new TypedInsertReturningBuilder(builder);
 	}
 	
@@ -69,7 +68,7 @@ export class TypedInsertBuilder {
 		const builder = new InsertBuilder({
 			...this._builder.build(),
 			returning: [...this._builder.build().returning, aliased]
-		}, this._paramIdx);
+		});
 		return new TypedInsertReturningBuilder(builder);
 	}
 	
@@ -77,72 +76,70 @@ export class TypedInsertBuilder {
 		const builder = new InsertBuilder({
 			...this._builder.build(),
 			returning: [star()]
-		}, this._paramIdx);
+		});
 		return new TypedInsertReturningBuilder(builder);
 	}
 	
 	onConflictDoNothing(...columns) {
-		return this._withBuilder(this._builder.onConflictDoNothing(...columns), this._paramIdx);
+		return this._withBuilder(this._builder.onConflictDoNothing(...columns));
 	}
 	
 	onConflictDoUpdate(columns, set) {
 		return this._withBuilder(this._builder.onConflictDoUpdate(columns, set.map((s) => ({
 			column: s.column,
 			value: unwrap(s.value)
-		}))), 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)
+					value: param(0, val)
 				});
-				idx++;
 			}
 		}
-		return this._withBuilder(this._builder.onConflictDoUpdate(columns, set), idx);
+		return this._withBuilder(this._builder.onConflictDoUpdate(columns, set));
 	}
 	
 	onConflictConstraintDoNothing(constraint) {
-		return this._withBuilder(this._builder.onConflictConstraintDoNothing(constraint), this._paramIdx);
+		return this._withBuilder(this._builder.onConflictConstraintDoNothing(constraint));
 	}
 	
 	onConflictConstraintDoUpdate(constraint, set) {
 		return this._withBuilder(this._builder.onConflictConstraintDoUpdate(constraint, set.map((s) => ({
 			column: s.column,
 			value: unwrap(s.value)
-		}))), this._paramIdx);
+		}))));
 	}
 	
 	orIgnore() {
-		return this._withBuilder(this._builder.orIgnore(), this._paramIdx);
+		return this._withBuilder(this._builder.orIgnore());
 	}
 	
 	orReplace() {
-		return this._withBuilder(this._builder.orReplace(), this._paramIdx);
+		return this._withBuilder(this._builder.orReplace());
 	}
 	
 	onDuplicateKeyUpdate(set) {
 		return this._withBuilder(this._builder.onDuplicateKeyUpdate(set.map((s) => ({
 			column: s.column,
 			value: unwrap(s.value)
-		}))), this._paramIdx);
+		}))));
 	}
 	
 	fromSelect(query) {
-		return this._withBuilder(this._builder.fromSelect(query), this._paramIdx);
+		return this._withBuilder(this._builder.fromSelect(query));
 	}
 	
 	defaultValues() {
-		return this._withBuilder(this._builder.defaultValues(), this._paramIdx);
+		return this._withBuilder(this._builder.defaultValues());
 	}
 	
 	with(name, query, recursive = false) {
-		return this._withBuilder(this._builder.with(name, query, recursive), this._paramIdx);
+		return this._withBuilder(this._builder.with(name, query, recursive));
 	}
 	
 	$if(condition, fn) {
@@ -158,6 +155,14 @@ export class TypedInsertBuilder {
 		return printer.print(this.build());
 	}
 	
+	toSQL() {
+		if (this._compile) return this._compile(this.build());
+		if (!this._printer) {
+			throw new Error("toSQL() requires a printer. Use db.insertInto() or pass a printer to compile().");
+		}
+		return this._printer.print(this.build());
+	}
+	
 	explain(options) {
 		const node = this.build();
 		const explainNode = {

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

@@ -19,8 +19,7 @@ export declare class TypedMergeBuilder<
 > {
 	private _targetTable;
 	private _sourceAlias;
-	private _paramIdx;
-	constructor(targetTable: Target & string, sourceTable: Source & string, sourceAlias: string, on: Expression<boolean>, paramIdx?: number);
+	constructor(targetTable: Target & string, sourceTable: Source & string, sourceAlias: string, on: Expression<boolean>);
 	whenMatchedThenUpdate(values: Updateable<DB[Target]>, condition?: (proxies: MergeProxies<DB, Target, Source>) => Expression<boolean>): TypedMergeBuilder<DB, Target, Source>;
 	whenMatchedThenDelete(condition?: (proxies: MergeProxies<DB, Target, Source>) => Expression<boolean>): TypedMergeBuilder<DB, Target, Source>;
 	whenNotMatchedThenInsert(row: Insertable<DB[Target]>, condition?: (proxies: MergeProxies<DB, Target, Source>) => Expression<boolean>): TypedMergeBuilder<DB, Target, Source>;

package/dist/builder/typed-merge.mjs

@@ -1,6 +1,6 @@
 import { param } from "../ast/expression.mjs";
 import { unwrap } from "../ast/typed-expression.mjs";
-import { Col, resetParams } from "./eb.mjs";
+import { Col } from "./eb.mjs";
 import { MergeBuilder } from "./merge.mjs";
 function createMergeProxies(targetTable, sourceAlias) {
 	const makeProxy = (prefix) => new Proxy({}, { get(_t, colName) {
@@ -16,15 +16,13 @@ export class TypedMergeBuilder {
 	_builder;
 	_targetTable;
 	_sourceAlias;
-	_paramIdx;
-	constructor(targetTable, sourceTable, sourceAlias, on, paramIdx = 0) {
+	constructor(targetTable, sourceTable, sourceAlias, on) {
 		this._targetTable = targetTable;
 		this._sourceAlias = sourceAlias;
-		this._paramIdx = paramIdx;
 		this._builder = new MergeBuilder().into(targetTable).using(sourceTable, sourceAlias).on(unwrap(on));
 	}
 	
-	_with(builder, paramIdx) {
+	_with(builder) {
 		const t = new TypedMergeBuilder("", "", "", { node: {
 			type: "literal",
 			value: true
@@ -32,57 +30,46 @@ export class TypedMergeBuilder {
 		t._builder = builder;
 		t._targetTable = this._targetTable;
 		t._sourceAlias = this._sourceAlias;
-		t._paramIdx = paramIdx;
 		return t;
 	}
 	whenMatchedThenUpdate(values, condition) {
-		let idx = this._paramIdx;
 		const set = [];
 		for (const [col, val] of Object.entries(values)) {
 			if (val !== undefined) {
 				set.push({
 					column: col,
-					value: param(idx, val)
+					value: param(0, val)
 				});
-				idx++;
 			}
 		}
 		let condExpr;
 		if (condition) {
-			resetParams();
 			const proxies = createMergeProxies(this._targetTable, this._sourceAlias);
 			condExpr = unwrap(condition(proxies));
 		}
-		return this._with(this._builder.whenMatchedUpdate(set, condExpr), idx);
+		return this._with(this._builder.whenMatchedUpdate(set, condExpr));
 	}
 	whenMatchedThenDelete(condition) {
 		let condExpr;
 		if (condition) {
-			resetParams();
 			const proxies = createMergeProxies(this._targetTable, this._sourceAlias);
 			condExpr = unwrap(condition(proxies));
 		}
-		return this._with(this._builder.whenMatchedDelete(condExpr), this._paramIdx);
+		return this._with(this._builder.whenMatchedDelete(condExpr));
 	}
 	whenNotMatchedThenInsert(row, condition) {
-		let idx = this._paramIdx;
 		const entries = Object.entries(row);
 		const columns = entries.map(([k]) => k);
-		const values = entries.map(([_, v]) => {
-			const p = param(idx, v);
-			idx++;
-			return p;
-		});
+		const values = entries.map(([_, v]) => param(0, v));
 		let condExpr;
 		if (condition) {
-			resetParams();
 			const proxies = createMergeProxies(this._targetTable, this._sourceAlias);
 			condExpr = unwrap(condition(proxies));
 		}
-		return this._with(this._builder.whenNotMatchedInsert(columns, values, condExpr), idx);
+		return this._with(this._builder.whenNotMatchedInsert(columns, values, condExpr));
 	}
 	with(name, query, recursive = false) {
-		return this._with(this._builder.with(name, query, recursive), this._paramIdx);
+		return this._with(this._builder.with(name, query, recursive));
 	}
 	build() {
 		return this._builder.build();

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

@@ -18,7 +18,8 @@ export declare class TypedSelectBuilder<
 	O
 > {
 	private _table;
-	constructor(builder: SelectBuilder, table?: string);
+	private _printer?;
+	constructor(builder: SelectBuilder, table?: string, printer?: Printer, compile?: (node: import("../ast/nodes.ts").ASTNode) => CompiledQuery);
 	/** Select specific columns. Narrows O. */
 	select<K extends keyof O & string>(...cols: K[]): TypedSelectBuilder<DB, TB, Pick<O, K>>;
 	/** Select all columns. */
@@ -164,10 +165,31 @@ export declare class TypedSelectBuilder<
 	$call<R>(fn: (qb: TypedSelectBuilder<DB, TB, O>) => R): R;
 	/** Conditionally apply a transformation. */
 	$if<O2>(condition: boolean, fn: (qb: TypedSelectBuilder<DB, TB, O>) => TypedSelectBuilder<DB, TB, O2>): TypedSelectBuilder<DB, TB, O | O2>;
+	/**
+	* Cursor-based (keyset) pagination.
+	*
+	* Adds WHERE column > cursor (ASC) or column < cursor (DESC),
+	* ORDER BY column, and LIMIT pageSize + 1 (for hasNextPage detection).
+	*
+	* ```ts
+	* db.selectFrom("users")
+	*   .select("id", "name")
+	*   .cursorPaginate({ column: "id", after: 42, pageSize: 20 })
+	*   .toSQL()
+	* ```
+	*/
+	cursorPaginate(options: {
+		column: keyof O & string;
+		after?: unknown;
+		before?: unknown;
+		pageSize: number;
+	}): TypedSelectBuilder<DB, TB, O>;
 	/** Build the AST node. */
 	build(): SelectNode;
-	/** Compile to SQL. */
+	/** Compile to SQL with explicit printer. */
 	compile(printer: Printer): CompiledQuery;
+	/** Compile to SQL using the dialect's printer. */
+	toSQL(): CompiledQuery;
 	/** EXPLAIN this query. */
 	explain(options?: {
 		analyze?: boolean;