@vantreeseba/drizzle-graphql 15.1.5 → 15.1.6

package/README.md

@@ -1375,7 +1375,10 @@ can count or summarise related rows without fetching them:
 All parents in a selection are aggregated with a single
 `SELECT <fk>, … WHERE <fk> IN (…) GROUP BY <fk>` per request, so `postsAggregate` on a list of
 users is one extra query, not one per user. Differently-aliased selections with different
-`where` arguments are batched separately.
+`where` arguments are batched separately. A batch whose parent keys would bind more than
+10,000 parameters (10,000 parents on a single-column key, 5,000 on a two-column one) is split
+into several such queries, which keeps it within SQLite's 32,766- and Postgres/MySQL's
+65,535-parameter limits; the batched relation fields split the same way.
 
 ## Distinct
 
@@ -1604,8 +1607,9 @@ mutation {
     out the rest of the row. Listing an unsupplied column in `update` is an error rather than
     a silent no-op
 -   That holds per row: a batch whose rows supply different columns is split into one
-    statement per run of consecutive rows that write the same columns, run in one transaction,
-    so a row that left a column out keeps it. The rows come back in the order they were sent
+    statement per run of consecutive rows that write the same columns, run in one transaction
+    (on a synchronous SQLite driver such as better-sqlite3 too), so a row that left a column out
+    keeps it. The rows come back in the order they were sent
 -   `target` must match one of the table's unique constraints exactly; anything else is
     rejected with the list of valid targets, instead of the database's opaque "no unique or
     exclusion constraint matching" error
@@ -2486,7 +2490,15 @@ Generated schemas resolve nested relations without N+1 query explosions:
     `ROW_NUMBER() OVER (PARTITION BY …)` window function — still one query, not one per
     parent. A relation joined on several columns (`from: [a, b], to: [x, y]`) is batched,
     grouped and partitioned by all of them, matching the parents with
-    `(a = … AND b = …) OR …` instead of `IN (…)`.
+    `(a = … AND b = …) OR …` instead of `IN (…)`, nested as a balanced tree so a batch of
+    thousands of parents stays within SQLite's expression-depth limit. A batch over 10,000 key
+    parameters runs as several queries, each parent read whole by one of them. The parent's join values are bound as the
+    column holds them, not in their GraphQL output form, so a relation joined on a timestamp,
+    `date`, `bigint` or decimal column works on this path and in `<relation>Aggregate` too. A
+    parent row this library remapped keeps its original values for that; a parent your own
+    resolver built in GraphQL form (an ISO string for a timestamp, say) has them mapped back the
+    way an input value would be, which cuts a `'string'`-mode microsecond timestamp to
+    milliseconds — return the row as drizzle read it to keep the full precision.
 
     ```Typescript
     // entities.fieldResolvers is keyed by table name, then relation name

package/dist/index.cjs

@@ -1259,6 +1259,39 @@ const remapToGraphQLCore = (key, value, tableName, column, relationMap) => {
 	}
 	return value;
 };
+/**
+* Where a remapped row keeps the values its columns held before remapping, by property name —
+* only for the columns remapping changed. The output form is not always reversible: a
+* microsecond timestamp read in `'string'` mode leaves as an ISO string the `DateTime` input
+* side would cut to milliseconds. A relation field correlating on the row's join columns reads
+* them from here (see `parentJoinValues`). Non-enumerable, so the row's own keys, JSON form and
+* equality are unchanged.
+*/
+const RAW_COLUMN_VALUES = Symbol("drizzle-graphql.rawColumnValues");
+/**
+* The value column `key` held in `row` before remapping: `{ found: true, value }` when remapping
+* changed it, `{ found: false }` when it did not (or the row was never remapped), in which case
+* `row[key]` is still the column's own value.
+*/
+const rawColumnValue = (row, key) => {
+	const raw = row[RAW_COLUMN_VALUES];
+	return raw && key in raw ? {
+		found: true,
+		value: raw[key]
+	} : { found: false };
+};
+const keepRawColumnValue = (row, key, value) => {
+	let raw = row[RAW_COLUMN_VALUES];
+	if (!raw) {
+		raw = Object.create(null);
+		Object.defineProperty(row, RAW_COLUMN_VALUES, {
+			value: raw,
+			enumerable: false,
+			configurable: true
+		});
+	}
+	if (!(key in raw)) raw[key] = value;
+};
 const remapToGraphQLSingleOutput = (queryOutput, tableName, table, relationMap) => {
 	const columns = (0, drizzle_orm.getColumns)(table);
 	for (const [key, value] of Object.entries(queryOutput)) {
@@ -1276,7 +1309,9 @@ const remapToGraphQLSingleOutput = (queryOutput, tableName, table, relationMap)
 			delete queryOutput[key];
 			continue;
 		}
-		queryOutput[key] = remapToGraphQLCore(key, value, tableName, column, relationMap);
+		const remapped = remapToGraphQLCore(key, value, tableName, column, relationMap);
+		if (column && remapped !== value) keepRawColumnValue(queryOutput, key, value);
+		queryOutput[key] = remapped;
 	}
 	return queryOutput;
 };
@@ -1855,17 +1890,104 @@ const extractRelationJoinColumnPairs = (relEntry, parentTable, targetTable) => {
 	}
 	return pairs;
 };
+/** A decimal written as text, in a form `canonicalDecimal` can normalise. */
+const DECIMAL_TEXT = /^([+-]?)(\d*)(?:\.(\d*))?$/;
+/**
+* Decimal text without the zeros that do not change its value: `1.500` and `01.5` are both
+* `1.5`, as SQL compares them. Anything else (an exponent, `NaN`) is returned unchanged.
+*/
+const canonicalDecimal = (value) => {
+	const match = DECIMAL_TEXT.exec(value);
+	if (!match || !match[2] && !match[3]) return value;
+	const whole = match[2].replace(/^0+(?=\d)/, "") || "0";
+	const fraction = (match[3] ?? "").replace(/0+$/, "");
+	const digits = fraction ? `${whole}.${fraction}` : whole;
+	return match[1] === "-" && digits !== "0" ? `-${digits}` : digits;
+};
+/** An ISO instant without trailing zeros in its fraction: `…:00.100Z` and `…:00.1Z` agree. */
+const trimIsoFraction = (iso) => iso.replace(/(\.\d*?)0+Z$/, "$1Z").replace(/\.Z$/, "Z");
+/**
+* One join value in a form both sides of a relation produce for the same SQL value. The parent's
+* key and a related row's can arrive in different JS forms — a `Date` and the text of the same
+* instant, `1.50` and `1.500` from decimals of different scale — and `String()` would tell them
+* apart (it even drops a `Date`'s milliseconds).
+*/
+const joinValueKey = (value, column) => {
+	if (value instanceof Date) {
+		if (Number.isNaN(value.getTime())) return String(value);
+		if (column && isDateOnlyColumn(column)) return dateToCalendarDate(value) ?? value.toISOString();
+		return trimIsoFraction(value.toISOString());
+	}
+	if (typeof value === "bigint") return value.toString();
+	if (value instanceof Uint8Array) return Buffer.from(value.buffer, value.byteOffset, value.byteLength).toString("hex");
+	if (typeof value === "string" && column) {
+		if (isMySqlDateTimeStringColumn(column)) return trimIsoFraction(mySqlDateTimeTextToIso(value));
+		if (isPgTimestampStringColumn(column)) return trimIsoFraction(pgTimestampTextToIso(value));
+		if ((column.dataType ?? "") === "string numeric") return canonicalDecimal(value);
+	}
+	return String(value);
+};
 /**
 * 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.
+* parent. `columns` are the columns the values were read from, in the same order: the parent's
+* join columns for a parent key, the target's (or the junction's) for a related row. Values the
+* database compares equal give the same key — see {@link joinValueKey}.
+*/
+const joinKeyOf = (values, columns) => values.length === 1 ? joinValueKey(values[0], columns?.[0]) : JSON.stringify(values.map((value, i) => joinValueKey(value, columns?.[i])));
+/**
+* The parent row's values for the relation's join columns, as the database holds them. The row
+* a relation field resolves under has been remapped to its GraphQL form — a `Date` is an ISO
+* string by then, a `bigint` a decimal string — which can neither be bound back through every
+* column's encoder (SQLite's integer timestamp calls `getTime()` on it) nor be compared with the
+* related rows' decoded values. The values from before remapping are used when the row kept
+* them; otherwise the output form is mapped back the way an input value would be.
+*/
+const parentJoinValues = (parent, pairs) => pairs.map(({ localColPropName, localCol }) => {
+	const raw = rawColumnValue(parent, localColPropName);
+	if (raw.found) return raw.value;
+	const value = parent[localColPropName];
+	if (value == null) return value;
+	try {
+		return remapFromGraphQLCore(value, localCol, localColPropName);
+	} catch {
+		return value;
+	}
+});
+/**
+* At most this many bound parameters for the parent keys of one batched relation query. SQLite
+* accepts 32,766 per statement, Postgres and MySQL 65,535; the rest is left to the request's own
+* filters. A batch with more parents runs as several queries.
+*/
+const MAX_PARENT_KEY_PARAMS = 1e4;
+/**
+* The parent keys of one batch split into the groups each query reads, so that no query binds
+* more than {@link MAX_PARENT_KEY_PARAMS} key values. Every parent lands in exactly one group, so
+* a per-parent result — its rows, its window, its count — is the same whichever query made it.
 */
-const joinKeyOf = (values) => values.length === 1 ? String(values[0]) : JSON.stringify(values.map((value) => String(value)));
+const parentKeyChunks = (keys, width) => {
+	const size = Math.max(1, Math.floor(MAX_PARENT_KEY_PARAMS / Math.max(1, width)));
+	const chunks = [];
+	for (let i = 0; i < keys.length; i += size) chunks.push(keys.slice(i, i + size));
+	return chunks;
+};
+/**
+* `or` over `conditions` as a balanced tree. A flat `a OR b OR c …` is parsed left-deep, and
+* SQLite refuses an expression more than 1,000 levels deep; balanced, a batch of thousands of
+* parents stays a few levels deep.
+*/
+const balancedOr = (conditions) => {
+	if (conditions.length <= 2) return (0, drizzle_orm.or)(...conditions);
+	const middle = Math.ceil(conditions.length / 2);
+	return (0, drizzle_orm.or)(balancedOr(conditions.slice(0, middle)), balancedOr(conditions.slice(middle)));
+};
 /**
 * 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.
+* every dialect accepts, unlike a row-value `IN` list. The `OR` is nested as a balanced tree.
+* Callers split a large batch with {@link parentKeyChunks} first, which keeps either form within
+* the dialects' parameter limits.
 */
-const parentKeyCondition = (cols, keys) => cols.length === 1 ? (0, drizzle_orm.inArray)(cols[0], keys.map((key) => key[0])) : (0, drizzle_orm.or)(...keys.map((key) => (0, drizzle_orm.and)(...cols.map((col, i) => (0, drizzle_orm.eq)(col, key[i])))));
+const parentKeyCondition = (cols, keys) => cols.length === 1 ? (0, drizzle_orm.inArray)(cols[0], keys.map((key) => key[0])) : balancedOr(keys.map((key) => (0, drizzle_orm.and)(...cols.map((col, i) => (0, drizzle_orm.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
@@ -4961,7 +5083,7 @@ const createRelationResolverFactory = (db, tables, nullOrdering, filterCtx, limi
 	if (!parentTable || !targetTable) return;
 	const joinPairs = extractRelationJoinColumnPairs(relEntry, parentTable, targetTable);
 	if (!joinPairs) return;
-	const localColPropNames = joinPairs.map((pair) => pair.localColPropName);
+	const localCols = joinPairs.map((pair) => pair.localCol);
 	const foreignCol = joinPairs[0].foreignCol;
 	const junction = extractJunctionColumns(relEntry);
 	const groupCols = junction ? [junction.sourceCol] : joinPairs.map((pair) => pair.foreignCol);
@@ -5007,7 +5129,7 @@ const createRelationResolverFactory = (db, tables, nullOrdering, filterCtx, limi
 	};
 	const resolve = async (parent, args, context, info) => {
 		if (parent[relationName] !== void 0) return parent[relationName];
-		const localValues = localColPropNames.map((name) => parent[name]);
+		const localValues = parentJoinValues(parent, joinPairs);
 		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}`, () => {
@@ -5051,55 +5173,60 @@ 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 (parentKeys) => {
 			const executor = resolveExecutor(db, context);
-			const uniqueKeys = [...new Map(parentKeys.map((key) => [joinKeyOf(key), key])).values()];
+			const uniqueKeys = [...new Map(parentKeys.map((key) => [joinKeyOf(key, localCols), key])).values()];
 			const scope = resolveScope(policies, context, filterCtx);
-			let whereCondition = withScope(scope, targetTableName, targetTable, (0, drizzle_orm.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,
-					table: targetTable,
-					tableName: targetTableName,
-					distinct,
-					pkNames: targetPkNames,
-					where: whereCondition,
-					orderBy: orderByArg,
-					partitionBy: groupCols,
-					junction: junction ? {
-						table: junction.table,
-						on: (0, drizzle_orm.eq)(junction.targetCol, foreignCol),
-						parentKey: junction.sourceCol
-					} : void 0
-				});
-				if (!keys.length) return parentKeys.map(() => isOne ? null : []);
-				whereCondition = (0, drizzle_orm.and)(whereCondition, junction ? (0, drizzle_orm.or)(...keys.map((key) => (0, drizzle_orm.and)((0, drizzle_orm.eq)(junction.sourceCol, key[DISTINCT_PARENT]), primaryKeyRestriction(targetTable, targetPkNames, [key])))) : primaryKeyRestriction(targetTable, targetPkNames, keys));
-			}
-			const selection = junction ? {
-				...columns ?? (0, drizzle_orm.getColumns)(targetTable),
-				[PARENT_KEY]: junction.sourceCol
-			} : columns;
-			let rows;
-			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) : [];
-				if (orderExprs.length) q = q.orderBy(...orderExprs);
-				rows = await q;
-			}
-			if (cursorEntries) attachRowCursors(rows, cursorEntries);
-			const keyOf = (row) => {
-				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]));
+			const loadChunk = async (chunkKeys) => {
+				let whereCondition = withScope(scope, targetTableName, targetTable, (0, drizzle_orm.and)(parentKeyCondition(groupCols, chunkKeys), 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,
+						table: targetTable,
+						tableName: targetTableName,
+						distinct,
+						pkNames: targetPkNames,
+						where: whereCondition,
+						orderBy: orderByArg,
+						partitionBy: groupCols,
+						junction: junction ? {
+							table: junction.table,
+							on: (0, drizzle_orm.eq)(junction.targetCol, foreignCol),
+							parentKey: junction.sourceCol
+						} : void 0
+					});
+					if (!keys.length) return /* @__PURE__ */ new Map();
+					whereCondition = (0, drizzle_orm.and)(whereCondition, junction ? (0, drizzle_orm.or)(...keys.map((key) => (0, drizzle_orm.and)((0, drizzle_orm.eq)(junction.sourceCol, key[DISTINCT_PARENT]), primaryKeyRestriction(targetTable, targetPkNames, [key])))) : primaryKeyRestriction(targetTable, targetPkNames, keys));
+				}
+				const selection = junction ? {
+					...columns ?? (0, drizzle_orm.getColumns)(targetTable),
+					[PARENT_KEY]: junction.sourceCol
+				} : columns;
+				let rows;
+				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) : [];
+					if (orderExprs.length) q = q.orderBy(...orderExprs);
+					rows = await q;
+				}
+				if (cursorEntries) attachRowCursors(rows, cursorEntries);
+				const keyOf = (row) => {
+					const key = joinKeyOf(groupKeys.map((name) => row[name]), groupCols);
+					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 byKey;
+				}
+				const grouped = new Map(chunkKeys.map((key) => [joinKeyOf(key, localCols), []]));
+				for (const row of rows) grouped.get(keyOf(row))?.push(row);
 				remapToGraphQLArrayOutput(rows, targetTableName, targetTable);
-				return parentKeys.map((key) => byKey.get(joinKeyOf(key)) ?? null);
-			}
-			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 parentKeys.map((key) => grouped.get(joinKeyOf(key)) ?? []);
+				return grouped;
+			};
+			const results = /* @__PURE__ */ new Map();
+			for (const chunk of parentKeyChunks(uniqueKeys, groupCols.length)) for (const [key, value] of await loadChunk(chunk)) results.set(key, value);
+			return parentKeys.map((key) => results.get(joinKeyOf(key, localCols)) ?? (isOne ? null : []));
 		}).load(localValues);
 	};
 	return async (parent, args, context, info) => {
@@ -6185,7 +6312,7 @@ const createRelationAggregateFactory = (db, tables, cacheCtx, typeNameMapper, fi
 			}
 			return;
 		}
-		const localColPropNames = joinPairs.map((pair) => pair.localColPropName);
+		const localCols = joinPairs.map((pair) => pair.localCol);
 		const foreignCol = joinPairs[0].foreignCol;
 		const junction = extractJunctionColumns(relEntry);
 		if (junction === null) return;
@@ -6215,23 +6342,26 @@ const createRelationAggregateFactory = (db, tables, cacheCtx, typeNameMapper, fi
 					};
 				});
 				if (!Object.keys(request.selection).length) return {};
-				const localValues = localColPropNames.map((name) => parent[name]);
+				const localValues = parentJoinValues(parent, joinPairs);
 				if (localValues.some((value) => value == null)) return assembleAggregateRow({}, request, target);
 				const whereArg = args?.where;
 				const deleted = args?.deleted;
 				const loader = getOrCreateLoader(context, loaderKey, async (parentKeys) => {
 					const executor = resolveExecutor(db, context);
-					const uniqueKeys = [...new Map(parentKeys.map((key) => [joinKeyOf(key), key])).values()];
+					const uniqueKeys = [...new Map(parentKeys.map((key) => [joinKeyOf(key, localCols), key])).values()];
 					const scope = resolveScope(policies, context, filterCtx);
-					const whereCondition = withScope(scope, targetTableName, targetTable, (0, drizzle_orm.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({
-						...groupSelection,
-						...request.selection
-					}).from(targetTable);
-					const rows = await (junction ? selected.innerJoin(junction.table, (0, drizzle_orm.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)) ?? {});
+					const byKey = /* @__PURE__ */ new Map();
+					for (const chunk of parentKeyChunks(uniqueKeys, groupCols.length)) {
+						const whereCondition = withScope(scope, targetTableName, targetTable, (0, drizzle_orm.and)(parentKeyCondition(groupCols, chunk), ownCondition, whereArg ? extractFilters(targetTable, targetTableName, whereArg, relationFilterCtx(filterCtx, targetTableName, scope)) : void 0), deleted ?? defaultDeleted);
+						const selected = executor.select({
+							...groupSelection,
+							...request.selection
+						}).from(targetTable);
+						const rows = await (junction ? selected.innerJoin(junction.table, (0, drizzle_orm.eq)(junction.targetCol, foreignCol)) : selected).where(whereCondition).groupBy(...groupCols);
+						for (const row of rows) byKey.set(joinKeyOf(groupAliases.map((alias) => row[alias]), groupCols), row);
+					}
+					return parentKeys.map((key) => byKey.get(joinKeyOf(key, localCols)) ?? {});
 				});
 				return assembleAggregateRow(await loader.load(localValues), request, target);
 			} catch (e) {
@@ -8318,7 +8448,7 @@ const buildWriteResolvers = (primaryKeyPropNames) => {
 						serverOwned: Object.keys(contextColumns ?? {}),
 						buildWhere: (where) => extractFilters(table, tableName, where, relationFilterCtx(filterCtx, tableName, scope))
 					});
-					const runBatch = async (executor, { values: rows, plan }) => {
+					const batchQuery = (executor, { values: rows, plan }) => {
 						let query = executor.insert(table).values(rows).returning(returning);
 						const setWhere = withScope(scope, tableName, table, plan.setWhere);
 						query = plan.action === "NOTHING" ? query.onConflictDoNothing(plan.target ? {
@@ -8330,12 +8460,22 @@ const buildWriteResolvers = (primaryKeyPropNames) => {
 							set: plan.set,
 							setWhere
 						});
-						return await query;
+						return query;
 					};
-					if (batches.length === 1) return runBatch(target, batches[0]);
-					return target.transaction(async (tx) => {
-						const rows = [];
-						for (const batch of batches) rows.push(...await runBatch(tx, batch));
+					if (batches.length === 1) return await batchQuery(target, batches[0]);
+					return target.transaction((tx) => {
+						const execute = (batch) => {
+							const query = batchQuery(tx, batch);
+							return typeof query.all === "function" ? query.all() : query;
+						};
+						const first = execute(batches[0]);
+						if (typeof first?.then === "function") return (async () => {
+							const rows = [...await first];
+							for (const batch of batches.slice(1)) rows.push(...await execute(batch));
+							return rows;
+						})();
+						const rows = [...first];
+						for (const batch of batches.slice(1)) rows.push(...execute(batch));
 						return rows;
 					});
 				};