pqb 0.71.4 → 0.72.1

package/dist/index.js

@@ -15,7 +15,7 @@ var __copyProps = (to, from, except, desc) => {
 	}
 	return to;
 };
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule || !__hasOwnProp.call(mod, "default") ? __defProp(target, "default", {
 	value: mod,
 	enumerable: true
 }) : target, mod));
@@ -455,9 +455,14 @@ var RawSql = class extends Expression {
 };
 const isRawSQL = (arg) => arg instanceof RawSql;
 RawSql.prototype.type = ExpressionTypeMethod.prototype.type;
-const rawSqlToCode = (rawSql, t) => {
+const rawSqlToCode = (rawSql, ctx) => {
 	const { _sql: sql, _values: values } = rawSql;
-	let code = `${t}.sql`;
+	let code;
+	if (typeof ctx === "string") code = `${ctx}.sql`;
+	else {
+		ctx.isSqlUsed = true;
+		code = ctx.sql ?? `${ctx.t}.sql`;
+	}
 	code += typeof sql === "string" ? values ? `({ raw: '${sql.replace(/'/g, "\\'")}' })` : `\`${sql.replace(/`/g, "\\`")}\`` : templateLiteralSQLToCode(sql);
 	if (values) code += `.values(${JSON.stringify(values)})`;
 	return code;
@@ -593,6 +598,15 @@ const parseIndexOrExclude = (item) => {
 	for (let i = item.columns.length - 1; i >= 0; i--) if (typeof item.columns[i] === "string") item.columns[i] = { column: item.columns[i] };
 	return item;
 };
+const getForeignKeyTableInstance = (table) => {
+	const item = "instance" in table ? table.instance() : new table();
+	if (!item.table) throw new Error("Referenced table is missing table property");
+	return {
+		...item,
+		schema: typeof item.schema === "function" ? item.schema() : item.schema,
+		table: item.table
+	};
+};
 function makeColumnNullable(column, inputSchema, outputSchema, querySchema) {
 	const c = setColumnData(column, "isNullable", true);
 	c.inputSchema = inputSchema;
@@ -664,20 +678,17 @@ var Column = class {
 	* Or you can specify a callback that returns a value. This function will be called for each creating record. Such a default won't be applied to a database.
 	*
 	* ```ts
-	* export class Table extends BaseTable {
-	*   readonly table = 'table';
-	*   columns = this.setColumns((t) => ({
-	*     // values as defaults:
-	*     int: t.integer().default(123),
-	*     text: t.text().default('text'),
+	* export const Table = defineTable('table', (t) => ({
+	*   // values as defaults:
+	*   int: t.integer().default(123),
+	*   text: t.text().default('text'),
 	*
-	*     // raw SQL default:
-	*     timestamp: t.timestamp().default(t.sql`now()`),
+	*   // raw SQL default:
+	*   timestamp: t.timestamp().default(t.sql`now()`),
 	*
-	*     // runtime default, each new records gets a new random value:
-	*     random: t.numeric().default(() => Math.random()),
-	*   }));
-	* }
+	*   // runtime default, each new records gets a new random value:
+	*   random: t.numeric().default(() => Math.random()),
+	* }));
 	* ```
 	*
 	* @param value - default value or a function returning a value
@@ -772,14 +783,11 @@ var Column = class {
 	* It won't be selected with `selectAll` or `select('*')` as well.
 	*
 	* ```ts
-	* export class UserTable extends BaseTable {
-	*   readonly table = 'user';
-	*   columns = this.setColumns((t) => ({
-	*     id: t.identity().primaryKey(),
-	*     name: t.string(),
-	*     password: t.string().select(false),
-	*   }));
-	* }
+	* export const UserTable = defineTable('user', (t) => ({
+	*   id: t.identity().primaryKey(),
+	*   name: t.string(),
+	*   password: t.string().select(false),
+	* }));
 	*
 	* // only id and name are selected, without password
 	* const user = await db.user.find(123);
@@ -822,20 +830,17 @@ var Column = class {
 	* `readOnly` column can be used together with a `default`.
 	*
 	* ```ts
-	* export class Table extends BaseTable {
-	*   readonly table = 'table';
-	*   columns = this.setColumns((t) => ({
-	*     id: t.identity().primaryKey(),
-	*     column: t.string().default(() => 'default value'),
-	*     another: t.string().readOnly(),
-	*   }));
-	*
-	*   init(orm: typeof db) {
-	*     this.beforeSave(({ set }) => {
+	* export const Table = defineTable('table', (t) => ({
+	*   id: t.identity().primaryKey(),
+	*   column: t.string().default(() => 'default value'),
+	*   another: t.string().nullable().readOnly(),
+	* })).init((orm: typeof db, hooks) => {
+	*   hooks.beforeSave(({ columns, set }) => {
+	*     if (columns.include('column')) {
 	*       set({ another: 'value' });
-	*     });
-	*   }
-	* }
+	*     }
+	*   });
+	* });
 	*
 	* // later in the code
 	* db.table.create({ column: 'value' }); // TS error, runtime error
@@ -851,13 +856,15 @@ var Column = class {
 	* If no value or undefined is returned, the hook won't have any effect.
 	*
 	* ```ts
-	* export class Table extends BaseTable {
-	*   readonly table = 'table';
-	*   columns = this.setColumns((t) => ({
-	*     id: t.identity().primaryKey(),
-	*     column: t.string().setOnCreate(() => 'value'),
-	*   }));
-	* }
+	* export const Table = defineTable('table', (t) => ({
+	*   id: t.identity().primaryKey(),
+	*   some: t.number(),
+	*   column: t
+	*     .string()
+	*     .setOnCreate(({ columns }) =>
+	*       columns.include('some') ? 'value' : undefined,
+	*     ),
+	* }));
 	* ```
 	*/
 	setOnCreate(fn) {
@@ -870,13 +877,15 @@ var Column = class {
 	* If no value or undefined is returned, the hook won't have any effect.
 	*
 	* ```ts
-	* export class Table extends BaseTable {
-	*   readonly table = 'table';
-	*   columns = this.setColumns((t) => ({
-	*     id: t.identity().primaryKey(),
-	*     column: t.string().setOnUpdate(() => 'value'),
-	*   }));
-	* }
+	* export const Table = defineTable('table', (t) => ({
+	*   id: t.identity().primaryKey(),
+	*   some: t.number(),
+	*   column: t
+	*     .string()
+	*     .setOnUpdate(({ columns }) =>
+	*       columns.include('some') ? 'value' : undefined,
+	*     ),
+	* }));
 	* ```
 	*/
 	setOnUpdate(fn) {
@@ -889,13 +898,15 @@ var Column = class {
 	* If no value or undefined is returned, the hook won't have any effect.
 	*
 	* ```ts
-	* export class Table extends BaseTable {
-	*   readonly table = 'table';
-	*   columns = this.setColumns((t) => ({
-	*     id: t.identity().primaryKey(),
-	*     column: t.string().setOnSave(() => 'value'),
-	*   }));
-	* }
+	* export const Table = defineTable('table', (t) => ({
+	*   id: t.identity().primaryKey(),
+	*   some: t.number(),
+	*   column: t
+	*     .string()
+	*     .setOnSave(({ columns }) =>
+	*       columns.include('some') ? 'value' : undefined,
+	*     ),
+	* }));
 	* ```
 	*/
 	setOnSave(fn) {
@@ -910,14 +921,11 @@ var Column = class {
 	* Using `primaryKey` on a `uuid` column will automatically add a [gen_random_uuid](https://www.postgresql.org/docs/current/functions-uuid.html) default.
 	*
 	* ```ts
-	* export class Table extends BaseTable {
-	*   readonly table = 'table';
-	*   columns = this.setColumns((t) => ({
-	*     id: t.uuid().primaryKey(),
-	*     // database-level name can be passed:
-	*     id: t.uuid().primaryKey('primary_key_name'),
-	*   }));
-	* }
+	* export const Table = defineTable('table', (t) => ({
+	*   id: t.uuid().primaryKey(),
+	*   // optionally, specify a database-level constraint name:
+	*   id: t.uuid().primaryKey('primary_key_name'),
+	* }));
 	*
 	* // primary key can be used by `find` later:
 	* db.table.find('97ba9e78-7510-415a-9c03-23d440aec443');
@@ -1307,8 +1315,8 @@ const codeToString = (code, tabs, shift) => {
 * @param t - column types variable name
 * @param value - column default
 */
-const columnDefaultArgumentToCode = (t, value) => {
-	if (typeof value === "object" && value && isRawSQL(value)) return rawSqlToCode(value, t);
+const columnDefaultArgumentToCode = (ctx, value) => {
+	if (typeof value === "object" && value && isRawSQL(value)) return rawSqlToCode(value, ctx);
 	else if (typeof value === "function") return value.toString();
 	else if (typeof value === "string") return singleQuote(value);
 	else return JSON.stringify(value);
@@ -1552,26 +1560,26 @@ const excludeInnerToCode = (item, t) => {
 	return code;
 };
 const excludeToCode = indexOrExcludeToCode(excludeInnerToCode);
-const constraintToCode = (item, t, m, prefix) => {
-	const code = constraintInnerToCode(item, t, m);
+const constraintToCode = (item, t, m, prefix, ctx) => {
+	const code = constraintInnerToCode(item, t, m, ctx);
 	if (prefix) code[0] = prefix + code[0];
 	const last = code[code.length - 1];
 	if (typeof last === "string" && !last.endsWith(",")) code[code.length - 1] += ",";
 	return code;
 };
-const constraintInnerToCode = (item, t, m) => {
+const constraintInnerToCode = (item, t, m, ctx) => {
 	if (item.references) return [
 		`${t}.foreignKey(`,
 		referencesArgsToCode(item.references, item.name, m),
 		"),"
 	];
-	return [`${t}.check(${rawSqlToCode(item.check, t)}${item.name ? `, ${singleQuote(item.name)}` : ""})`];
+	return [`${t}.check(${rawSqlToCode(item.check, ctx ?? t)}${item.name ? `, ${singleQuote(item.name)}` : ""})`];
 };
 const referencesArgsToCode = ({ columns, fnOrTable, foreignColumns, options }, name = options?.name || false, m) => {
 	const args = [];
 	args.push(`${singleQuoteArray(columns)},`);
 	if (m && typeof fnOrTable !== "string") {
-		const { schema, table } = new (fnOrTable())();
+		const { schema, table } = getForeignKeyTableInstance(fnOrTable());
 		fnOrTable = schema ? `${schema}.${table}` : table;
 	}
 	args.push(`${typeof fnOrTable === "string" ? singleQuote(fnOrTable) : fnOrTable.toString()},`);
@@ -1600,7 +1608,7 @@ const columnForeignKeysToCode = (foreignKeys, migration) => {
 const foreignKeyArgumentToCode = ({ fnOrTable, foreignColumns, options = emptyObject }, migration) => {
 	const code = [];
 	if (migration && typeof fnOrTable !== "string") {
-		const { schema, table } = new (fnOrTable())();
+		const { schema, table } = getForeignKeyTableInstance(fnOrTable());
 		fnOrTable = schema ? `${schema}.${table}` : table;
 	}
 	code.push(typeof fnOrTable === "string" ? singleQuote(fnOrTable) : fnOrTable.toString());
@@ -1668,7 +1676,7 @@ const columnExcludesToCode = (items) => {
 	return code;
 };
 const columnCheckToCode = (ctx, checks) => {
-	return checks.map(({ sql, name }) => `.check(${rawSqlToCode(sql, ctx.t)}${name ? `, '${name}'` : ""})`).join("");
+	return checks.map(({ sql, name }) => `.check(${rawSqlToCode(sql, ctx)}${name ? `, '${name}'` : ""})`).join("");
 };
 const identityToCode = (identity, dataType) => {
 	const code = [];
@@ -1704,7 +1712,7 @@ const columnCode = (type, ctx, key, code) => {
 	if (data.explicitSelect) addCode(code, ".select(false)");
 	if (data.isNullable) addCode(code, ".nullable()");
 	if (data.as && !ctx.migration) addCode(code, `.as(${data.as.toCode(ctx, key)})`);
-	if (data.default !== void 0 && data.default !== data.defaultDefault && (!ctx.migration || typeof data.default !== "function")) addCode(code, `.default(${columnDefaultArgumentToCode(ctx.t, data.default)})`);
+	if (data.default !== void 0 && data.default !== data.defaultDefault && (!ctx.migration || typeof data.default !== "function")) addCode(code, `.default(${columnDefaultArgumentToCode(ctx, data.default)})`);
 	if (data.indexes) for (const part of columnIndexesToCode(data.indexes)) addCode(code, part);
 	if (data.excludes) for (const part of columnExcludesToCode(data.excludes)) addCode(code, part);
 	if (data.comment) addCode(code, `.comment(${singleQuote(data.comment)})`);
@@ -2306,6 +2314,17 @@ const make = (_op) => {
 		(q.chain ??= []).push(_op, val || value);
 		if (getValueParser(q.parsers)) setValueParser(q, void 0);
 		q.getColumn = BooleanColumn.instance;
+		if (this instanceof Expression && this.result) {
+			let column;
+			if (this.result.value?.data.name) {
+				column = Object.create(BooleanColumn.instance);
+				column.data = {
+					...column.data,
+					name: this.result.value.data.name
+				};
+			} else column = BooleanColumn.instance;
+			this.result.value = column;
+		}
 		return setQueryOperators(this, boolean);
 	}, { _op });
 };
@@ -2812,7 +2831,8 @@ var SimpleRawSQL = class extends RawSql {
 };
 const raw$1 = (sql) => new SimpleRawSQL(sql);
 const makeTimestamps = (timestamp) => {
-	const nowRaw = raw$1(getDefaultNowFn());
+	const now = getDefaultNowFn();
+	const nowRaw = raw$1(now);
 	const updatedAt = timestamp().default(nowRaw);
 	let updater;
 	updatedAt.data.modifyQuery = (q, column) => {
@@ -2845,7 +2865,7 @@ const timestampHelpers = {
 };
 const defaultSrid = 4326;
 const encode = ({ srid = defaultSrid, lon, lat }) => {
-	const arr = new Uint8Array(25);
+	const arr = /* @__PURE__ */ new Uint8Array(25);
 	const view = new DataView(arr.buffer);
 	view.setInt8(0, 1);
 	view.setInt8(1, 1);
@@ -2874,7 +2894,7 @@ var PostgisGeographyPointColumn = class extends Column {
 	}
 };
 const parse = (input) => {
-	const bytes = new Uint8Array(20);
+	const bytes = /* @__PURE__ */ new Uint8Array(20);
 	for (let i = 0; i < 40; i += 2) bytes[i / 2] = parseInt(input.slice(10 + i, 12 + i), 16);
 	const view = new DataView(bytes.buffer);
 	const srid = view.getUint32(0, true);
@@ -3742,24 +3762,19 @@ var QueryStorage = class {
 * so later they can be identified when handling after commit errors.
 *
 * ```ts
-* class SomeTable extends BaseTable {
-*   readonly table = 'someTable';
-*   columns = this.setColumns((t) => ({
-*     ...someColumns,
-*   }));
-*
-*   init(orm: typeof db) {
-*     // anonymous funciton - has no name
-*     this.afterCreateCommit([], async () => {
-*       // ...
-*     });
+* export const SomeTable = defineTable('someTable', (t) => ({
+*   ...someColumns,
+* })).init((orm: typeof db, hooks) => {
+*   // anonymous funciton - has no name
+*   hooks.afterCreateCommit([], async () => {
+*     // ...
+*   });
 *
-*     // named function
-*     this.afterCreateCommit([], function myHook() => {
-*       // ...
-*     });
-*   }
-* }
+*   // named function
+*   hooks.afterCreateCommit([], function myHook() {
+*     // ...
+*   });
+* });
 * ```
 */
 var AfterCommitError = class extends OrchidOrmError {
@@ -3824,7 +3839,8 @@ var QueryTransaction = class QueryTransaction {
 		return QueryTransaction.prototype.transaction.call(this, cb);
 	}
 	isInTransaction() {
-		return isInUserTransaction(this.internal.asyncStorage.getStore());
+		const trx = this.internal.asyncStorage.getStore();
+		return isInUserTransaction(trx);
 	}
 	/**
 	* Schedules a hook to run after the outermost transaction commits:
@@ -4512,21 +4528,16 @@ const _unscope = (q, scope) => {
 * If you define a scope with name `default`, it will be applied for all table queries by default.
 *
 * ```ts
-* import { BaseTable } from './baseTable';
+* import { defineTable } from './table-factory';
 *
-* export class SomeTable extends BaseTable {
-*   readonly table = 'some';
-*   columns = this.setColumns((t) => ({
-*     id: t.identity().primaryKey(),
-*     hidden: t.boolean(),
-*     active: t.boolean(),
-*   }));
-*
-*   scopes = this.setScopes({
-*     default: (q) => q.where({ hidden: false }),
-*     active: (q) => q.where({ active: true }),
-*   });
-* }
+* export const SomeTable = defineTable('some', (t) => ({
+*   id: t.identity().primaryKey(),
+*   hidden: t.boolean(),
+*   active: t.boolean(),
+* })).scopes({
+*   default: (q) => q.where({ hidden: false }),
+*   active: (q) => q.where({ active: true }),
+* });
 *
 * const db = orchidORM(
 *   { databaseURL: '...' },
@@ -5689,7 +5700,8 @@ const resolveCallbacksInArgs = (q, args) => {
 			qb.q.and = qb.q.or = qb.q.scopes = void 0;
 			qb.q.subQuery = 1;
 			_setSubQueryAliases(qb);
-			args[i] = prepareSubQueryForSql(q, resolveSubQueryCallback(qb, arg));
+			const resolved = resolveSubQueryCallback(qb, arg);
+			args[i] = prepareSubQueryForSql(q, resolved);
 		} else if (arg.constructor === Object) {
 			const copy = args[i] = { ...arg };
 			for (const key in arg) {
@@ -5834,7 +5846,7 @@ var Where = class {
 	* Constructing `WHERE` conditions:
 	*
 	* ```ts
-	* import { sql } from './baseTable'
+	* import { sql } from './table-factory';
 	*
 	* db.table.where({
 	*   // column of the current table
@@ -5850,7 +5862,7 @@ var Where = class {
 	*   },
 	*
 	*   // where column equals to raw SQL
-	*   // import `sql` from your `BaseTable`
+	*   // import `sql` from your table factory
 	*   column: sql`sql expression`,
 	*   // or use `(q) => sql` for the same
 	*   column2: (q) => sql`sql expression`,
@@ -6461,7 +6473,8 @@ var Where = class {
 	* @param args - no arguments needed when the first argument is a relation name, or conditions to join the table with.
 	*/
 	whereNotExists(arg, ...args) {
-		return _queryWhereNotExists(_clone(this), arg, args);
+		const q = _clone(this);
+		return _queryWhereNotExists(q, arg, args);
 	}
 	/**
 	* Acts as `whereExists`, but prepends the condition with `OR` and negates it with `NOT`:
@@ -6608,7 +6621,11 @@ const tableColumnToSql = (ctx, queryData, shape, table, key, quotedAs, select, a
 const columnToSqlNotSelect = (ctx, data, shape, column, quotedAs, useSelectList) => columnToSql(ctx, data, shape, column, quotedAs, void 0, void 0, void 0, useSelectList, true);
 const columnToSql = (ctx, data, shape, column, quotedAs, select, as, jsonList, useSelectList, skipValueToArray) => {
 	let index = column.indexOf(".");
-	if (index !== -1) return tableColumnToSql(ctx, data, shape, column.slice(0, index), column.slice(index + 1), quotedAs, select, as, jsonList, skipValueToArray);
+	if (index !== -1) {
+		const table = column.slice(0, index);
+		const key = column.slice(index + 1);
+		return tableColumnToSql(ctx, data, shape, table, key, quotedAs, select, as, jsonList, skipValueToArray);
+	}
 	return simpleColumnToSQL(ctx, data, shape, column, shape[column], quotedAs, select, as, jsonList, useSelectList, void 0, skipValueToArray);
 };
 const rawOrColumnToSql = (ctx, data, shape, expr, quotedAs, select, skipValueToArray) => {
@@ -6851,11 +6868,20 @@ const _addToHookSelectWithTable = (query, selects, table) => {
 };
 const moveQueryToCte = (ctx, query, type, dontAddTableHook) => {
 	const { returnType } = query.q;
+	const throwOnNotFound = returnType === "valueOrThrow";
 	let valueAs;
 	if (returnType === "value" || returnType === "valueOrThrow" || returnType === "pluck") {
 		const first = query.q.select[0];
-		if (first instanceof SelectItemExpression && typeof first.item === "string") valueAs = first.item;
-		else {
+		if (first instanceof SelectItemExpression && typeof first.item === "string") {
+			const columnName = first.result.value?.data.name;
+			if (columnName && columnName !== first.item) {
+				query = _clone(query);
+				query.q.returnType = "one";
+				query.q.select = [{ selectAs: { [first.item]: first } }];
+				if (throwOnNotFound && query.q.type !== "upsert") query.q.cteThrowOnNotFound = true;
+			}
+			valueAs = first.item;
+		} else {
 			query = _clone(query);
 			query.q.returnType = "one";
 			query.q.select = [{ selectAs: { value: query.q.select[0] } }];
@@ -6912,7 +6938,7 @@ const addTableHook = (ctx, q, data, select, hookPurpose, dontAddTableHook) => {
 	const afterUpdateCommit = data.afterUpdateCommit;
 	const afterSaveCommit = data.afterSaveCommit;
 	const afterDeleteCommit = data.afterDeleteCommit;
-	const throwOnNotFound = hookPurpose !== "Create" && (data.returnType === "oneOrThrow" || data.returnType === "valueOrThrow");
+	const throwOnNotFound = hookPurpose !== "Create" && (data.cteThrowOnNotFound || data.returnType === "oneOrThrow" || data.returnType === "valueOrThrow");
 	const hasAfterHook = afterCreate || afterUpdate || afterSave || afterDelete || afterCreateCommit || afterUpdateCommit || afterSaveCommit || afterDeleteCommit;
 	if (!select && !hasAfterHook && !throwOnNotFound) return;
 	const tableHook = {
@@ -6937,7 +6963,8 @@ const addTableHook = (ctx, q, data, select, hookPurpose, dontAddTableHook) => {
 				tableHook,
 				throwOnNotFound
 			};
-			const cteHooks = setCteHooks(ctx, throwOnNotFound || !!tableHook.select);
+			const hasSelect = throwOnNotFound || !!tableHook.select;
+			const cteHooks = setCteHooks(ctx, hasSelect);
 			(cteHooks.tableHooks ??= {})[ctx.cteName] ??= item;
 		}
 	} else ctx.topCtx.tableHook = tableHook;
@@ -7330,7 +7357,8 @@ const processWhere = (ands, ctx, table, query, data, quotedAs) => {
 		const value = data[key];
 		if (value === void 0) continue;
 		if (key === "AND") {
-			const sql = processAnds(toArray(value), ctx, table, query, quotedAs);
+			const arr = toArray(value);
+			const sql = processAnds(arr, ctx, table, query, quotedAs);
 			if (sql) ands.push(sql);
 		} else if (key === "OR") {
 			const sqls = value.map(toArray).reduce((acc, and) => {
@@ -8973,7 +9001,9 @@ const _queryCreate = (q, data) => {
 };
 const _queryInsert = (query, data) => {
 	throwIfReadOnly(query);
-	return insert(query, handleOneData(query, data, createCtx()));
+	const ctx = createCtx();
+	const obj = handleOneData(query, data, ctx);
+	return insert(query, obj);
 };
 const _queryCreateMany = (q, data) => {
 	throwIfReadOnly(q);
@@ -8982,7 +9012,8 @@ const _queryCreateMany = (q, data) => {
 };
 const _queryInsertMany = (q, data) => {
 	throwIfReadOnly(q);
-	let result = insert(q, handleManyData(q, data, createCtx()), true);
+	const ctx = createCtx();
+	let result = insert(q, handleManyData(q, data, ctx), true);
 	if (!data.length) result = result.none();
 	return result;
 };
@@ -9173,31 +9204,26 @@ var QueryCreate = class {
 	* A primary key or a unique index for a **single** column can be fined on a column:
 	*
 	* ```ts
-	* export class MyTable extends BaseTable {
-	*   columns = this.setColumns((t) => ({
-	*     pkey: t.uuid().primaryKey(),
-	*     unique: t.string().unique(),
-	*   }));
-	* }
+	* export const MyTable = defineTable('myTable', (t) => ({
+	*   pkey: t.uuid().primaryKey(),
+	*   unique: t.string().unique(),
+	* }));
 	* ```
 	*
 	* But for composite primary keys or indexes (having multiple columns), define it in a separate function:
 	*
 	* ```ts
-	* export class MyTable extends BaseTable {
-	*   columns = this.setColumns(
-	*     (t) => ({
-	*       one: t.integer(),
-	*       two: t.string(),
-	*       three: t.boolean(),
-	*     }),
-	*     (t) => [t.primaryKey(['one', 'two']), t.unique(['two', 'three'])],
-	*   );
-	* }
+	* export const MyTable = defineTable('myTable', (t) => ({
+	*   one: t.integer(),
+	*   two: t.string(),
+	*   three: t.boolean(),
+	* }))
+	*   .primaryKey(['one', 'two'])
+	*   .unique(['two', 'three']);
 	* ```
 	* :::
 	*
-	* You can use the `sql` function exported from your `BaseTable` file in onConflict.
+	* You can use the `sql` function exported from your table factory file in onConflict.
 	* It can be useful to specify a condition when you have a partial index:
 	*
 	* ```ts
@@ -9587,12 +9613,15 @@ const toSql = (table, type, topCtx, isSubSql, cteName, calledByThen, dontAddTabl
 				if (upsertOrCreate.q.returnType === "oneOrThrow") upsertOrCreate.q.returnType = "one";
 				else if (upsertOrCreate.q.returnType === "valueOrThrow") upsertOrCreate.q.returnType = "value";
 				const { as, makeSql: makeFirstSql } = moveMutativeQueryToCteBase(toSql, ctx, upsertOrCreate, upsertUpdate ? "update" : null);
+				query.upsertUpdateAsFns?.forEach((fn) => fn(as));
 				upsertOrCreate.q.or = upsertOrCreate.q.scopes = void 0;
 				upsertOrCreate.q.and = [new RawSql(`NOT EXISTS (SELECT 1 FROM "${as}")`)];
 				if (query.upsertInsert) {
-					_queryInsert(upsertOrCreate, query.upsertInsert());
+					const insertData = query.upsertInsert();
+					_queryInsert(upsertOrCreate, insertData);
 					upsertOrCreate.q.type = "upsert";
 				}
+				upsertOrCreate.q.with = query.upsertCreateWith;
 				upsertOrCreate.q.appendQueries = query.upsertCreateAppendQueries;
 				upsertOrCreate.q.asFns = query.upsertCreateAsFns;
 				const { makeSql: makeSecondSql } = moveMutativeQueryToCteBase(toSql, ctx, upsertOrCreate, "insert");
@@ -9702,7 +9731,8 @@ const cteToSqlGiveAs = (ctx, item, type, dontAddTableHook) => {
 	let as;
 	if (typeof item.n === "string") as = item.n;
 	else if (ctx === ctx.topCtx) {
-		as = setFreeAlias((ctx.topCtx.topCTE ??= newTopCte(ctx)).names, "q", true);
+		const topCTE = ctx.topCtx.topCTE ??= newTopCte(ctx);
+		as = setFreeAlias(topCTE.names, "q", true);
 		item.n(as);
 	} else throw new Error("not implemented yet");
 	if (item.q) inner = getSqlText(toSql(item.q, type, ctx.topCtx, true, as, void 0, dontAddTableHook));
@@ -10164,36 +10194,21 @@ var QueryJoin = class {
 	* For the following examples, imagine you have a `User` table with `id` and `name`, and `Message` table with `id`, `text`, messages belongs to user via `userId` column:
 	*
 	* ```ts
-	* export class UserTable extends BaseTable {
-	*   readonly table = 'user';
-	*   columns = this.setColumns((t) => ({
-	*     id: t.identity().primaryKey(),
-	*     name: t.text(),
-	*   }));
-	*
-	*   relations = {
-	*     messages: this.hasMany(() => MessageTable, {
-	*       primaryKey: 'id',
-	*       foreignKey: 'userId',
-	*     }),
-	*   };
-	* }
-	*
-	* export class MessageTable extends BaseTable {
-	*   readonly table = 'message';
-	*   columns = this.setColumns((t) => ({
-	*     id: t.identity().primaryKey(),
-	*     text: t.text(),
-	*     ...t.timestamps(),
-	*   }));
+	* export const UserTable = defineTable('user', (t) => ({
+	*   id: t.identity().primaryKey(),
+	*   name: t.text(),
+	* })).relations((user) => ({
+	*   messages: user('id').hasMany(() => MessageTable('userId')),
+	* }));
 	*
-	*   relations = {
-	*     user: this.belongsTo(() => UserTable, {
-	*       primaryKey: 'id',
-	*       foreignKey: 'userId',
-	*     }),
-	*   };
-	* }
+	* export const MessageTable = defineTable('message', (t) => ({
+	*   id: t.identity().primaryKey(),
+	*   userId: t.integer(),
+	*   text: t.text(),
+	*   ...t.timestamps(),
+	* })).relations((message) => ({
+	*   user: message('userId').belongsTo(() => UserTable('id')),
+	* }));
 	* ```
 	*
 	* `join` is a method for SQL `JOIN`, which is equivalent to `INNER JOIN`, `LEFT INNERT JOIN`.
@@ -10390,7 +10405,7 @@ var QueryJoin = class {
 	* ```ts
 	* db.user.join(
 	*   db.message,
-	*   // `sql` can be imported from your `BaseTable` file
+	*   // `sql` can be imported from your table factory file
 	*   sql`lower("message"."text") = lower("user"."name")`,
 	* );
 	* ```
@@ -10841,12 +10856,15 @@ var OnMethods = class {
 const setSelectRelation = (q) => {
 	q.selectRelation = true;
 };
-const addParsersForSelectJoined = (q, arg, as = arg) => {
+const addParsersForSelectJoinedWildcard = (q, arg, as = arg) => {
 	const parsers = q.q.joinedParsers?.[arg];
 	if (parsers) setParserToQuery(q.q, as, (row) => parseRecord(parsers, row));
 	const batchParsers = q.q.joinedBatchParsers?.[arg];
 	if (batchParsers) pushQueryArrayImmutable(q, "batchParsers", batchParsers.map((x) => ({
-		path: [{ key: as }, ...x.path],
+		path: [{
+			key: as,
+			returnType: "one"
+		}, ...x.path],
 		fn: x.fn
 	})));
 };
@@ -11028,7 +11046,8 @@ const processSelectAsArg = (q, selectAs, as, key, arg, columnAlias, outerReturnT
 					subQuery = value;
 				} else subQuery = value.json(false);
 				else subQuery = value;
-				const as = _joinLateral(q, innerJoinLateral || query.q.returnType === "valueOrThrow" ? "JOIN" : "LEFT JOIN", subQuery, key, innerJoinLateral && returnType !== "one" && returnType !== "oneOrThrow");
+				const joinLateral = innerJoinLateral || query.q.returnType === "valueOrThrow";
+				const as = _joinLateral(q, joinLateral ? "JOIN" : "LEFT JOIN", subQuery, key, innerJoinLateral && returnType !== "one" && returnType !== "oneOrThrow");
 				if (as) value.q.joinedForSelect = _copyQueryAliasToQuery(value, q, as);
 			}
 			if (value.q.getColumn?.data.skipValueToArray) value.q.notFoundDefault ??= null;
@@ -11060,7 +11079,7 @@ const setParserForSelectedString = (query, arg, as, columnAs, columnAlias) => {
 	const table = getFullColumnTable(query, arg, index, as);
 	const column = arg.slice(index + 1);
 	if (column === "*") {
-		addParsersForSelectJoined(query, table, columnAs);
+		addParsersForSelectJoinedWildcard(query, table, columnAs);
 		return table === as ? column : arg;
 	}
 	if (table === as) return selectColumn(query, q, column, columnAs, columnAlias);
@@ -11486,6 +11505,7 @@ function _orCreate(query, data, updateData, mergeData) {
 	const { q } = query;
 	q.returnsOne = true;
 	if (!q.select) q.returnType = "void";
+	q.type = "upsert";
 	if (typeof data === "function") q.upsertInsert = () => mergeData ? {
 		...mergeData,
 		...data(updateData)
@@ -12475,7 +12495,17 @@ const _appendQuery = (main, append, asFn) => {
 const _appendQueryOnUpsertCreate = (main, append, asFn) => {
 	return pushQueryValueImmutable(pushQueryValueImmutable(main, "upsertCreateAppendQueries", prepareSubQueryForSql(main, append)), "upsertCreateAsFns", asFn);
 };
-const mergableObjects = new Set([
+const _onUpsertUpdate = (q, asFn) => {
+	return pushQueryValueImmutable(q, "upsertUpdateAsFns", asFn);
+};
+const _prependWithOnUpsertCreate = (q, name, query) => {
+	const prev = q.q.with;
+	q.q.with = q.q.upsertCreateWith;
+	_prependWith(q, name, query);
+	q.q.upsertCreateWith = q.q.with;
+	q.q.with = prev;
+};
+const mergableObjects = /* @__PURE__ */ new Set([
 	"selectShape",
 	"withShapes",
 	"defaultParsers",
@@ -12487,7 +12517,7 @@ const mergableObjects = new Set([
 	"joinedBatchParsers",
 	"selectedComputeds"
 ]);
-const dontMergeArrays = new Set(["selectAllColumns"]);
+const dontMergeArrays = /* @__PURE__ */ new Set(["selectAllColumns"]);
 var MergeQueryMethods = class {
 	merge(q) {
 		const query = _clone(this);
@@ -12501,20 +12531,18 @@ var MergeQueryMethods = class {
 				case "number":
 					a[key] = value;
 					break;
-				case "object":
-					if (Array.isArray(value)) {
-						if (!dontMergeArrays.has(key)) a[key] = a[key] ? [...a[key], ...value] : value;
-					} else if (mergableObjects.has(key)) a[key] = a[key] ? {
-						...a[key],
-						...value
-					} : value;
-					else if (key === "union") a[key] = a[key] ? {
-						b: a[key].b,
-						u: [...a[key].u, ...value.u]
-					} : value;
-					else if (value instanceof Set) a[key] = a[key] ? new Set([...a[key], ...value]) : value;
-					else a[key] = value;
-					break;
+				case "object": if (Array.isArray(value)) {
+					if (!dontMergeArrays.has(key)) a[key] = a[key] ? [...a[key], ...value] : value;
+				} else if (mergableObjects.has(key)) a[key] = a[key] ? {
+					...a[key],
+					...value
+				} : value;
+				else if (key === "union") a[key] = a[key] ? {
+					b: a[key].b,
+					u: [...a[key].u, ...value.u]
+				} : value;
+				else if (value instanceof Set) a[key] = a[key] ? /* @__PURE__ */ new Set([...a[key], ...value]) : value;
+				else a[key] = value;
 			}
 		}
 		if (b.returnType) a.returnType = b.returnType;
@@ -12698,12 +12726,12 @@ var SearchMethods = class {
 	*
 	* By default, the search language is English.
 	*
-	* You can set a different default language in the `createBaseTable` config:
+	* You can set a different default language in the `createTableFactory` config:
 	*
 	* ```ts
-	* import { createBaseTable } from 'orchid-orm';
+	* import { createTableFactory } from 'orchid-orm';
 	*
-	* export const BaseTable = createBaseTable({
+	* export const { defineTable, defineView, sql } = createTableFactory({
 	*   language: 'swedish',
 	* });
 	* ```
@@ -13089,20 +13117,20 @@ const _softDelete = (column, customNowSQL) => {
 * All queries on such table will filter out deleted records by default.
 *
 * ```ts
-* import { BaseTable } from './baseTable';
-*
-* export class SomeTable extends BaseTable {
-*   readonly table = 'some';
-*   columns = this.setColumns((t) => ({
-*     id: t.identity().primaryKey(),
-*     deletedAt: t.timestamp().nullable(),
-*   }));
+* import { defineTable } from './table-factory';
 *
+* export const SomeTable = defineTable('some', (t) => ({
+*   id: t.identity().primaryKey(),
+*   deletedAt: t.timestamp().nullable(),
+* }))
 *   // true is for using `deletedAt` column
-*   readonly softDelete = true;
-*   // or provide a different column name
-*   readonly softDelete = 'myDeletedAt';
-* }
+*   .softDelete();
+*
+* // or provide a different column name
+* export const OtherTable = defineTable('other', (t) => ({
+*   id: t.identity().primaryKey(),
+*   myDeletedAt: t.timestamp().nullable(),
+* })).softDelete('myDeletedAt');
 *
 * const db = orchidORM(
 *   { databaseURL: '...' },
@@ -13492,7 +13520,8 @@ var QueryMethods = class {
 	* @param args - SQL expression
 	*/
 	findBySql(...args) {
-		return _queryTake(_queryWhereSql(_clone(this), args));
+		const q = _clone(this);
+		return _queryTake(_queryWhereSql(q, args));
 	}
 	/**
 	* Finds a single record by the primary key (id), returns `undefined` when not found.
@@ -14032,7 +14061,8 @@ var Db = class extends QueryMethods {
 			if (options.noPrimaryKey === "error") throw new Error(message);
 			else logger.warn(message);
 		}
-		this.columns = Object.keys(shape);
+		const columns = Object.keys(shape);
+		this.columns = columns;
 		if (options.computed) applyComputedColumns(this, options.computed);
 		if (prepareSelectAll) {
 			const selectAllShape = this.q.selectAllShape = {};
@@ -14399,11 +14429,14 @@ function getColumnInfo(query, column) {
 	};
 	return q;
 }
+const columnsSql = (shape, columns) => {
+	return columns.map((item) => `"${shape[item]?.data.name || item}"`).join(", ");
+};
 const makeCopySql = (table, copy) => {
 	const ctx = newToSqlCtx(table);
 	const { q } = table;
 	const quotedAs = `"${q.as || table.table}"`;
-	const columns = copy.columns ? `(${copy.columns.map((item) => `"${table.shape[item]?.data.name || item}"`).join(", ")})` : "";
+	const columns = copy.columns ? `(${columnsSql(table.shape, copy.columns)})` : "";
 	const target = "from" in copy ? copy.from : copy.to;
 	const quotedTable = quoteTableWithSchema(table);
 	ctx.sql.push(`COPY ${quotedTable}${columns} ${"from" in copy ? "FROM" : "TO"} ${typeof target === "string" ? escapeString(target) : `PROGRAM ${escapeString(target.program)}`}`);
@@ -14416,9 +14449,9 @@ const makeCopySql = (table, copy) => {
 		if (copy.header) options.push(`HEADER ${copy.header}`);
 		if (copy.quote) options.push(`QUOTE ${escapeString(copy.quote)}`);
 		if (copy.escape) options.push(`ESCAPE ${escapeString(copy.escape)}`);
-		if (copy.forceQuote) options.push(`FORCE_QUOTE ${copy.forceQuote === "*" ? "*" : `(${copy.forceQuote.map((x) => `"${x}"`).join(", ")})`}`);
-		if (copy.forceNotNull) options.push(`FORCE_NOT_NULL (${copy.forceNotNull.map((x) => `"${x}"`).join(", ")})`);
-		if (copy.forceNull) options.push(`FORCE_NULL (${copy.forceNull.map((x) => `"${x}"`).join(", ")})`);
+		if (copy.forceQuote) options.push(`FORCE_QUOTE ${copy.forceQuote === "*" ? "*" : `(${columnsSql(table.shape, copy.forceQuote)})`}`);
+		if (copy.forceNotNull) options.push(`FORCE_NOT_NULL (${columnsSql(table.shape, copy.forceNotNull)})`);
+		if (copy.forceNull) options.push(`FORCE_NULL (${columnsSql(table.shape, copy.forceNull)})`);
 		if (copy.encoding) options.push(`ENCODING ${escapeString(copy.encoding)}`);
 		ctx.sql.push(`WITH (${options.join(", ")})`);
 	}
@@ -14485,6 +14518,12 @@ var Rollback = class extends Error {};
 const trxForTest = Symbol("trxForTest");
 const argToDb = (arg) => "$qb" in arg ? arg.$qb : arg;
 const testTransaction = {
+	/**
+	* Start a test transaction.
+	* The returned promise is resolved immediately when transaction starts, not waiting for it to end.
+	*
+	* @param arg - ORM instance or a queryable instance (such as db.someTable).
+	*/
 	start(arg) {
 		const db = argToDb(arg);
 		const { asyncStorage } = db.internal;
@@ -14520,6 +14559,11 @@ const testTransaction = {
 			});
 		});
 	},
+	/**
+	* Rollback a test transaction.
+	*
+	* @param arg - the same ORM or query argument passed into the `testTransaction.start`.
+	*/
 	rollback(arg) {
 		const db = argToDb(arg);
 		const data = db.internal[trxForTest];
@@ -14529,6 +14573,12 @@ const testTransaction = {
 		last.reject?.(new Rollback());
 		return last.promise;
 	},
+	/**
+	* Will roll back the current `testTransaction` (won't have any effect if it was rolled back already),
+	* and if there's no nested test transactions left, it will close the db connection.
+	*
+	* @param arg - the same ORM or query argument passed into the `testTransaction.start`.
+	*/
 	async close(arg) {
 		const db = argToDb(arg);
 		await this.rollback(db);
@@ -14609,8 +14659,10 @@ exports._clone = _clone;
 exports._createDbSqlMethod = _createDbSqlMethod;
 exports._hookSelectColumns = _hookSelectColumns;
 exports._initQueryBuilder = _initQueryBuilder;
+exports._onUpsertUpdate = _onUpsertUpdate;
 exports._orCreate = _orCreate;
 exports._prependWith = _prependWith;
+exports._prependWithOnUpsertCreate = _prependWithOnUpsertCreate;
 exports._queryCreate = _queryCreate;
 exports._queryCreateMany = _queryCreateMany;
 exports._queryCreateManyFrom = _queryCreateManyFrom;
@@ -14644,6 +14696,7 @@ exports.codeToString = codeToString;
 exports.colors = colors;
 exports.columnsShapeToCode = columnsShapeToCode;
 exports.constraintInnerToCode = constraintInnerToCode;
+exports.constraintToCode = constraintToCode;
 exports.consumeColumnName = consumeColumnName;
 exports.copyTableData = copyTableData;
 exports.createDbWithAdapter = createDbWithAdapter;
@@ -14654,6 +14707,7 @@ exports.emptyObject = emptyObject;
 exports.escapeForMigration = escapeForMigration;
 exports.escapeString = escapeString;
 exports.excludeInnerToCode = excludeInnerToCode;
+exports.excludeToCode = excludeToCode;
 exports.exhaustive = exhaustive;
 exports.getCallerFilePath = getCallerFilePath;
 exports.getClonedQueryData = getClonedQueryData;
@@ -14674,6 +14728,7 @@ exports.getSqlText = getSqlText;
 exports.getStackTrace = getStackTrace;
 exports.getSupportedDefaultPrivileges = getSupportedDefaultPrivileges;
 exports.indexInnerToCode = indexInnerToCode;
+exports.indexToCode = indexToCode;
 exports.internalSchemaConfig = internalSchemaConfig;
 exports.isExpression = isExpression;
 exports.isQueryReturnsAll = isQueryReturnsAll;