sumak 0.0.5 → 0.0.6

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,10 +91,101 @@ 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);
 	}
@@ -114,18 +217,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 +263,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 +295,43 @@ 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 exists(query) {
 	return wrap(rawExists(query));
 }
@@ -280,6 +444,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 +553,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

@@ -13,6 +13,9 @@ export declare class 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

@@ -101,6 +101,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.
 	*/

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",

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

@@ -18,6 +18,10 @@ 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>>;
@@ -30,12 +34,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 ... */

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",
@@ -70,6 +78,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);
 	}

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

@@ -28,6 +28,8 @@ export declare class TypedSelectBuilder<
 		Alias extends string,
 		T
 	>(expr: Expression<T>, alias: Alias): TypedSelectBuilder<DB, TB, O & Record<Alias, T>>;
+	/** Select multiple aliased expressions at once. */
+	selectExprs<Aliases extends Record<string, Expression<any>>>(exprs: Aliases): TypedSelectBuilder<DB, TB, O & { [K in keyof Aliases] : any }>;
 	/** DISTINCT */
 	distinct(): TypedSelectBuilder<DB, TB, O>;
 	/** DISTINCT ON (PG-specific) */
@@ -59,12 +61,12 @@ export declare class TypedSelectBuilder<
 	leftJoin<T extends keyof DB & string>(table: T, onOrCallback: Expression<boolean> | ((cols: JoinProxies<DB, TB, T>) => Expression<boolean>)): TypedSelectBuilder<DB, TB | T, O & Nullable<SelectRow<DB, T>>>;
 	/** RIGHT JOIN */
 	rightJoin<T extends keyof DB & string>(table: T, onOrCallback: Expression<boolean> | ((cols: JoinProxies<DB, TB, T>) => Expression<boolean>)): TypedSelectBuilder<DB, TB | T, Nullable<O> & SelectRow<DB, T>>;
-	/** GROUP BY */
-	groupBy(...cols: (keyof O & string)[]): TypedSelectBuilder<DB, TB, O>;
+	/** GROUP BY — accepts column names or expressions */
+	groupBy(...cols: ((keyof O & string) | Expression<any>)[]): TypedSelectBuilder<DB, TB, O>;
 	/** HAVING */
 	having(exprOrCallback: Expression<boolean> | WhereCallback<DB, TB>): TypedSelectBuilder<DB, TB, O>;
-	/** ORDER BY */
-	orderBy(col: keyof O & string, direction?: OrderDirection, nulls?: "FIRST" | "LAST"): TypedSelectBuilder<DB, TB, O>;
+	/** ORDER BY — accepts column name or expression */
+	orderBy(col: (keyof O & string) | Expression<any>, direction?: OrderDirection, nulls?: "FIRST" | "LAST"): TypedSelectBuilder<DB, TB, O>;
 	/** LIMIT */
 	limit(n: number): TypedSelectBuilder<DB, TB, O>;
 	/** OFFSET */
@@ -99,8 +101,45 @@ export declare class TypedSelectBuilder<
 	exceptAll(query: TypedSelectBuilder<DB, any, O>): TypedSelectBuilder<DB, TB, O>;
 	/** FULL JOIN — both sides become nullable. */
 	fullJoin<T extends keyof DB & string>(table: T, onOrCallback: Expression<boolean> | ((cols: JoinProxies<DB, TB, T>) => Expression<boolean>)): TypedSelectBuilder<DB, TB | T, Nullable<O> & Nullable<SelectRow<DB, T>>>;
+	/** INNER JOIN LATERAL (subquery) */
+	innerJoinLateral<
+		Alias extends string,
+		R
+	>(subquery: {
+		build(): SelectNode;
+	}, alias: Alias, on: Expression<boolean>): TypedSelectBuilder<DB, TB, O & Record<Alias, R>>;
+	/** LEFT JOIN LATERAL (subquery) */
+	leftJoinLateral<
+		Alias extends string,
+		R
+	>(subquery: {
+		build(): SelectNode;
+	}, alias: Alias, on: Expression<boolean>): TypedSelectBuilder<DB, TB, O & Partial<Record<Alias, R>>>;
 	/** CROSS JOIN — cartesian product. */
 	crossJoin<T extends keyof DB & string>(table: T): TypedSelectBuilder<DB, TB | T, O & SelectRow<DB, T>>;
+	/** CROSS JOIN LATERAL (subquery) */
+	crossJoinLateral<
+		Alias extends string,
+		R
+	>(subquery: {
+		build(): SelectNode;
+	}, alias: Alias): TypedSelectBuilder<DB, TB, O & Record<Alias, R>>;
+	/** Clear WHERE clause. */
+	clearWhere(): TypedSelectBuilder<DB, TB, O>;
+	/** Clear ORDER BY clause. */
+	clearOrderBy(): TypedSelectBuilder<DB, TB, O>;
+	/** Clear LIMIT. */
+	clearLimit(): TypedSelectBuilder<DB, TB, O>;
+	/** Clear OFFSET. */
+	clearOffset(): TypedSelectBuilder<DB, TB, O>;
+	/** Clear GROUP BY clause. */
+	clearGroupBy(): TypedSelectBuilder<DB, TB, O>;
+	/** Clear HAVING clause. */
+	clearHaving(): TypedSelectBuilder<DB, TB, O>;
+	/** Clear SELECT columns (resets to empty). */
+	clearSelect(): TypedSelectBuilder<DB, TB, O>;
+	/** Pipe builder through a function for reusable query fragments. */
+	$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>;
 	/** Build the AST node. */

package/dist/builder/typed-select.mjs

@@ -25,6 +25,16 @@ export class TypedSelectBuilder {
 		return new TypedSelectBuilder(this._builder.columns(aliased), this._table);
 	}
 	
+	selectExprs(exprs) {
+		let builder = this._builder;
+		for (const [alias, expr] of Object.entries(exprs)) {
+			const node = unwrap(expr);
+			const aliased = aliasExpr(node, alias);
+			builder = builder.columns(aliased);
+		}
+		return new TypedSelectBuilder(builder, this._table);
+	}
+	
 	distinct() {
 		return new TypedSelectBuilder(this._builder.distinct(), this._table);
 	}
@@ -59,7 +69,8 @@ export class TypedSelectBuilder {
 	}
 	
 	groupBy(...cols) {
-		return new TypedSelectBuilder(this._builder.groupBy(...cols), this._table);
+		const resolved = cols.map((c) => typeof c === "string" ? c : unwrap(c));
+		return new TypedSelectBuilder(this._builder.groupBy(...resolved), this._table);
 	}
 	
 	having(exprOrCallback) {
@@ -73,7 +84,8 @@ export class TypedSelectBuilder {
 	}
 	
 	orderBy(col, direction = "ASC", nulls) {
-		return new TypedSelectBuilder(this._builder.orderBy(col, direction, nulls), this._table);
+		const expr = typeof col === "string" ? col : unwrap(col);
+		return new TypedSelectBuilder(this._builder.orderBy(expr, direction, nulls), this._table);
 	}
 	
 	limit(n) {
@@ -151,10 +163,90 @@ export class TypedSelectBuilder {
 		return new TypedSelectBuilder(this._builder.join("FULL", table, unwrap(on)), this._table);
 	}
 	
+	innerJoinLateral(subquery, alias, on) {
+		const sub = {
+			type: "subquery",
+			query: subquery.build(),
+			alias
+		};
+		return new TypedSelectBuilder(this._builder.innerJoinLateral(sub, unwrap(on)), this._table);
+	}
+	
+	leftJoinLateral(subquery, alias, on) {
+		const sub = {
+			type: "subquery",
+			query: subquery.build(),
+			alias
+		};
+		return new TypedSelectBuilder(this._builder.leftJoinLateral(sub, unwrap(on)), this._table);
+	}
+	
 	crossJoin(table) {
 		return new TypedSelectBuilder(this._builder.join("CROSS", table), this._table);
 	}
 	
+	crossJoinLateral(subquery, alias) {
+		const sub = {
+			type: "subquery",
+			query: subquery.build(),
+			alias
+		};
+		return new TypedSelectBuilder(this._builder.crossJoinLateral(sub), this._table);
+	}
+	
+	clearWhere() {
+		return new TypedSelectBuilder(new SelectBuilder({
+			...this._builder.build(),
+			where: undefined
+		}), this._table);
+	}
+	
+	clearOrderBy() {
+		return new TypedSelectBuilder(new SelectBuilder({
+			...this._builder.build(),
+			orderBy: []
+		}), this._table);
+	}
+	
+	clearLimit() {
+		return new TypedSelectBuilder(new SelectBuilder({
+			...this._builder.build(),
+			limit: undefined
+		}), this._table);
+	}
+	
+	clearOffset() {
+		return new TypedSelectBuilder(new SelectBuilder({
+			...this._builder.build(),
+			offset: undefined
+		}), this._table);
+	}
+	
+	clearGroupBy() {
+		return new TypedSelectBuilder(new SelectBuilder({
+			...this._builder.build(),
+			groupBy: []
+		}), this._table);
+	}
+	
+	clearHaving() {
+		return new TypedSelectBuilder(new SelectBuilder({
+			...this._builder.build(),
+			having: undefined
+		}), this._table);
+	}
+	
+	clearSelect() {
+		return new TypedSelectBuilder(new SelectBuilder({
+			...this._builder.build(),
+			columns: []
+		}), this._table);
+	}
+	
+	$call(fn) {
+		return fn(this);
+	}
+	
 	$if(condition, fn) {
 		if (condition) {
 			return fn(this);

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

@@ -35,6 +35,10 @@ export declare class TypedUpdateBuilder<
 	* RETURNING all columns.
 	*/
 	returningAll(): TypedUpdateReturningBuilder<DB, TB, SelectRow<DB, TB>>;
+	/** INNER JOIN for UPDATE (MySQL pattern) */
+	innerJoin(table: string, on: Expression<boolean>): TypedUpdateBuilder<DB, TB>;
+	/** LEFT JOIN for UPDATE */
+	leftJoin(table: string, on: Expression<boolean>): TypedUpdateBuilder<DB, TB>;
 	/** FROM clause (for UPDATE ... FROM ... WHERE joins). */
 	from<T extends keyof DB & string>(table: T): TypedUpdateBuilder<DB, TB>;
 	/** WITH (CTE) */