orchid-orm 1.76.4 → 1.77.0

package/dist/index.mjs

@@ -1,4 +1,4 @@
-import { DynamicRawSQL, QueryHooks, RawSql, VirtualColumn, _appendQuery, _appendQueryOnUpsertCreate, _clone, _createDbSqlMethod, _hookSelectColumns, _initQueryBuilder, _orCreate, _prependWith, _queryCreate, _queryCreateMany, _queryCreateManyFrom, _queryDefaults, _queryDelete, _queryFindBy, _queryFindByOptional, _queryHookAfterCreate, _queryHookAfterUpdate, _queryInsert, _queryInsertMany, _queryJoinOn, _queryRows, _querySelect, _queryTake, _queryTakeOptional, _queryUpdate, _queryUpdateOrThrow, _queryUpsert, _queryWhere, _queryWhereExists, _queryWhereIn, applyMixins, cloneQueryBaseUnscoped, defaultSchemaConfig, emptyArray, emptyObject, getCallerFilePath, getClonedQueryData, getColumnTypes, getFreeAlias, getPrimaryKeys, getQueryAs, getShapeFromSelect, getStackTrace, internalSchemaConfig, isExpression, isQueryReturnsAll, makeColumnTypes, noop, objectHasValues, parseTableData, pick, prepareSubQueryForSql, pushQueryOnForOuter, setQueryObjectValueImmutable, toArray, toSnakeCase } from "pqb/internal";
+import { DynamicRawSQL, QueryHooks, RawSql, VirtualColumn, _appendQuery, _appendQueryOnUpsertCreate, _clone, _createDbSqlMethod, _hookSelectColumns, _initQueryBuilder, _onUpsertUpdate, _orCreate, _prependWith, _prependWithOnUpsertCreate, _queryCreate, _queryCreateMany, _queryCreateManyFrom, _queryDefaults, _queryDelete, _queryFindBy, _queryFindByOptional, _queryHookAfterCreate, _queryHookAfterUpdate, _queryInsert, _queryInsertMany, _queryInsertManyFrom, _queryJoinOn, _queryRows, _querySelect, _queryTake, _queryTakeOptional, _queryUpdate, _queryUpdateOrThrow, _queryUpsert, _queryWhere, _queryWhereExists, _queryWhereIn, applyMixins, cloneQueryBaseUnscoped, defaultSchemaConfig, emptyArray, emptyObject, getCallerFilePath, getClonedQueryData, getColumnTypes, getForeignKeyTableInstance, getFreeAlias, getPrimaryKeys, getQueryAs, getShapeFromSelect, getStackTrace, internalSchemaConfig, isExpression, isQueryReturnsAll, makeColumnTypes, noop, objectHasValues, parseTableData, parseTableDataInput, pick, prepareSubQueryForSql, pushQueryOnForOuter, setQueryObjectValueImmutable, tableDataMethods, toArray, toSnakeCase } from "pqb/internal";
 import { Db, NotFoundError, OrchidOrmInternalError } from "pqb";
 import { AsyncLocalStorage } from "node:async_hooks";
 export * from "pqb";
@@ -152,6 +152,422 @@ function createBaseTable({ schemaConfig = defaultSchemaConfig, columnTypes: 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 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 ?? defaultSchemaConfig)();
+	const defaultColumnTypes = makeColumnTypes(schema);
+	const columnTypesOption = options?.columnTypes;
+	const columnTypes = typeof columnTypesOption === "function" ? columnTypesOption(defaultColumnTypes) : columnTypesOption || defaultColumnTypes;
+	const defineTableExportAs = options?.defineTableExportAs ?? "defineTable";
+	const filePathOrStack = options?.filePath || 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 = 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 = toSnakeCase(key);
+			if (snakeName !== key) column.data.name = snakeName;
+		}
+		const nameInDb = tableOptions?.nameInDb ?? (snakeCase ? 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) => {
+			parseTableDataInput(tableData, tableDataMethods.primaryKey(...args));
+			return definition;
+		};
+		definition.index = (...args) => {
+			parseTableDataInput(tableData, tableDataMethods.index(...args));
+			return definition;
+		};
+		definition.searchIndex = (...args) => {
+			parseTableDataInput(tableData, tableDataMethods.searchIndex(...args));
+			return definition;
+		};
+		definition.unique = (...args) => {
+			parseTableDataInput(tableData, tableDataMethods.unique(...args));
+			return definition;
+		};
+		definition.exclude = (...args) => {
+			parseTableDataInput(tableData, tableDataMethods.exclude(...args));
+			return definition;
+		};
+		definition.check = (...args) => {
+			parseTableDataInput(tableData, 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) => {
+			parseTableDataInput(tableData, 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 = 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 = getColumnTypes(columnTypes, t, options?.nowSQL, language);
+		const tableData = {};
+		const nameInDb = viewOptions?.nameInDb ?? (snakeCase ? toSnakeCase(name) : name);
+		if (snakeCase) for (const key in shape) {
+			const column = shape[key];
+			if (column.data.name) continue;
+			const snakeName = 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: _createDbSqlMethod(columnTypes),
+		exportAs: defineTableExportAs
+	};
+};
 const throwIfQueryReturnsAllForNestedUpdate = (q, params) => {
 	if (!(params.set || params.create || params.upsert) || !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 = 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 = 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,39 @@ var BelongsToVirtualColumn = class extends 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) _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 RawSql("");
+				_onUpsertUpdate(queryForCreate, (as) => {
+					createWhereNotExists._sql = `NOT EXISTS (SELECT 1 FROM "${as}")`;
 				});
-			});
-		}, _queryInsertMany(query.select(...primaryKeys), create.values));
+				createQuery = _queryInsertManyFrom(selectPKeys, _queryWhere(_queryTake(_querySelect(_clone(query.qb), [{}])), [createWhereNotExists]), create.values);
+			} else createQuery = _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") _prependWithOnUpsertCreate(queryForCreate, setForeignKeys, createQuery);
+			else _prependWith(queryForCreate, setForeignKeys, createQuery);
+		}
 		if (connect) connect.values.forEach((value, itemI) => {
 			const as = getFreeAlias(queryForCreate.q.withShapes, "q");
-			_prependWith(queryForCreate, as, query.select(...primaryKeys).findBy(value));
+			(queryForCreate.q.type === "upsert" ? _prependWithOnUpsertCreate : _prependWith)(queryForCreate, as, query.select(...primaryKeys).findBy(value));
 			foreignKeys.map((foreignKey, i) => {
 				connect.items[itemI][foreignKey] = new RawSql(selectCteColumnMustExistSql(i, as, primaryKeys[i]));
 			});
 		});
 		if (connectOrCreate) connectOrCreate.values.forEach((value, itemI) => {
-			_prependWith(queryForCreate, setForeignKeysFromCte(connectOrCreate.items[itemI], primaryKeys, foreignKeys), _orCreate(_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" ? _prependWithOnUpsertCreate : _prependWith)(queryForCreate, asFn, _orCreate(_queryWhere(selectPKeys, [value.where]), value.create));
 		});
 	}
 	update(q, set) {
@@ -580,31 +1011,100 @@ var HasOneVirtualColumn = class extends 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);
+				});
+			};
 			_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) _appendQuery(querySelf, _queryInsertMany(_clone(rel), create.items), (as) => createAs = as);
+			if (create) {
+				let query;
+				if (querySelf.q.type === "upsert") {
+					createWhereExists = new RawSql("");
+					createSelectAs = {};
+					for (const key of foreignKeys) createSelectAs[key] = new RawSql("");
+					const sourceQuery = _queryWhere(_queryTake(_querySelect(_clone(rel.qb), [createSelectAs])), [createWhereExists]);
+					query = _queryInsertManyFrom(_clone(rel), sourceQuery, create.items);
+				} else query = _queryInsertMany(_clone(rel), create.items);
+				if (querySelf.q.type === "upsert") _appendQueryOnUpsertCreate(querySelf, query, (as) => {
+					upsertCreateAs = as;
+					setUpsertCreatePlaceholders();
+				});
+				else _appendQuery(querySelf, query, (as) => createAs = as);
+			}
 			if (connect) connect.values.forEach((value, i) => {
+				const connectWhereExists = querySelf.q.type === "upsert" ? new RawSql("") : void 0;
 				const query = _queryUpdateOrThrow(rel.where(value), connect.items[i]);
+				if (connectWhereExists) _queryWhere(query, [connectWhereExists]);
 				query.q.ensureCount = 1;
-				_appendQuery(querySelf, query, (as) => connectAs = as);
+				(querySelf.q.type === "upsert" ? _appendQueryOnUpsertCreate : _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) => {
-				_appendQuery(querySelf, _queryUpsert(rel.where(value.where), {
-					update: connectOrCreate.items[i],
+				const foreignKeyValues = connectOrCreate.items[i];
+				const connectOrCreateWhereExists = querySelf.q.type === "upsert" ? new 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 = _queryUpsert(rel.where(value.where), {
+					update: foreignKeyValues,
 					create: {
 						...value.create,
-						...connectOrCreate.items[i]
+						...foreignKeyValues
 					}
-				}), (as) => connectOrCreateAs = as);
+				});
+				if (connectOrCreateWhereExists) {
+					_queryWhere(query, [connectOrCreateWhereExists]);
+					const guardQuery = _queryWhere(_queryTake(_querySelect(_clone(rel.qb), [{ one: new RawSql("1") }])), [connectOrCreateWhereExists]);
+					const sourceQuery = _querySelect(_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 = prepareSubQueryForSql(query, sourceQuery);
+				}
+				(querySelf.q.type === "upsert" ? _appendQueryOnUpsertCreate : _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);
 	}
@@ -633,7 +1133,8 @@ var HasOneVirtualColumn = class extends VirtualColumn {
 const makeHasOneMethod = (tableConfig, table, relation, relationName, query) => {
 	const relPKeys = getPrimaryKeys(query);
 	if ("through" in relation.options) {
-		const { through, source } = relation.options;
+		const { through, source, on } = relation.options;
+		if (on) _queryWhere(query, [on]);
 		const throughRelation = getThroughRelation(table, through);
 		const sourceRelation = getSourceRelation(throughRelation, source);
 		const sourceRelationQuery = sourceRelation.query.as(relationName);
@@ -777,9 +1278,30 @@ var HasManyVirtualColumn = class extends 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);
+				});
+			};
 			_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 +1311,72 @@ var HasManyVirtualColumn = class extends 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) _appendQuery(querySelf, _queryInsertMany(_clone(rel), create.items.flat()), (as) => createAs = as);
+			if (create) {
+				let query;
+				if (querySelf.q.type === "upsert") {
+					createWhereExists = new RawSql("");
+					createSelectAs = {};
+					for (const key of foreignKeys) createSelectAs[key] = new RawSql("");
+					const sourceQuery = _queryWhere(_queryTake(_querySelect(_clone(rel.qb), [createSelectAs])), [createWhereExists]);
+					query = _queryInsertManyFrom(_clone(rel), sourceQuery, create.items.flat());
+				} else query = _queryInsertMany(_clone(rel), create.items.flat());
+				if (querySelf.q.type === "upsert") _appendQueryOnUpsertCreate(querySelf, query, (as) => {
+					upsertCreateAs = as;
+					setUpsertCreatePlaceholders();
+				});
+				else _appendQuery(querySelf, query, (as) => createAs = as);
+			}
 			if (connect) connect.values.forEach((value, i) => {
+				const connectWhereExists = querySelf.q.type === "upsert" ? new RawSql("") : void 0;
 				const query = _queryUpdateOrThrow(rel.whereOneOf(...value), connect.items[i]);
+				if (connectWhereExists) _queryWhere(query, [connectWhereExists]);
 				query.q.ensureCount = value.length;
-				_appendQuery(querySelf, query, (as) => connectAs = as);
+				(querySelf.q.type === "upsert" ? _appendQueryOnUpsertCreate : _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) _appendQuery(querySelf, _queryUpsert(rel.where(value.where), {
-					update: foreignKeyValues,
-					create: {
-						...value.create,
-						...foreignKeyValues
+				for (const value of array) {
+					const connectOrCreateWhereExists = querySelf.q.type === "upsert" ? new 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 = _queryUpsert(rel.where(value.where), {
+						update: foreignKeyValues,
+						create: {
+							...value.create,
+							...foreignKeyValues
+						}
+					});
+					if (connectOrCreateWhereExists) {
+						_queryWhere(query, [connectOrCreateWhereExists]);
+						const guardQuery = _queryWhere(_queryTake(_querySelect(_clone(rel.qb), [{ one: new RawSql("1") }])), [connectOrCreateWhereExists]);
+						const sourceQuery = _querySelect(_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 = prepareSubQueryForSql(query, sourceQuery);
 					}
-				}), (as) => connectOrCreateAs = as);
+					(querySelf.q.type === "upsert" ? _appendQueryOnUpsertCreate : _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 +1397,8 @@ var HasManyVirtualColumn = class extends VirtualColumn {
 const makeHasManyMethod = (tableConfig, table, relation, relationName, query) => {
 	const relPKeys = getPrimaryKeys(query);
 	if ("through" in relation.options) {
-		const { through, source } = relation.options;
+		const { through, source, on } = relation.options;
+		if (on) _queryWhere(query, [on]);
 		const throughRelation = getThroughRelation(table, through);
 		const sourceRelation = getSourceRelation(throughRelation, source);
 		const sourceRelationQuery = sourceRelation.query.as(relationName);
@@ -1070,7 +1642,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 ? toSnakeCase(options.through.table) : options.through.table;
 	const originalThroughForeignKeys = options.through.columns;
 	const throughForeignKeys = snakeCase ? [...originalThroughForeignKeys] : originalThroughForeignKeys;
 	const throughPrimaryKeys = options.through.references;
@@ -1362,9 +1934,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}`);
@@ -1690,6 +2268,6 @@ const createRepo = (table, methods) => {
 		return q[key];
 	} });
 };
-export { bundleOrchidORM, bundleOrchidORMTables, createBaseTable, createRepo, defineRls, makeOrchidOrmDbWithAdapter, orchidORMWithAdapter, setGrants };
+export { bundleOrchidORM, bundleOrchidORMTables, createBaseTable, createRepo, createTableFactory, defineRls, makeOrchidOrmDbWithAdapter, orchidORMWithAdapter, setGrants };
 
 //# sourceMappingURL=index.mjs.map