@vantreeseba/drizzle-graphql 10.0.1 → 10.0.3

package/dist/index.cjs

@@ -1537,11 +1537,44 @@ const extractUniqueKeyFilter = (table, tableName, fieldName, members, value) =>
 };
 //#endregion
 //#region src/util/builders/common/relation-filters.ts
-/** Narrows the build-scoped relation filter context to the table a resolver is filtering. */
-const relationFilterCtx = (base, tableKey) => base ? {
-	...base,
-	tableKey
-} : void 0;
+/**
+* The narrowed contexts already handed out, keyed by the build-scoped base and then by
+* table. The base is created once per `buildSchema` and the result depends on nothing else,
+* so every call for one table produces the same value — a `WeakMap` on the base keeps them
+* for exactly as long as that build is reachable.
+*/
+const narrowedCtxCache = /* @__PURE__ */ new WeakMap();
+/**
+* Narrows the build-scoped relation filter context to the table a resolver is filtering.
+*
+* Cached rather than rebuilt: the base carries the build's whole `tables` and `relationMap`,
+* and the spread copied both on every call — three per parent row in the lazy relation
+* resolver, one per parent row in the relation aggregate, and up to four per select, several
+* of them inside callbacks drizzle invokes lazily.
+*
+* The one field written after the fact is `aliases`, the counter that keeps subquery aliases
+* apart ({@link extractRelationFilter}). Sharing it is what makes the caching safe rather
+* than a hazard: the counter now spans the process instead of restarting per extraction, and
+* aliases only ever have to be unique *within* one statement, which a number that never
+* repeats gives more surely than one that restarts.
+*/
+const relationFilterCtx = (base, tableKey) => {
+	if (!base) return;
+	let byTable = narrowedCtxCache.get(base);
+	if (!byTable) {
+		byTable = /* @__PURE__ */ new Map();
+		narrowedCtxCache.set(base, byTable);
+	}
+	let ctx = byTable.get(tableKey);
+	if (!ctx) {
+		ctx = {
+			...base,
+			tableKey
+		};
+		byTable.set(tableKey, ctx);
+	}
+	return ctx;
+};
 /**
 * Correlates the parent row with the aliased target table using the relation's own join
 * columns. Columns are matched by SQL name rather than object identity so this also works when
@@ -3145,16 +3178,23 @@ const extractRelationsParams = (relationMap, tables, tableName, info, typeName,
 	if (!info) return;
 	const relationsForTable = relationMap[tableName];
 	if (!relationsForTable) return;
-	const baseField = Object.entries(info.fieldsByTypeName).find(([key, _value]) => key === typeName)?.[1];
+	const baseField = info.fieldsByTypeName[typeName];
 	if (!baseField) return;
+	const selectionsByName = /* @__PURE__ */ new Map();
+	for (const selection of Object.values(baseField)) {
+		const selections = selectionsByName.get(selection.name);
+		if (selections) selections.push(selection);
+		else selectionsByName.set(selection.name, [selection]);
+	}
 	const args = {};
 	for (const [relName, relEntry] of Object.entries(relationsForTable)) {
 		const { targetTableName, targetPkNames } = relEntry;
 		const relTypeName = resolveObjectTypeName(targetTableName, typeNameMapper, resolveName);
-		const field = baseField[relName] ?? Object.values(baseField).find((f) => f.name === relName);
-		if (!field) continue;
-		if (Object.values(baseField).reduce((n, f) => n + (f.name === relName ? 1 : 0), 0) > 1) continue;
-		const relFieldSelection = (field?.fieldsByTypeName)?.[relTypeName];
+		const selections = selectionsByName.get(relName);
+		if (!selections) continue;
+		const field = selections[0];
+		if (selections.length > 1) continue;
+		const relFieldSelection = field.fieldsByTypeName[relTypeName];
 		if (!relFieldSelection) continue;
 		const eagerArgs = field.args;
 		if (!(0, drizzle_orm.is)(relEntry.relation ?? relEntry, drizzle_orm.One) && (eagerArgs?.after != null || !!(eagerArgs?.distinct)?.length || isCursorFieldSelected(relFieldSelection, tables[targetTableName]))) continue;
@@ -3166,8 +3206,7 @@ const extractRelationsParams = (relationMap, tables, tableName, info, typeName,
 		});
 		const thisRecord = {};
 		thisRecord.columns = columns;
-		const relationField = Object.values(baseField).find((e) => e.name === relName);
-		const relationArgs = (0, drizzle_orm.is)(relEntry.relation, drizzle_orm.One) ? relationField?.args : relationField && withDefaultOrderBy(relationField.args ?? {}, targetTableName, defaultOrderBy);
+		const relationArgs = (0, drizzle_orm.is)(relEntry.relation, drizzle_orm.One) ? field.args : withDefaultOrderBy(field.args ?? {}, targetTableName, defaultOrderBy);
 		const offset = relationArgs?.offset ?? void 0;
 		const limit = (0, drizzle_orm.is)(relEntry.relation, drizzle_orm.One) ? relationArgs?.limit ?? void 0 : applyLimitPolicy(relationArgs?.limit, limits?.(targetTableName), {
 			table: targetTableName,
@@ -3182,7 +3221,7 @@ const extractRelationsParams = (relationMap, tables, tableName, info, typeName,
 		thisRecord.orderBy = relationArgs?.orderBy ? (aliasedTable) => extractOrderBy(aliasedTable, relationArgs.orderBy, relationFilterCtx(filterCtx, targetTableName), relWhere) : hasPagination && pkNames.length ? (aliasedTable) => primaryKeyOrderExprs(aliasedTable, pkNames) : void 0;
 		thisRecord.offset = offset;
 		thisRecord.limit = limit;
-		thisRecord.with = extractRelationsParams(relationMap, tables, targetTableName, relationField, relTypeName, options);
+		thisRecord.with = extractRelationsParams(relationMap, tables, targetTableName, field, relTypeName, options);
 		args[relName] = thisRecord;
 	}
 	return args;