@prisma/orm-family-sql 8.0.0-rc.11-dev.2 → 8.0.0-rc.11-dev.4

package/dist/orm-client.mjs

@@ -481,6 +481,13 @@ function stripHiddenMappedFields(contract, namespaceId, modelName, mapped, hidde
 function mapStorageRowToModelFields(contract, namespaceId, modelName, row) {
 	const columnToField = getColumnToFieldMap(contract, namespaceId, modelName);
 	if (Object.keys(columnToField).length === 0) return { ...row };
+	return mapColumnNames(row, columnToField);
+}
+function createStorageRowMapper(contract, namespaceId, modelName) {
+	const columnToField = getColumnToFieldMap(contract, namespaceId, modelName);
+	return Object.keys(columnToField).length === 0 ? (row) => ({ ...row }) : (row) => mapColumnNames(row, columnToField);
+}
+function mapColumnNames(row, columnToField) {
 	const mapped = {};
 	for (const [columnName, value] of Object.entries(row)) mapped[columnToField[columnName] ?? columnName] = value;
 	return mapped;
@@ -1972,7 +1979,8 @@ function dispatchWithIncludes(options) {
 				mapped: polyInfo ? mapPolymorphicRow(contract, namespaceId, modelName, polyInfo, row, state.variantName) : mapStorageRowToModelFields(contract, namespaceId, modelName, row)
 			};
 		});
-		for (const parent of parentRows) for (const include of state.includes) parent.mapped[include.relationName] = await decodeIncludePayload(contract, context, include, parent.raw[include.relationName]);
+		const bindings = /* @__PURE__ */ new WeakMap();
+		for (const parent of parentRows) for (const include of state.includes) parent.mapped[include.relationName] = await decodeIncludePayload(contract, context, include, parent.raw[include.relationName], bindings);
 		for (const row of parentRows) yield blindCast(row.mapped);
 	};
 	return new AsyncIterableResult(generator());
@@ -2055,42 +2063,53 @@ function buildIdentityInFilter(contract, namespaceId, tableName, identityColumns
 * each branch is dispatched to the row or scalar decoder per its
 * declared shape (see `decodeCombineIncludePayload`).
 */
-async function decodeIncludePayload(contract, context, include, raw) {
+async function decodeIncludePayload(contract, context, include, raw, bindings) {
 	if (include.scalar) return Promise.resolve(decodeScalarIncludePayload(contract, context, include, include.scalar, raw));
-	if (include.combine) return decodeCombineIncludePayload(contract, context, include, include.combine, raw);
+	if (include.combine) return decodeCombineIncludePayload(contract, context, include, include.combine, raw, bindings);
 	const rawChildren = parseIncludedRows(include, raw);
 	const polyInfo = resolvePolymorphismInfo(contract, include.relatedNamespaceId, include.relatedModelName);
-	const mapChildRow = polyInfo ? (childRow) => mapPolymorphicRow(contract, include.relatedNamespaceId, include.relatedModelName, polyInfo, childRow, include.nested.variantName) : (childRow) => mapStorageRowToModelFields(contract, include.relatedNamespaceId, include.relatedModelName, childRow);
+	const mapChildRow = polyInfo ? (childRow) => mapPolymorphicRow(contract, include.relatedNamespaceId, include.relatedModelName, polyInfo, childRow, include.nested.variantName) : createStorageRowMapper(contract, include.relatedNamespaceId, include.relatedModelName);
+	let columns = bindings.get(include);
+	if (!columns) {
+		columns = /* @__PURE__ */ new Map();
+		bindings.set(include, columns);
+	}
 	const mappedChildren = [];
 	for (const childRow of rawChildren) {
-		const decodedChildRow = await decodeIncludedStorageRow(contract, context, include, childRow);
+		const decodedChildRow = decodeIncludedStorageRow(contract, context, include, childRow, columns);
 		const mapped = mapChildRow(decodedChildRow);
-		for (const nestedInclude of include.nested.includes) mapped[nestedInclude.relationName] = await decodeIncludePayload(contract, context, nestedInclude, decodedChildRow[nestedInclude.relationName]);
+		for (const nestedInclude of include.nested.includes) mapped[nestedInclude.relationName] = await decodeIncludePayload(contract, context, nestedInclude, decodedChildRow[nestedInclude.relationName], bindings);
 		mappedChildren.push(mapped);
 	}
 	return coerceSingleQueryIncludeResult(mappedChildren, include.cardinality);
 }
-async function decodeIncludedStorageRow(contract, context, include, row) {
+function decodeIncludedStorageRow(contract, context, include, row, bindings) {
 	const decoded = {};
 	for (const [key, value] of Object.entries(row)) {
 		if (value === null || value === void 0) {
 			decoded[key] = value;
 			continue;
 		}
-		const ref = resolveIncludedColumnRef(contract, include, key);
-		if (!ref) {
-			decoded[key] = value;
-			continue;
+		let binding = bindings.get(key);
+		if (binding === void 0) {
+			binding = resolveIncludedColumnBinding(contract, context, include, key);
+			bindings.set(key, binding);
 		}
-		const codec = context.contractCodecs.forColumn(include.relatedNamespaceId, ref.table, ref.column);
-		if (!codec) {
-			decoded[key] = value;
-			continue;
-		}
-		decoded[key] = await decodeIncludedColumnValue(ref, context.codecDescriptors.codecRefForColumn(include.relatedNamespaceId, ref.table, ref.column)?.codecId ?? ref.storageColumn.codecId, codec, value);
+		decoded[key] = binding ? decodeIncludedColumnValue(binding.ref, binding.codecId, binding.codec, value) : value;
 	}
 	return decoded;
 }
+function resolveIncludedColumnBinding(contract, context, include, key) {
+	const ref = resolveIncludedColumnRef(contract, include, key);
+	if (!ref) return null;
+	const codec = context.contractCodecs.forColumn(include.relatedNamespaceId, ref.table, ref.column);
+	if (!codec) return null;
+	return {
+		ref,
+		codec,
+		codecId: context.codecDescriptors.codecRefForColumn(include.relatedNamespaceId, ref.table, ref.column)?.codecId ?? ref.storageColumn.codecId
+	};
+}
 function resolveIncludedColumnRef(contract, include, key) {
 	const baseColumn = resolveStorageColumn(contract, include.relatedNamespaceId, include.relatedTableName, key);
 	if (baseColumn) return {
@@ -2115,7 +2134,7 @@ function resolveIncludedColumnRef(contract, include, key) {
 function resolveStorageColumn(contract, namespaceId, tableName, columnName) {
 	return contract.storage.namespaces[namespaceId]?.entries.table?.[tableName]?.columns[columnName];
 }
-async function decodeIncludedColumnValue(ref, codecId, codec, value) {
+function decodeIncludedColumnValue(ref, codecId, codec, value) {
 	if (ref.storageColumn.many === true) {
 		if (!Array.isArray(value)) wrapIncludedDecodeFailure(/* @__PURE__ */ new TypeError(`expected an array from the driver for many-typed column, got ${typeof value}`), ref, codecId);
 		const decoded = [];
@@ -2169,7 +2188,7 @@ function wrapIncludedDecodeFailure(error, ref, codecId) {
 * bug — `parseCombineEnvelope` throws loudly rather than papering over
 * it with an empty shape.
 */
-async function decodeCombineIncludePayload(contract, context, include, branches, raw) {
+async function decodeCombineIncludePayload(contract, context, include, branches, raw, bindings) {
 	const parsed = parseCombineEnvelope(include, raw);
 	const result = {};
 	for (const [branchName, branch] of Object.entries(branches)) {
@@ -2179,7 +2198,7 @@ async function decodeCombineIncludePayload(contract, context, include, branches,
 			nested: branch.state,
 			scalar: void 0,
 			combine: void 0
-		}, branchRaw);
+		}, branchRaw, bindings);
 		else result[branchName] = decodeScalarIncludePayload(contract, context, include, branch.selector, branchRaw);
 	}
 	return result;