sumak 0.0.5 → 0.0.7

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) */
@@ -46,6 +48,10 @@ export declare class TypedSelectBuilder<
 	*/
 	where(exprOrCallback: Expression<boolean> | WhereCallback<DB, TB>): TypedSelectBuilder<DB, TB, O>;
 	/**
+	* OR WHERE — ORs with existing WHERE clause instead of AND.
+	*/
+	orWhere(exprOrCallback: Expression<boolean> | WhereCallback<DB, TB>): TypedSelectBuilder<DB, TB, O>;
+	/**
 	* INNER JOIN.
 	*
 	* ```ts
@@ -59,12 +65,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 +105,63 @@ 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>>>;
+	/**
+	* INNER JOIN with alias — for self-joins.
+	*
+	* ```ts
+	* .innerJoinAs("users", "u2", ({ users, u2 }) => users.managerId.eqCol(u2.id))
+	* ```
+	*/
+	innerJoinAs<
+		T extends keyof DB & string,
+		A extends string
+	>(table: T, alias: A, onCallback: (cols: { [Table in (TB | A) & string] : import("./eb.ts").ColumnProxies<DB, TB> }) => Expression<boolean>): TypedSelectBuilder<DB, TB | T, O & SelectRow<DB, T>>;
+	/**
+	* LEFT JOIN with alias — for self-joins.
+	*/
+	leftJoinAs<
+		T extends keyof DB & string,
+		A extends string
+	>(table: T, alias: A, onCallback: (cols: { [Table in (TB | A) & string] : import("./eb.ts").ColumnProxies<DB, TB> }) => Expression<boolean>): TypedSelectBuilder<DB, TB | T, O & Nullable<SelectRow<DB, T>>>;
 	/** 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);
 	}
@@ -43,6 +53,16 @@ export class TypedSelectBuilder {
 		return new TypedSelectBuilder(this._builder.where(unwrap(exprOrCallback)), this._table);
 	}
 	
+	orWhere(exprOrCallback) {
+		if (typeof exprOrCallback === "function") {
+			resetParams();
+			const cols = createColumnProxies(this._table);
+			const result = exprOrCallback(cols);
+			return new TypedSelectBuilder(this._builder.orWhere(unwrap(result)), this._table);
+		}
+		return new TypedSelectBuilder(this._builder.orWhere(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);
@@ -59,7 +79,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 +94,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 +173,118 @@ 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);
+	}
+	
+	innerJoinAs(table, alias, onCallback) {
+		const proxies = new Proxy({}, { get(_target, tableName) {
+			return new Proxy({}, { get(_t2, colName) {
+				return new Col(colName, tableName);
+			} });
+		} });
+		const on = onCallback(proxies);
+		return new TypedSelectBuilder(this._builder.join("INNER", {
+			type: "table_ref",
+			name: table,
+			alias
+		}, unwrap(on)), this._table);
+	}
+	
+	leftJoinAs(table, alias, onCallback) {
+		const proxies = new Proxy({}, { get(_target, tableName) {
+			return new Proxy({}, { get(_t2, colName) {
+				return new Col(colName, tableName);
+			} });
+		} });
+		const on = onCallback(proxies);
+		return new TypedSelectBuilder(this._builder.join("LEFT", {
+			type: "table_ref",
+			name: table,
+			alias
+		}, 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) */
@@ -43,6 +47,14 @@ export declare class TypedUpdateBuilder<
 	$if(condition: boolean, fn: (qb: TypedUpdateBuilder<DB, TB>) => TypedUpdateBuilder<DB, TB>): TypedUpdateBuilder<DB, TB>;
 	build(): UpdateNode;
 	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 TypedUpdateReturningBuilder<
 	DB,

package/dist/builder/typed-update.mjs

@@ -66,6 +66,14 @@ export class TypedUpdateBuilder {
 		}));
 	}
 	
+	innerJoin(table, on) {
+		return this._with(this._builder.innerJoin(table, unwrap(on)), this._paramIdx);
+	}
+	
+	leftJoin(table, on) {
+		return this._with(this._builder.leftJoin(table, unwrap(on)), this._paramIdx);
+	}
+	
 	from(table) {
 		return this._with(this._builder.from(table), this._paramIdx);
 	}
@@ -86,6 +94,20 @@ export class TypedUpdateBuilder {
 	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 TypedUpdateReturningBuilder {
 	

package/dist/builder/update.d.mts

@@ -6,11 +6,14 @@ export declare class UpdateBuilder {
 	table(table: string | TableRefNode): UpdateBuilder;
 	set(column: string, value: ExpressionNode): UpdateBuilder;
 	where(expr: ExpressionNode): UpdateBuilder;
+	orWhere(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;
+	orderBy(expr: string | ExpressionNode, direction?: "ASC" | "DESC"): UpdateBuilder;
+	limit(n: ExpressionNode): UpdateBuilder;
 	returning(...exprs: ExpressionNode[]): UpdateBuilder;
 	with(name: string, query: SelectNode, recursive?: boolean): UpdateBuilder;
 	build(): UpdateNode;

package/dist/builder/update.mjs

@@ -43,6 +43,23 @@ export class UpdateBuilder {
 			where: expr
 		});
 	}
+	orWhere(expr) {
+		if (this.node.where) {
+			return new UpdateBuilder({
+				...this.node,
+				where: {
+					type: "binary_op",
+					op: "OR",
+					left: this.node.where,
+					right: expr
+				}
+			});
+		}
+		return new UpdateBuilder({
+			...this.node,
+			where: expr
+		});
+	}
 	from(table) {
 		const ref = typeof table === "string" ? {
 			type: "table_ref",
@@ -76,6 +93,25 @@ export class UpdateBuilder {
 	leftJoin(table, on) {
 		return this.join("LEFT", table, on);
 	}
+	orderBy(expr, direction = "ASC") {
+		const node = {
+			expr: typeof expr === "string" ? {
+				type: "column_ref",
+				column: expr
+			} : expr,
+			direction
+		};
+		return new UpdateBuilder({
+			...this.node,
+			orderBy: [...this.node.orderBy ?? [], node]
+		});
+	}
+	limit(n) {
+		return new UpdateBuilder({
+			...this.node,
+			limit: n
+		});
+	}
 	returning(...exprs) {
 		return new UpdateBuilder({
 			...this.node,

package/dist/index.d.mts

@@ -1,4 +1,4 @@
-export type { AliasedExprNode, ArrayExprNode, ASTNode, BetweenNode, BinaryOpNode, CaseNode, CastNode, ColumnRefNode, CTENode, DeleteNode, ExistsNode, ExplainNode, ExpressionNode, FrameBound, FrameKind, FrameSpec, FullTextSearchMode, FullTextSearchNode, FunctionCallNode, InNode, InsertMode, InsertNode, IsNullNode, JoinNode, JsonAccessNode, LiteralNode, LockClause, LockMode, MergeNode, MergeWhenMatched, MergeWhenNotMatched, OnConflictNode, OrderByNode, ParamNode, RawNode, SelectNode, StarNode, SubqueryNode, TableRefNode, TemporalClause, UnaryOpNode, UpdateNode, WindowFunctionNode } from "./ast/nodes.mjs";
+export type { AliasedExprNode, ArrayExprNode, ASTNode, BetweenNode, BinaryOpNode, CaseNode, CastNode, ColumnRefNode, CTENode, DeleteNode, ExistsNode, ExplainNode, ExpressionNode, FrameBound, FrameKind, FrameSpec, FullTextSearchMode, FullTextSearchNode, FunctionCallNode, InNode, InsertMode, InsertNode, IsNullNode, JoinNode, JsonAccessNode, LiteralNode, LockClause, LockMode, MergeNode, MergeWhenMatched, MergeWhenNotMatched, OnConflictNode, OrderByNode, ParamNode, RawNode, SelectNode, StarNode, SubqueryNode, TableRefNode, TupleNode, TemporalClause, UnaryOpNode, UpdateNode, WindowFunctionNode } from "./ast/nodes.mjs";
 export { createDeleteNode, createInsertNode, createMergeNode, createSelectNode, createUpdateNode, tableRef } from "./ast/nodes.mjs";
 export { between, binOp, col, colAs, eq, fn, gt, gte, inList, isNull, like, lit, lt, lte, neq, param, raw, star, subquery, unaryOp } from "./ast/expression.mjs";
 export { ASTTransformer } from "./ast/transformer.mjs";
@@ -28,10 +28,11 @@ export type { Dialect } from "./dialect/types.mjs";
 export { quoteIdentifier, quoteTableRef } from "./utils/identifier.mjs";
 export { formatParam } from "./utils/param.mjs";
 export type { CompiledQuery, DialectConfig, JoinType, OrderDirection, Primitive, SetOperator, SQLDialect } from "./types.mjs";
-export { bigint, bigserial, boolean, bytea, char, ColumnBuilder, date, defineTable, doublePrecision, enumType, integer, json, jsonb, numeric, real, serial, smallint, text, time, timestamp, timestamptz, uuid, varchar } from "./schema/index.mjs";
+export { bigint, bigserial, boolean, bytea, char, ColumnBuilder, date, defineTable, doublePrecision, enumType, integer, interval, json, jsonb, numeric, real, serial, smallint, text, time, timestamp, timestamptz, uuid, varchar } from "./schema/index.mjs";
 export type { ColumnDef, ColumnType, Generated, GeneratedAlways, InferTable, Insertable, InsertType, Nullable, Selectable, SelectRow, SelectType, TableDefinition, Updateable, UpdateType } from "./schema/index.mjs";
-export { abs, and, avg, case_, CaseBuilder, cast, ceil, coalesce, Col, concat, count, countDistinct, currentTimestamp, denseRank, exists, filter, floor, greatest, jsonRef, lag, lead, least, length, lower, max, min, not, notExists, now, ntile, nullif, or, over, rank, resetParams, round, rowNumber, sqlFn, substring, sum, textSearch, trim, upper, val, WindowBuilder } from "./builder/eb.mjs";
+export { abs, add, aggOrderBy, and, arrayAgg, arrayContainedBy, arrayContains, arrayOverlaps, avg, avgDistinct, case_, CaseBuilder, cast, ceil, coalesce, Col, concat, count, countDistinct, currentTimestamp, denseRank, div, exists, filter, floor, greatest, jsonAgg, jsonBuildObject, jsonRef, lag, lead, least, length, lower, max, min, mod, mul, neg, not, notExists, now, ntile, nullif, or, over, rank, rawExpr, resetParams, round, rowNumber, sqlFn, stringAgg, subqueryExpr, sub, substring, sum, sumDistinct, textSearch, toJson, trim, tuple, upper, val, WindowBuilder } from "./builder/eb.mjs";
 export type { ColumnProxies, WhereCallback } from "./builder/eb.mjs";
+export { sql } from "./builder/sql.mjs";
 export { sumak, Sumak } from "./sumak.mjs";
 export type { SumakConfig } from "./sumak.mjs";
 export { TypedSelectBuilder } from "./builder/typed-select.mjs";
@@ -46,4 +47,12 @@ export { SoftDeletePlugin } from "./plugin/soft-delete.mjs";
 export { CamelCasePlugin } from "./plugin/camel-case.mjs";
 export { Hookable } from "./plugin/hooks.mjs";
 export type { HookContext, HookName, SumakHooks } from "./plugin/hooks.mjs";
+export { CreateTableBuilder, ColumnDefBuilder, ForeignKeyBuilder } from "./builder/ddl/create-table.mjs";
+export { AlterTableBuilder } from "./builder/ddl/alter-table.mjs";
+export { CreateIndexBuilder } from "./builder/ddl/create-index.mjs";
+export { CreateViewBuilder } from "./builder/ddl/create-view.mjs";
+export { DropTableBuilder, DropIndexBuilder, DropViewBuilder, TruncateTableBuilder } from "./builder/ddl/drop.mjs";
+export { DDLPrinter } from "./printer/ddl.mjs";
+export { SchemaBuilder } from "./sumak.mjs";
+export type { AlterColumnSet, AlterTableAction, AlterTableNode, CheckConstraintNode, ColumnDefinitionNode, CreateIndexNode, CreateTableNode, CreateViewNode, DDLNode, DropIndexNode, DropTableNode, DropViewNode, ForeignKeyAction, ForeignKeyConstraintNode, PrimaryKeyConstraintNode, TableConstraintNode, TruncateTableNode, UniqueConstraintNode } from "./ast/ddl-nodes.mjs";
 export { EmptyQueryError, InvalidExpressionError, SumakError, UnsupportedDialectFeatureError } from "./errors.mjs";

package/dist/index.mjs

@@ -26,9 +26,11 @@ export { sqliteDialect } from "./dialect/sqlite.mjs";
 export { quoteIdentifier, quoteTableRef } from "./utils/identifier.mjs";
 export { formatParam } from "./utils/param.mjs";
 
-export { bigint, bigserial, boolean, bytea, char, ColumnBuilder, date, defineTable, doublePrecision, enumType, integer, json, jsonb, numeric, real, serial, smallint, text, time, timestamp, timestamptz, uuid, varchar } from "./schema/index.mjs";
+export { bigint, bigserial, boolean, bytea, char, ColumnBuilder, date, defineTable, doublePrecision, enumType, integer, interval, json, jsonb, numeric, real, serial, smallint, text, time, timestamp, timestamptz, uuid, varchar } from "./schema/index.mjs";
 
-export { abs, and, avg, case_, CaseBuilder, cast, ceil, coalesce, Col, concat, count, countDistinct, currentTimestamp, denseRank, exists, filter, floor, greatest, jsonRef, lag, lead, least, length, lower, max, min, not, notExists, now, ntile, nullif, or, over, rank, resetParams, round, rowNumber, sqlFn, substring, sum, textSearch, trim, upper, val, WindowBuilder } from "./builder/eb.mjs";
+export { abs, add, aggOrderBy, and, arrayAgg, arrayContainedBy, arrayContains, arrayOverlaps, avg, avgDistinct, case_, CaseBuilder, cast, ceil, coalesce, Col, concat, count, countDistinct, currentTimestamp, denseRank, div, exists, filter, floor, greatest, jsonAgg, jsonBuildObject, jsonRef, lag, lead, least, length, lower, max, min, mod, mul, neg, not, notExists, now, ntile, nullif, or, over, rank, rawExpr, resetParams, round, rowNumber, sqlFn, stringAgg, subqueryExpr, sub, substring, sum, sumDistinct, textSearch, toJson, trim, tuple, upper, val, WindowBuilder } from "./builder/eb.mjs";
+
+export { sql } from "./builder/sql.mjs";
 
 export { sumak, Sumak } from "./sumak.mjs";
 export { TypedSelectBuilder } from "./builder/typed-select.mjs";
@@ -43,4 +45,12 @@ export { CamelCasePlugin } from "./plugin/camel-case.mjs";
 
 export { Hookable } from "./plugin/hooks.mjs";
 
+export { CreateTableBuilder, ColumnDefBuilder, ForeignKeyBuilder } from "./builder/ddl/create-table.mjs";
+export { AlterTableBuilder } from "./builder/ddl/alter-table.mjs";
+export { CreateIndexBuilder } from "./builder/ddl/create-index.mjs";
+export { CreateViewBuilder } from "./builder/ddl/create-view.mjs";
+export { DropTableBuilder, DropIndexBuilder, DropViewBuilder, TruncateTableBuilder } from "./builder/ddl/drop.mjs";
+export { DDLPrinter } from "./printer/ddl.mjs";
+export { SchemaBuilder } from "./sumak.mjs";
+
 export { EmptyQueryError, InvalidExpressionError, SumakError, UnsupportedDialectFeatureError } from "./errors.mjs";

package/dist/printer/base.d.mts

@@ -1,4 +1,4 @@
-import type { AliasedExprNode, ArrayExprNode, ASTNode, BetweenNode, BinaryOpNode, CaseNode, CastNode, ColumnRefNode, CTENode, DeleteNode, ExistsNode, ExplainNode, ExpressionNode, FrameBound, FrameSpec, FunctionCallNode, InNode, InsertNode, IsNullNode, JoinNode, JsonAccessNode, LiteralNode, OnConflictNode, OrderByNode, ParamNode, RawNode, SelectNode, StarNode, SubqueryNode, TableRefNode, UnaryOpNode, UpdateNode, WindowFunctionNode } from "../ast/nodes.mjs";
+import type { AliasedExprNode, ArrayExprNode, ASTNode, BetweenNode, BinaryOpNode, CaseNode, CastNode, ColumnRefNode, CTENode, DeleteNode, ExistsNode, ExplainNode, ExpressionNode, FrameBound, FrameSpec, FunctionCallNode, InNode, InsertNode, IsNullNode, JoinNode, JsonAccessNode, LiteralNode, OnConflictNode, OrderByNode, ParamNode, RawNode, SelectNode, StarNode, SubqueryNode, TableRefNode, TupleNode, UnaryOpNode, UpdateNode, WindowFunctionNode } from "../ast/nodes.mjs";
 import type { FullTextSearchNode, MergeNode, MergeWhenMatched, MergeWhenNotMatched } from "../ast/nodes.mjs";
 import type { CompiledQuery, SQLDialect } from "../types.mjs";
 import type { Printer } from "./types.mjs";
@@ -43,6 +43,7 @@ export declare class BasePrinter implements Printer {
 	protected printMergeWhenMatched(when: MergeWhenMatched): string;
 	protected printMergeWhenNotMatched(when: MergeWhenNotMatched): string;
 	protected printAliasedExpr(node: AliasedExprNode): string;
+	protected printTuple(node: TupleNode): string;
 	protected printExplain(node: ExplainNode): string;
 	protected printFullTextSearch(node: FullTextSearchNode): string;
 }

package/dist/printer/base.mjs

@@ -146,6 +146,12 @@ export class BasePrinter {
 		if (node.where) {
 			parts.push("WHERE", this.printExpression(node.where));
 		}
+		if (node.orderBy && node.orderBy.length > 0) {
+			parts.push("ORDER BY", node.orderBy.map((o) => this.printOrderBy(o)).join(", "));
+		}
+		if (node.limit) {
+			parts.push("LIMIT", this.printExpression(node.limit));
+		}
 		if (node.returning.length > 0) {
 			parts.push("RETURNING", node.returning.map((r) => this.printExpression(r)).join(", "));
 		}
@@ -166,6 +172,12 @@ export class BasePrinter {
 		if (node.where) {
 			parts.push("WHERE", this.printExpression(node.where));
 		}
+		if (node.orderBy && node.orderBy.length > 0) {
+			parts.push("ORDER BY", node.orderBy.map((o) => this.printOrderBy(o)).join(", "));
+		}
+		if (node.limit) {
+			parts.push("LIMIT", this.printExpression(node.limit));
+		}
 		if (node.returning.length > 0) {
 			parts.push("RETURNING", node.returning.map((r) => this.printExpression(r)).join(", "));
 		}
@@ -193,6 +205,7 @@ export class BasePrinter {
 			case "window_function": return this.printWindowFunction(node);
 			case "aliased_expr": return this.printAliasedExpr(node);
 			case "full_text_search": return this.printFullTextSearch(node);
+			case "tuple": return this.printTuple(node);
 		}
 	}
 	printColumnRef(node) {
@@ -219,7 +232,11 @@ export class BasePrinter {
 	}
 	printFunctionCall(node) {
 		const distinctPrefix = node.distinct ? "DISTINCT " : "";
-		let result = `${node.name}(${distinctPrefix}${node.args.map((a) => this.printExpression(a)).join(", ")})`;
+		let inner = `${distinctPrefix}${node.args.map((a) => this.printExpression(a)).join(", ")}`;
+		if (node.orderBy && node.orderBy.length > 0) {
+			inner += ` ORDER BY ${node.orderBy.map((o) => this.printOrderBy(o)).join(", ")}`;
+		}
+		let result = `${node.name}(${inner})`;
 		if (node.filter) {
 			result += ` FILTER (WHERE ${this.printExpression(node.filter)})`;
 		}
@@ -245,7 +262,8 @@ export class BasePrinter {
 	}
 	printBetween(node) {
 		const neg = node.negated ? "NOT " : "";
-		return `(${this.printExpression(node.expr)} ${neg}BETWEEN ${this.printExpression(node.low)} AND ${this.printExpression(node.high)})`;
+		const sym = node.symmetric ? " SYMMETRIC" : "";
+		return `(${this.printExpression(node.expr)} ${neg}BETWEEN${sym} ${this.printExpression(node.low)} AND ${this.printExpression(node.high)})`;
 	}
 	printIn(node) {
 		const neg = node.negated ? "NOT " : "";
@@ -303,7 +321,8 @@ export class BasePrinter {
 	}
 	printJoin(node) {
 		const parts = [];
-		parts.push(`${node.joinType} JOIN`);
+		const lateral = node.lateral ? " LATERAL" : "";
+		parts.push(`${node.joinType} JOIN${lateral}`);
 		if (node.table.type === "subquery") {
 			parts.push(this.printSubquery(node.table));
 		} else {
@@ -426,6 +445,9 @@ export class BasePrinter {
 	printAliasedExpr(node) {
 		return `${this.printExpression(node.expr)} AS ${quoteIdentifier(node.alias, this.dialect)}`;
 	}
+	printTuple(node) {
+		return `(${node.elements.map((e) => this.printExpression(e)).join(", ")})`;
+	}
 	printExplain(node) {
 		const parts = ["EXPLAIN"];
 		if (node.analyze) {

package/dist/printer/ddl.d.mts

@@ -0,0 +1,21 @@
+import type { DDLNode } from "../ast/ddl-nodes.mjs";
+import type { CompiledQuery, SQLDialect } from "../types.mjs";
+export declare class DDLPrinter {
+	private dialect;
+	private params;
+	constructor(dialect: SQLDialect);
+	print(node: DDLNode): CompiledQuery;
+	private printNode;
+	private printCreateTable;
+	private printColumnDef;
+	private printConstraint;
+	private printForeignKeyConstraint;
+	private printAlterTable;
+	private printDropTable;
+	private printCreateIndex;
+	private printDropIndex;
+	private printCreateView;
+	private printDropView;
+	private printTruncateTable;
+	private printExpr;
+}