@prisma/orm-family-sql 8.0.0-rc.11-dev.12 → 8.0.0-rc.11-dev.13

package/dist/orm-client.mjs

@@ -2038,7 +2038,7 @@ function createPreparedRowsConsumer(options) {
 			raw,
 			mapped: mapRow(raw)
 		}));
-		for (const parent of parents) for (const include of includes) parent.mapped[include.alias] = await include.consume(parent.raw[include.alias]);
+		for (const parent of parents) for (const include of includes) parent.mapped[include.alias] = include.consume(parent.raw[include.alias]);
 		for (const parent of parents) yield castRow(parent.mapped);
 	})());
 }
@@ -2061,10 +2061,10 @@ function createPreparedIncludeConsumer(context, include) {
 		}));
 		return {
 			alias,
-			consume: async (raw) => {
+			consume: (raw) => {
 				const parsed = parseCombineEnvelope(include, raw);
 				const result = {};
-				for (const branch of branches) result[branch.name] = await branch.consume(parsed[branch.name]);
+				for (const branch of branches) result[branch.name] = branch.consume(parsed[branch.name]);
 				return result;
 			}
 		};
@@ -2080,14 +2080,62 @@ function createPreparedIncludeConsumer(context, include) {
 	const bindingFor = (key) => bindings().get(key)?.() ?? null;
 	const nested = include.nested.includes.map((child) => createPreparedIncludeConsumer(context, child));
 	const toOne = isToOneCardinality(include.cardinality);
+	const fused = deferResolution(() => createPreparedIncludedRowDecoder(contract, include, bindingFor));
 	return {
 		alias,
-		consume: (raw) => consumeRowInclude(parseIncludedRows(include, raw), mapRow, bindingFor, nested, toOne)
+		consume: (raw) => {
+			const rows = parseIncludedRows(include, raw);
+			if (rows.length === 0) return toOne ? null : [];
+			const decoder = fused();
+			if (!decoder || !rows.every(decoder.matches)) return consumeRowInclude(rows, mapRow, bindingFor, nested, toOne);
+			const mapped = rows.map((row) => {
+				const result = decoder.decode(row);
+				for (const child of nested) result[child.alias] = child.consume(row[child.alias]);
+				return result;
+			});
+			return toOne ? mapped[0] ?? null : mapped;
+		}
+	};
+}
+function createPreparedIncludedRowDecoder(contract, include, bindingFor) {
+	const namespace = include.relatedNamespaceId;
+	const model = include.relatedModelName;
+	if (resolvePolymorphismInfo(contract, namespace, model)) return void 0;
+	const fieldToColumn = getFieldToColumnMap(contract, namespace, model);
+	const columnToField = getColumnToFieldMap(contract, namespace, model);
+	const columns = (include.nested.selectedFields ?? Object.keys(fieldToColumn)).map((field) => Object.hasOwn(fieldToColumn, field) ? fieldToColumn[field] ?? field : field);
+	const aliases = include.nested.includes.map((child) => child.relationName);
+	const table = contract.storage.namespaces[namespace]?.entries.table?.[include.relatedTableName];
+	if (aliases.some((alias) => table?.columns[alias] !== void 0)) return void 0;
+	const keys = [...columns, ...aliases];
+	if (keys.includes("__proto__") || new Set(keys).size !== keys.length) return void 0;
+	const operations = keys.map((key) => {
+		const binding = deferResolution(() => bindingFor(key));
+		return {
+			key,
+			field: Object.hasOwn(columnToField, key) ? columnToField[key] ?? key : key,
+			decode(value) {
+				if (value === null || value === void 0) return value;
+				const resolved = binding();
+				return resolved ? decodeIncludedColumnValue(resolved.ref, resolved.codecId, resolved.codec, value) : value;
+			}
+		};
+	});
+	return {
+		matches(row) {
+			const actual = Object.keys(row);
+			return actual.length === keys.length && actual.every((key, index) => key === keys[index]);
+		},
+		decode(row) {
+			const result = {};
+			for (const operation of operations) result[operation.field] = operation.decode(row[operation.key]);
+			return result;
+		}
 	};
 }
 function createPreparedScalarConsumer(context, include, scalar) {
 	const metadata = deferResolution(() => resolveScalarIncludeMetadata(context.contract, context, include, scalar));
-	return async (raw) => {
+	return (raw) => {
 		const { resolved, codec } = metadata();
 		return consumeScalarInclude(include, resolved, codec, raw);
 	};
@@ -2135,7 +2183,7 @@ function consumeIncludeRows(context, state, namespaceId, modelName, rows) {
 			};
 		});
 		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 parent of parentRows) for (const include of state.includes) parent.mapped[include.relationName] = decodeIncludePayload(contract, context, include, parent.raw[include.relationName], bindings);
 		for (const row of parentRows) yield blindCast(row.mapped);
 	};
 	return new AsyncIterableResult(generator());
@@ -2218,8 +2266,8 @@ 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, bindings) {
-	if (include.scalar) return Promise.resolve(decodeScalarIncludePayload(contract, context, include, include.scalar, raw));
+function decodeIncludePayload(contract, context, include, raw, bindings) {
+	if (include.scalar) return decodeScalarIncludePayload(contract, context, include, include.scalar, 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);
@@ -2242,12 +2290,12 @@ async function decodeIncludePayload(contract, context, include, raw, bindings) {
 		consume: (value) => decodeIncludePayload(contract, context, nested, value, bindings)
 	})), isToOneCardinality(include.cardinality));
 }
-async function consumeRowInclude(rawChildren, mapChildRow, bindingFor, nested, toOne) {
+function consumeRowInclude(rawChildren, mapChildRow, bindingFor, nested, toOne) {
 	const mappedChildren = [];
 	for (const childRow of rawChildren) {
 		const decodedChildRow = decodeIncludedStorageRow(childRow, bindingFor);
 		const mapped = mapChildRow(decodedChildRow);
-		for (const child of nested) mapped[child.alias] = await child.consume(decodedChildRow[child.alias]);
+		for (const child of nested) mapped[child.alias] = child.consume(decodedChildRow[child.alias]);
 		mappedChildren.push(mapped);
 	}
 	return toOne ? mappedChildren[0] ?? null : mappedChildren;
@@ -2353,12 +2401,12 @@ 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, bindings) {
+function decodeCombineIncludePayload(contract, context, include, branches, raw, bindings) {
 	const parsed = parseCombineEnvelope(include, raw);
 	const result = {};
 	for (const [branchName, branch] of Object.entries(branches)) {
 		const branchRaw = parsed[branchName];
-		if (branch.kind === "rows") result[branchName] = await decodeIncludePayload(contract, context, {
+		if (branch.kind === "rows") result[branchName] = decodeIncludePayload(contract, context, {
 			...include,
 			nested: branch.state,
 			scalar: void 0,