durcno 1.0.0-alpha.0

package/dist/src/query-builders/rq.mjs

@@ -0,0 +1,231 @@
+import { QueryPromise } from "./query-promise.mjs";
+import { snakeToCamel } from "../utils.mjs";
+import { Query } from "./query.mjs";
+//#region src/query-builders/rq.ts
+var RelationQueryBuilder = class {
+	#table;
+	#relations;
+	#allRelations;
+	#config;
+	#executor;
+	constructor(table, relations, allRelations, config, executor) {
+		this.#table = table;
+		this.#relations = relations;
+		this.#allRelations = allRelations;
+		this.#config = config;
+		this.#executor = executor;
+	}
+	findMany(options) {
+		return new RelationQuery(this.#table, this.#relations, this.#allRelations, options, this.#config, this.#executor);
+	}
+	async findFirst(options) {
+		return (await new RelationQuery(this.#table, this.#relations, this.#allRelations, {
+			...options,
+			limit: 1
+		}, this.#config, this.#executor)).at(0) ?? null;
+	}
+};
+var RelationQuery = class extends QueryPromise {
+	#table;
+	#relations;
+	#allRelations;
+	#options;
+	#config;
+	#executor;
+	constructor(table, relations, allRelations, options, config, executor) {
+		super();
+		this.#table = table;
+		this.#relations = relations;
+		this.#allRelations = allRelations;
+		this.#options = options;
+		this.#config = config;
+		this.#executor = executor;
+	}
+	toQuery() {
+		const options = this.#options;
+		const query = new Query("SELECT ", this.handleRows.bind(this));
+		const selects = [];
+		if (options.columns === void 0 || Object.keys(options.columns).length === 0) for (const [, column] of Object.entries(this.#table._.columns)) selects.push(column.fullName);
+		else if (Object.values(options.columns).at(0) === true) for (const [colName, column] of Object.entries(this.#table._.columns)) colName in options.columns && selects.push(column.fullName);
+		else for (const [colName, column] of Object.entries(this.#table._.columns)) !(colName in options.columns) && selects.push(column.fullName);
+		const relations = this.#allRelations[this.#table._.fullName];
+		if (relations) {
+			if (options.with) {
+				for (const key in options.with) if (relations.map[key]) {
+					const select = `"${key}"."data" AS "${key}"`;
+					selects.push(select);
+				}
+			}
+		}
+		query.sql += selects.join(", ");
+		query.sql += " FROM";
+		query.sql += ` ${this.#table._.fullName} "${this.#table._.name}"`;
+		if (options.with) for (const key in options.with) {
+			const o = options.with[key];
+			const relations = this.#allRelations[this.#table._.fullName];
+			if (relations) {
+				const relation = relations.map[key];
+				if (relation) query.sql += buildRelationSubquery(key, this.#table._.name, o, relation, this.#allRelations, this.#config);
+			}
+		}
+		if (options.where) query.sql += ` WHERE ${options.where.toSQL()}`;
+		if (options.orderBy) {
+			const orders = Array.isArray(options.orderBy) ? options.orderBy : [options.orderBy];
+			query.sql += ` ORDER BY ${orders.map((o) => o.toSQL()).join(", ")}`;
+		}
+		if (options.limit) query.sql += ` LIMIT ${options.limit}`;
+		const optionsWithOffset = this.#options;
+		if (optionsWithOffset.offset) query.sql += ` OFFSET ${optionsWithOffset.offset}`;
+		query.sql += ";";
+		return query;
+	}
+	async execute() {
+		const query = this.toQuery();
+		const res = await this.#executor.query(query.sql, query.arguments);
+		const rows = this.#executor.getRows(res);
+		return this.handleRows(rows);
+	}
+	handleRows(rows) {
+		rows.forEach((row) => {
+			convert(row, this.#table, this.#allRelations);
+		});
+		return rows;
+	}
+};
+/**
+* Build the json_build_object selects for a relation, including nested relations.
+* @param alias - The alias used for the inner subquery (e.g., "posts", "posts__comments")
+* @param options - The options for this relation
+* @param table - The table being selected from
+* @param allRelations - All relations in the schema
+*/
+function getJsonBuildObjectSelects(alias, options, table, allRelations) {
+	const selects = [];
+	if (options.columns === void 0 || Object.keys(options.columns).length === 0) for (const [colName, column] of Object.entries(table._.columns)) selects.push(`'${colName}', "${alias}"."${column.nameSnake}"`);
+	else if (Object.values(options.columns).at(0) === true) for (const [colName, column] of Object.entries(table._.columns)) colName in options.columns && selects.push(`'${colName}', "${alias}"."${column.nameSnake}"`);
+	else for (const [colName, column] of Object.entries(table._.columns)) !(colName in options.columns) && selects.push(`'${colName}', "${alias}"."${column.nameSnake}"`);
+	if (options.with) {
+		const tableRelations = allRelations[table._.fullName];
+		if (tableRelations) {
+			for (const nestedKey in options.with) if (tableRelations.map[nestedKey]) selects.push(`'${nestedKey}', "${alias}"."${nestedKey}_data"`);
+		}
+	}
+	return selects;
+}
+/**
+* Build a LATERAL JOIN subquery for a relation, recursively handling nested relations.
+* Alias path format: "relationKey" for top-level, "parent__child" for nested (debuggable).
+*
+* @param aliasPath - The full alias path (e.g., "posts", "posts__comments")
+* @param parentTableAlias - The alias of the parent table (e.g., "users" for top-level, "posts" for nested)
+* @param options - The options for this relation
+* @param relation - The relation definition (Many, One, or Fk)
+* @param allRelations - All relations in the schema
+* @param config - The database config
+*/
+function buildRelationSubquery(aliasPath, parentTableAlias, options, relation, allRelations, config) {
+	let sql = " LEFT JOIN LATERAL (";
+	const jsonSelects = getJsonBuildObjectSelects(aliasPath, options, relation.table, allRelations);
+	if (relation.t === "Many") sql += `SELECT coalesce(json_agg(json_build_object(${jsonSelects.join(", ")})), '[]'::json) AS "data"`;
+	else sql += `SELECT json_build_object(${jsonSelects.join(", ")}) AS "data"`;
+	sql += ` FROM (SELECT "${aliasPath}".*`;
+	if (options.with) {
+		const tableRelations = allRelations[relation.table._.fullName];
+		if (tableRelations) {
+			for (const nestedKey in options.with) if (tableRelations.map[nestedKey]) {
+				const nestedAliasPath = `${aliasPath}__${nestedKey}`;
+				sql += `, "${nestedAliasPath}"."data" AS "${nestedKey}_data"`;
+			}
+		}
+	}
+	sql += ` FROM ${relation.table._.fullName} "${aliasPath}"`;
+	if (options.with) {
+		const tableRelations = allRelations[relation.table._.fullName];
+		if (tableRelations) for (const nestedKey in options.with) {
+			const nestedOptions = options.with[nestedKey];
+			const nestedRelation = tableRelations.map[nestedKey];
+			if (nestedRelation && nestedOptions) {
+				const nestedAliasPath = `${aliasPath}__${nestedKey}`;
+				sql += buildNestedRelationSubquery(nestedAliasPath, aliasPath, nestedOptions, nestedRelation, allRelations, config);
+			}
+		}
+	}
+	if (relation.t === "Many" || relation.t === "One") {
+		const referencedCol = relation.col.referencesCol;
+		sql += ` WHERE "${aliasPath}"."${relation.col.nameSnake}" = "${parentTableAlias}"."${referencedCol.nameSnake}"`;
+		if (relation.t === "One") sql += ` LIMIT 1`;
+	} else if (relation.t === "Fk") {
+		const referencedCol = relation.col.referencesCol;
+		sql += ` WHERE "${aliasPath}"."${referencedCol.nameSnake}" = "${parentTableAlias}"."${relation.col.nameSnake}"`;
+		sql += ` LIMIT 1`;
+	}
+	sql += `) "${aliasPath}"`;
+	sql += `) "${aliasPath}" ON true`;
+	return sql;
+}
+/**
+* Build a nested LATERAL JOIN subquery (for relations within relations).
+* Similar to buildRelationSubquery but with parent alias reference for WHERE conditions.
+*/
+function buildNestedRelationSubquery(aliasPath, parentAliasPath, options, relation, allRelations, config) {
+	let sql = " LEFT JOIN LATERAL (";
+	const jsonSelects = getJsonBuildObjectSelects(aliasPath, options, relation.table, allRelations);
+	if (relation.t === "Many") sql += `SELECT coalesce(json_agg(json_build_object(${jsonSelects.join(", ")})), '[]'::json) AS "data"`;
+	else sql += `SELECT json_build_object(${jsonSelects.join(", ")}) AS "data"`;
+	sql += ` FROM (SELECT "${aliasPath}".*`;
+	if (options.with) {
+		const tableRelations = allRelations[relation.table._.fullName];
+		if (tableRelations) {
+			for (const nestedKey in options.with) if (tableRelations.map[nestedKey]) {
+				const nestedAliasPath = `${aliasPath}__${nestedKey}`;
+				sql += `, "${nestedAliasPath}"."data" AS "${nestedKey}_data"`;
+			}
+		}
+	}
+	sql += ` FROM ${relation.table._.fullName} "${aliasPath}"`;
+	if (options.with) {
+		const tableRelations = allRelations[relation.table._.fullName];
+		if (tableRelations) for (const nestedKey in options.with) {
+			const nestedOptions = options.with[nestedKey];
+			const nestedRelation = tableRelations.map[nestedKey];
+			if (nestedRelation && nestedOptions) {
+				const nestedAliasPath = `${aliasPath}__${nestedKey}`;
+				sql += buildNestedRelationSubquery(nestedAliasPath, aliasPath, nestedOptions, nestedRelation, allRelations, config);
+			}
+		}
+	}
+	if (relation.t === "Many" || relation.t === "One") {
+		sql += ` WHERE "${aliasPath}"."${relation.col.nameSnake}" = "${parentAliasPath}"."${relation.col.referencesCol.nameSnake}"`;
+		if (relation.t === "One") sql += ` LIMIT 1`;
+	} else if (relation.t === "Fk") {
+		sql += ` WHERE "${aliasPath}"."${relation.col.referencesCol.nameSnake}" = "${parentAliasPath}"."${relation.col.nameSnake}"`;
+		sql += ` LIMIT 1`;
+	}
+	sql += `) "${aliasPath}"`;
+	sql += `) "${aliasPath}" ON true`;
+	return sql;
+}
+function convert(object, table, allRelations) {
+	for (const key of Object.keys(object)) {
+		const value = object[key];
+		const keyCamel = snakeToCamel(key);
+		const column = table._.columns[keyCamel];
+		if (column) {
+			object[keyCamel] = column.fromDriver(value);
+			if (keyCamel !== key) delete object[key];
+		} else {
+			const relations = allRelations[table._.fullName];
+			if (relations) {
+				const relation = relations.map[keyCamel];
+				if (relation) {
+					if (relation.t === "Many") for (const row in object[key]) convert(object[key][row], relation.table, allRelations);
+					else if (relation.t === "One" || relation.t === "Fk") {
+						if (object[key] !== null) convert(object[key], relation.table, allRelations);
+					}
+				}
+			}
+		}
+	}
+}
+//#endregion
+export { RelationQueryBuilder };

package/dist/src/query-builders/select.d.mts

@@ -0,0 +1,48 @@
+import { Query } from "./query.mjs";
+import { OrderBy } from "./orderby-clause.mjs";
+import { QueryPromise } from "./query-promise.mjs";
+import { BuildFilterExpression, StdCondition } from "../filters/index.mjs";
+import { AnyColumn, AnyTableWithColumns, BuildScmTblColumns, StdTableColumn, TColsToLeftRight, TableColumn, TableWithColumns } from "../table.mjs";
+import { Config } from "../index.mjs";
+import { QueryExecutor } from "../connectors/common.mjs";
+
+//#region src/query-builders/select.d.ts
+declare class SelectBuilder<TTSchema extends string, TTName extends string, TTColumns extends Record<string, AnyColumn>, TPrepare extends boolean, TInnerJoins extends null | [{
+  table: AnyTableWithColumns;
+  on: BuildFilterExpression<TColsToLeftRight<AnyTableWithColumns["_"]["columns"]>>;
+}, ...{
+  table: AnyTableWithColumns;
+  on: BuildFilterExpression<TColsToLeftRight<AnyTableWithColumns["_"]["columns"]>>;
+}[]]> {
+  #private;
+  constructor(table: TableWithColumns<TTSchema, TTName, TTColumns>, innerJoins: TInnerJoins, distinctOn: StdTableColumn[] | undefined, config: Config, executor: QueryExecutor, prepare: TPrepare);
+  innerJoin<TJoinTSchema extends string, TJoinTName extends string, TJoinTColumns extends Record<string, AnyColumn>, TOn extends BuildFilterExpression<TColsToLeftRight<BuildScmTblColumns<TTSchema, TTName, TTColumns> & BuildScmTblColumns<TJoinTSchema, TJoinTName, TJoinTColumns> & (TInnerJoins extends unknown[] ? UnionToIntersection<TInnerJoins[number]["table"]["$"]["_"]["scmTblColumns"]> : Record<never, never>)>>>(table: TableWithColumns<TJoinTSchema, TJoinTName, TJoinTColumns>, on: TOn): SelectBuilder<TTSchema, TTName, TTColumns, TPrepare, TInnerJoins extends unknown[] ? [...TInnerJoins, {
+    table: TableWithColumns<TJoinTSchema, TJoinTName, TJoinTColumns>;
+    on: StdCondition;
+  }] : [{
+    table: TableWithColumns<TJoinTSchema, TJoinTName, TJoinTColumns>;
+    on: StdCondition;
+  }]>;
+  distinctOn(columns: SelfOrArray<Valueof<TableWithColumns<TTSchema, TTName, TTColumns>["_"]["columns"]> | (TInnerJoins extends unknown[] ? Valueof<TInnerJoins[number]["table"]["_"]["columns"]> : never)>): Omit<SelectBuilder<TTSchema, TTName, TTColumns, TPrepare, TInnerJoins>, "distinctOn" | "innerJoin">;
+  select(): SelectQuery<TTSchema, TTName, TTColumns, TInnerJoins, undefined, TPrepare, undefined, undefined>;
+  select<TSelects extends Record<string, Valueof<TableWithColumns<TTSchema, TTName, TTColumns>["_"]["columns"]> | (TInnerJoins extends unknown[] ? Valueof<TInnerJoins[number]["table"]["_"]["columns"]> : never)>>(selects: TSelects): SelectQuery<TTSchema, TTName, TTColumns, TInnerJoins, TSelects, TPrepare, undefined, undefined>;
+}
+declare class SelectQuery<TTSchema extends string, TTName extends string, TTColumns extends Record<string, AnyColumn>, TInnerJoins extends null | [{
+  table: AnyTableWithColumns;
+  on: BuildFilterExpression<TColsToLeftRight<AnyTableWithColumns["$"]["_"]["scmTblColumns"]>>;
+}, ...{
+  table: AnyTableWithColumns;
+  on: BuildFilterExpression<TColsToLeftRight<AnyTableWithColumns["$"]["_"]["scmTblColumns"]>>;
+}[]], TSelects extends Record<string, Valueof<NoInfer<TableWithColumns<TTSchema, TTName, TTColumns>>["_"]["columns"]> | (TInnerJoins extends unknown[] ? Valueof<TInnerJoins[number]["table"]["_"]["columns"]> : never)> | undefined, TPrepare extends boolean, TWhere extends BuildFilterExpression<TColsToLeftRight<NoInfer<TableWithColumns<TTSchema, TTName, TTColumns>>["_"]["columns"]>, TPrepare> | undefined, TOrderBy extends OrderBy<NoInfer<TableWithColumns<TTSchema, TTName, TTColumns>>> | OrderBy<NoInfer<TableWithColumns<TTSchema, TTName, TTColumns>>>[] | undefined, TReturn = (TSelects extends Record<string, unknown> ? { [TCol in keyof TSelects]: TSelects[TCol] extends TableColumn<string, string, Key, infer TColumn> ? TColumn["ValTypeSelect"] : never } : Prettify<TableWithColumns<TTSchema, TTName, TTColumns>["$"]["inferSelect"] & (TInnerJoins extends unknown[] ? UnionToIntersection<TInnerJoins[number]["table"]["$"]["inferSelect"]> : Record<never, never>)>)[]> extends QueryPromise<TReturn> {
+  #private;
+  constructor(table: TableWithColumns<TTSchema, TTName, TTColumns>, innerJoins: TInnerJoins, select: TSelects, distinctOn: StdTableColumn[] | undefined, where: TWhere, orderBy: TOrderBy, limit: number | undefined, offset: number | undefined, config: Config, executor: QueryExecutor, prepare: TPrepare);
+  where<TWhere extends BuildFilterExpression<TColsToLeftRight<BuildScmTblColumns<TTSchema, TTName, TTColumns> & (TInnerJoins extends unknown[] ? UnionToIntersection<TInnerJoins[number]["table"]["$"]["_"]["scmTblColumns"]> : Record<never, never>)>, TPrepare> | undefined>(where: TWhere): SelectQuery<TTSchema, TTName, TTColumns, TInnerJoins, TSelects, TPrepare, TWhere, TOrderBy, (TSelects extends Record<string, unknown> ? { [TCol in keyof TSelects]: TSelects[TCol] extends TableColumn<string, string, Key, infer TColumn extends AnyColumn> ? TColumn["ValTypeSelect"] : never } : TableWithColumns<TTSchema, TTName, TTColumns>["$"]["inferSelect"] & (TInnerJoins extends unknown[] ? UnionToIntersection<TInnerJoins[number]["table"]["$"]["inferSelect"]> : Record<never, never>) extends infer T ? { [K in keyof T]: T[K] } : never)[]>;
+  orderBy<TOrderBys extends (OrderBy<TableWithColumns<TTSchema, TTName, TTColumns>> | (TInnerJoins extends unknown[] ? OrderBy<TInnerJoins[number]["table"]> : never)) | (OrderBy<TableWithColumns<TTSchema, TTName, TTColumns>> | (TInnerJoins extends unknown[] ? OrderBy<TInnerJoins[number]["table"]> : never))[]>(orderBy: TOrderBys): SelectQuery<TTSchema, TTName, TTColumns, TInnerJoins, TSelects, TPrepare, TWhere, TOrderBys, (TSelects extends Record<string, unknown> ? { [TCol in keyof TSelects]: TSelects[TCol] extends TableColumn<string, string, Key, infer TColumn extends AnyColumn> ? TColumn["ValTypeSelect"] : never } : TableWithColumns<TTSchema, TTName, TTColumns>["$"]["inferSelect"] & (TInnerJoins extends unknown[] ? UnionToIntersection<TInnerJoins[number]["table"]["$"]["inferSelect"]> : Record<never, never>) extends infer T ? { [K in keyof T]: T[K] } : never)[]>;
+  limit(limit: number): Omit<this, "limit">;
+  offset(offset: number): Omit<this, "offset">;
+  toQuery(): Query<TReturn>;
+  execute(): Promise<TReturn>;
+  handleRows(rows: Record<string, unknown>[]): TReturn;
+}
+//#endregion
+export { SelectBuilder, SelectQuery };

package/dist/src/query-builders/select.mjs

@@ -0,0 +1,118 @@
+import { QueryPromise } from "./query-promise.mjs";
+import { camelToSnake, snakeToCamel } from "../utils.mjs";
+import { Query } from "./query.mjs";
+//#region src/query-builders/select.ts
+var SelectBuilder = class SelectBuilder {
+	#table;
+	#config;
+	#executor;
+	#prepare;
+	#$innerJoins;
+	#$distinctOn;
+	constructor(table, innerJoins, distinctOn, config, executor, prepare) {
+		this.#table = table;
+		this.#$innerJoins = innerJoins;
+		this.#$distinctOn = distinctOn;
+		this.#config = config;
+		this.#executor = executor;
+		this.#prepare = prepare;
+	}
+	innerJoin(table, on) {
+		return new SelectBuilder(this.#table, this.#$innerJoins ? [...this.#$innerJoins, {
+			table,
+			on
+		}] : [{
+			table,
+			on
+		}], void 0, this.#config, this.#executor, this.#prepare);
+	}
+	distinctOn(columns) {
+		return new SelectBuilder(this.#table, this.#$innerJoins, Array.isArray(columns) ? columns : [columns], this.#config, this.#executor, this.#prepare);
+	}
+	select(selects) {
+		return new SelectQuery(this.#table, this.#$innerJoins, selects, this.#$distinctOn, void 0, void 0, void 0, void 0, this.#config, this.#executor, this.#prepare);
+	}
+};
+var SelectQuery = class SelectQuery extends QueryPromise {
+	#table;
+	#$select;
+	#$distinctOn;
+	#$where;
+	#$innerJoins;
+	#$orderBy;
+	#$limit;
+	#$offset;
+	#config;
+	#executor;
+	#prepare;
+	constructor(table, innerJoins, select, distinctOn, where, orderBy, limit, offset, config, executor, prepare) {
+		super();
+		this.#table = table;
+		this.#$select = select;
+		this.#$distinctOn = distinctOn;
+		this.#$innerJoins = innerJoins;
+		this.#$where = where;
+		this.#$orderBy = orderBy;
+		this.#$limit = limit;
+		this.#$offset = offset;
+		this.#config = config;
+		this.#executor = executor;
+		this.#prepare = prepare;
+	}
+	where(where) {
+		return new SelectQuery(this.#table, this.#$innerJoins, this.#$select, this.#$distinctOn, where, this.#$orderBy, this.#$limit, this.#$offset, this.#config, this.#executor, this.#prepare);
+	}
+	orderBy(orderBy) {
+		return new SelectQuery(this.#table, this.#$innerJoins, this.#$select, this.#$distinctOn, this.#$where, orderBy, this.#$limit, this.#$offset, this.#config, this.#executor, this.#prepare);
+	}
+	limit(limit) {
+		return new SelectQuery(this.#table, this.#$innerJoins, this.#$select, this.#$distinctOn, this.#$where, this.#$orderBy, limit, this.#$offset, this.#config, this.#executor, this.#prepare);
+	}
+	offset(offset) {
+		return new SelectQuery(this.#table, this.#$innerJoins, this.#$select, this.#$distinctOn, this.#$where, this.#$orderBy, this.#$limit, offset, this.#config, this.#executor, this.#prepare);
+	}
+	toQuery() {
+		const query = new Query("SELECT ", this.handleRows.bind(this));
+		if (this.#$distinctOn?.length) query.sql += `DISTINCT ON (${this.#$distinctOn.map((c) => c.fullName).join(", ")}) `;
+		query.sql += this.#$select ? Object.entries(this.#$select).map(([key, column]) => `${column.fullName} AS ${camelToSnake(key)}`).join(", ") : "*";
+		query.sql += " FROM ";
+		query.sql += this.#table._.fullName;
+		this.#$innerJoins?.forEach((innerJoin) => {
+			const join = innerJoin;
+			query.sql += ` INNER JOIN ${join.table._.fullName} ON ${join.on.toSQL()}`;
+		});
+		if (this.#$where) {
+			query.sql += " WHERE ";
+			if (this.#prepare) this.#$where.toQuery(query);
+			else query.sql += this.#$where.toSQL();
+		}
+		if (this.#$orderBy) {
+			const orders = Array.isArray(this.#$orderBy) ? this.#$orderBy : [this.#$orderBy];
+			query.sql += ` ORDER BY ${orders.map((o) => o.toSQL()).join(", ")}`;
+		}
+		if (this.#$limit) query.sql += ` LIMIT ${this.#$limit}`;
+		if (this.#$offset) query.sql += ` OFFSET ${this.#$offset}`;
+		return query;
+	}
+	async execute() {
+		const query = this.toQuery();
+		query.sql += ";";
+		const res = await this.#executor.query(query.sql, query.arguments);
+		const rows = this.#executor.getRows(res);
+		return this.handleRows(rows);
+	}
+	handleRows(rows) {
+		const { columns } = this.#table._;
+		const cols = this.#$select ?? columns;
+		rows.forEach((row) => {
+			for (const [key, value] of Object.entries(row)) {
+				const keyCamel = snakeToCamel(key);
+				row[keyCamel] = cols[keyCamel].fromDriver(value);
+				if (keyCamel !== key) delete row[key];
+			}
+		});
+		return rows;
+	}
+};
+//#endregion
+export { SelectBuilder };

package/dist/src/query-builders/update.d.mts

@@ -0,0 +1,24 @@
+import { Query } from "./query.mjs";
+import { QueryPromise } from "./query-promise.mjs";
+import { BuildFilterExpression } from "../filters/index.mjs";
+import { AnyColumn, TColsToLeftRight, TableWithColumns } from "../table.mjs";
+import { Config } from "../index.mjs";
+import { QueryExecutor } from "../connectors/common.mjs";
+
+//#region src/query-builders/update.d.ts
+declare class UpdateBuilder<TTableWC extends TableWithColumns<string, string, Record<string, AnyColumn>>, TPrepare extends boolean> {
+  #private;
+  constructor(table: TTableWC, config: Config, executor: QueryExecutor, prepare: TPrepare);
+  set<TValues extends { [colName in keyof TTableWC["_"]["columns"]]?: TTableWC["_"]["columns"][colName]["ValTypeUpdate"] }>(values: TValues): UpdateQuery<TTableWC, TValues, TPrepare, undefined, undefined, null>;
+}
+declare class UpdateQuery<TTableWC extends TableWithColumns<string, string, Record<string, AnyColumn>>, TValues extends { [colName in keyof TTableWC["_"]["columns"]]?: TTableWC["_"]["columns"][colName]["ValTypeUpdate"] }, TPrepare extends boolean, TWhere extends BuildFilterExpression<TColsToLeftRight<TTableWC["_"]["columns"]>, TPrepare> | undefined, TReturning extends { [ColName in keyof TTableWC["_"]["columns"]]?: true } | { [ColName in keyof TTableWC["_"]["columns"]]?: false } | undefined, TReturn = (TReturning extends Record<Key, boolean> ? TReturning extends { [ColName in keyof TTableWC["_"]["columns"]]?: false } ? { [ColName in keyof TTableWC["_"]["columns"] as TReturning[ColName] extends false ? never : ColName]: TTableWC["_"]["columns"][ColName]["ValTypeSelect"] }[] : { [ColName in keyof TTableWC["_"]["columns"] as TReturning[ColName] extends true ? ColName : never]: TTableWC["_"]["columns"][ColName]["ValTypeSelect"] }[] : null)> extends QueryPromise<TReturn> {
+  #private;
+  constructor(table: TTableWC, values: TValues, where: TWhere, returnings: TReturning, config: Config, executor: QueryExecutor, prepare: TPrepare);
+  where<TWhere extends BuildFilterExpression<TColsToLeftRight<TTableWC["_"]["columns"]>, TPrepare>>(where: TWhere): UpdateQuery<TTableWC, TValues, TPrepare, TWhere, TReturning, TReturning extends Record<Key, boolean> ? TReturning extends { [ColName in keyof TTableWC["_"]["columns"]]?: false | undefined } ? { [ColName_1 in keyof TTableWC["_"]["columns"] as TReturning[ColName_1] extends false ? never : ColName_1]: TTableWC["_"]["columns"][ColName_1]["ValTypeSelect"] }[] : { [ColName_2 in keyof TTableWC["_"]["columns"] as TReturning[ColName_2] extends true ? ColName_2 : never]: TTableWC["_"]["columns"][ColName_2]["ValTypeSelect"] }[] : null>;
+  returning<TReturnings extends { [ColName in keyof TTableWC["_"]["columns"]]?: true } | { [ColName in keyof TTableWC["_"]["columns"]]?: false }>(returnings: TReturnings): UpdateQuery<TTableWC, TValues, TPrepare, TWhere, TReturnings, TReturnings extends Record<Key, boolean> ? TReturnings extends { [ColName in keyof TTableWC["_"]["columns"]]?: false | undefined } ? { [ColName_1 in keyof TTableWC["_"]["columns"] as TReturnings[ColName_1] extends false ? never : ColName_1]: TTableWC["_"]["columns"][ColName_1]["ValTypeSelect"] }[] : { [ColName_2 in keyof TTableWC["_"]["columns"] as TReturnings[ColName_2] extends true ? ColName_2 : never]: TTableWC["_"]["columns"][ColName_2]["ValTypeSelect"] }[] : null>;
+  toQuery(): Query<TReturn>;
+  execute(): Promise<TReturn>;
+  handleRows(rows: Record<string, unknown>[]): TReturn;
+}
+//#endregion
+export { UpdateBuilder };

package/dist/src/query-builders/update.mjs

@@ -0,0 +1,99 @@
+import { QueryPromise } from "./query-promise.mjs";
+import { snakeToCamel } from "../utils.mjs";
+import { Query } from "./query.mjs";
+//#region src/query-builders/update.ts
+var UpdateBuilder = class {
+	#table;
+	#config;
+	#executor;
+	#prepare;
+	constructor(table, config, executor, prepare) {
+		this.#table = table;
+		this.#config = config;
+		this.#executor = executor;
+		this.#prepare = prepare;
+	}
+	set(values) {
+		return new UpdateQuery(this.#table, values, void 0, void 0, this.#config, this.#executor, this.#prepare);
+	}
+};
+var UpdateQuery = class UpdateQuery extends QueryPromise {
+	#table;
+	#values;
+	#$where;
+	#$returning;
+	#config;
+	#executor;
+	#prepare;
+	constructor(table, values, where, returnings, config, executor, prepare) {
+		super();
+		this.#table = table;
+		this.#values = values;
+		this.#$where = where;
+		this.#$returning = returnings;
+		this.#config = config;
+		this.#executor = executor;
+		this.#prepare = prepare;
+	}
+	where(where) {
+		return new UpdateQuery(this.#table, this.#values, where, this.#$returning, this.#config, this.#executor, this.#prepare);
+	}
+	returning(returnings) {
+		return new UpdateQuery(this.#table, this.#values, this.#$where, returnings, this.#config, this.#executor, this.#prepare);
+	}
+	toQuery() {
+		const query = new Query("UPDATE ", this.handleRows.bind(this));
+		query.sql += this.#table._.fullName;
+		query.sql += " SET ";
+		const explicitFields = new Set(Object.keys(this.#values));
+		const allFields = [];
+		const allValues = [];
+		for (const field of explicitFields) {
+			allFields.push(field);
+			allValues.push(this.#values[field]);
+		}
+		for (const colName in this.#table._.columns) {
+			const column = this.#table._.columns[colName];
+			if (!explicitFields.has(colName) && column.hasUpdateFn) {
+				allFields.push(colName);
+				allValues.push(column.getUpdateFnVal());
+			}
+		}
+		if (this.#prepare) query.sql += allFields.map((field, index) => `"${field}" = ${this.#table._.columns[field].toSQL(allValues[index])}`).join(", ");
+		else {
+			query.arguments = allFields.map((field, index) => this.#table._.columns[field].toDriver(allValues[index]));
+			query.sql += allFields.map((field, index) => `"${this.#table._.columns[field].nameSnake}" = $${index + 1}`).join(", ");
+		}
+		if (this.#$where) {
+			query.sql += ` WHERE `;
+			if (this.#prepare) this.#$where.toQuery(query);
+			else query.sql += this.#$where.toSQL();
+		}
+		if (this.#$returning) {
+			query.sql += " RETURNING ";
+			const returningFields = Object.keys(this.#$returning).filter((k) => this.#$returning?.[k] === true);
+			query.sql += returningFields.map((field) => `"${this.#table._.columns[field].nameSnake}"`).join(", ");
+		}
+		query.sql += ";";
+		return query;
+	}
+	async execute() {
+		const query = this.toQuery();
+		const res = await this.#executor.query(query.sql, query.arguments);
+		const rows = this.#executor.getRows(res);
+		return this.handleRows(rows);
+	}
+	handleRows(rows) {
+		const { columns } = this.#table._;
+		rows.forEach((row) => {
+			for (const [key, value] of Object.entries(row)) {
+				const keyCamel = snakeToCamel(key);
+				row[keyCamel] = columns[keyCamel].fromDriver(value);
+				if (keyCamel !== key) delete row[key];
+			}
+		});
+		return rows;
+	}
+};
+//#endregion
+export { UpdateBuilder };

package/dist/src/sequence.d.mts

@@ -0,0 +1,48 @@
+import { Sql } from "./sql.mjs";
+import { entityType } from "./symbols.mjs";
+
+//#region src/sequence.d.ts
+interface SequenceOptions {
+  /** The starting value of the sequence */
+  startWith?: number;
+  /** The increment value for the sequence */
+  increment?: number;
+  /** The minimum value of the sequence */
+  minValue?: number;
+  /** The maximum value of the sequence */
+  maxValue?: number;
+  /** Whether the sequence should cycle when it reaches its max/min value */
+  cycle?: boolean;
+  /** The number of sequence values to cache for faster access */
+  cache?: number;
+}
+declare class Sequence<TConfig extends SequenceOptions = SequenceOptions> {
+  #private;
+  static readonly [entityType] = "Sequence";
+  constructor(schema: string, name: string, config: TConfig);
+  get schema(): string;
+  get name(): string;
+  get config(): TConfig;
+  /** Returns SQL: nextval('schema.sequence_name') for use in column defaults or queries */
+  nextval(): Sql;
+  /** Returns SQL: currval('schema.sequence_name') */
+  currval(): Sql;
+  /** Returns SQL: setval('schema.sequence_name', value) */
+  setval(value: number): Sql;
+}
+/**
+ * Creates a typed PostgreSQL sequence definition.
+ *
+ * @example
+ * ```ts
+ * import { sequence } from "durcno";
+ *
+ * export const UserIdSeq = sequence("public", "user_id_seq", {
+ *   startWith: 1,
+ *   increment: 1,
+ * });
+ * ```
+ */
+declare function sequence<TConfig extends SequenceOptions>(schema: string, name: string, config?: TConfig): Sequence<TConfig>;
+//#endregion
+export { Sequence, SequenceOptions, sequence };

package/dist/src/sequence.mjs

@@ -0,0 +1,53 @@
+import { entityType } from "./symbols.mjs";
+import { Sql } from "./sql.mjs";
+//#region src/sequence.ts
+var Sequence = class {
+	static [entityType] = "Sequence";
+	#schema;
+	#name;
+	#config;
+	constructor(schema, name, config) {
+		this.#schema = schema;
+		this.#name = name;
+		this.#config = config;
+	}
+	get schema() {
+		return this.#schema;
+	}
+	get name() {
+		return this.#name;
+	}
+	get config() {
+		return this.#config;
+	}
+	/** Returns SQL: nextval('schema.sequence_name') for use in column defaults or queries */
+	nextval() {
+		return new Sql(`nextval('${this.#schema ? `"${this.#schema}"."${this.#name}"` : `"${this.#name}"`}')`);
+	}
+	/** Returns SQL: currval('schema.sequence_name') */
+	currval() {
+		return new Sql(`currval('${this.#schema ? `"${this.#schema}"."${this.#name}"` : `"${this.#name}"`}')`);
+	}
+	/** Returns SQL: setval('schema.sequence_name', value) */
+	setval(value) {
+		return new Sql(`setval('${this.#schema ? `"${this.#schema}"."${this.#name}"` : `"${this.#name}"`}', ${value})`);
+	}
+};
+/**
+* Creates a typed PostgreSQL sequence definition.
+*
+* @example
+* ```ts
+* import { sequence } from "durcno";
+*
+* export const UserIdSeq = sequence("public", "user_id_seq", {
+*   startWith: 1,
+*   increment: 1,
+* });
+* ```
+*/
+function sequence(schema, name, config = {}) {
+	return new Sequence(schema, name, config);
+}
+//#endregion
+export { Sequence, sequence };

package/dist/src/sql.d.mts

@@ -0,0 +1,15 @@
+import { Query } from "./query-builders/query.mjs";
+import { AnyTableColumn } from "./table.mjs";
+
+//#region src/sql.d.ts
+declare class Sql {
+  #private;
+  constructor(sql: string);
+  get string(): string;
+  toSQL(): string;
+  toQuery(query: Query): void;
+}
+type SqlParam = string | number | bigint | boolean | null | undefined | AnyTableColumn;
+declare function sql(strings: TemplateStringsArray, ...params: SqlParam[]): Sql;
+//#endregion
+export { Sql, sql };