orchid-orm 1.76.5 → 1.77.1

package/dist/index.js

@@ -152,6 +152,422 @@ function createBaseTable({ schemaConfig = pqb_internal.defaultSchemaConfig, colu
 	base.prototype.autoForeignKeys = autoForeignKeys === true ? {} : autoForeignKeys || void 0;
 	return base;
 }
+const makeRelationEndpoint = (id, columns, on, through, source) => {
+	const endpoint = {
+		id,
+		columns,
+		on,
+		relationThrough: through,
+		relationSource: source,
+		where(conditions) {
+			return makeRelationEndpoint(id, columns, {
+				...on,
+				...conditions
+			}, through, source);
+		}
+	};
+	if (through) {
+		endpoint.through = through;
+		endpoint.source = source;
+	} else endpoint.through = (through, source) => makeRelationEndpoint(id, columns, on, through, source);
+	return endpoint;
+};
+const getRelationTargetId = (target) => {
+	const item = target;
+	const id = item.id ?? item.data?.id;
+	if (!id) throw new Error("Cannot get relation target id");
+	return id;
+};
+const getRelationEndpointOptions = (endpoint) => endpoint.on ? {
+	references: endpoint.columns,
+	on: endpoint.on
+} : { references: endpoint.columns };
+const getRelationThroughOptions = (endpoint) => {
+	const options = {
+		through: endpoint.relationThrough,
+		source: endpoint.relationSource
+	};
+	if (endpoint.on) options.on = endpoint.on;
+	return options;
+};
+const makeRelationBuilder = () => {
+	const withRequired = (relation) => {
+		const item = relation;
+		item.required = (value = true) => {
+			item.options.required = value;
+			return item;
+		};
+		item.foreignKey = (value = true) => {
+			item.options.foreignKey = value;
+			return item;
+		};
+		return item;
+	};
+	const builder = ((...columns) => ({
+		belongsTo: (fn) => {
+			const endpoint = fn();
+			return withRequired({
+				type: "belongsTo",
+				id: getRelationTargetId(endpoint),
+				options: {
+					columns,
+					...getRelationEndpointOptions(endpoint)
+				}
+			});
+		},
+		hasOne: (fn) => {
+			const endpoint = fn();
+			return withRequired({
+				type: "hasOne",
+				id: getRelationTargetId(endpoint),
+				options: {
+					columns,
+					...getRelationEndpointOptions(endpoint)
+				}
+			});
+		},
+		hasMany: (fn) => {
+			const endpoint = fn();
+			return withRequired({
+				type: "hasMany",
+				id: getRelationTargetId(endpoint),
+				options: {
+					columns,
+					...getRelationEndpointOptions(endpoint)
+				}
+			});
+		},
+		hasAndBelongsToMany: (fn) => {
+			const endpoint = fn();
+			const options = { columns };
+			return {
+				type: "hasAndBelongsToMany",
+				id: getRelationTargetId(endpoint),
+				options,
+				through(joinTable, selfColumns, relColumns, throughOptions) {
+					this.options.references = Array.isArray(selfColumns) ? selfColumns : [selfColumns];
+					this.options.on = endpoint.on;
+					const schemaIndex = joinTable.indexOf(".");
+					const parsedSchema = schemaIndex === -1 ? void 0 : joinTable.slice(0, schemaIndex);
+					const table = schemaIndex === -1 ? joinTable : joinTable.slice(schemaIndex + 1);
+					this.options.through = {
+						schema: throughOptions?.schema ?? parsedSchema,
+						table,
+						snakeCase: throughOptions?.joinTableSnakeCase,
+						columns: Array.isArray(relColumns) ? relColumns : [relColumns],
+						references: endpoint.columns
+					};
+					return this;
+				},
+				foreignKey(value) {
+					if (value === false) {
+						this.options.foreignKey = false;
+						if (this.options.through) this.options.through.foreignKey = false;
+					} else if (value === void 0 || value === true) {
+						this.options.foreignKey = true;
+						if (this.options.through) this.options.through.foreignKey = true;
+					} else if ("forBothTables" in value) {
+						this.options.foreignKey = value.forBothTables ?? true;
+						if (this.options.through) this.options.through.foreignKey = value.forBothTables ?? true;
+					} else {
+						this.options.foreignKey = value.forThisTable ?? true;
+						if (this.options.through) this.options.through.foreignKey = value.forRelatedTable ?? true;
+					}
+					return this;
+				}
+			};
+		}
+	}));
+	builder.hasOne = (fn) => {
+		const endpoint = fn();
+		return withRequired({
+			type: "hasOne",
+			id: getRelationTargetId(endpoint),
+			options: getRelationThroughOptions(endpoint)
+		});
+	};
+	builder.hasMany = (fn) => {
+		const endpoint = fn();
+		return {
+			type: "hasMany",
+			id: getRelationTargetId(endpoint),
+			options: getRelationThroughOptions(endpoint)
+		};
+	};
+	return builder;
+};
+var InitHookTarget = class extends pqb_internal.QueryHooks {
+	constructor(q) {
+		super();
+		this.q = q;
+	}
+	clone() {
+		return this;
+	}
+};
+const setDefinitionSchemaMethods = (definition, schema, shape) => {
+	definition.prototype ??= {};
+	definition.prototype.columns = { shape };
+	definition.inputSchema = schema.inputSchema;
+	definition.outputSchema = schema.outputSchema;
+	definition.querySchema = schema.querySchema;
+	definition.pkeySchema = schema.pkeySchema;
+	definition.createSchema = schema.createSchema;
+	definition.updateSchema = schema.updateSchema;
+};
+const createTableFactory = (options) => {
+	const schema = (options?.schemaConfig ?? pqb_internal.defaultSchemaConfig)();
+	const defaultColumnTypes = (0, pqb_internal.makeColumnTypes)(schema);
+	const columnTypesOption = options?.columnTypes;
+	const columnTypes = typeof columnTypesOption === "function" ? columnTypesOption(defaultColumnTypes) : columnTypesOption || defaultColumnTypes;
+	const defineTableExportAs = options?.defineTableExportAs ?? "defineTable";
+	const filePathOrStack = options?.filePath || (0, pqb_internal.getStackTrace)();
+	let filePath;
+	const defineTable = ((table, optionsOrT, maybeT) => {
+		const tableOptions = typeof optionsOrT === "function" ? void 0 : optionsOrT;
+		const t = typeof optionsOrT === "function" ? optionsOrT : maybeT;
+		if (!t) throw new Error("Column definitions are required");
+		const id = tableOptions?.id ?? table;
+		const shape = (0, pqb_internal.getColumnTypes)(columnTypes, t, options?.nowSQL, options?.language);
+		const tableData = {};
+		const snakeCase = tableOptions?.snakeCase ?? options?.snakeCase;
+		if (snakeCase) for (const key in shape) {
+			const column = shape[key];
+			if (column.data.name) continue;
+			const snakeName = (0, pqb_internal.toSnakeCase)(key);
+			if (snakeName !== key) column.data.name = snakeName;
+		}
+		const nameInDb = tableOptions?.nameInDb ?? (snakeCase ? (0, pqb_internal.toSnakeCase)(table) : table);
+		const autoForeignKeys = tableOptions?.autoForeignKeys !== void 0 ? tableOptions.autoForeignKeys : options?.autoForeignKeys;
+		const instance = {
+			id,
+			table,
+			nameInDb,
+			schema: tableOptions?.schema,
+			noPrimaryKey: tableOptions?.noPrimaryKey,
+			snakeCase,
+			comment: tableOptions?.comment,
+			generatorIgnore: tableOptions?.generatorIgnore,
+			readOnly: tableOptions?.readOnly,
+			columns: {
+				shape,
+				data: tableData
+			},
+			types: columnTypes,
+			filePath: options?.filePath ?? "",
+			language: options?.language,
+			autoForeignKeys: autoForeignKeys === true ? {} : autoForeignKeys || void 0,
+			q: {}
+		};
+		const definition = ((...columns) => makeRelationEndpoint(id, columns));
+		definition.data = {
+			id,
+			table,
+			name: void 0,
+			relations: void 0,
+			columns: shape,
+			types: void 0,
+			computed: void 0,
+			scopes: void 0,
+			readOnly: tableOptions?.readOnly,
+			tableData
+		};
+		setDefinitionSchemaMethods(definition, schema, shape);
+		definition.exportAs = defineTableExportAs;
+		definition.nowSQL = options?.nowSQL;
+		definition.instance = () => {
+			const { computed, relations, scopes, softDelete, readOnly } = definition.data;
+			instance.computed = computed;
+			instance.scopes = scopes;
+			instance.softDelete = softDelete;
+			instance.readOnly = readOnly;
+			instance.relations = typeof relations === "function" ? relations(makeRelationBuilder()) : relations;
+			return instance;
+		};
+		definition.where = function(conditions) {
+			return makeRelationEndpoint(id, [], conditions);
+		};
+		definition.through = (through, source) => makeRelationEndpoint(id, [], void 0, through, source);
+		definition.primaryKey = (...args) => {
+			(0, pqb_internal.parseTableDataInput)(tableData, pqb_internal.tableDataMethods.primaryKey(...args));
+			return definition;
+		};
+		definition.index = (...args) => {
+			(0, pqb_internal.parseTableDataInput)(tableData, pqb_internal.tableDataMethods.index(...args));
+			return definition;
+		};
+		definition.searchIndex = (...args) => {
+			(0, pqb_internal.parseTableDataInput)(tableData, pqb_internal.tableDataMethods.searchIndex(...args));
+			return definition;
+		};
+		definition.unique = (...args) => {
+			(0, pqb_internal.parseTableDataInput)(tableData, pqb_internal.tableDataMethods.unique(...args));
+			return definition;
+		};
+		definition.exclude = (...args) => {
+			(0, pqb_internal.parseTableDataInput)(tableData, pqb_internal.tableDataMethods.exclude(...args));
+			return definition;
+		};
+		definition.check = (...args) => {
+			(0, pqb_internal.parseTableDataInput)(tableData, pqb_internal.tableDataMethods.check(...args));
+			return definition;
+		};
+		definition.softDelete = (column) => {
+			definition.data.softDelete = column || true;
+			return definition;
+		};
+		definition.computed = (computed) => {
+			definition.data.computed = computed;
+			return definition;
+		};
+		definition.scopes = (scopes) => {
+			definition.data.scopes = scopes;
+			return definition;
+		};
+		definition.grants = (grants) => {
+			instance.grants = grants;
+			return definition;
+		};
+		definition.rls = (rls) => {
+			instance.rls = rls;
+			return definition;
+		};
+		definition.init = (fn) => {
+			instance.init = function(orm) {
+				fn(orm, new InitHookTarget(this.q));
+			};
+			return definition;
+		};
+		definition.foreignKey = (columns, fnOrTable, foreignColumns, options) => {
+			(0, pqb_internal.parseTableDataInput)(tableData, pqb_internal.tableDataMethods.foreignKey(columns, fnOrTable, foreignColumns, options));
+			return definition;
+		};
+		definition.relations = (fn) => {
+			definition.data.relations = fn;
+			return definition;
+		};
+		return definition;
+	});
+	defineTable.getFilePath = () => {
+		if (filePath) return filePath;
+		if (typeof filePathOrStack === "string") return filePath = filePathOrStack;
+		filePath = (0, pqb_internal.getCallerFilePath)(filePathOrStack);
+		if (filePath) return filePath;
+		throw new Error("Failed to determine file path of a table factory. Please set the `filePath` option of `createTableFactory` manually.");
+	};
+	defineTable.types = columnTypes;
+	defineTable.exportAs = defineTableExportAs;
+	defineTable.nowSQL = options?.nowSQL;
+	defineTable.snakeCase = options?.snakeCase;
+	defineTable.language = options?.language;
+	const defineView = ((name, optionsOrT, maybeT) => {
+		const viewOptions = typeof optionsOrT === "function" ? void 0 : optionsOrT;
+		const materialized = viewOptions?.materialized;
+		const readOnly = materialized || viewOptions?.readOnly !== false;
+		const t = typeof optionsOrT === "function" ? optionsOrT : maybeT;
+		if (!t) throw new Error("Column definitions are required");
+		const language = viewOptions?.language ?? options?.language;
+		const snakeCase = viewOptions?.snakeCase ?? options?.snakeCase;
+		const shape = (0, pqb_internal.getColumnTypes)(columnTypes, t, options?.nowSQL, language);
+		const tableData = {};
+		const nameInDb = viewOptions?.nameInDb ?? (snakeCase ? (0, pqb_internal.toSnakeCase)(name) : name);
+		if (snakeCase) for (const key in shape) {
+			const column = shape[key];
+			if (column.data.name) continue;
+			const snakeName = (0, pqb_internal.toSnakeCase)(key);
+			if (snakeName !== key) column.data.name = snakeName;
+		}
+		const instance = {
+			id: viewOptions?.id ?? name,
+			name,
+			nameInDb,
+			schema: viewOptions?.schema,
+			snakeCase,
+			columns: {
+				shape,
+				data: tableData
+			},
+			types: columnTypes,
+			filePath: options?.filePath ?? "",
+			language,
+			readOnly,
+			materialized,
+			generatorIgnore: viewOptions?.generatorIgnore,
+			withData: viewOptions?.withData,
+			sql: viewOptions?.sql,
+			recursive: viewOptions?.recursive,
+			checkOption: viewOptions?.checkOption,
+			securityBarrier: viewOptions?.securityBarrier,
+			securityInvoker: viewOptions?.securityInvoker,
+			q: {}
+		};
+		const viewId = viewOptions?.id ?? name;
+		const definition = ((...columns) => makeRelationEndpoint(viewId, columns));
+		definition.data = {
+			id: viewOptions?.id ?? name,
+			table: void 0,
+			name,
+			relations: void 0,
+			columns: shape,
+			types: void 0,
+			computed: void 0,
+			scopes: void 0,
+			readOnly,
+			materialized,
+			tableData
+		};
+		setDefinitionSchemaMethods(definition, schema, shape);
+		definition.nowSQL = options?.nowSQL;
+		definition.instance = () => {
+			const { computed, relations, scopes, softDelete } = definition.data;
+			instance.computed = computed;
+			instance.scopes = scopes;
+			instance.softDelete = softDelete;
+			instance.relations = typeof relations === "function" ? relations(makeRelationBuilder()) : relations;
+			return instance;
+		};
+		definition.query = (fn) => {
+			instance.init = (orm) => {
+				instance.query = fn(orm);
+			};
+			return definition;
+		};
+		definition.through = (through, source) => makeRelationEndpoint(viewId, [], void 0, through, source);
+		definition.softDelete = (column) => {
+			definition.data.softDelete = column || true;
+			return definition;
+		};
+		definition.computed = (computed) => {
+			definition.data.computed = computed;
+			return definition;
+		};
+		definition.scopes = (scopes) => {
+			definition.data.scopes = scopes;
+			return definition;
+		};
+		definition.grants = (grants) => {
+			instance.grants = grants;
+			return definition;
+		};
+		definition.init = (fn) => {
+			instance.init = function(orm) {
+				fn(orm, new InitHookTarget(this.q));
+			};
+			return definition;
+		};
+		definition.relations = (fn) => {
+			definition.data.relations = fn;
+			return definition;
+		};
+		return definition;
+	});
+	return {
+		defineTable,
+		defineView,
+		sql: (0, pqb_internal._createDbSqlMethod)(columnTypes),
+		exportAs: defineTableExportAs
+	};
+};
 const throwIfQueryReturnsAllForNestedUpdate = (q, params) => {
 	if (!(params.set || params.create || params.upsert) || !(0, pqb_internal.isQueryReturnsAll)(q)) return;
 	let key;
@@ -231,7 +647,7 @@ const addAutoForeignKey = (tableConfig, from, to, primaryKeys, foreignKeys, opti
 					fkeyTable = fkey.fnOrTable;
 					fkeyColumn = getColumnKeyFromDbName(to, fkeyColumn);
 				} else {
-					const instance = fkey.fnOrTable().instance();
+					const instance = (0, pqb_internal.getForeignKeyTableInstance)(fkey.fnOrTable());
 					fkeyTable = instance.nameInDb || instance.table;
 				}
 				if (toTable === fkeyTable && pkey === fkeyColumn) return;
@@ -247,7 +663,7 @@ const addAutoForeignKey = (tableConfig, from, to, primaryKeys, foreignKeys, opti
 			let sameForeignTable = false;
 			if (typeof refs.fnOrTable === "string") sameForeignTable = refs.fnOrTable === toTable && refs.foreignColumns.every((column, i) => getColumnKeyFromDbName(to, column) === sortedPkeys[i]);
 			else {
-				const instance = refs.fnOrTable().instance();
+				const instance = (0, pqb_internal.getForeignKeyTableInstance)(refs.fnOrTable());
 				sameForeignTable = (instance.nameInDb || instance.table) === toTable && refs.foreignColumns.every((column, i) => column === sortedPkeys[i]);
 			}
 			if (refs.columns.length === sortedFkeys.length && refs.columns.every((column, i) => column === sortedFkeys[i]) && refs.foreignColumns.length === sortedPkeys.length && sameForeignTable) return;
@@ -394,24 +810,40 @@ var BelongsToVirtualColumn = class extends pqb_internal.VirtualColumn {
 		if (!nestedCreateItems) return;
 		for (const key of foreignKeys) if (!ctx.columns.has(key)) ctx.columns.set(key, ctx.columns.size);
 		const { create, connect, connectOrCreate } = nestedCreateItems;
-		if (create) (0, pqb_internal._prependWith)(queryForCreate, (as) => {
-			const count = create.items.length;
-			foreignKeys.forEach((foreignKey, i) => {
-				const primaryKey = primaryKeys[i];
-				create.items.forEach((item, i) => {
-					item[foreignKey]._sql = selectCteColumnFromManySql(as, primaryKey, i, count);
+		if (create) {
+			const selectPKeys = query.select(...primaryKeys);
+			let createQuery;
+			if (queryForCreate.q.type === "upsert") {
+				const createWhereNotExists = new pqb_internal.RawSql("");
+				(0, pqb_internal._onUpsertUpdate)(queryForCreate, (as) => {
+					createWhereNotExists._sql = `NOT EXISTS (SELECT 1 FROM "${as}")`;
 				});
-			});
-		}, (0, pqb_internal._queryInsertMany)(query.select(...primaryKeys), create.values));
+				const sourceQuery = (0, pqb_internal._queryWhere)((0, pqb_internal._queryTake)((0, pqb_internal._querySelect)((0, pqb_internal._clone)(query.qb), [{}])), [createWhereNotExists]);
+				createQuery = (0, pqb_internal._queryInsertManyFrom)(selectPKeys, sourceQuery, create.values);
+			} else createQuery = (0, pqb_internal._queryInsertMany)(selectPKeys, create.values);
+			const setForeignKeys = (as) => {
+				const count = create.items.length;
+				foreignKeys.forEach((foreignKey, i) => {
+					const primaryKey = primaryKeys[i];
+					create.items.forEach((item, i) => {
+						item[foreignKey]._sql = selectCteColumnFromManySql(as, primaryKey, i, count);
+					});
+				});
+			};
+			if (queryForCreate.q.type === "upsert") (0, pqb_internal._prependWithOnUpsertCreate)(queryForCreate, setForeignKeys, createQuery);
+			else (0, pqb_internal._prependWith)(queryForCreate, setForeignKeys, createQuery);
+		}
 		if (connect) connect.values.forEach((value, itemI) => {
 			const as = (0, pqb_internal.getFreeAlias)(queryForCreate.q.withShapes, "q");
-			(0, pqb_internal._prependWith)(queryForCreate, as, query.select(...primaryKeys).findBy(value));
+			(queryForCreate.q.type === "upsert" ? pqb_internal._prependWithOnUpsertCreate : pqb_internal._prependWith)(queryForCreate, as, query.select(...primaryKeys).findBy(value));
 			foreignKeys.map((foreignKey, i) => {
 				connect.items[itemI][foreignKey] = new pqb_internal.RawSql(selectCteColumnMustExistSql(i, as, primaryKeys[i]));
 			});
 		});
 		if (connectOrCreate) connectOrCreate.values.forEach((value, itemI) => {
-			(0, pqb_internal._prependWith)(queryForCreate, setForeignKeysFromCte(connectOrCreate.items[itemI], primaryKeys, foreignKeys), (0, pqb_internal._orCreate)((0, pqb_internal._queryWhere)(query.select(...primaryKeys), [value.where]), value.create));
+			const asFn = setForeignKeysFromCte(connectOrCreate.items[itemI], primaryKeys, foreignKeys);
+			const selectPKeys = query.select(...primaryKeys);
+			(queryForCreate.q.type === "upsert" ? pqb_internal._prependWithOnUpsertCreate : pqb_internal._prependWith)(queryForCreate, asFn, (0, pqb_internal._orCreate)((0, pqb_internal._queryWhere)(selectPKeys, [value.where]), value.create));
 		});
 	}
 	update(q, set) {
@@ -472,7 +904,8 @@ const nestedUpdate$2 = ({ query, primaryKeys, foreignKeys, len }) => {
 	return ((self, update, params) => {
 		if (params.create) {
 			const createQuery = (0, pqb_internal._querySelect)((0, pqb_internal._queryCreate)(query.clone(), params.create), primaryKeys);
-			(0, pqb_internal._prependWith)(self, setForeignKeysFromCte(update, primaryKeys, foreignKeys), createQuery);
+			const asFn = setForeignKeysFromCte(update, primaryKeys, foreignKeys);
+			(0, pqb_internal._prependWith)(self, asFn, createQuery);
 		} else if (params.update) {
 			let appendedAs;
 			(0, pqb_internal._hookSelectColumns)(self, foreignKeys, (aliasedForeignKeys) => {
@@ -486,7 +919,8 @@ const nestedUpdate$2 = ({ query, primaryKeys, foreignKeys, len }) => {
 			if ((0, pqb_internal.isQueryReturnsAll)(self)) throw new Error("`upsert` option is not allowed in a batch update");
 			const { relQuery } = relWithSelectIds(self, query, primaryKeys, foreignKeys);
 			const upsertQuery = (0, pqb_internal._querySelect)((0, pqb_internal._queryUpsert)(relQuery, params.upsert), primaryKeys);
-			(0, pqb_internal._prependWith)(self, setForeignKeysFromCte(update, primaryKeys, foreignKeys), upsertQuery);
+			const asFn = setForeignKeysFromCte(update, primaryKeys, foreignKeys);
+			(0, pqb_internal._prependWith)(self, asFn, upsertQuery);
 		} else if (params.delete) {
 			(0, pqb_internal._hookSelectColumns)(self, foreignKeys, pqb_internal.noop);
 			disconnect(update, foreignKeys);
@@ -508,7 +942,10 @@ const nestedUpdate$2 = ({ query, primaryKeys, foreignKeys, len }) => {
 					(loadForeignKeys ??= []).push(foreignKeys[i]);
 				}
 			}
-			if (loadPrimaryKeys) (0, pqb_internal._prependWith)(self, setForeignKeysFromCte(update, loadPrimaryKeys, loadForeignKeys, true), (0, pqb_internal._queryFindBy)(query.select(...loadPrimaryKeys), params.set));
+			if (loadPrimaryKeys) {
+				const asFn = setForeignKeysFromCte(update, loadPrimaryKeys, loadForeignKeys, true);
+				(0, pqb_internal._prependWith)(self, asFn, (0, pqb_internal._queryFindBy)(query.select(...loadPrimaryKeys), params.set));
+			}
 		}
 	});
 };
@@ -580,31 +1017,100 @@ var HasOneVirtualColumn = class extends pqb_internal.VirtualColumn {
 			});
 			if (!nestedCreateItems) return;
 			let createAs;
+			let createWhereExists;
+			let createSelectAs;
+			let createAliasedPrimaryKeys;
+			let upsertCreateAs;
 			let connectAs;
 			let connectOrCreateAs;
+			const setUpsertCreatePlaceholders = () => {
+				if (!upsertCreateAs || !createAliasedPrimaryKeys) return;
+				const aliasedPrimaryKeys = createAliasedPrimaryKeys;
+				if (createWhereExists) createWhereExists._sql = `EXISTS (SELECT 1 FROM "${upsertCreateAs}")`;
+				if (createSelectAs) foreignKeys.forEach((key, keyI) => {
+					createSelectAs[key]._sql = selectCteColumnFromManySql(upsertCreateAs, aliasedPrimaryKeys[keyI], 0, 1);
+				});
+				if (connect) foreignKeys.forEach((key, keyI) => {
+					const primaryKey = aliasedPrimaryKeys[keyI];
+					for (let i = 0; i < connect.items.length; i++) connect.items[i][key]._sql = selectCteColumnFromManySql(upsertCreateAs, primaryKey, connect.indexes[i], count);
+				});
+				if (connectOrCreate) foreignKeys.forEach((key, keyI) => {
+					const primaryKey = aliasedPrimaryKeys[keyI];
+					for (let i = 0; i < connectOrCreate.items.length; i++) connectOrCreate.items[i][key]._sql = selectCteColumnFromManySql(upsertCreateAs, primaryKey, connectOrCreate.indexes[i], count);
+				});
+			};
 			(0, pqb_internal._hookSelectColumns)(querySelf, primaryKeys, (aliasedPrimaryKeys) => {
+				createAliasedPrimaryKeys = aliasedPrimaryKeys;
 				foreignKeys.forEach((key, keyI) => {
 					const primaryKey = aliasedPrimaryKeys[keyI];
 					if (create && createAs) for (let i = 0; i < create.items.length; i++) create.items[i][key]._sql = selectCteColumnFromManySql(createAs, primaryKey, create.indexes[i], count);
 					if (connect && connectAs) for (let i = 0; i < connect.items.length; i++) connect.items[i][key]._sql = selectCteColumnFromManySql(connectAs, primaryKey, connect.indexes[i], count);
 					if (connectOrCreate && connectOrCreateAs) for (let i = 0; i < connectOrCreate.items.length; i++) connectOrCreate.items[i][key]._sql = selectCteColumnFromManySql(connectOrCreateAs, primaryKey, connectOrCreate.indexes[i], count);
 				});
+				setUpsertCreatePlaceholders();
 			});
 			const { create, connect, connectOrCreate } = nestedCreateItems;
-			if (create) (0, pqb_internal._appendQuery)(querySelf, (0, pqb_internal._queryInsertMany)((0, pqb_internal._clone)(rel), create.items), (as) => createAs = as);
+			if (create) {
+				let query;
+				if (querySelf.q.type === "upsert") {
+					createWhereExists = new pqb_internal.RawSql("");
+					createSelectAs = {};
+					for (const key of foreignKeys) createSelectAs[key] = new pqb_internal.RawSql("");
+					const sourceQuery = (0, pqb_internal._queryWhere)((0, pqb_internal._queryTake)((0, pqb_internal._querySelect)((0, pqb_internal._clone)(rel.qb), [createSelectAs])), [createWhereExists]);
+					query = (0, pqb_internal._queryInsertManyFrom)((0, pqb_internal._clone)(rel), sourceQuery, create.items);
+				} else query = (0, pqb_internal._queryInsertMany)((0, pqb_internal._clone)(rel), create.items);
+				if (querySelf.q.type === "upsert") (0, pqb_internal._appendQueryOnUpsertCreate)(querySelf, query, (as) => {
+					upsertCreateAs = as;
+					setUpsertCreatePlaceholders();
+				});
+				else (0, pqb_internal._appendQuery)(querySelf, query, (as) => createAs = as);
+			}
 			if (connect) connect.values.forEach((value, i) => {
+				const connectWhereExists = querySelf.q.type === "upsert" ? new pqb_internal.RawSql("") : void 0;
 				const query = (0, pqb_internal._queryUpdateOrThrow)(rel.where(value), connect.items[i]);
+				if (connectWhereExists) (0, pqb_internal._queryWhere)(query, [connectWhereExists]);
 				query.q.ensureCount = 1;
-				(0, pqb_internal._appendQuery)(querySelf, query, (as) => connectAs = as);
+				(querySelf.q.type === "upsert" ? pqb_internal._appendQueryOnUpsertCreate : pqb_internal._appendQuery)(querySelf, query, (as) => {
+					upsertCreateAs = as;
+					setUpsertCreatePlaceholders();
+					connectAs = as;
+					if (connectWhereExists) connectWhereExists._sql = `EXISTS (SELECT 1 FROM "${as}")`;
+				});
 			});
 			if (connectOrCreate) connectOrCreate.values.forEach((value, i) => {
-				(0, pqb_internal._appendQuery)(querySelf, (0, pqb_internal._queryUpsert)(rel.where(value.where), {
-					update: connectOrCreate.items[i],
+				const foreignKeyValues = connectOrCreate.items[i];
+				const connectOrCreateWhereExists = querySelf.q.type === "upsert" ? new pqb_internal.RawSql("") : void 0;
+				const connectOrCreateSelectAs = {};
+				if (connectOrCreateWhereExists) for (const key of foreignKeys) {
+					const value = foreignKeyValues[key];
+					value.result = { value: rel.qb.shape[key] };
+					connectOrCreateSelectAs[key] = value;
+				}
+				const query = (0, pqb_internal._queryUpsert)(rel.where(value.where), {
+					update: foreignKeyValues,
 					create: {
 						...value.create,
-						...connectOrCreate.items[i]
+						...foreignKeyValues
 					}
-				}), (as) => connectOrCreateAs = as);
+				});
+				if (connectOrCreateWhereExists) {
+					(0, pqb_internal._queryWhere)(query, [connectOrCreateWhereExists]);
+					const guardQuery = (0, pqb_internal._queryWhere)((0, pqb_internal._queryTake)((0, pqb_internal._querySelect)((0, pqb_internal._clone)(rel.qb), [{ one: new pqb_internal.RawSql("1") }])), [connectOrCreateWhereExists]);
+					const sourceQuery = (0, pqb_internal._querySelect)((0, pqb_internal._clone)(rel.qb).from(guardQuery), [connectOrCreateSelectAs]);
+					const q = query.q;
+					const columns = q.columns || [];
+					const foreignKeysSet = new Set(foreignKeys);
+					q.columns = [...foreignKeys, ...columns.filter((column) => !foreignKeysSet.has(column))];
+					q.values = q.values.map((row) => row.filter((_, i) => !foreignKeysSet.has(columns[i])));
+					q.queryColumnsCount = foreignKeys.length;
+					q.insertFrom = (0, pqb_internal.prepareSubQueryForSql)(query, sourceQuery);
+				}
+				(querySelf.q.type === "upsert" ? pqb_internal._appendQueryOnUpsertCreate : pqb_internal._appendQuery)(querySelf, query, (as) => {
+					upsertCreateAs = as;
+					setUpsertCreatePlaceholders();
+					connectOrCreateAs = as;
+					if (connectOrCreateWhereExists) connectOrCreateWhereExists._sql = `EXISTS (SELECT 1 FROM "${as}")`;
+				});
 			});
 		} else hasRelationHandleCreate(querySelf, ctx, items, rowIndexes, this.key, this.state.primaryKeys, this.nestedInsert);
 	}
@@ -618,11 +1124,13 @@ var HasOneVirtualColumn = class extends pqb_internal.VirtualColumn {
 			const nullifyOrDeleteQuery = params.update ? (0, pqb_internal._queryUpdate)(ids.existingRelQuery, params.update) : params.upsert ? (0, pqb_internal._queryUpsert)(ids.existingRelQuery, makeNestedUpdateUpsertData(params.upsert, ids.setIds)) : params.delete ? (0, pqb_internal._queryDelete)(ids.existingRelQuery) : (0, pqb_internal._queryUpdate)(ids.existingRelQuery, this.setNulls);
 			nullifyOrDeleteQuery.q.returnType = "void";
 			(0, pqb_internal._appendQuery)(querySelf, nullifyOrDeleteQuery, ids.setAppendedAs);
-			if (params.create) (0, pqb_internal._appendQuery)(querySelf, (0, pqb_internal._queryInsert)((0, pqb_internal._clone)(relQuery), {
-				...params.create,
-				...ids.setIds
-			}), pqb_internal.noop);
-			else if (params.set) {
+			if (params.create) {
+				const createQuery = (0, pqb_internal._queryInsert)((0, pqb_internal._clone)(relQuery), {
+					...params.create,
+					...ids.setIds
+				});
+				(0, pqb_internal._appendQuery)(querySelf, createQuery, pqb_internal.noop);
+			} else if (params.set) {
 				const setQuery = (0, pqb_internal._queryUpdate)((0, pqb_internal._queryWhere)((0, pqb_internal._clone)(relQuery), [params.set]), ids.setIds);
 				setQuery.q.returnType = "void";
 				(0, pqb_internal._appendQuery)(querySelf, setQuery, pqb_internal.noop);
@@ -633,7 +1141,8 @@ var HasOneVirtualColumn = class extends pqb_internal.VirtualColumn {
 const makeHasOneMethod = (tableConfig, table, relation, relationName, query) => {
 	const relPKeys = (0, pqb_internal.getPrimaryKeys)(query);
 	if ("through" in relation.options) {
-		const { through, source } = relation.options;
+		const { through, source, on } = relation.options;
+		if (on) (0, pqb_internal._queryWhere)(query, [on]);
 		const throughRelation = getThroughRelation(table, through);
 		const sourceRelation = getSourceRelation(throughRelation, source);
 		const sourceRelationQuery = sourceRelation.query.as(relationName);
@@ -777,9 +1286,30 @@ var HasManyVirtualColumn = class extends pqb_internal.VirtualColumn {
 			});
 			if (!nestedCreateItems) return;
 			let createAs;
+			let createWhereExists;
+			let createSelectAs;
+			let createAliasedPrimaryKeys;
+			let upsertCreateAs;
 			let connectAs;
 			let connectOrCreateAs;
+			const setUpsertCreatePlaceholders = () => {
+				if (!upsertCreateAs || !createAliasedPrimaryKeys) return;
+				const aliasedPrimaryKeys = createAliasedPrimaryKeys;
+				if (createWhereExists) createWhereExists._sql = `EXISTS (SELECT 1 FROM "${upsertCreateAs}")`;
+				if (createSelectAs) foreignKeys.forEach((key, keyI) => {
+					createSelectAs[key]._sql = selectCteColumnFromManySql(upsertCreateAs, aliasedPrimaryKeys[keyI], 0, 1);
+				});
+				if (connect) foreignKeys.forEach((key, keyI) => {
+					const primaryKey = aliasedPrimaryKeys[keyI];
+					for (let i = 0; i < connect.items.length; i++) connect.items[i][key]._sql = selectCteColumnFromManySql(upsertCreateAs, primaryKey, connect.indexes[i], count);
+				});
+				if (connectOrCreate) foreignKeys.forEach((key, keyI) => {
+					const primaryKey = aliasedPrimaryKeys[keyI];
+					for (let i = 0; i < connectOrCreate.items.length; i++) connectOrCreate.items[i][key]._sql = selectCteColumnFromManySql(upsertCreateAs, primaryKey, connectOrCreate.indexes[i], count);
+				});
+			};
 			(0, pqb_internal._hookSelectColumns)(querySelf, primaryKeys, (aliasedPrimaryKeys) => {
+				createAliasedPrimaryKeys = aliasedPrimaryKeys;
 				foreignKeys.forEach((key, keyI) => {
 					const primaryKey = aliasedPrimaryKeys[keyI];
 					if (create && createAs) for (let i = 0; i < create.items.length; i++) {
@@ -789,23 +1319,72 @@ var HasManyVirtualColumn = class extends pqb_internal.VirtualColumn {
 					if (connect && connectAs) for (let i = 0; i < connect.items.length; i++) connect.items[i][key]._sql = selectCteColumnFromManySql(connectAs, primaryKey, connect.indexes[i], count);
 					if (connectOrCreate && connectOrCreateAs) for (let i = 0; i < connectOrCreate.items.length; i++) connectOrCreate.items[i][key]._sql = selectCteColumnFromManySql(connectOrCreateAs, primaryKey, connectOrCreate.indexes[i], count);
 				});
+				setUpsertCreatePlaceholders();
 			});
 			const { create, connect, connectOrCreate } = nestedCreateItems;
-			if (create) (0, pqb_internal._appendQuery)(querySelf, (0, pqb_internal._queryInsertMany)((0, pqb_internal._clone)(rel), create.items.flat()), (as) => createAs = as);
+			if (create) {
+				let query;
+				if (querySelf.q.type === "upsert") {
+					createWhereExists = new pqb_internal.RawSql("");
+					createSelectAs = {};
+					for (const key of foreignKeys) createSelectAs[key] = new pqb_internal.RawSql("");
+					const sourceQuery = (0, pqb_internal._queryWhere)((0, pqb_internal._queryTake)((0, pqb_internal._querySelect)((0, pqb_internal._clone)(rel.qb), [createSelectAs])), [createWhereExists]);
+					query = (0, pqb_internal._queryInsertManyFrom)((0, pqb_internal._clone)(rel), sourceQuery, create.items.flat());
+				} else query = (0, pqb_internal._queryInsertMany)((0, pqb_internal._clone)(rel), create.items.flat());
+				if (querySelf.q.type === "upsert") (0, pqb_internal._appendQueryOnUpsertCreate)(querySelf, query, (as) => {
+					upsertCreateAs = as;
+					setUpsertCreatePlaceholders();
+				});
+				else (0, pqb_internal._appendQuery)(querySelf, query, (as) => createAs = as);
+			}
 			if (connect) connect.values.forEach((value, i) => {
+				const connectWhereExists = querySelf.q.type === "upsert" ? new pqb_internal.RawSql("") : void 0;
 				const query = (0, pqb_internal._queryUpdateOrThrow)(rel.whereOneOf(...value), connect.items[i]);
+				if (connectWhereExists) (0, pqb_internal._queryWhere)(query, [connectWhereExists]);
 				query.q.ensureCount = value.length;
-				(0, pqb_internal._appendQuery)(querySelf, query, (as) => connectAs = as);
+				(querySelf.q.type === "upsert" ? pqb_internal._appendQueryOnUpsertCreate : pqb_internal._appendQuery)(querySelf, query, (as) => {
+					upsertCreateAs = as;
+					setUpsertCreatePlaceholders();
+					connectAs = as;
+					if (connectWhereExists) connectWhereExists._sql = `EXISTS (SELECT 1 FROM "${as}")`;
+				});
 			});
 			if (connectOrCreate) connectOrCreate.values.forEach((array, i) => {
 				const foreignKeyValues = connectOrCreate.items[i];
-				for (const value of array) (0, pqb_internal._appendQuery)(querySelf, (0, pqb_internal._queryUpsert)(rel.where(value.where), {
-					update: foreignKeyValues,
-					create: {
-						...value.create,
-						...foreignKeyValues
+				for (const value of array) {
+					const connectOrCreateWhereExists = querySelf.q.type === "upsert" ? new pqb_internal.RawSql("") : void 0;
+					const connectOrCreateSelectAs = {};
+					if (connectOrCreateWhereExists) for (const key of foreignKeys) {
+						const value = foreignKeyValues[key];
+						value.result = { value: rel.qb.shape[key] };
+						connectOrCreateSelectAs[key] = value;
+					}
+					const query = (0, pqb_internal._queryUpsert)(rel.where(value.where), {
+						update: foreignKeyValues,
+						create: {
+							...value.create,
+							...foreignKeyValues
+						}
+					});
+					if (connectOrCreateWhereExists) {
+						(0, pqb_internal._queryWhere)(query, [connectOrCreateWhereExists]);
+						const guardQuery = (0, pqb_internal._queryWhere)((0, pqb_internal._queryTake)((0, pqb_internal._querySelect)((0, pqb_internal._clone)(rel.qb), [{ one: new pqb_internal.RawSql("1") }])), [connectOrCreateWhereExists]);
+						const sourceQuery = (0, pqb_internal._querySelect)((0, pqb_internal._clone)(rel.qb).from(guardQuery), [connectOrCreateSelectAs]);
+						const q = query.q;
+						const columns = q.columns || [];
+						const foreignKeysSet = new Set(foreignKeys);
+						q.columns = [...foreignKeys, ...columns.filter((column) => !foreignKeysSet.has(column))];
+						q.values = q.values.map((row) => row.filter((_, i) => !foreignKeysSet.has(columns[i])));
+						q.queryColumnsCount = foreignKeys.length;
+						q.insertFrom = (0, pqb_internal.prepareSubQueryForSql)(query, sourceQuery);
 					}
-				}), (as) => connectOrCreateAs = as);
+					(querySelf.q.type === "upsert" ? pqb_internal._appendQueryOnUpsertCreate : pqb_internal._appendQuery)(querySelf, query, (as) => {
+						upsertCreateAs = as;
+						setUpsertCreatePlaceholders();
+						connectOrCreateAs = as;
+						if (connectOrCreateWhereExists) connectOrCreateWhereExists._sql = `EXISTS (SELECT 1 FROM "${as}")`;
+					});
+				}
 			});
 		} else hasRelationHandleCreate(querySelf, ctx, items, rowIndexes, this.key, this.state.primaryKeys, this.nestedInsert);
 	}
@@ -826,7 +1405,8 @@ var HasManyVirtualColumn = class extends pqb_internal.VirtualColumn {
 const makeHasManyMethod = (tableConfig, table, relation, relationName, query) => {
 	const relPKeys = (0, pqb_internal.getPrimaryKeys)(query);
 	if ("through" in relation.options) {
-		const { through, source } = relation.options;
+		const { through, source, on } = relation.options;
+		if (on) (0, pqb_internal._queryWhere)(query, [on]);
 		const throughRelation = getThroughRelation(table, through);
 		const sourceRelation = getSourceRelation(throughRelation, source);
 		const sourceRelationQuery = sourceRelation.query.as(relationName);
@@ -1034,10 +1614,11 @@ const nestedUpdateUpsert = (querySelf, state, upsert) => {
 		parentIdsSql._sql = selectCteColumnsSql(parentAs, aliasedPrimaryKeys);
 		for (let i = 0; i < state.foreignKeys.length; i++) parentValues[i]._sql = selectCteColumnSql(parentAs, aliasedPrimaryKeys[i]);
 	});
-	const upsertQuery = (0, pqb_internal._querySelect)((0, pqb_internal._queryUpsert)((0, pqb_internal._queryWhereExists)((0, pqb_internal._queryWhere)((0, pqb_internal._clone)(state.relatedTableQuery), [upsert.findBy]), state.joinTableQuery, [(q) => {
+	const existingRelQuery = (0, pqb_internal._queryWhereExists)((0, pqb_internal._queryWhere)((0, pqb_internal._clone)(state.relatedTableQuery), [upsert.findBy]), state.joinTableQuery, [(q) => {
 		for (let i = 0; i < state.throughPrimaryKeys.length; i++) (0, pqb_internal._queryJoinOn)(q, [state.throughForeignKeysFull[i], state.throughPrimaryKeysFull[i]]);
 		return (0, pqb_internal._queryWhereIn)(q, true, state.foreignKeysFull, parentIdsSql);
-	}]), {
+	}]);
+	const upsertQuery = (0, pqb_internal._querySelect)((0, pqb_internal._queryUpsert)(existingRelQuery, {
 		update: upsert.update,
 		create: upsert.create || {}
 	}), state.throughPrimaryKeys);
@@ -1070,7 +1651,7 @@ const makeHasAndBelongsToManyMethod = (tableConfig, table, qb, relation, relatio
 	const primaryKeys = options.columns;
 	const originalForeignKeys = options.references;
 	const foreignKeys = snakeCase ? [...originalForeignKeys] : originalForeignKeys;
-	const joinTable = options.through.table;
+	const joinTable = snakeCase && options.through.snakeCase !== false ? (0, pqb_internal.toSnakeCase)(options.through.table) : options.through.table;
 	const originalThroughForeignKeys = options.through.columns;
 	const throughForeignKeys = snakeCase ? [...originalThroughForeignKeys] : originalThroughForeignKeys;
 	const throughPrimaryKeys = options.through.references;
@@ -1340,7 +1921,8 @@ const nestedUpdate = (state) => {
 		}
 		if (params.disconnect) await (0, pqb_internal._queryDelete)(queryJoinTable(state, data, params.disconnect));
 		if (params.delete) {
-			const idsRows = await (0, pqb_internal._queryDelete)((0, pqb_internal._queryRows)((0, pqb_internal._querySelect)(queryJoinTable(state, data, params.delete), state.throughForeignKeys)));
+			const j = queryJoinTable(state, data, params.delete);
+			const idsRows = await (0, pqb_internal._queryDelete)((0, pqb_internal._queryRows)((0, pqb_internal._querySelect)(j, state.throughForeignKeys)));
 			await (0, pqb_internal._queryDelete)(state.relatedTableQuery.where({ IN: {
 				columns: state.throughPrimaryKeys,
 				values: idsRows
@@ -1349,7 +1931,10 @@ const nestedUpdate = (state) => {
 		if (params.set) {
 			const j = queryJoinTable(state, data);
 			await (0, pqb_internal._queryDelete)(j);
-			if (Array.isArray(params.set) ? params.set.length : (0, pqb_internal.objectHasValues)(params.set)) await insertToJoinTable(state, j, data, await (0, pqb_internal._queryRows)((0, pqb_internal._querySelect)(state.relatedTableQuery.where(conditionsToWhereArg(params.set)), state.throughPrimaryKeys)));
+			if (Array.isArray(params.set) ? params.set.length : (0, pqb_internal.objectHasValues)(params.set)) {
+				const idsRows = await (0, pqb_internal._queryRows)((0, pqb_internal._querySelect)(state.relatedTableQuery.where(conditionsToWhereArg(params.set)), state.throughPrimaryKeys));
+				await insertToJoinTable(state, j, data, idsRows);
+			}
 		}
 	});
 };
@@ -1362,9 +1947,15 @@ const applyRelations = (qb, tables, result, schema) => {
 		const dbTable = result[name];
 		for (const relationName in table.relations) {
 			const relation = table.relations[relationName];
-			const otherTableClass = relation.fn();
-			const otherTable = tableEntries.find((pair) => pair[1] instanceof otherTableClass);
-			if (!otherTable) throw new Error(`Cannot find table class for class ${otherTableClass.name}`);
+			const otherTableClass = relation.fn?.();
+			const otherTable = otherTableClass ? tableEntries.find((pair) => pair[1] instanceof otherTableClass) : tableEntries.find(([, table]) => {
+				const { id } = relation;
+				return table.id === id || table.table === id;
+			}) || tableEntries.find(([, table]) => {
+				const { id } = relation;
+				return table.name === id;
+			});
+			if (!otherTable) throw new Error(otherTableClass ? `Cannot find table class for class ${otherTableClass.name}` : `Cannot find table for relation target ${relation.id}`);
 			const otherTableName = otherTable[0];
 			const otherDbTable = result[otherTableName];
 			if (!otherDbTable) throw new Error(`Cannot find table class by name ${otherTableName}`);
@@ -1694,6 +2285,7 @@ exports.bundleOrchidORM = bundleOrchidORM;
 exports.bundleOrchidORMTables = bundleOrchidORMTables;
 exports.createBaseTable = createBaseTable;
 exports.createRepo = createRepo;
+exports.createTableFactory = createTableFactory;
 exports.defineRls = defineRls;
 exports.makeOrchidOrmDbWithAdapter = makeOrchidOrmDbWithAdapter;
 exports.orchidORMWithAdapter = orchidORMWithAdapter;