@vantreeseba/drizzle-graphql 15.1.3 → 15.1.4

package/dist/index.d.cts

@@ -1112,6 +1112,11 @@ declare const drizzleExecutorKey: unique symbol;
  * Returns the JS property name of the local column on the parent table and the
  * Column object for the foreign column on the target table, or undefined if the
  * relation internals are not accessible.
+ *
+ * Only the relation's *first* column pair is reported. A relation joined on several columns
+ * (`from: [a, b], to: [x, y]`) is not described fully by it, so anything that reads rows by
+ * this pair alone mixes up parents that share the first column. Read paths use
+ * {@link extractRelationJoinColumnPairs}, which returns every pair.
  */
 declare const extractRelationJoinColumns: (relEntry: TableNamedRelations, parentTable: Table, targetTable: Table) => {
   localColPropName: string;

package/dist/index.d.ts

@@ -1112,6 +1112,11 @@ declare const drizzleExecutorKey: unique symbol;
  * Returns the JS property name of the local column on the parent table and the
  * Column object for the foreign column on the target table, or undefined if the
  * relation internals are not accessible.
+ *
+ * Only the relation's *first* column pair is reported. A relation joined on several columns
+ * (`from: [a, b], to: [x, y]`) is not described fully by it, so anything that reads rows by
+ * this pair alone mixes up parents that share the first column. Read paths use
+ * {@link extractRelationJoinColumnPairs}, which returns every pair.
  */
 declare const extractRelationJoinColumns: (relEntry: TableNamedRelations, parentTable: Table, targetTable: Table) => {
   localColPropName: string;

package/dist/index.js

@@ -1778,6 +1778,11 @@ const warnUnresolvedJoin = (relEntry, tableName, relationName, omitted) => {
 * Returns the JS property name of the local column on the parent table and the
 * Column object for the foreign column on the target table, or undefined if the
 * relation internals are not accessible.
+*
+* Only the relation's *first* column pair is reported. A relation joined on several columns
+* (`from: [a, b], to: [x, y]`) is not described fully by it, so anything that reads rows by
+* this pair alone mixes up parents that share the first column. Read paths use
+* {@link extractRelationJoinColumnPairs}, which returns every pair.
 */
 const extractRelationJoinColumns = (relEntry, parentTable, targetTable) => {
 	const rel = relEntry.relation ?? relEntry;
@@ -1796,6 +1801,48 @@ const extractRelationJoinColumns = (relEntry, parentTable, targetTable) => {
 	};
 };
 /**
+* Every column pair the relation joins on, in declaration order — one for an ordinary relation,
+* several for one declared `from: [a, b], to: [x, y]`. A row of the target belongs to a parent
+* only when *all* pairs match, so a read path has to correlate on every one of them.
+*
+* `undefined` when the relation's columns cannot be matched to the two tables, or when its two
+* sides list a different number of columns.
+*/
+const extractRelationJoinColumnPairs = (relEntry, parentTable, targetTable) => {
+	const rel = relEntry.relation ?? relEntry;
+	const sourceCols = relationColumns(rel, "source");
+	const targetCols = relationColumns(rel, "target");
+	if (!sourceCols?.length || sourceCols.length !== targetCols?.length) return;
+	const parentEntries = Object.entries(getColumns(parentTable));
+	const targetEntries = Object.entries(getColumns(targetTable));
+	const pairs = [];
+	for (let i = 0; i < sourceCols.length; i++) {
+		const localCol = sourceCols[i];
+		const foreignCol = targetCols[i];
+		const localColPropName = parentEntries.find(([, c]) => c === localCol)?.[0];
+		const foreignColPropName = targetEntries.find(([, c]) => c === foreignCol)?.[0];
+		if (!localColPropName || !foreignColPropName) return;
+		pairs.push({
+			localColPropName,
+			localCol,
+			foreignColPropName,
+			foreignCol
+		});
+	}
+	return pairs;
+};
+/**
+* A string identifying one combination of join-column values, for grouping a batch's rows by
+* parent. Values are compared by their string form, as a single-column key always has been.
+*/
+const joinKeyOf = (values) => values.length === 1 ? String(values[0]) : JSON.stringify(values.map((value) => String(value)));
+/**
+* The rows whose `cols` hold one of `keys`: `col IN (…)` for a single join column, and an `OR`
+* of per-parent equalities for several — `(a = 1 AND b = 1) OR (a = 1 AND b = 2)` — which
+* every dialect accepts, unlike a row-value `IN` list.
+*/
+const parentKeyCondition = (cols, keys) => cols.length === 1 ? inArray(cols[0], keys.map((key) => key[0])) : or(...keys.map((key) => and(...cols.map((col, i) => eq(col, key[i])))));
+/**
 * The junction table and its two columns for a `.through()` (many-to-many) relation:
 * `sourceCol` holds the parent's key, `targetCol` the target's. `undefined` for a relation
 * with no junction; `null` for one whose junction cannot be used here — more than one column
@@ -1826,16 +1873,18 @@ const extractJunctionColumns = (relEntry) => {
 *
 * A reversed filter (inherited from the relation on the other side) is written against the
 * parent table, so it is applied as "the row's parent key belongs to a parent that passes it".
-* `parentKeyCol` is the parent's join column and `groupCol` the column in the query that holds
-* the parent key for each row — the target's foreign key, or the junction's source column.
+* `parentKeyCols` are the parent's join columns and `groupCols` the columns in the query that
+* hold the parent key for each row — the target's foreign key, or the junction's source
+* column — in the same order. A key of several columns is compared as a row value.
 */
-const relationOwnCondition = (relEntry, parentTable, targetTable, parentKeyCol, groupCol) => {
+const relationOwnCondition = (relEntry, parentTable, targetTable, parentKeyCols, groupCols) => {
 	const rel = relEntry.relation ?? relEntry;
 	const ownWhere = relationOwnWhere(rel);
 	if (!ownWhere) return;
 	if (!isRelationFilterReversed(rel)) return relationsFilterToSQL(targetTable, ownWhere);
 	const parentFilter = relationsFilterToSQL(parentTable, ownWhere);
-	return sql`${groupCol} in (select ${parentKeyCol} from ${parentTable} where ${parentFilter})`;
+	if (groupCols.length === 1) return sql`${groupCols[0]} in (select ${parentKeyCols[0]} from ${parentTable} where ${parentFilter})`;
+	return sql`(${sql.join([...groupCols], sql`, `)}) in (select ${sql.join([...parentKeyCols], sql`, `)} from ${parentTable} where ${parentFilter})`;
 };
 /**
 * Whether a to-one relation can back a relation orderBy hop. `.through()` (junction)
@@ -3821,8 +3870,7 @@ const relationJoinColumns = (tree, table, selectionCtx) => {
 		const relEntry = fieldData.name.endsWith(AGGREGATE_FIELD_SUFFIX) ? relations[fieldData.name.slice(0, -9)] : relations[fieldData.name];
 		const targetTable = relEntry ? selectionCtx.tables[relEntry.targetTableName] : void 0;
 		if (!relEntry || !targetTable) continue;
-		const joinCols = extractRelationJoinColumns(relEntry, table, targetTable);
-		if (joinCols) needed.push(joinCols.localColPropName);
+		for (const pair of extractRelationJoinColumnPairs(relEntry, table, targetTable) ?? []) needed.push(pair.localColPropName);
 	}
 	return needed;
 };
@@ -4843,13 +4891,12 @@ const identifyRows = (field, args) => {
 * Window functions require PostgreSQL, MySQL >= 8.0, or SQLite >= 3.25.
 * Returns raw rows (NOT remapped); the caller groups + remaps them.
 */
-const batchedPaginatedRelationQuery = async (db, targetTable, foreignCol, whereCondition, orderByArg, limit, offset, pkNames, columns, orderCtx, whereArgs, junction) => {
+const batchedPaginatedRelationQuery = async (db, targetTable, foreignCol, partitionCols, whereCondition, orderByArg, limit, offset, pkNames, columns, orderCtx, whereArgs, junction) => {
 	const cols = columns ?? getColumns(targetTable);
 	const orderExprs = [...orderByArg ? extractOrderBy(targetTable, orderByArg, orderCtx, whereArgs) : [], ...primaryKeyOrderExprs(targetTable, pkNames)];
 	const orderClause = orderExprs.length ? sql` order by ${sql.join(orderExprs, sql`, `)}` : sql``;
 	const RN = "__drizzle_graphql_rn";
-	const partitionCol = junction ? junction.sourceCol : foreignCol;
-	const rowNumber = sql`row_number() over (partition by ${partitionCol}${orderClause})`.as(RN);
+	const rowNumber = sql`row_number() over (partition by ${sql.join([...partitionCols], sql`, `)}${orderClause})`.as(RN);
 	const sub = withJunction(db.select({
 		...cols,
 		[RN]: rowNumber
@@ -4888,13 +4935,14 @@ const createRelationResolverFactory = (db, tables, nullOrdering, filterCtx, limi
 	const targetTableName = relEntry.targetTableName;
 	const targetTable = tables[targetTableName];
 	if (!parentTable || !targetTable) return;
-	const joinCols = extractRelationJoinColumns(relEntry, parentTable, targetTable);
-	if (!joinCols) return;
-	const { localColPropName, foreignCol, foreignColPropName } = joinCols;
+	const joinPairs = extractRelationJoinColumnPairs(relEntry, parentTable, targetTable);
+	if (!joinPairs) return;
+	const localColPropNames = joinPairs.map((pair) => pair.localColPropName);
+	const foreignCol = joinPairs[0].foreignCol;
 	const junction = extractJunctionColumns(relEntry);
-	const groupCol = junction ? junction.sourceCol : foreignCol;
-	const groupKey = junction ? PARENT_KEY : foreignColPropName;
-	const ownCondition = relationOwnCondition(relEntry, parentTable, targetTable, getColumns(parentTable)[localColPropName], groupCol);
+	const groupCols = junction ? [junction.sourceCol] : joinPairs.map((pair) => pair.foreignCol);
+	const groupKeys = junction ? [PARENT_KEY] : joinPairs.map((pair) => pair.foreignColPropName);
+	const ownCondition = relationOwnCondition(relEntry, parentTable, targetTable, joinPairs.map((pair) => pair.localCol), groupCols);
 	const defaultDeleted = relationDeletedDefault(policies?.softDelete, targetTableName, isOne && relEntry.relation?.optional === false);
 	const limitPolicy = isOne ? void 0 : limits?.(targetTableName);
 	const targetPkNames = relEntry.targetPkNames ?? [];
@@ -4923,7 +4971,7 @@ const createRelationResolverFactory = (db, tables, nullOrdering, filterCtx, limi
 			allRelations: filterCtx?.relationMap
 		});
 		const targetColumns = getColumns(targetTable);
-		columns[foreignColPropName] = foreignCol;
+		for (const pair of joinPairs) columns[pair.foreignColPropName] = pair.foreignCol;
 		for (const [columnName] of cursorEntries ?? []) {
 			const column = targetColumns[columnName];
 			if (column) columns[columnName] = column;
@@ -4935,8 +4983,8 @@ const createRelationResolverFactory = (db, tables, nullOrdering, filterCtx, limi
 	};
 	const resolve = async (parent, args, context, info) => {
 		if (parent[relationName] !== void 0) return parent[relationName];
-		const localValue = parent[localColPropName];
-		if (localValue == null) return isOne ? null : [];
+		const localValues = localColPropNames.map((name) => parent[name]);
+		if (localValues.some((value) => value == null)) return isOne ? null : [];
 		const { where: whereArg, limit: requestedLimit, offset, after, deleted } = args ?? {};
 		const { orderByArg, limit, distinct, cursorEntries, cursorValues, columns, loaderKey } = getOrCreateRequestValue(context, info?.fieldNodes?.[0], `relation:${tableName}::${relationName}`, () => {
 			const orderByArg = isOne ? args?.orderBy : withDefaultOrderBy(args ?? {}, targetTableName, policies?.defaultOrderBy).orderBy;
@@ -4977,11 +5025,11 @@ const createRelationResolverFactory = (db, tables, nullOrdering, filterCtx, limi
 			};
 		});
 		if (junction === null) throw drizzleError(`Relation '${tableName}.${relationName}' goes through a junction with a composite key, which can only be loaded together with its parent. Leave it to eager loading (eagerLoadRelations).`, { code: "DRIZZLE_UNSUPPORTED_RELATION" });
-		return getOrCreateLoader(context, loaderKey, async (parentIds) => {
+		return getOrCreateLoader(context, loaderKey, async (parentKeys) => {
 			const executor = resolveExecutor(db, context);
-			const uniqueIds = [...new Set(parentIds)];
+			const uniqueKeys = [...new Map(parentKeys.map((key) => [joinKeyOf(key), key])).values()];
 			const scope = resolveScope(policies, context, filterCtx);
-			let whereCondition = withScope(scope, targetTableName, targetTable, and(inArray(groupCol, uniqueIds), ownCondition, whereArg ? extractFilters(targetTable, targetTableName, whereArg, relationFilterCtx(filterCtx, targetTableName, scope)) : void 0, cursorValues ? buildCursorCondition(targetTable, cursorEntries, cursorValues, nullOrdering) : void 0), deleted ?? defaultDeleted);
+			let whereCondition = withScope(scope, targetTableName, targetTable, and(parentKeyCondition(groupCols, uniqueKeys), ownCondition, whereArg ? extractFilters(targetTable, targetTableName, whereArg, relationFilterCtx(filterCtx, targetTableName, scope)) : void 0, cursorValues ? buildCursorCondition(targetTable, cursorEntries, cursorValues, nullOrdering) : void 0), deleted ?? defaultDeleted);
 			if (distinct) {
 				const keys = await selectDistinctKeys({
 					db: executor,
@@ -4991,22 +5039,22 @@ const createRelationResolverFactory = (db, tables, nullOrdering, filterCtx, limi
 					pkNames: targetPkNames,
 					where: whereCondition,
 					orderBy: orderByArg,
-					partitionBy: [groupCol],
+					partitionBy: groupCols,
 					junction: junction ? {
 						table: junction.table,
 						on: eq(junction.targetCol, foreignCol),
-						parentKey: groupCol
+						parentKey: junction.sourceCol
 					} : void 0
 				});
-				if (!keys.length) return parentIds.map(() => isOne ? null : []);
-				whereCondition = and(whereCondition, junction ? or(...keys.map((key) => and(eq(groupCol, key[DISTINCT_PARENT]), primaryKeyRestriction(targetTable, targetPkNames, [key])))) : primaryKeyRestriction(targetTable, targetPkNames, keys));
+				if (!keys.length) return parentKeys.map(() => isOne ? null : []);
+				whereCondition = and(whereCondition, junction ? or(...keys.map((key) => and(eq(junction.sourceCol, key[DISTINCT_PARENT]), primaryKeyRestriction(targetTable, targetPkNames, [key])))) : primaryKeyRestriction(targetTable, targetPkNames, keys));
 			}
 			const selection = junction ? {
 				...columns ?? getColumns(targetTable),
-				[PARENT_KEY]: groupCol
+				[PARENT_KEY]: junction.sourceCol
 			} : columns;
 			let rows;
-			if (limit != null || offset != null) rows = await batchedPaginatedRelationQuery(executor, targetTable, foreignCol, whereCondition, orderByArg, limit ?? null, offset ?? null, targetPkNames, selection, relationFilterCtx(filterCtx, targetTableName, scope), whereArg, junction);
+			if (limit != null || offset != null) rows = await batchedPaginatedRelationQuery(executor, targetTable, foreignCol, groupCols, whereCondition, orderByArg, limit ?? null, offset ?? null, targetPkNames, selection, relationFilterCtx(filterCtx, targetTableName, scope), whereArg, junction);
 			else {
 				let q = withJunction((selection ? executor.select(selection) : executor.select()).from(targetTable), junction, foreignCol).where(whereCondition);
 				const orderExprs = cursorEntries ? cursorOrderExprs(targetTable, cursorEntries) : orderByArg ? extractOrderBy(targetTable, orderByArg, relationFilterCtx(filterCtx, targetTableName, scope), whereArg) : [];
@@ -5015,20 +5063,20 @@ const createRelationResolverFactory = (db, tables, nullOrdering, filterCtx, limi
 			}
 			if (cursorEntries) attachRowCursors(rows, cursorEntries);
 			const keyOf = (row) => {
-				const key = String(row[groupKey]);
+				const key = joinKeyOf(groupKeys.map((name) => row[name]));
 				if (junction) delete row[PARENT_KEY];
 				return key;
 			};
 			if (isOne) {
 				const byKey = new Map(rows.map((row) => [keyOf(row), row]));
 				remapToGraphQLArrayOutput(rows, targetTableName, targetTable);
-				return parentIds.map((id) => byKey.get(String(id)) ?? null);
+				return parentKeys.map((key) => byKey.get(joinKeyOf(key)) ?? null);
 			}
-			const grouped = new Map(uniqueIds.map((id) => [String(id), []]));
+			const grouped = new Map(uniqueKeys.map((key) => [joinKeyOf(key), []]));
 			for (const row of rows) grouped.get(keyOf(row))?.push(row);
 			remapToGraphQLArrayOutput(rows, targetTableName, targetTable);
-			return parentIds.map((id) => grouped.get(String(id)) ?? []);
-		}).load(localValue);
+			return parentKeys.map((key) => grouped.get(joinKeyOf(key)) ?? []);
+		}).load(localValues);
 	};
 	return async (parent, args, context, info) => {
 		try {
@@ -6104,8 +6152,8 @@ const createRelationAggregateFactory = (db, tables, cacheCtx, typeNameMapper, fi
 		const targetTableName = relEntry.targetTableName;
 		const targetTable = tables[targetTableName];
 		if (!parentTable || !targetTable) return;
-		const joinCols = extractRelationJoinColumns(relEntry, parentTable, targetTable);
-		if (!joinCols) {
+		const joinPairs = extractRelationJoinColumnPairs(relEntry, parentTable, targetTable);
+		if (!joinPairs) {
 			const key = `${tableName}.${relationName}`;
 			if (!warned.has(key)) {
 				warned.add(key);
@@ -6113,11 +6161,13 @@ const createRelationAggregateFactory = (db, tables, cacheCtx, typeNameMapper, fi
 			}
 			return;
 		}
-		const { localColPropName, foreignCol } = joinCols;
+		const localColPropNames = joinPairs.map((pair) => pair.localColPropName);
+		const foreignCol = joinPairs[0].foreignCol;
 		const junction = extractJunctionColumns(relEntry);
 		if (junction === null) return;
-		const groupCol = junction ? junction.sourceCol : foreignCol;
-		const ownCondition = relationOwnCondition(relEntry, parentTable, targetTable, getColumns(parentTable)[localColPropName], groupCol);
+		const groupCols = junction ? [junction.sourceCol] : joinPairs.map((pair) => pair.foreignCol);
+		const groupAliases = groupCols.map((_, i) => `${GROUP_KEY}${i}`);
+		const ownCondition = relationOwnCondition(relEntry, parentTable, targetTable, joinPairs.map((pair) => pair.localCol), groupCols);
 		const defaultDeleted = relationDeletedDefault(policies?.softDelete, targetTableName, false);
 		const targetTypeName = resolveTypeName(targetTableName, typeNameMapper);
 		const type = generateAggregateTypes(targetTable, targetTableName, targetTypeName, cacheCtx);
@@ -6141,24 +6191,25 @@ const createRelationAggregateFactory = (db, tables, cacheCtx, typeNameMapper, fi
 					};
 				});
 				if (!Object.keys(request.selection).length) return {};
-				const localValue = parent[localColPropName];
-				if (localValue == null) return assembleAggregateRow({}, request, target);
+				const localValues = localColPropNames.map((name) => parent[name]);
+				if (localValues.some((value) => value == null)) return assembleAggregateRow({}, request, target);
 				const whereArg = args?.where;
 				const deleted = args?.deleted;
-				const loader = getOrCreateLoader(context, loaderKey, async (parentIds) => {
+				const loader = getOrCreateLoader(context, loaderKey, async (parentKeys) => {
 					const executor = resolveExecutor(db, context);
-					const uniqueIds = [...new Set(parentIds)];
+					const uniqueKeys = [...new Map(parentKeys.map((key) => [joinKeyOf(key), key])).values()];
 					const scope = resolveScope(policies, context, filterCtx);
-					const whereCondition = withScope(scope, targetTableName, targetTable, and(inArray(groupCol, uniqueIds), ownCondition, whereArg ? extractFilters(targetTable, targetTableName, whereArg, relationFilterCtx(filterCtx, targetTableName, scope)) : void 0), deleted ?? defaultDeleted);
+					const whereCondition = withScope(scope, targetTableName, targetTable, and(parentKeyCondition(groupCols, uniqueKeys), ownCondition, whereArg ? extractFilters(targetTable, targetTableName, whereArg, relationFilterCtx(filterCtx, targetTableName, scope)) : void 0), deleted ?? defaultDeleted);
+					const groupSelection = Object.fromEntries(groupAliases.map((alias, i) => [alias, groupCols[i]]));
 					const selected = executor.select({
-						[GROUP_KEY]: groupCol,
+						...groupSelection,
 						...request.selection
 					}).from(targetTable);
-					const rows = await (junction ? selected.innerJoin(junction.table, eq(junction.targetCol, foreignCol)) : selected).where(whereCondition).groupBy(groupCol);
-					const byKey = new Map(rows.map((row) => [row[GROUP_KEY], row]));
-					return parentIds.map((id) => byKey.get(id) ?? {});
+					const rows = await (junction ? selected.innerJoin(junction.table, eq(junction.targetCol, foreignCol)) : selected).where(whereCondition).groupBy(...groupCols);
+					const byKey = new Map(rows.map((row) => [joinKeyOf(groupAliases.map((alias) => row[alias])), row]));
+					return parentKeys.map((key) => byKey.get(joinKeyOf(key)) ?? {});
 				});
-				return assembleAggregateRow(await loader.load(localValue), request, target);
+				return assembleAggregateRow(await loader.load(localValues), request, target);
 			} catch (e) {
 				throw withErrorContext(toGraphQLError(e), errorCtx);
 			}