orchid-orm 1.72.4 → 1.72.6

package/dist/index.d.ts

@@ -96,6 +96,11 @@ interface HasManyInfo<T extends RelationConfigSelf, Name extends string, Rel ext
     set?: MaybeArray<WhereArg<Q>>;
     add?: MaybeArray<WhereArg<Q>>;
     create?: CreateData<Q>[];
+    upsert?: {
+      findBy: Q['internal']['uniqueColumns'];
+      update: UpdateData<Q>;
+      create?: CreateData<Q> | (() => CreateData<Q>);
+    };
   } : never;
 }
 interface RelJoin extends JoinQueryMethod {
@@ -428,6 +433,11 @@ interface HasAndBelongsToManyInfo<T extends RelationConfigSelf, Name extends str
       data: UpdateData<Q>;
     };
     create?: CreateData<Q>[];
+    upsert?: {
+      findBy: Q['internal']['uniqueColumns'];
+      update: UpdateData<Q>;
+      create?: CreateData<Q> | (() => CreateData<Q>);
+    };
   } : {
     disconnect?: MaybeArray<WhereArg<Q>>;
     set?: MaybeArray<WhereArg<Q>>;

package/dist/index.js

@@ -137,6 +137,25 @@ function createBaseTable({ schemaConfig = pqb_internal.defaultSchemaConfig, colu
 	base.prototype.autoForeignKeys = autoForeignKeys === true ? {} : autoForeignKeys || void 0;
 	return base;
 }
+const throwIfQueryReturnsAllForNestedUpdate = (q, params) => {
+	if (!(params.set || params.create || params.upsert) || !(0, pqb_internal.isQueryReturnsAll)(q)) return;
+	let key;
+	if (params.set) key = "set";
+	else if (params.create) key = "create";
+	else key = "upsert";
+	throw new Error(`\`${key}\` option is not allowed in a batch update`);
+};
+const getNestedUpdateUpsertCreate = (upsert) => {
+	if (typeof upsert.create === "function") return upsert.create();
+	return upsert.create || pqb_internal.emptyObject;
+};
+const makeNestedUpdateUpsertData = (upsert, setIds) => ({
+	update: upsert.update,
+	create: {
+		...getNestedUpdateUpsertCreate(upsert),
+		...setIds
+	}
+});
 const getThroughRelation = (table, through) => {
 	return table.relations[through];
 };
@@ -224,8 +243,27 @@ const getColumnKeyFromDbName = (query, name) => {
 	for (const k in query.shape) if (query.shape[k].data.name === name) return k;
 	return name;
 };
-const selectCteColumnsSql = (cteAs, columns) => `(SELECT ${columns.map((c) => `"${cteAs}"."${c}"`).join(", ")} FROM "${cteAs}")`;
-const selectCteColumnSql = (cteAs, column) => `(SELECT "${cteAs}"."${column}" FROM "${cteAs}")`;
+const selectCteColumnsSql$1 = (cteAs, columns) => `(SELECT ${columns.map((c) => `"${cteAs}"."${c}"`).join(", ")} FROM "${cteAs}")`;
+const selectCteColumnSql$1 = (cteAs, column) => `(SELECT "${cteAs}"."${column}" FROM "${cteAs}")`;
+const makeNestedUpdateRelationIds = (q, relQuery, primaryKeys, foreignKeys) => {
+	const selectIdsSql = new pqb_internal.RawSql("");
+	const setIds = {};
+	for (const foreignKey of foreignKeys) setIds[foreignKey] = new pqb_internal.RawSql("");
+	let appendedAs;
+	(0, pqb_internal._hookSelectColumns)(q, primaryKeys, (aliasedPrimaryKeys) => {
+		selectIdsSql._sql = selectCteColumnsSql$1(appendedAs, aliasedPrimaryKeys);
+		foreignKeys.forEach((foreignKey, i) => {
+			setIds[foreignKey]._sql = selectCteColumnSql$1(appendedAs, aliasedPrimaryKeys[i]);
+		});
+	});
+	return {
+		existingRelQuery: (0, pqb_internal._queryWhereIn)((0, pqb_internal._clone)(relQuery), true, foreignKeys, selectIdsSql),
+		setIds,
+		setAppendedAs(as) {
+			appendedAs = as;
+		}
+	};
+};
 const selectCteColumnFromManySql = (cteAs, column, rowIndex, count) => {
 	let sql = `(SELECT "${cteAs}"."${column}" FROM "${cteAs}"`;
 	if (count > 1) {
@@ -406,7 +444,7 @@ const nestedUpdate$2 = ({ query, primaryKeys, foreignKeys, len }) => {
 		} else if (params.update) {
 			let appendedAs;
 			(0, pqb_internal._hookSelectColumns)(self, foreignKeys, (aliasedForeignKeys) => {
-				selectIdsSql._sql = selectCteColumnsSql(appendedAs, aliasedForeignKeys);
+				selectIdsSql._sql = selectCteColumnsSql$1(appendedAs, aliasedForeignKeys);
 			});
 			const selectIdsSql = new pqb_internal.RawSql("");
 			const updateQuery = (0, pqb_internal._queryUpdate)((0, pqb_internal._queryWhereIn)(query.clone(), true, primaryKeys, selectIdsSql), params.update);
@@ -449,7 +487,7 @@ const relWithSelectIds = (self, rel, primaryKeys, foreignKeys) => {
 	const selectIdsQuery = makeSelectIdsQuery(self, foreignKeys);
 	const selectIdsSql = new pqb_internal.RawSql("");
 	(0, pqb_internal._prependWith)(self, (as) => {
-		selectIdsSql._sql = selectCteColumnsSql(as, foreignKeys);
+		selectIdsSql._sql = selectCteColumnsSql$1(as, foreignKeys);
 	}, selectIdsQuery);
 	return {
 		selectIdsSql,
@@ -470,12 +508,12 @@ const setForeignKeysFromCte = (record, primaryKeys, foreignKeys, mustExist) => {
 		foreignKeys.forEach(mustExist ? (foreignKey, i) => {
 			record[foreignKey]._sql = selectCteColumnMustExistSql(i, as, primaryKeys[i]);
 		} : (foreignKey, i) => {
-			record[foreignKey]._sql = selectCteColumnSql(as, primaryKeys[i]);
+			record[foreignKey]._sql = selectCteColumnSql$1(as, primaryKeys[i]);
 		});
 	};
 };
 const selectCteColumnMustExistSql = (i, cteAs, column) => {
-	const selectColumn = selectCteColumnSql(cteAs, column);
+	const selectColumn = selectCteColumnSql$1(cteAs, column);
 	return i === 0 ? `CASE WHEN (SELECT count(*) FROM "${cteAs}") = 0 AND (SELECT 'not-found')::int = 0 THEN NULL ELSE ${selectColumn} END` : selectColumn;
 };
 var HasOneVirtualColumn = class extends pqb_internal.VirtualColumn {
@@ -541,43 +579,19 @@ var HasOneVirtualColumn = class extends pqb_internal.VirtualColumn {
 	update(self, set) {
 		const querySelf = self;
 		const params = set[this.key];
-		if ((params.set || params.create || params.upsert) && (0, pqb_internal.isQueryReturnsAll)(querySelf)) {
-			const key = params.set ? "set" : params.create ? "create" : "upsert";
-			throw new Error(`\`${key}\` option is not allowed in a batch update`);
-		}
+		throwIfQueryReturnsAllForNestedUpdate(querySelf, params);
 		const { primaryKeys, foreignKeys, query: relQuery } = this.state;
 		if (params.create || params.update || params.upsert || params.disconnect || params.set || params.delete) {
-			let appendedAs;
-			(0, pqb_internal._hookSelectColumns)(querySelf, primaryKeys, (aliasedPrimaryKeys) => {
-				selectIdsSql._sql = selectCteColumnsSql(appendedAs, aliasedPrimaryKeys);
-				if (params.create || params.set || params.upsert) foreignKeys.forEach((foreignKey, i) => {
-					setIds[foreignKey]._sql = selectCteColumnSql(appendedAs, aliasedPrimaryKeys[i]);
-				});
-			});
-			const selectIdsSql = new pqb_internal.RawSql("");
-			const existingRelQuery = (0, pqb_internal._queryWhereIn)((0, pqb_internal._clone)(relQuery), true, foreignKeys, selectIdsSql);
-			let setIds = void 0;
-			if (params.create || params.set || params.upsert) {
-				setIds = {};
-				foreignKeys.forEach((foreignKey) => {
-					setIds[foreignKey] = new pqb_internal.RawSql("");
-				});
-			}
-			const nullifyOrDeleteQuery = params.update ? (0, pqb_internal._queryUpdate)(existingRelQuery, params.update) : params.upsert ? (0, pqb_internal._queryUpsert)(existingRelQuery, {
-				update: params.upsert.update,
-				create: {
-					...typeof params.upsert.create === "function" ? params.upsert.create() : params.upsert.create,
-					...setIds
-				}
-			}) : params.delete ? (0, pqb_internal._queryDelete)(existingRelQuery) : (0, pqb_internal._queryUpdate)(existingRelQuery, this.setNulls);
+			const ids = makeNestedUpdateRelationIds(querySelf, relQuery, primaryKeys, foreignKeys);
+			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, (as) => appendedAs = as);
+			(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,
-				...setIds
+				...ids.setIds
 			}), pqb_internal.noop);
 			else if (params.set) {
-				const setQuery = (0, pqb_internal._queryUpdate)((0, pqb_internal._queryWhere)((0, pqb_internal._clone)(relQuery), [params.set]), setIds);
+				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);
 			}
@@ -691,6 +705,8 @@ var HasManyVirtualColumn = class extends pqb_internal.VirtualColumn {
 		this.state = state;
 		this.nestedInsert = nestedInsert$1(state);
 		this.nestedUpdate = nestedUpdate$1(state);
+		this.setNulls = {};
+		for (const foreignKey of state.foreignKeys) this.setNulls[foreignKey] = null;
 	}
 	create(self, ctx, items, rowIndexes, count) {
 		const querySelf = self;
@@ -761,14 +777,18 @@ var HasManyVirtualColumn = class extends pqb_internal.VirtualColumn {
 			});
 		} else hasRelationHandleCreate(querySelf, ctx, items, rowIndexes, this.key, this.state.primaryKeys, this.nestedInsert);
 	}
-	update(q, set) {
-		const query = q;
+	update(self, set) {
+		const querySelf = self;
 		const params = set[this.key];
-		if ((params.set || params.create) && (0, pqb_internal.isQueryReturnsAll)(query)) {
-			const key = params.set ? "set" : "create";
-			throw new Error(`\`${key}\` option is not allowed in a batch update`);
+		throwIfQueryReturnsAllForNestedUpdate(querySelf, params);
+		hasRelationHandleUpdate(querySelf, set, this.key, this.state.primaryKeys, this.nestedUpdate);
+		if (params.upsert) {
+			const { primaryKeys, foreignKeys, query: relQuery } = this.state;
+			const ids = makeNestedUpdateRelationIds(querySelf, relQuery, primaryKeys, foreignKeys);
+			const appendedQuery = (0, pqb_internal._queryUpsert)(ids.existingRelQuery, makeNestedUpdateUpsertData(params.upsert, ids.setIds));
+			appendedQuery.q.returnType = "void";
+			(0, pqb_internal._appendQuery)(querySelf, appendedQuery, ids.setAppendedAs);
 		}
-		hasRelationHandleUpdate(query, set, this.key, this.state.primaryKeys, this.nestedUpdate);
 	}
 };
 const makeHasManyMethod = (tableConfig, table, relation, relationName, query) => {
@@ -908,10 +928,10 @@ const nestedInsert$1 = ({ query, primaryKeys, foreignKeys }) => {
 		}
 	});
 };
-const nestedUpdate$1 = ({ query, primaryKeys, foreignKeys }) => {
+const nestedUpdate$1 = ({ query: relQuery, primaryKeys, foreignKeys }) => {
 	const len = primaryKeys.length;
 	return (async (_, data, params) => {
-		const t = query.clone();
+		const t = relQuery.clone();
 		if (params.create) {
 			const obj = {};
 			for (let i = 0; i < len; i++) obj[foreignKeys[i]] = data[0][primaryKeys[i]];
@@ -921,12 +941,12 @@ const nestedUpdate$1 = ({ query, primaryKeys, foreignKeys }) => {
 			})));
 		}
 		if (params.add) {
-			if (data.length > 1) throw new pqb.OrchidOrmInternalError(query, "`connect` is not available when updating multiple records, it is only applicable for a single record update");
+			if (data.length > 1) throw new pqb.OrchidOrmInternalError(relQuery, "`connect` is not available when updating multiple records, it is only applicable for a single record update");
 			const obj = {};
 			for (let i = 0; i < len; i++) obj[foreignKeys[i]] = data[0][primaryKeys[i]];
 			const relatedWheres = (0, pqb_internal.toArray)(params.add);
 			const count = await (0, pqb_internal._queryUpdate)(t.where({ OR: relatedWheres }), obj);
-			if (count < relatedWheres.length) throw new pqb.OrchidOrmInternalError(query, `Expected to find at least ${relatedWheres.length} record(s) based on \`add\` conditions, but found ${count}`);
+			if (count < relatedWheres.length) throw new pqb.OrchidOrmInternalError(relQuery, `Expected to find at least ${relatedWheres.length} record(s) based on \`add\` conditions, but found ${count}`);
 		}
 		if (params.disconnect || params.set) {
 			const obj = {};
@@ -961,9 +981,48 @@ var HasAndBelongsToManyVirtualColumn = class extends pqb_internal.VirtualColumn
 		hasRelationHandleCreate(q, ctx, items, rowIndexes, this.key, this.state.primaryKeys, this.nestedInsert);
 	}
 	update(q, set) {
-		hasRelationHandleUpdate(q, set, this.key, this.state.primaryKeys, this.nestedUpdate);
+		const querySelf = q;
+		const params = set[this.key];
+		hasRelationHandleUpdate(querySelf, set, this.key, this.state.primaryKeys, this.nestedUpdate);
+		if (params.upsert) {
+			throwIfQueryReturnsAllForNestedUpdate(querySelf, { upsert: params.upsert });
+			nestedUpdateUpsert(querySelf, this.state, params.upsert);
+		}
 	}
 };
+const selectCteColumnsSql = (cteAs, columns) => `(SELECT ${columns.map((c) => `"${cteAs}"."${c}"`).join(", ")} FROM "${cteAs}")`;
+const selectCteColumnSql = (cteAs, column) => `(SELECT "${cteAs}"."${column}" FROM "${cteAs}")`;
+const nestedUpdateUpsert = (querySelf, state, upsert) => {
+	const parentIdsSql = new pqb_internal.RawSql("");
+	const parentValues = state.foreignKeys.map(() => new pqb_internal.RawSql(""));
+	const relatedIdsSql = new pqb_internal.RawSql("");
+	const relatedValues = state.throughPrimaryKeys.map(() => new pqb_internal.RawSql(""));
+	let parentAs;
+	(0, pqb_internal._hookSelectColumns)(querySelf, state.primaryKeys, (aliasedPrimaryKeys) => {
+		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) => {
+		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);
+	}]), {
+		update: upsert.update,
+		create: upsert.create || {}
+	}), state.throughPrimaryKeys);
+	const selectAs = {};
+	for (let i = 0; i < state.foreignKeys.length; i++) selectAs[state.foreignKeys[i]] = parentValues[i];
+	for (let i = 0; i < state.throughForeignKeys.length; i++) selectAs[state.throughForeignKeys[i]] = relatedValues[i];
+	const joinRows = (0, pqb_internal._querySelect)((0, pqb_internal._clone)(state.queryBuilder), [selectAs]);
+	(0, pqb_internal._queryWhere)(joinRows, [relatedIdsSql]);
+	const joinQuery = state.joinTableQuery.insertForEachFrom(joinRows);
+	joinQuery.q.returnType = "void";
+	(0, pqb_internal._appendQuery)(querySelf, (0, pqb_internal._appendQueryOnUpsertCreate)(upsertQuery, joinQuery, (as) => {
+		relatedIdsSql._sql = `EXISTS (SELECT 1 FROM "${as}")`;
+		for (let i = 0; i < relatedValues.length; i++) relatedValues[i]._sql = selectCteColumnSql(as, state.throughPrimaryKeys[i]);
+	}), (as) => {
+		parentAs = as;
+	});
+};
 const removeColumnName = (column) => {
 	if (!column.data.name) return column;
 	const cloned = Object.create(column);
@@ -1021,6 +1080,7 @@ const makeHasAndBelongsToManyMethod = (tableConfig, table, qb, relation, relatio
 	addAutoForeignKey(tableConfig, subQuery, table, primaryKeys, foreignKeys, relation.options, originalForeignKeys);
 	addAutoForeignKey(tableConfig, subQuery, query, throughPrimaryKeys, throughForeignKeys, relation.options.through, originalThroughForeignKeys);
 	const state = {
+		queryBuilder: qb,
 		relatedTableQuery: query,
 		joinTableQuery: subQuery,
 		primaryKeys,