@vantreeseba/drizzle-graphql 5.3.0 → 5.5.0

package/dist/index.cjs

@@ -598,6 +598,203 @@ var resolveQueryExecutor = (db, context, tableName, buildTimeQueryBase) => {
     queryBase: buildTimeQueryBase ? executor?.query?.[tableName] ?? buildTimeQueryBase : buildTimeQueryBase
   };
 };
+var createMutationTxCtx = (options) => options ? { timeoutMs: options.timeoutMs, fieldNames: /* @__PURE__ */ new Set(), states: /* @__PURE__ */ new WeakMap() } : void 0;
+var includedByDirectives = (node, variables) => {
+  for (const directive of node.directives ?? []) {
+    const name = directive.name.value;
+    if (name !== "skip" && name !== "include") {
+      continue;
+    }
+    const ifArg = directive.arguments?.find((arg) => arg.name.value === "if");
+    let value;
+    if (ifArg?.value.kind === "BooleanValue") {
+      value = ifArg.value.value;
+    } else if (ifArg?.value.kind === "Variable") {
+      value = variables?.[ifArg.value.name.value];
+    }
+    if (name === "skip" && value === true) {
+      return false;
+    }
+    if (name === "include" && value !== true) {
+      return false;
+    }
+  }
+  return true;
+};
+var collectRootMutationKeys = (selectionSet, fragments, variables, known, keys, visitedFragments) => {
+  for (const selection of selectionSet.selections) {
+    if (!includedByDirectives(selection, variables)) {
+      continue;
+    }
+    if (selection.kind === "Field") {
+      const name = selection.name.value;
+      if (name === "__typename") {
+        continue;
+      }
+      if (!known.has(name)) {
+        return false;
+      }
+      keys.add(selection.alias?.value ?? name);
+    } else if (selection.kind === "InlineFragment") {
+      if (!collectRootMutationKeys(selection.selectionSet, fragments, variables, known, keys, visitedFragments)) {
+        return false;
+      }
+    } else if (selection.kind === "FragmentSpread") {
+      const fragmentName = selection.name.value;
+      if (visitedFragments.has(fragmentName)) {
+        continue;
+      }
+      visitedFragments.add(fragmentName);
+      const fragment = fragments?.[fragmentName];
+      if (!fragment) {
+        return false;
+      }
+      if (!collectRootMutationKeys(fragment.selectionSet, fragments, variables, known, keys, visitedFragments)) {
+        return false;
+      }
+    }
+  }
+  return true;
+};
+var abortedBatchError = () => new import_graphql4.GraphQLError(
+  "Drizzle-GraphQL Error: Mutation was not executed because an earlier mutation in the same request failed and the shared transaction was rolled back."
+);
+var openSharedTx = (db, context, txCtx, stateKey, expected) => {
+  let release;
+  let rejectLatch;
+  const latch = new Promise((resolve, reject) => {
+    release = resolve;
+    rejectLatch = reject;
+  });
+  let readyResolve;
+  let readyReject;
+  const ready = new Promise((resolve, reject) => {
+    readyResolve = resolve;
+    readyReject = reject;
+  });
+  ready.catch(() => {
+  });
+  const canStash = context !== null && typeof context === "object" && !Object.isFrozen(context);
+  const settled = db.transaction(async (tx) => {
+    if (canStash) {
+      context[drizzleExecutorKey] = tx;
+    }
+    readyResolve(tx);
+    await latch;
+  });
+  let timer;
+  const clearTimer = () => {
+    if (timer !== void 0) {
+      clearTimeout(timer);
+      timer = void 0;
+    }
+  };
+  const state = {
+    kind: "shared",
+    expected,
+    completed: 0,
+    failure: void 0,
+    aborted: false,
+    done: false,
+    ready,
+    settled,
+    release,
+    abort: (e) => {
+      if (!state.aborted) {
+        state.aborted = true;
+        state.failure = e;
+      }
+      rejectLatch(e);
+    },
+    suspendTimer: clearTimer,
+    bumpTimer: () => {
+      clearTimer();
+      if (state.done) {
+        return;
+      }
+      timer = setTimeout(() => {
+        state.abort(
+          new import_graphql4.GraphQLError(
+            `Drizzle-GraphQL Error: Shared mutation transaction timed out after ${txCtx.timeoutMs}ms waiting for the remaining mutation fields; rolling back.`
+          )
+        );
+      }, txCtx.timeoutMs);
+      timer.unref?.();
+    }
+  };
+  const cleanup = () => {
+    state.done = true;
+    clearTimer();
+    if (canStash) {
+      delete context[drizzleExecutorKey];
+    }
+    if (!state.aborted) {
+      txCtx.states.delete(stateKey);
+    }
+  };
+  settled.then(cleanup, (e) => {
+    cleanup();
+    readyReject(e);
+  });
+  state.bumpTimer();
+  return state;
+};
+var runOnSharedTx = async (state, body) => {
+  if (state.aborted) {
+    await state.settled.catch(() => {
+    });
+    throw abortedBatchError();
+  }
+  state.suspendTimer();
+  const tx = await state.ready;
+  try {
+    if (state.aborted) {
+      throw abortedBatchError();
+    }
+    const result = await body(tx);
+    state.completed += 1;
+    if (state.completed >= state.expected) {
+      state.release();
+      await state.settled;
+    } else {
+      state.bumpTimer();
+    }
+    return result;
+  } catch (e) {
+    state.abort(e);
+    await state.settled.catch(() => {
+    });
+    throw e;
+  }
+};
+var runMutation = async (db, context, info, txCtx, body) => {
+  const contextIsObject = context !== null && (typeof context === "object" || typeof context === "function");
+  const stateKey = contextIsObject ? context : info.operation;
+  let state = txCtx?.states.get(stateKey);
+  if (!state) {
+    if (contextIsObject && context[drizzleExecutorKey]) {
+      return body(context[drizzleExecutorKey]);
+    }
+    if (!txCtx || info.operation.operation !== "mutation") {
+      return body(db);
+    }
+    const keys = /* @__PURE__ */ new Set();
+    const allKnown = collectRootMutationKeys(
+      info.operation.selectionSet,
+      info.fragments,
+      info.variableValues,
+      txCtx.fieldNames,
+      keys,
+      /* @__PURE__ */ new Set()
+    );
+    state = !allKnown || keys.size <= 1 ? { kind: "passthrough" } : openSharedTx(db, context, txCtx, stateKey, keys.size);
+    txCtx.states.set(stateKey, state);
+  }
+  if (state.kind === "passthrough") {
+    return body(resolveExecutor(db, context));
+  }
+  return runOnSharedTx(state, body);
+};
 var batchedPaginatedRelationQuery = async (db, targetTable, foreignCol, whereCondition, orderByArg, limit, offset, pkNames, orderCtx) => {
   const cols = (0, import_drizzle_orm3.getColumns)(targetTable);
   const orderExprs = [
@@ -2244,6 +2441,7 @@ var computeResolverFieldNames = (tableName, typeNameMapper, prefixes, suffixes)
   const upsertArrayFieldName = `${upsertPrefix}${mapped ? capitalize(mapped.plural) : capitalize(tableName)}`;
   const upsertSingleFieldName = mapped ? `${upsertPrefix}${capitalize(mapped.singular)}` : `${upsertPrefix}${capitalize(tableName)}${suffixes.single}`;
   const updateFieldName = `${prefixes.update}${mapped ? capitalize(mapped.singular) : capitalize(tableName)}`;
+  const updateManyFieldName = `${prefixes.update}${mapped ? capitalize(mapped.plural) : capitalize(tableName)}Many`;
   const deleteFieldName = `${prefixes.delete}${mapped ? capitalize(mapped.singular) : capitalize(tableName)}`;
   const writeSingleSuffix = suffixes.single === "" ? "Single" : suffixes.single;
   const updateSingleFieldName = `${updateFieldName}${writeSingleSuffix}`;
@@ -2259,11 +2457,28 @@ var computeResolverFieldNames = (tableName, typeNameMapper, prefixes, suffixes)
     upsertArrayFieldName,
     upsertSingleFieldName,
     updateFieldName,
+    updateManyFieldName,
     updateSingleFieldName,
     deleteFieldName,
     deleteSingleFieldName
   };
 };
+var generateUpdateManyInput = (params) => {
+  const { typeName, updatePrefix, updateInput, tableFilters } = params;
+  return new import_graphql4.GraphQLInputObjectType({
+    name: `${capitalize(updatePrefix)}${typeName}ManyInput`,
+    description: `One entry of a batch update of ${typeName}: the rows \`where\` matches get this entry's \`set\` applied.`,
+    fields: {
+      where: {
+        type: tableFilters,
+        description: "Rows this entry updates. An omitted filter updates every row."
+      },
+      set: {
+        type: new import_graphql4.GraphQLNonNull(updateInput)
+      }
+    }
+  });
+};
 var extractRequiredFilters = (table, tableName, where, fieldName, relationCtx) => {
   const filters = where ? extractFilters(table, tableName, where, relationCtx) : void 0;
   if (!filters) {
@@ -2991,7 +3206,7 @@ var generateSelectSingle = (db, tableName, tables, relationMap, orderArgs, filte
     args: queryArgs
   };
 };
-var generateInsertArray = (db, _tableName, table, baseType, fieldName) => {
+var generateInsertArray = (db, _tableName, table, baseType, fieldName, txCtx) => {
   const queryArgs = {
     values: {
       type: new import_graphql6.GraphQLNonNull(new import_graphql6.GraphQLList(new import_graphql6.GraphQLNonNull(baseType)))
@@ -2999,14 +3214,16 @@ var generateInsertArray = (db, _tableName, table, baseType, fieldName) => {
   };
   return {
     name: fieldName,
-    resolver: async (_source, args, context, _info) => {
+    resolver: async (_source, args, context, info) => {
       try {
-        const input = remapFromGraphQLArrayInput(args.values, table);
-        if (!input.length) {
-          throw new import_graphql6.GraphQLError("No values were provided!");
-        }
-        await resolveExecutor(db, context).insert(table).values(input);
-        return { isSuccess: true };
+        return await runMutation(db, context, info, txCtx, async (executor) => {
+          const input = remapFromGraphQLArrayInput(args.values, table);
+          if (!input.length) {
+            throw new import_graphql6.GraphQLError("No values were provided!");
+          }
+          await executor.insert(table).values(input);
+          return { isSuccess: true };
+        });
       } catch (e) {
         throw toGraphQLError(e);
       }
@@ -3014,7 +3231,7 @@ var generateInsertArray = (db, _tableName, table, baseType, fieldName) => {
     args: queryArgs
   };
 };
-var generateInsertSingle = (db, _tableName, table, baseType, fieldName) => {
+var generateInsertSingle = (db, _tableName, table, baseType, fieldName, txCtx) => {
   const queryArgs = {
     values: {
       type: new import_graphql6.GraphQLNonNull(baseType)
@@ -3022,11 +3239,13 @@ var generateInsertSingle = (db, _tableName, table, baseType, fieldName) => {
   };
   return {
     name: fieldName,
-    resolver: async (_source, args, context, _info) => {
+    resolver: async (_source, args, context, info) => {
       try {
-        const input = remapFromGraphQLSingleInput(args.values, table);
-        await resolveExecutor(db, context).insert(table).values(input);
-        return { isSuccess: true };
+        return await runMutation(db, context, info, txCtx, async (executor) => {
+          const input = remapFromGraphQLSingleInput(args.values, table);
+          await executor.insert(table).values(input);
+          return { isSuccess: true };
+        });
       } catch (e) {
         throw toGraphQLError(e);
       }
@@ -3034,7 +3253,7 @@ var generateInsertSingle = (db, _tableName, table, baseType, fieldName) => {
     args: queryArgs
   };
 };
-var generateUpsert = (db, table, baseType, onConflictType, fieldName, single) => {
+var generateUpsert = (db, table, baseType, onConflictType, fieldName, single, txCtx) => {
   const queryArgs = {
     values: {
       type: single ? new import_graphql6.GraphQLNonNull(baseType) : new import_graphql6.GraphQLNonNull(new import_graphql6.GraphQLList(new import_graphql6.GraphQLNonNull(baseType)))
@@ -3047,28 +3266,29 @@ var generateUpsert = (db, table, baseType, onConflictType, fieldName, single) =>
   const pkNames = mysqlPrimaryKeyPropNames(table);
   return {
     name: fieldName,
-    resolver: async (_source, args, context, _info) => {
+    resolver: async (_source, args, context, info) => {
       try {
-        const input = single ? [remapFromGraphQLSingleInput(args.values, table)] : remapFromGraphQLArrayInput(args.values, table);
-        if (!input.length) {
-          throw new import_graphql6.GraphQLError("No values were provided!");
-        }
-        const plan = resolveConflictPlan({
-          table,
-          values: input,
-          onConflict: args.onConflict,
-          pkNames,
-          uniqueSets: [],
-          excludedRef: mysqlValuesColumnRef,
-          withTarget: false
+        return await runMutation(db, context, info, txCtx, async (executor) => {
+          const input = single ? [remapFromGraphQLSingleInput(args.values, table)] : remapFromGraphQLArrayInput(args.values, table);
+          if (!input.length) {
+            throw new import_graphql6.GraphQLError("No values were provided!");
+          }
+          const plan = resolveConflictPlan({
+            table,
+            values: input,
+            onConflict: args.onConflict,
+            pkNames,
+            uniqueSets: [],
+            excludedRef: mysqlValuesColumnRef,
+            withTarget: false
+          });
+          if (plan.action === "NOTHING") {
+            await executor.insert(table).ignore().values(input);
+          } else {
+            await executor.insert(table).values(input).onDuplicateKeyUpdate({ set: plan.set });
+          }
+          return { isSuccess: true };
         });
-        const executor = resolveExecutor(db, context);
-        if (plan.action === "NOTHING") {
-          await executor.insert(table).ignore().values(input);
-        } else {
-          await executor.insert(table).values(input).onDuplicateKeyUpdate({ set: plan.set });
-        }
-        return { isSuccess: true };
       } catch (e) {
         throw toGraphQLError(e);
       }
@@ -3076,7 +3296,7 @@ var generateUpsert = (db, table, baseType, onConflictType, fieldName, single) =>
     args: queryArgs
   };
 };
-var generateUpdate = (db, tableName, table, setArgs, filterArgs, fieldName, single, requireWhere, filterCtx) => {
+var generateUpdate = (db, tableName, table, setArgs, filterArgs, fieldName, single, requireWhere, filterCtx, txCtx) => {
   const queryArgs = {
     set: {
       type: new import_graphql6.GraphQLNonNull(setArgs)
@@ -3087,25 +3307,69 @@ var generateUpdate = (db, tableName, table, setArgs, filterArgs, fieldName, sing
   };
   return {
     name: fieldName,
-    resolver: async (_source, args, context, _info) => {
+    resolver: async (_source, args, context, info) => {
       try {
-        const { where, set } = args;
-        const input = remapFromGraphQLSingleInput(set, table);
-        if (!Object.keys(input).length) {
-          throw new import_graphql6.GraphQLError("Unable to update with no values specified!");
-        }
-        const relationCtx = relationFilterCtx(filterCtx, tableName);
-        const filters = single || requireWhere ? extractRequiredFilters(table, tableName, where, fieldName, relationCtx) : where ? extractFilters(table, tableName, where, relationCtx) : void 0;
-        const executor = resolveExecutor(db, context);
-        if (single) {
-          await assertSingleMatch(executor, table, filters, fieldName);
-        }
-        let query = executor.update(table).set(input);
-        if (filters) {
-          query = query.where(filters);
-        }
-        await query;
-        return { isSuccess: true };
+        return await runMutation(db, context, info, txCtx, async (executor) => {
+          const { where, set } = args;
+          const input = remapFromGraphQLSingleInput(set, table);
+          if (!Object.keys(input).length) {
+            throw new import_graphql6.GraphQLError("Unable to update with no values specified!");
+          }
+          const relationCtx = relationFilterCtx(filterCtx, tableName);
+          const filters = single || requireWhere ? extractRequiredFilters(table, tableName, where, fieldName, relationCtx) : where ? extractFilters(table, tableName, where, relationCtx) : void 0;
+          if (single) {
+            await assertSingleMatch(executor, table, filters, fieldName);
+          }
+          let query = executor.update(table).set(input);
+          if (filters) {
+            query = query.where(filters);
+          }
+          await query;
+          return { isSuccess: true };
+        });
+      } catch (e) {
+        throw toGraphQLError(e);
+      }
+    },
+    args: queryArgs
+  };
+};
+var generateUpdateMany = (db, tableName, table, updateManyInput, fieldName, filterCtx, txCtx) => {
+  const queryArgs = {
+    updates: {
+      type: new import_graphql6.GraphQLNonNull(new import_graphql6.GraphQLList(new import_graphql6.GraphQLNonNull(updateManyInput)))
+    }
+  };
+  return {
+    name: fieldName,
+    resolver: async (_source, args, context, info) => {
+      try {
+        return await runMutation(db, context, info, txCtx, async (executor) => {
+          const { updates } = args;
+          if (!updates.length) {
+            throw new import_graphql6.GraphQLError("No updates were provided!");
+          }
+          const entries = updates.map(({ where, set }) => {
+            const input = remapFromGraphQLSingleInput(set, table);
+            if (!Object.keys(input).length) {
+              throw new import_graphql6.GraphQLError("Unable to update with no values specified!");
+            }
+            return {
+              set: input,
+              filters: where ? extractFilters(table, tableName, where, relationFilterCtx(filterCtx, tableName)) : void 0
+            };
+          });
+          await executor.transaction(async (tx) => {
+            for (const entry of entries) {
+              let query = tx.update(table).set(entry.set);
+              if (entry.filters) {
+                query = query.where(entry.filters);
+              }
+              await query;
+            }
+          });
+          return { isSuccess: true };
+        });
       } catch (e) {
         throw toGraphQLError(e);
       }
@@ -3113,7 +3377,7 @@ var generateUpdate = (db, tableName, table, setArgs, filterArgs, fieldName, sing
     args: queryArgs
   };
 };
-var generateDelete = (db, tableName, table, filterArgs, fieldName, single, requireWhere, filterCtx) => {
+var generateDelete = (db, tableName, table, filterArgs, fieldName, single, requireWhere, filterCtx, txCtx) => {
   const queryArgs = {
     where: {
       type: single || requireWhere ? new import_graphql6.GraphQLNonNull(filterArgs) : filterArgs
@@ -3121,21 +3385,22 @@ var generateDelete = (db, tableName, table, filterArgs, fieldName, single, requi
   };
   return {
     name: fieldName,
-    resolver: async (_source, args, context, _info) => {
+    resolver: async (_source, args, context, info) => {
       try {
-        const { where } = args;
-        const relationCtx = relationFilterCtx(filterCtx, tableName);
-        const filters = single || requireWhere ? extractRequiredFilters(table, tableName, where, fieldName, relationCtx) : where ? extractFilters(table, tableName, where, relationCtx) : void 0;
-        const executor = resolveExecutor(db, context);
-        if (single) {
-          await assertSingleMatch(executor, table, filters, fieldName);
-        }
-        let query = executor.delete(table);
-        if (filters) {
-          query = query.where(filters);
-        }
-        await query;
-        return { isSuccess: true };
+        return await runMutation(db, context, info, txCtx, async (executor) => {
+          const { where } = args;
+          const relationCtx = relationFilterCtx(filterCtx, tableName);
+          const filters = single || requireWhere ? extractRequiredFilters(table, tableName, where, fieldName, relationCtx) : where ? extractFilters(table, tableName, where, relationCtx) : void 0;
+          if (single) {
+            await assertSingleMatch(executor, table, filters, fieldName);
+          }
+          let query = executor.delete(table);
+          if (filters) {
+            query = query.where(filters);
+          }
+          await query;
+          return { isSuccess: true };
+        });
       } catch (e) {
         throw toGraphQLError(e);
       }
@@ -3175,6 +3440,7 @@ var generateSchemaData = (db, schema, relations, options) => {
   const relationAggregateFactory = features.relationAggregates ? createRelationAggregateFactory(db, tables, cacheCtx, typeNameMapper, filterCtx) : void 0;
   const queries = {};
   const mutations = {};
+  const mutationTxCtx = createMutationTxCtx(options.transactions);
   const gqlSchemaTypes = Object.fromEntries(
     Object.entries(tables).map(([tableName, _table]) => [
       tableName,
@@ -3220,6 +3486,7 @@ var generateSchemaData = (db, schema, relations, options) => {
       upsertArrayFieldName,
       upsertSingleFieldName,
       updateFieldName,
+      updateManyFieldName,
       updateSingleFieldName,
       deleteFieldName,
       deleteSingleFieldName
@@ -3249,8 +3516,22 @@ var generateSchemaData = (db, schema, relations, options) => {
       typeNameMapper,
       filterCtx
     );
-    const insertArrGenerated = features.insert ? generateInsertArray(db, tableName, schema[tableName], insertInput, createArrayFieldName) : void 0;
-    const insertSingleGenerated = features.insert ? generateInsertSingle(db, tableName, schema[tableName], insertInput, createSingleFieldName) : void 0;
+    const insertArrGenerated = features.insert ? generateInsertArray(
+      db,
+      tableName,
+      schema[tableName],
+      insertInput,
+      createArrayFieldName,
+      mutationTxCtx
+    ) : void 0;
+    const insertSingleGenerated = features.insert ? generateInsertSingle(
+      db,
+      tableName,
+      schema[tableName],
+      insertInput,
+      createSingleFieldName,
+      mutationTxCtx
+    ) : void 0;
     const onConflictInput = features.upsert ? generateOnConflictInput({
       table: schema[tableName],
       typeName,
@@ -3258,8 +3539,24 @@ var generateSchemaData = (db, schema, relations, options) => {
       tableFilters,
       withTarget: false
     }) : void 0;
-    const upsertArrGenerated = onConflictInput ? generateUpsert(db, schema[tableName], insertInput, onConflictInput, upsertArrayFieldName, false) : void 0;
-    const upsertSingleGenerated = onConflictInput ? generateUpsert(db, schema[tableName], insertInput, onConflictInput, upsertSingleFieldName, true) : void 0;
+    const upsertArrGenerated = onConflictInput ? generateUpsert(
+      db,
+      schema[tableName],
+      insertInput,
+      onConflictInput,
+      upsertArrayFieldName,
+      false,
+      mutationTxCtx
+    ) : void 0;
+    const upsertSingleGenerated = onConflictInput ? generateUpsert(
+      db,
+      schema[tableName],
+      insertInput,
+      onConflictInput,
+      upsertSingleFieldName,
+      true,
+      mutationTxCtx
+    ) : void 0;
     const updateGenerated = features.update ? generateUpdate(
       db,
       tableName,
@@ -3269,7 +3566,8 @@ var generateSchemaData = (db, schema, relations, options) => {
       updateFieldName,
       false,
       features.requireWhere,
-      filterCtx
+      filterCtx,
+      mutationTxCtx
     ) : void 0;
     const updateSingleGenerated = features.update ? generateUpdate(
       db,
@@ -3280,7 +3578,18 @@ var generateSchemaData = (db, schema, relations, options) => {
       updateSingleFieldName,
       true,
       features.requireWhere,
-      filterCtx
+      filterCtx,
+      mutationTxCtx
+    ) : void 0;
+    const updateManyInput = features.update && features.updateMany ? generateUpdateManyInput({ typeName, updatePrefix: prefixes.update, updateInput, tableFilters }) : void 0;
+    const updateManyGenerated = updateManyInput ? generateUpdateMany(
+      db,
+      tableName,
+      schema[tableName],
+      updateManyInput,
+      updateManyFieldName,
+      filterCtx,
+      mutationTxCtx
     ) : void 0;
     const deleteGenerated = features.delete ? generateDelete(
       db,
@@ -3290,7 +3599,8 @@ var generateSchemaData = (db, schema, relations, options) => {
       deleteFieldName,
       false,
       features.requireWhere,
-      filterCtx
+      filterCtx,
+      mutationTxCtx
     ) : void 0;
     const deleteSingleGenerated = features.delete ? generateDelete(
       db,
@@ -3300,7 +3610,8 @@ var generateSchemaData = (db, schema, relations, options) => {
       deleteSingleFieldName,
       true,
       features.requireWhere,
-      filterCtx
+      filterCtx,
+      mutationTxCtx
     ) : void 0;
     const aggregateType = features.aggregates ? generateAggregateTypes(schema[tableName], tableName, typeName, cacheCtx) : void 0;
     const aggregateGenerated = features.aggregates ? generateAggregate(
@@ -3359,6 +3670,7 @@ var generateSchemaData = (db, schema, relations, options) => {
       upsertArrGenerated,
       upsertSingleGenerated,
       updateGenerated,
+      updateManyGenerated,
       updateSingleGenerated,
       deleteGenerated,
       deleteSingleGenerated
@@ -3376,6 +3688,7 @@ var generateSchemaData = (db, schema, relations, options) => {
       ...features.insert || onConflictInput ? [insertInput] : [],
       ...onConflictInput ? [onConflictInput] : [],
       ...features.update ? [updateInput] : [],
+      ...updateManyInput ? [updateManyInput] : [],
       tableFilters,
       tableOrder
     ];
@@ -3391,6 +3704,11 @@ var generateSchemaData = (db, schema, relations, options) => {
       inputs[havingInput.name] = havingInput;
     }
   }
+  if (mutationTxCtx) {
+    for (const name of Object.keys(mutations)) {
+      mutationTxCtx.fieldNames.add(name);
+    }
+  }
   const fieldResolvers = {};
   for (const [tableName, tableRelations] of Object.entries(namedRelations)) {
     const relResolvers = {};
@@ -3594,7 +3912,7 @@ var generateSelectSingle2 = (db, tableName, tables, relationMap, orderArgs, filt
   };
 };
 var pgPrimaryKeyPropNames = (table) => getPrimaryKeyPropNamesFromConfig(table, import_pg_core2.getTableConfig);
-var generateInsertArray2 = (db, tableName, table, tables, relationMap, baseType, fieldName, typeName, typeNameMapper, conflictDoNothing = false) => {
+var generateInsertArray2 = (db, tableName, table, tables, relationMap, baseType, fieldName, typeName, typeNameMapper, conflictDoNothing = false, txCtx) => {
   const queryArgs = {
     values: {
       type: new import_graphql7.GraphQLNonNull(new import_graphql7.GraphQLList(new import_graphql7.GraphQLNonNull(baseType)))
@@ -3605,31 +3923,32 @@ var generateInsertArray2 = (db, tableName, table, tables, relationMap, baseType,
     name: fieldName,
     resolver: async (_source, args, context, info) => {
       try {
-        const input = remapFromGraphQLArrayInput(args.values, table);
-        if (!input.length) {
-          throw new import_graphql7.GraphQLError("No values were provided!");
-        }
-        const parsedInfo = (0, import_graphql_parse_resolve_info3.parseResolveInfo)(info, {
-          deep: true
-        });
-        const { columns, hasRelations, withParams } = prepareMutationRelationColumns({
-          relationMap,
-          tables,
-          tableName,
-          typeName,
-          typeNameMapper,
-          table,
-          pkNames,
-          parsedInfo
+        return await runMutation(db, context, info, txCtx, async (executor) => {
+          const input = remapFromGraphQLArrayInput(args.values, table);
+          if (!input.length) {
+            throw new import_graphql7.GraphQLError("No values were provided!");
+          }
+          const parsedInfo = (0, import_graphql_parse_resolve_info3.parseResolveInfo)(info, {
+            deep: true
+          });
+          const { columns, hasRelations, withParams } = prepareMutationRelationColumns({
+            relationMap,
+            tables,
+            tableName,
+            typeName,
+            typeNameMapper,
+            table,
+            pkNames,
+            parsedInfo
+          });
+          let query = executor.insert(table).values(input).returning(columns);
+          if (conflictDoNothing) {
+            query = query.onConflictDoNothing();
+          }
+          const result = await query;
+          const enriched = hasRelations ? await eagerLoadMutationRelations(executor, tableName, result, pkNames, withParams) : result;
+          return remapToGraphQLArrayOutput(enriched, tableName, table, relationMap);
         });
-        const executor = resolveExecutor(db, context);
-        let query = executor.insert(table).values(input).returning(columns);
-        if (conflictDoNothing) {
-          query = query.onConflictDoNothing();
-        }
-        const result = await query;
-        const enriched = hasRelations ? await eagerLoadMutationRelations(executor, tableName, result, pkNames, withParams) : result;
-        return remapToGraphQLArrayOutput(enriched, tableName, table, relationMap);
       } catch (e) {
         throw toGraphQLError(e);
       }
@@ -3637,7 +3956,7 @@ var generateInsertArray2 = (db, tableName, table, tables, relationMap, baseType,
     args: queryArgs
   };
 };
-var generateInsertSingle2 = (db, tableName, table, tables, relationMap, baseType, fieldName, typeName, typeNameMapper, conflictDoNothing = false) => {
+var generateInsertSingle2 = (db, tableName, table, tables, relationMap, baseType, fieldName, typeName, typeNameMapper, conflictDoNothing = false, txCtx) => {
   const queryArgs = {
     values: {
       type: new import_graphql7.GraphQLNonNull(baseType)
@@ -3648,31 +3967,32 @@ var generateInsertSingle2 = (db, tableName, table, tables, relationMap, baseType
     name: fieldName,
     resolver: async (_source, args, context, info) => {
       try {
-        const input = remapFromGraphQLSingleInput(args.values, table);
-        const parsedInfo = (0, import_graphql_parse_resolve_info3.parseResolveInfo)(info, {
-          deep: true
-        });
-        const { columns, hasRelations, withParams } = prepareMutationRelationColumns({
-          relationMap,
-          tables,
-          tableName,
-          typeName,
-          typeNameMapper,
-          table,
-          pkNames,
-          parsedInfo
+        return await runMutation(db, context, info, txCtx, async (executor) => {
+          const input = remapFromGraphQLSingleInput(args.values, table);
+          const parsedInfo = (0, import_graphql_parse_resolve_info3.parseResolveInfo)(info, {
+            deep: true
+          });
+          const { columns, hasRelations, withParams } = prepareMutationRelationColumns({
+            relationMap,
+            tables,
+            tableName,
+            typeName,
+            typeNameMapper,
+            table,
+            pkNames,
+            parsedInfo
+          });
+          let query = executor.insert(table).values(input).returning(columns);
+          if (conflictDoNothing) {
+            query = query.onConflictDoNothing();
+          }
+          const result = await query;
+          if (!result[0]) {
+            return void 0;
+          }
+          const enriched = hasRelations ? await eagerLoadMutationRelations(executor, tableName, result, pkNames, withParams) : result;
+          return remapToGraphQLSingleOutput(enriched[0], tableName, table, relationMap);
         });
-        const executor = resolveExecutor(db, context);
-        let query = executor.insert(table).values(input).returning(columns);
-        if (conflictDoNothing) {
-          query = query.onConflictDoNothing();
-        }
-        const result = await query;
-        if (!result[0]) {
-          return void 0;
-        }
-        const enriched = hasRelations ? await eagerLoadMutationRelations(executor, tableName, result, pkNames, withParams) : result;
-        return remapToGraphQLSingleOutput(enriched[0], tableName, table, relationMap);
       } catch (e) {
         throw toGraphQLError(e);
       }
@@ -3680,7 +4000,7 @@ var generateInsertSingle2 = (db, tableName, table, tables, relationMap, baseType
     args: queryArgs
   };
 };
-var generateUpsert2 = (db, tableName, table, tables, relationMap, baseType, onConflictType, uniqueSets, fieldName, typeName, single, typeNameMapper, filterCtx) => {
+var generateUpsert2 = (db, tableName, table, tables, relationMap, baseType, onConflictType, uniqueSets, fieldName, typeName, single, typeNameMapper, filterCtx, txCtx) => {
   const queryArgs = {
     values: {
       type: single ? new import_graphql7.GraphQLNonNull(baseType) : new import_graphql7.GraphQLNonNull(new import_graphql7.GraphQLList(new import_graphql7.GraphQLNonNull(baseType)))
@@ -3695,40 +4015,41 @@ var generateUpsert2 = (db, tableName, table, tables, relationMap, baseType, onCo
     name: fieldName,
     resolver: async (_source, args, context, info) => {
       try {
-        const input = single ? [remapFromGraphQLSingleInput(args.values, table)] : remapFromGraphQLArrayInput(args.values, table);
-        if (!input.length) {
-          throw new import_graphql7.GraphQLError("No values were provided!");
-        }
-        const parsedInfo = (0, import_graphql_parse_resolve_info3.parseResolveInfo)(info, { deep: true });
-        const { columns, hasRelations, withParams } = prepareMutationRelationColumns({
-          relationMap,
-          tables,
-          tableName,
-          typeName,
-          typeNameMapper,
-          table,
-          pkNames,
-          parsedInfo
-        });
-        const plan = resolveConflictPlan({
-          table,
-          values: input,
-          onConflict: args.onConflict,
-          pkNames,
-          uniqueSets,
-          excludedRef: excludedColumnRef,
-          withTarget: true,
-          buildWhere: (where) => extractFilters(table, tableName, where, relationFilterCtx(filterCtx, tableName))
+        return await runMutation(db, context, info, txCtx, async (executor) => {
+          const input = single ? [remapFromGraphQLSingleInput(args.values, table)] : remapFromGraphQLArrayInput(args.values, table);
+          if (!input.length) {
+            throw new import_graphql7.GraphQLError("No values were provided!");
+          }
+          const parsedInfo = (0, import_graphql_parse_resolve_info3.parseResolveInfo)(info, { deep: true });
+          const { columns, hasRelations, withParams } = prepareMutationRelationColumns({
+            relationMap,
+            tables,
+            tableName,
+            typeName,
+            typeNameMapper,
+            table,
+            pkNames,
+            parsedInfo
+          });
+          const plan = resolveConflictPlan({
+            table,
+            values: input,
+            onConflict: args.onConflict,
+            pkNames,
+            uniqueSets,
+            excludedRef: excludedColumnRef,
+            withTarget: true,
+            buildWhere: (where) => extractFilters(table, tableName, where, relationFilterCtx(filterCtx, tableName))
+          });
+          let query = executor.insert(table).values(input).returning(columns);
+          query = plan.action === "NOTHING" ? query.onConflictDoNothing(plan.target ? { target: plan.target } : void 0) : query.onConflictDoUpdate({ target: plan.target, set: plan.set, setWhere: plan.setWhere });
+          const result = await query;
+          if (single && !result[0]) {
+            return void 0;
+          }
+          const enriched = hasRelations ? await eagerLoadMutationRelations(executor, tableName, result, pkNames, withParams) : result;
+          return single ? remapToGraphQLSingleOutput(enriched[0], tableName, table, relationMap) : remapToGraphQLArrayOutput(enriched, tableName, table, relationMap);
         });
-        const executor = resolveExecutor(db, context);
-        let query = executor.insert(table).values(input).returning(columns);
-        query = plan.action === "NOTHING" ? query.onConflictDoNothing(plan.target ? { target: plan.target } : void 0) : query.onConflictDoUpdate({ target: plan.target, set: plan.set, setWhere: plan.setWhere });
-        const result = await query;
-        if (single && !result[0]) {
-          return void 0;
-        }
-        const enriched = hasRelations ? await eagerLoadMutationRelations(executor, tableName, result, pkNames, withParams) : result;
-        return single ? remapToGraphQLSingleOutput(enriched[0], tableName, table, relationMap) : remapToGraphQLArrayOutput(enriched, tableName, table, relationMap);
       } catch (e) {
         throw toGraphQLError(e);
       }
@@ -3736,7 +4057,7 @@ var generateUpsert2 = (db, tableName, table, tables, relationMap, baseType, onCo
     args: queryArgs
   };
 };
-var generateUpdate2 = (db, tableName, table, tables, relationMap, setArgs, filterArgs, fieldName, typeName, single, requireWhere, typeNameMapper, filterCtx) => {
+var generateUpdate2 = (db, tableName, table, tables, relationMap, setArgs, filterArgs, fieldName, typeName, single, requireWhere, typeNameMapper, filterCtx, txCtx) => {
   const queryArgs = {
     set: {
       type: new import_graphql7.GraphQLNonNull(setArgs)
@@ -3750,44 +4071,118 @@ var generateUpdate2 = (db, tableName, table, tables, relationMap, setArgs, filte
     name: fieldName,
     resolver: async (_source, args, context, info) => {
       try {
-        const { where, set } = args;
-        const parsedInfo = (0, import_graphql_parse_resolve_info3.parseResolveInfo)(info, {
-          deep: true
+        return await runMutation(db, context, info, txCtx, async (executor) => {
+          const { where, set } = args;
+          const parsedInfo = (0, import_graphql_parse_resolve_info3.parseResolveInfo)(info, {
+            deep: true
+          });
+          const { columns, hasRelations, withParams } = prepareMutationRelationColumns({
+            relationMap,
+            tables,
+            tableName,
+            typeName,
+            typeNameMapper,
+            table,
+            pkNames,
+            parsedInfo
+          });
+          const input = remapFromGraphQLSingleInput(set, table);
+          if (!Object.keys(input).length) {
+            throw new import_graphql7.GraphQLError("Unable to update with no values specified!");
+          }
+          const relationCtx = relationFilterCtx(filterCtx, tableName);
+          const filters = single || requireWhere ? extractRequiredFilters(table, tableName, where, fieldName, relationCtx) : where ? extractFilters(table, tableName, where, relationCtx) : void 0;
+          if (single) {
+            await assertSingleMatch(executor, table, filters, fieldName);
+          }
+          let query = executor.update(table).set(input);
+          if (filters) {
+            query = query.where(filters);
+          }
+          query = query.returning(columns);
+          const result = await query;
+          if (single && result.length > 1) {
+            throw new import_graphql7.GraphQLError(`${fieldName}: 'where' matched more than one row!`);
+          }
+          if (single && !result[0]) {
+            return void 0;
+          }
+          const enriched = hasRelations ? await eagerLoadMutationRelations(executor, tableName, result, pkNames, withParams) : result;
+          return single ? remapToGraphQLSingleOutput(enriched[0], tableName, table, relationMap) : remapToGraphQLArrayOutput(enriched, tableName, table, relationMap);
         });
-        const { columns, hasRelations, withParams } = prepareMutationRelationColumns({
-          relationMap,
-          tables,
-          tableName,
-          typeName,
-          typeNameMapper,
-          table,
-          pkNames,
-          parsedInfo
+      } catch (e) {
+        throw toGraphQLError(e);
+      }
+    },
+    args: queryArgs
+  };
+};
+var generateUpdateMany2 = (db, tableName, table, tables, relationMap, updateManyInput, fieldName, typeName, typeNameMapper, filterCtx, txCtx) => {
+  const queryArgs = {
+    updates: {
+      type: new import_graphql7.GraphQLNonNull(new import_graphql7.GraphQLList(new import_graphql7.GraphQLNonNull(updateManyInput)))
+    }
+  };
+  const pkNames = pgPrimaryKeyPropNames(table);
+  return {
+    name: fieldName,
+    resolver: async (_source, args, context, info) => {
+      try {
+        return await runMutation(db, context, info, txCtx, async (executor) => {
+          const { updates } = args;
+          if (!updates.length) {
+            throw new import_graphql7.GraphQLError("No updates were provided!");
+          }
+          const parsedInfo = (0, import_graphql_parse_resolve_info3.parseResolveInfo)(info, {
+            deep: true
+          });
+          const { columns, hasRelations, withParams } = prepareMutationRelationColumns({
+            relationMap,
+            tables,
+            tableName,
+            typeName,
+            typeNameMapper,
+            table,
+            pkNames,
+            parsedInfo
+          });
+          const entries = updates.map(({ where, set }) => {
+            const input = remapFromGraphQLSingleInput(set, table);
+            if (!Object.keys(input).length) {
+              throw new import_graphql7.GraphQLError("Unable to update with no values specified!");
+            }
+            return {
+              set: input,
+              filters: where ? extractFilters(table, tableName, where, relationFilterCtx(filterCtx, tableName)) : void 0
+            };
+          });
+          const perEntry = await executor.transaction(async (tx) => {
+            const results = [];
+            for (const entry of entries) {
+              let query = tx.update(table).set(entry.set);
+              if (entry.filters) {
+                query = query.where(entry.filters);
+              }
+              results.push(await query.returning(columns));
+            }
+            return results;
+          });
+          const flatRows = perEntry.flat();
+          const enriched = hasRelations ? await eagerLoadMutationRelations(executor, tableName, flatRows, pkNames, withParams) : flatRows;
+          const output = [];
+          let offset = 0;
+          for (const rows of perEntry) {
+            if (!rows.length) {
+              output.push(null);
+              continue;
+            }
+            for (let i = 0; i < rows.length; i++) {
+              output.push(remapToGraphQLSingleOutput(enriched[offset + i], tableName, table, relationMap));
+            }
+            offset += rows.length;
+          }
+          return output;
         });
-        const input = remapFromGraphQLSingleInput(set, table);
-        if (!Object.keys(input).length) {
-          throw new import_graphql7.GraphQLError("Unable to update with no values specified!");
-        }
-        const relationCtx = relationFilterCtx(filterCtx, tableName);
-        const filters = single || requireWhere ? extractRequiredFilters(table, tableName, where, fieldName, relationCtx) : where ? extractFilters(table, tableName, where, relationCtx) : void 0;
-        const executor = resolveExecutor(db, context);
-        if (single) {
-          await assertSingleMatch(executor, table, filters, fieldName);
-        }
-        let query = executor.update(table).set(input);
-        if (filters) {
-          query = query.where(filters);
-        }
-        query = query.returning(columns);
-        const result = await query;
-        if (single && result.length > 1) {
-          throw new import_graphql7.GraphQLError(`${fieldName}: 'where' matched more than one row!`);
-        }
-        if (single && !result[0]) {
-          return void 0;
-        }
-        const enriched = hasRelations ? await eagerLoadMutationRelations(executor, tableName, result, pkNames, withParams) : result;
-        return single ? remapToGraphQLSingleOutput(enriched[0], tableName, table, relationMap) : remapToGraphQLArrayOutput(enriched, tableName, table, relationMap);
       } catch (e) {
         throw toGraphQLError(e);
       }
@@ -3795,7 +4190,7 @@ var generateUpdate2 = (db, tableName, table, tables, relationMap, setArgs, filte
     args: queryArgs
   };
 };
-var generateDelete2 = (db, tableName, table, filterArgs, fieldName, typeName, single, requireWhere, filterCtx, selectionCtx) => {
+var generateDelete2 = (db, tableName, table, filterArgs, fieldName, typeName, single, requireWhere, filterCtx, selectionCtx, txCtx) => {
   const queryArgs = {
     where: {
       type: single || requireWhere ? new import_graphql7.GraphQLNonNull(filterArgs) : filterArgs
@@ -3805,34 +4200,35 @@ var generateDelete2 = (db, tableName, table, filterArgs, fieldName, typeName, si
     name: fieldName,
     resolver: async (_source, args, context, info) => {
       try {
-        const { where } = args;
-        const parsedInfo = (0, import_graphql_parse_resolve_info3.parseResolveInfo)(info, {
-          deep: true
+        return await runMutation(db, context, info, txCtx, async (executor) => {
+          const { where } = args;
+          const parsedInfo = (0, import_graphql_parse_resolve_info3.parseResolveInfo)(info, {
+            deep: true
+          });
+          const columns = extractSelectedColumnsFromTreeSQLFormat(
+            parsedInfo.fieldsByTypeName[typeName],
+            table,
+            selectionCtx
+          );
+          const relationCtx = relationFilterCtx(filterCtx, tableName);
+          const filters = single || requireWhere ? extractRequiredFilters(table, tableName, where, fieldName, relationCtx) : where ? extractFilters(table, tableName, where, relationCtx) : void 0;
+          if (single) {
+            await assertSingleMatch(executor, table, filters, fieldName);
+          }
+          let query = executor.delete(table);
+          if (filters) {
+            query = query.where(filters);
+          }
+          query = query.returning(columns);
+          const result = await query;
+          if (single && result.length > 1) {
+            throw new import_graphql7.GraphQLError(`${fieldName}: 'where' matched more than one row!`);
+          }
+          if (single) {
+            return result[0] ? remapToGraphQLSingleOutput(result[0], tableName, table) : void 0;
+          }
+          return remapToGraphQLArrayOutput(result, tableName, table);
         });
-        const columns = extractSelectedColumnsFromTreeSQLFormat(
-          parsedInfo.fieldsByTypeName[typeName],
-          table,
-          selectionCtx
-        );
-        const relationCtx = relationFilterCtx(filterCtx, tableName);
-        const filters = single || requireWhere ? extractRequiredFilters(table, tableName, where, fieldName, relationCtx) : where ? extractFilters(table, tableName, where, relationCtx) : void 0;
-        const executor = resolveExecutor(db, context);
-        if (single) {
-          await assertSingleMatch(executor, table, filters, fieldName);
-        }
-        let query = executor.delete(table);
-        if (filters) {
-          query = query.where(filters);
-        }
-        query = query.returning(columns);
-        const result = await query;
-        if (single && result.length > 1) {
-          throw new import_graphql7.GraphQLError(`${fieldName}: 'where' matched more than one row!`);
-        }
-        if (single) {
-          return result[0] ? remapToGraphQLSingleOutput(result[0], tableName, table) : void 0;
-        }
-        return remapToGraphQLArrayOutput(result, tableName, table);
       } catch (e) {
         throw toGraphQLError(e);
       }
@@ -3879,6 +4275,7 @@ function generateSchemaData2(db, schema, relations, options) {
   const relationAggregateFactory = features.relationAggregates ? createRelationAggregateFactory(db, tables, cacheCtx, typeNameMapper, filterCtx) : void 0;
   const queries = {};
   const mutations = {};
+  const mutationTxCtx = createMutationTxCtx(options.transactions);
   const gqlSchemaTypes = Object.fromEntries(
     Object.entries(tables).map(([tableName, _table]) => [
       tableName,
@@ -3913,6 +4310,7 @@ function generateSchemaData2(db, schema, relations, options) {
       upsertArrayFieldName,
       upsertSingleFieldName,
       updateFieldName,
+      updateManyFieldName,
       updateSingleFieldName,
       deleteFieldName,
       deleteSingleFieldName
@@ -3952,7 +4350,8 @@ function generateSchemaData2(db, schema, relations, options) {
       createArrayFieldName,
       typeName,
       typeNameMapper,
-      conflictDoNothing
+      conflictDoNothing,
+      mutationTxCtx
     ) : void 0;
     const insertSingleGenerated = features.insert ? generateInsertSingle2(
       db,
@@ -3964,7 +4363,8 @@ function generateSchemaData2(db, schema, relations, options) {
       createSingleFieldName,
       typeName,
       typeNameMapper,
-      conflictDoNothing
+      conflictDoNothing,
+      mutationTxCtx
     ) : void 0;
     const uniqueSets = features.upsert ? getUniqueColumnSets(schema[tableName], import_pg_core2.getTableConfig) : [];
     const onConflictInput = features.upsert ? generateOnConflictInput({
@@ -3987,7 +4387,8 @@ function generateSchemaData2(db, schema, relations, options) {
       typeName,
       false,
       typeNameMapper,
-      filterCtx
+      filterCtx,
+      mutationTxCtx
     ) : void 0;
     const upsertSingleGenerated = onConflictInput ? generateUpsert2(
       db,
@@ -4002,7 +4403,8 @@ function generateSchemaData2(db, schema, relations, options) {
       typeName,
       true,
       typeNameMapper,
-      filterCtx
+      filterCtx,
+      mutationTxCtx
     ) : void 0;
     const updateGenerated = features.update ? generateUpdate2(
       db,
@@ -4017,7 +4419,8 @@ function generateSchemaData2(db, schema, relations, options) {
       false,
       features.requireWhere,
       typeNameMapper,
-      filterCtx
+      filterCtx,
+      mutationTxCtx
     ) : void 0;
     const updateSingleGenerated = features.update ? generateUpdate2(
       db,
@@ -4032,7 +4435,22 @@ function generateSchemaData2(db, schema, relations, options) {
       true,
       features.requireWhere,
       typeNameMapper,
-      filterCtx
+      filterCtx,
+      mutationTxCtx
+    ) : void 0;
+    const updateManyInput = features.update && features.updateMany ? generateUpdateManyInput({ typeName, updatePrefix: prefixes.update, updateInput, tableFilters }) : void 0;
+    const updateManyGenerated = updateManyInput ? generateUpdateMany2(
+      db,
+      tableName,
+      schema[tableName],
+      tables,
+      eagerRelations,
+      updateManyInput,
+      updateManyFieldName,
+      typeName,
+      typeNameMapper,
+      filterCtx,
+      mutationTxCtx
     ) : void 0;
     const deleteGenerated = features.delete ? generateDelete2(
       db,
@@ -4044,7 +4462,8 @@ function generateSchemaData2(db, schema, relations, options) {
       false,
       features.requireWhere,
       filterCtx,
-      { tableName, relationMap: namedRelations, tables }
+      { tableName, relationMap: namedRelations, tables },
+      mutationTxCtx
     ) : void 0;
     const deleteSingleGenerated = features.delete ? generateDelete2(
       db,
@@ -4056,7 +4475,8 @@ function generateSchemaData2(db, schema, relations, options) {
       true,
       features.requireWhere,
       filterCtx,
-      { tableName, relationMap: namedRelations, tables }
+      { tableName, relationMap: namedRelations, tables },
+      mutationTxCtx
     ) : void 0;
     const aggregateType = features.aggregates ? generateAggregateTypes(schema[tableName], tableName, typeName, cacheCtx) : void 0;
     const aggregateGenerated = features.aggregates ? generateAggregate(
@@ -4144,6 +4564,14 @@ function generateSchemaData2(db, schema, relations, options) {
         resolve: updateGenerated.resolver
       };
     }
+    if (updateManyGenerated) {
+      mutations[updateManyGenerated.name] = {
+        // Nullable items: a no-match entry yields `null` in its slot.
+        type: new import_graphql7.GraphQLNonNull(new import_graphql7.GraphQLList(singleTableItemOutput)),
+        args: updateManyGenerated.args,
+        resolve: updateManyGenerated.resolver
+      };
+    }
     if (updateSingleGenerated) {
       mutations[updateSingleGenerated.name] = {
         type: singleTableItemOutput,
@@ -4170,6 +4598,7 @@ function generateSchemaData2(db, schema, relations, options) {
       ...features.insert || onConflictInput ? [insertInput] : [],
       ...onConflictInput ? [onConflictInput] : [],
       ...features.update ? [updateInput] : [],
+      ...updateManyInput ? [updateManyInput] : [],
       tableFilters,
       tableOrder
     ];
@@ -4186,6 +4615,11 @@ function generateSchemaData2(db, schema, relations, options) {
       inputs[havingInput.name] = havingInput;
     }
   }
+  if (mutationTxCtx) {
+    for (const name of Object.keys(mutations)) {
+      mutationTxCtx.fieldNames.add(name);
+    }
+  }
   const fieldResolvers = {};
   for (const [tableName, tableRelations] of Object.entries(namedRelations)) {
     const relResolvers = {};
@@ -4291,7 +4725,7 @@ var generateSelectSingle3 = (db, tableName, tables, relationMap, orderArgs, filt
   };
 };
 var sqlitePrimaryKeyPropNames = (table) => getPrimaryKeyPropNamesFromConfig(table, import_sqlite_core2.getTableConfig);
-var generateInsertArray3 = (db, tableName, table, tables, relationMap, baseType, fieldName, typeName, typeNameMapper, conflictDoNothing = false) => {
+var generateInsertArray3 = (db, tableName, table, tables, relationMap, baseType, fieldName, typeName, typeNameMapper, conflictDoNothing = false, txCtx) => {
   const queryArgs = {
     values: {
       type: new import_graphql8.GraphQLNonNull(new import_graphql8.GraphQLList(new import_graphql8.GraphQLNonNull(baseType)))
@@ -4302,31 +4736,32 @@ var generateInsertArray3 = (db, tableName, table, tables, relationMap, baseType,
     name: fieldName,
     resolver: async (_source, args, context, info) => {
       try {
-        const input = remapFromGraphQLArrayInput(args.values, table);
-        if (!input.length) {
-          throw new import_graphql8.GraphQLError("No values were provided!");
-        }
-        const parsedInfo = (0, import_graphql_parse_resolve_info4.parseResolveInfo)(info, {
-          deep: true
-        });
-        const { columns, hasRelations, withParams } = prepareMutationRelationColumns({
-          relationMap,
-          tables,
-          tableName,
-          typeName,
-          typeNameMapper,
-          table,
-          pkNames,
-          parsedInfo
+        return await runMutation(db, context, info, txCtx, async (executor) => {
+          const input = remapFromGraphQLArrayInput(args.values, table);
+          if (!input.length) {
+            throw new import_graphql8.GraphQLError("No values were provided!");
+          }
+          const parsedInfo = (0, import_graphql_parse_resolve_info4.parseResolveInfo)(info, {
+            deep: true
+          });
+          const { columns, hasRelations, withParams } = prepareMutationRelationColumns({
+            relationMap,
+            tables,
+            tableName,
+            typeName,
+            typeNameMapper,
+            table,
+            pkNames,
+            parsedInfo
+          });
+          let query = executor.insert(table).values(input).returning(columns);
+          if (conflictDoNothing) {
+            query = query.onConflictDoNothing();
+          }
+          const result = await query;
+          const enriched = hasRelations ? await eagerLoadMutationRelations(executor, tableName, result, pkNames, withParams) : result;
+          return remapToGraphQLArrayOutput(enriched, tableName, table, relationMap);
         });
-        const executor = resolveExecutor(db, context);
-        let query = executor.insert(table).values(input).returning(columns);
-        if (conflictDoNothing) {
-          query = query.onConflictDoNothing();
-        }
-        const result = await query;
-        const enriched = hasRelations ? await eagerLoadMutationRelations(executor, tableName, result, pkNames, withParams) : result;
-        return remapToGraphQLArrayOutput(enriched, tableName, table, relationMap);
       } catch (e) {
         throw toGraphQLError(e);
       }
@@ -4334,7 +4769,7 @@ var generateInsertArray3 = (db, tableName, table, tables, relationMap, baseType,
     args: queryArgs
   };
 };
-var generateInsertSingle3 = (db, tableName, table, tables, relationMap, baseType, fieldName, typeName, typeNameMapper, conflictDoNothing = false) => {
+var generateInsertSingle3 = (db, tableName, table, tables, relationMap, baseType, fieldName, typeName, typeNameMapper, conflictDoNothing = false, txCtx) => {
   const queryArgs = {
     values: {
       type: new import_graphql8.GraphQLNonNull(baseType)
@@ -4345,31 +4780,32 @@ var generateInsertSingle3 = (db, tableName, table, tables, relationMap, baseType
     name: fieldName,
     resolver: async (_source, args, context, info) => {
       try {
-        const input = remapFromGraphQLSingleInput(args.values, table);
-        const parsedInfo = (0, import_graphql_parse_resolve_info4.parseResolveInfo)(info, {
-          deep: true
-        });
-        const { columns, hasRelations, withParams } = prepareMutationRelationColumns({
-          relationMap,
-          tables,
-          tableName,
-          typeName,
-          typeNameMapper,
-          table,
-          pkNames,
-          parsedInfo
+        return await runMutation(db, context, info, txCtx, async (executor) => {
+          const input = remapFromGraphQLSingleInput(args.values, table);
+          const parsedInfo = (0, import_graphql_parse_resolve_info4.parseResolveInfo)(info, {
+            deep: true
+          });
+          const { columns, hasRelations, withParams } = prepareMutationRelationColumns({
+            relationMap,
+            tables,
+            tableName,
+            typeName,
+            typeNameMapper,
+            table,
+            pkNames,
+            parsedInfo
+          });
+          let query = executor.insert(table).values(input).returning(columns);
+          if (conflictDoNothing) {
+            query = query.onConflictDoNothing();
+          }
+          const result = await query;
+          if (!result[0]) {
+            return void 0;
+          }
+          const enriched = hasRelations ? await eagerLoadMutationRelations(executor, tableName, result, pkNames, withParams) : result;
+          return remapToGraphQLSingleOutput(enriched[0], tableName, table, relationMap);
         });
-        const executor = resolveExecutor(db, context);
-        let query = executor.insert(table).values(input).returning(columns);
-        if (conflictDoNothing) {
-          query = query.onConflictDoNothing();
-        }
-        const result = await query;
-        if (!result[0]) {
-          return void 0;
-        }
-        const enriched = hasRelations ? await eagerLoadMutationRelations(executor, tableName, result, pkNames, withParams) : result;
-        return remapToGraphQLSingleOutput(enriched[0], tableName, table, relationMap);
       } catch (e) {
         throw toGraphQLError(e);
       }
@@ -4377,7 +4813,7 @@ var generateInsertSingle3 = (db, tableName, table, tables, relationMap, baseType
     args: queryArgs
   };
 };
-var generateUpsert3 = (db, tableName, table, tables, relationMap, baseType, onConflictType, uniqueSets, fieldName, typeName, single, typeNameMapper, filterCtx) => {
+var generateUpsert3 = (db, tableName, table, tables, relationMap, baseType, onConflictType, uniqueSets, fieldName, typeName, single, typeNameMapper, filterCtx, txCtx) => {
   const queryArgs = {
     values: {
       type: single ? new import_graphql8.GraphQLNonNull(baseType) : new import_graphql8.GraphQLNonNull(new import_graphql8.GraphQLList(new import_graphql8.GraphQLNonNull(baseType)))
@@ -4392,40 +4828,41 @@ var generateUpsert3 = (db, tableName, table, tables, relationMap, baseType, onCo
     name: fieldName,
     resolver: async (_source, args, context, info) => {
       try {
-        const input = single ? [remapFromGraphQLSingleInput(args.values, table)] : remapFromGraphQLArrayInput(args.values, table);
-        if (!input.length) {
-          throw new import_graphql8.GraphQLError("No values were provided!");
-        }
-        const parsedInfo = (0, import_graphql_parse_resolve_info4.parseResolveInfo)(info, { deep: true });
-        const { columns, hasRelations, withParams } = prepareMutationRelationColumns({
-          relationMap,
-          tables,
-          tableName,
-          typeName,
-          typeNameMapper,
-          table,
-          pkNames,
-          parsedInfo
-        });
-        const plan = resolveConflictPlan({
-          table,
-          values: input,
-          onConflict: args.onConflict,
-          pkNames,
-          uniqueSets,
-          excludedRef: excludedColumnRef,
-          withTarget: true,
-          buildWhere: (where) => extractFilters(table, tableName, where, relationFilterCtx(filterCtx, tableName))
+        return await runMutation(db, context, info, txCtx, async (executor) => {
+          const input = single ? [remapFromGraphQLSingleInput(args.values, table)] : remapFromGraphQLArrayInput(args.values, table);
+          if (!input.length) {
+            throw new import_graphql8.GraphQLError("No values were provided!");
+          }
+          const parsedInfo = (0, import_graphql_parse_resolve_info4.parseResolveInfo)(info, { deep: true });
+          const { columns, hasRelations, withParams } = prepareMutationRelationColumns({
+            relationMap,
+            tables,
+            tableName,
+            typeName,
+            typeNameMapper,
+            table,
+            pkNames,
+            parsedInfo
+          });
+          const plan = resolveConflictPlan({
+            table,
+            values: input,
+            onConflict: args.onConflict,
+            pkNames,
+            uniqueSets,
+            excludedRef: excludedColumnRef,
+            withTarget: true,
+            buildWhere: (where) => extractFilters(table, tableName, where, relationFilterCtx(filterCtx, tableName))
+          });
+          let query = executor.insert(table).values(input).returning(columns);
+          query = plan.action === "NOTHING" ? query.onConflictDoNothing(plan.target ? { target: plan.target } : void 0) : query.onConflictDoUpdate({ target: plan.target, set: plan.set, setWhere: plan.setWhere });
+          const result = await query;
+          if (single && !result[0]) {
+            return void 0;
+          }
+          const enriched = hasRelations ? await eagerLoadMutationRelations(executor, tableName, result, pkNames, withParams) : result;
+          return single ? remapToGraphQLSingleOutput(enriched[0], tableName, table, relationMap) : remapToGraphQLArrayOutput(enriched, tableName, table, relationMap);
         });
-        const executor = resolveExecutor(db, context);
-        let query = executor.insert(table).values(input).returning(columns);
-        query = plan.action === "NOTHING" ? query.onConflictDoNothing(plan.target ? { target: plan.target } : void 0) : query.onConflictDoUpdate({ target: plan.target, set: plan.set, setWhere: plan.setWhere });
-        const result = await query;
-        if (single && !result[0]) {
-          return void 0;
-        }
-        const enriched = hasRelations ? await eagerLoadMutationRelations(executor, tableName, result, pkNames, withParams) : result;
-        return single ? remapToGraphQLSingleOutput(enriched[0], tableName, table, relationMap) : remapToGraphQLArrayOutput(enriched, tableName, table, relationMap);
       } catch (e) {
         throw toGraphQLError(e);
       }
@@ -4433,7 +4870,7 @@ var generateUpsert3 = (db, tableName, table, tables, relationMap, baseType, onCo
     args: queryArgs
   };
 };
-var generateUpdate3 = (db, tableName, table, tables, relationMap, setArgs, filterArgs, fieldName, typeName, single, requireWhere, typeNameMapper, filterCtx) => {
+var generateUpdate3 = (db, tableName, table, tables, relationMap, setArgs, filterArgs, fieldName, typeName, single, requireWhere, typeNameMapper, filterCtx, txCtx) => {
   const queryArgs = {
     set: {
       type: new import_graphql8.GraphQLNonNull(setArgs)
@@ -4447,44 +4884,131 @@ var generateUpdate3 = (db, tableName, table, tables, relationMap, setArgs, filte
     name: fieldName,
     resolver: async (_source, args, context, info) => {
       try {
-        const { where, set } = args;
-        const parsedInfo = (0, import_graphql_parse_resolve_info4.parseResolveInfo)(info, {
-          deep: true
+        return await runMutation(db, context, info, txCtx, async (executor) => {
+          const { where, set } = args;
+          const parsedInfo = (0, import_graphql_parse_resolve_info4.parseResolveInfo)(info, {
+            deep: true
+          });
+          const { columns, hasRelations, withParams } = prepareMutationRelationColumns({
+            relationMap,
+            tables,
+            tableName,
+            typeName,
+            typeNameMapper,
+            table,
+            pkNames,
+            parsedInfo
+          });
+          const input = remapFromGraphQLSingleInput(set, table);
+          if (!Object.keys(input).length) {
+            throw new import_graphql8.GraphQLError("Unable to update with no values specified!");
+          }
+          const relationCtx = relationFilterCtx(filterCtx, tableName);
+          const filters = single || requireWhere ? extractRequiredFilters(table, tableName, where, fieldName, relationCtx) : where ? extractFilters(table, tableName, where, relationCtx) : void 0;
+          if (single) {
+            await assertSingleMatch(executor, table, filters, fieldName);
+          }
+          let query = executor.update(table).set(input);
+          if (filters) {
+            query = query.where(filters);
+          }
+          query = query.returning(columns);
+          const result = await query;
+          if (single && result.length > 1) {
+            throw new import_graphql8.GraphQLError(`${fieldName}: 'where' matched more than one row!`);
+          }
+          if (single && !result[0]) {
+            return void 0;
+          }
+          const enriched = hasRelations ? await eagerLoadMutationRelations(executor, tableName, result, pkNames, withParams) : result;
+          return single ? remapToGraphQLSingleOutput(enriched[0], tableName, table, relationMap) : remapToGraphQLArrayOutput(enriched, tableName, table, relationMap);
         });
-        const { columns, hasRelations, withParams } = prepareMutationRelationColumns({
-          relationMap,
-          tables,
-          tableName,
-          typeName,
-          typeNameMapper,
-          table,
-          pkNames,
-          parsedInfo
+      } catch (e) {
+        throw toGraphQLError(e);
+      }
+    },
+    args: queryArgs
+  };
+};
+var generateUpdateMany3 = (db, tableName, table, tables, relationMap, updateManyInput, fieldName, typeName, typeNameMapper, filterCtx, txCtx) => {
+  const queryArgs = {
+    updates: {
+      type: new import_graphql8.GraphQLNonNull(new import_graphql8.GraphQLList(new import_graphql8.GraphQLNonNull(updateManyInput)))
+    }
+  };
+  const pkNames = sqlitePrimaryKeyPropNames(table);
+  return {
+    name: fieldName,
+    resolver: async (_source, args, context, info) => {
+      try {
+        return await runMutation(db, context, info, txCtx, async (executor) => {
+          const { updates } = args;
+          if (!updates.length) {
+            throw new import_graphql8.GraphQLError("No updates were provided!");
+          }
+          const parsedInfo = (0, import_graphql_parse_resolve_info4.parseResolveInfo)(info, {
+            deep: true
+          });
+          const { columns, hasRelations, withParams } = prepareMutationRelationColumns({
+            relationMap,
+            tables,
+            tableName,
+            typeName,
+            typeNameMapper,
+            table,
+            pkNames,
+            parsedInfo
+          });
+          const entries = updates.map(({ where, set }) => {
+            const input = remapFromGraphQLSingleInput(set, table);
+            if (!Object.keys(input).length) {
+              throw new import_graphql8.GraphQLError("Unable to update with no values specified!");
+            }
+            return {
+              set: input,
+              filters: where ? extractFilters(table, tableName, where, relationFilterCtx(filterCtx, tableName)) : void 0
+            };
+          });
+          const runEntry = (tx, entry) => {
+            let query = tx.update(table).set(entry.set);
+            if (entry.filters) {
+              query = query.where(entry.filters);
+            }
+            return query.returning(columns).all();
+          };
+          const perEntry = await executor.transaction((tx) => {
+            const first = runEntry(tx, entries[0]);
+            if (typeof first?.then === "function") {
+              return (async () => {
+                const results2 = [await first];
+                for (let i = 1; i < entries.length; i++) {
+                  results2.push(await runEntry(tx, entries[i]));
+                }
+                return results2;
+              })();
+            }
+            const results = [first];
+            for (let i = 1; i < entries.length; i++) {
+              results.push(runEntry(tx, entries[i]));
+            }
+            return results;
+          });
+          const flatRows = perEntry.flat();
+          const enriched = hasRelations ? await eagerLoadMutationRelations(executor, tableName, flatRows, pkNames, withParams) : flatRows;
+          const output = [];
+          let offset = 0;
+          for (const rows of perEntry) {
+            if (!rows.length) {
+              output.push(null);
+              continue;
+            }
+            for (let i = 0; i < rows.length; i++) {
+              output.push(remapToGraphQLSingleOutput(enriched[offset + i], tableName, table, relationMap));
+            }
+            offset += rows.length;
+          }
+          return output;
         });
-        const input = remapFromGraphQLSingleInput(set, table);
-        if (!Object.keys(input).length) {
-          throw new import_graphql8.GraphQLError("Unable to update with no values specified!");
-        }
-        const relationCtx = relationFilterCtx(filterCtx, tableName);
-        const filters = single || requireWhere ? extractRequiredFilters(table, tableName, where, fieldName, relationCtx) : where ? extractFilters(table, tableName, where, relationCtx) : void 0;
-        const executor = resolveExecutor(db, context);
-        if (single) {
-          await assertSingleMatch(executor, table, filters, fieldName);
-        }
-        let query = executor.update(table).set(input);
-        if (filters) {
-          query = query.where(filters);
-        }
-        query = query.returning(columns);
-        const result = await query;
-        if (single && result.length > 1) {
-          throw new import_graphql8.GraphQLError(`${fieldName}: 'where' matched more than one row!`);
-        }
-        if (single && !result[0]) {
-          return void 0;
-        }
-        const enriched = hasRelations ? await eagerLoadMutationRelations(executor, tableName, result, pkNames, withParams) : result;
-        return single ? remapToGraphQLSingleOutput(enriched[0], tableName, table, relationMap) : remapToGraphQLArrayOutput(enriched, tableName, table, relationMap);
       } catch (e) {
         throw toGraphQLError(e);
       }
@@ -4492,7 +5016,7 @@ var generateUpdate3 = (db, tableName, table, tables, relationMap, setArgs, filte
     args: queryArgs
   };
 };
-var generateDelete3 = (db, tableName, table, filterArgs, fieldName, typeName, single, requireWhere, filterCtx, selectionCtx) => {
+var generateDelete3 = (db, tableName, table, filterArgs, fieldName, typeName, single, requireWhere, filterCtx, selectionCtx, txCtx) => {
   const queryArgs = {
     where: {
       type: single || requireWhere ? new import_graphql8.GraphQLNonNull(filterArgs) : filterArgs
@@ -4502,34 +5026,35 @@ var generateDelete3 = (db, tableName, table, filterArgs, fieldName, typeName, si
     name: fieldName,
     resolver: async (_source, args, context, info) => {
       try {
-        const { where } = args;
-        const parsedInfo = (0, import_graphql_parse_resolve_info4.parseResolveInfo)(info, {
-          deep: true
+        return await runMutation(db, context, info, txCtx, async (executor) => {
+          const { where } = args;
+          const parsedInfo = (0, import_graphql_parse_resolve_info4.parseResolveInfo)(info, {
+            deep: true
+          });
+          const columns = extractSelectedColumnsFromTreeSQLFormat(
+            parsedInfo.fieldsByTypeName[typeName],
+            table,
+            selectionCtx
+          );
+          const relationCtx = relationFilterCtx(filterCtx, tableName);
+          const filters = single || requireWhere ? extractRequiredFilters(table, tableName, where, fieldName, relationCtx) : where ? extractFilters(table, tableName, where, relationCtx) : void 0;
+          if (single) {
+            await assertSingleMatch(executor, table, filters, fieldName);
+          }
+          let query = executor.delete(table);
+          if (filters) {
+            query = query.where(filters);
+          }
+          query = query.returning(columns);
+          const result = await query;
+          if (single && result.length > 1) {
+            throw new import_graphql8.GraphQLError(`${fieldName}: 'where' matched more than one row!`);
+          }
+          if (single) {
+            return result[0] ? remapToGraphQLSingleOutput(result[0], tableName, table) : void 0;
+          }
+          return remapToGraphQLArrayOutput(result, tableName, table);
         });
-        const columns = extractSelectedColumnsFromTreeSQLFormat(
-          parsedInfo.fieldsByTypeName[typeName],
-          table,
-          selectionCtx
-        );
-        const relationCtx = relationFilterCtx(filterCtx, tableName);
-        const filters = single || requireWhere ? extractRequiredFilters(table, tableName, where, fieldName, relationCtx) : where ? extractFilters(table, tableName, where, relationCtx) : void 0;
-        const executor = resolveExecutor(db, context);
-        if (single) {
-          await assertSingleMatch(executor, table, filters, fieldName);
-        }
-        let query = executor.delete(table);
-        if (filters) {
-          query = query.where(filters);
-        }
-        query = query.returning(columns);
-        const result = await query;
-        if (single && result.length > 1) {
-          throw new import_graphql8.GraphQLError(`${fieldName}: 'where' matched more than one row!`);
-        }
-        if (single) {
-          return result[0] ? remapToGraphQLSingleOutput(result[0], tableName, table) : void 0;
-        }
-        return remapToGraphQLArrayOutput(result, tableName, table);
       } catch (e) {
         throw toGraphQLError(e);
       }
@@ -4577,6 +5102,12 @@ var generateSchemaData3 = (db, schema, relations, options) => {
   const relationAggregateFactory = features.relationAggregates ? createRelationAggregateFactory(db, tables, cacheCtx, typeNameMapper, filterCtx) : void 0;
   const queries = {};
   const mutations = {};
+  if (options.transactions && db.resultKind === "sync") {
+    throw new Error(
+      "Drizzle-GraphQL Error: transactions: 'auto' requires an asynchronous SQLite driver (e.g. libsql). Synchronous drivers cannot hold a transaction open across resolvers."
+    );
+  }
+  const mutationTxCtx = createMutationTxCtx(options.transactions);
   const gqlSchemaTypes = Object.fromEntries(
     Object.entries(tables).map(([tableName, _table]) => [
       tableName,
@@ -4611,6 +5142,7 @@ var generateSchemaData3 = (db, schema, relations, options) => {
       upsertArrayFieldName,
       upsertSingleFieldName,
       updateFieldName,
+      updateManyFieldName,
       updateSingleFieldName,
       deleteFieldName,
       deleteSingleFieldName
@@ -4650,7 +5182,8 @@ var generateSchemaData3 = (db, schema, relations, options) => {
       createArrayFieldName,
       typeName,
       typeNameMapper,
-      conflictDoNothing
+      conflictDoNothing,
+      mutationTxCtx
     ) : void 0;
     const insertSingleGenerated = features.insert ? generateInsertSingle3(
       db,
@@ -4662,7 +5195,8 @@ var generateSchemaData3 = (db, schema, relations, options) => {
       createSingleFieldName,
       typeName,
       typeNameMapper,
-      conflictDoNothing
+      conflictDoNothing,
+      mutationTxCtx
     ) : void 0;
     const uniqueSets = features.upsert ? getUniqueColumnSets(schema[tableName], import_sqlite_core2.getTableConfig) : [];
     const onConflictInput = features.upsert ? generateOnConflictInput({
@@ -4685,7 +5219,8 @@ var generateSchemaData3 = (db, schema, relations, options) => {
       typeName,
       false,
       typeNameMapper,
-      filterCtx
+      filterCtx,
+      mutationTxCtx
     ) : void 0;
     const upsertSingleGenerated = onConflictInput ? generateUpsert3(
       db,
@@ -4700,7 +5235,8 @@ var generateSchemaData3 = (db, schema, relations, options) => {
       typeName,
       true,
       typeNameMapper,
-      filterCtx
+      filterCtx,
+      mutationTxCtx
     ) : void 0;
     const updateGenerated = features.update ? generateUpdate3(
       db,
@@ -4715,7 +5251,8 @@ var generateSchemaData3 = (db, schema, relations, options) => {
       false,
       features.requireWhere,
       typeNameMapper,
-      filterCtx
+      filterCtx,
+      mutationTxCtx
     ) : void 0;
     const updateSingleGenerated = features.update ? generateUpdate3(
       db,
@@ -4730,7 +5267,22 @@ var generateSchemaData3 = (db, schema, relations, options) => {
       true,
       features.requireWhere,
       typeNameMapper,
-      filterCtx
+      filterCtx,
+      mutationTxCtx
+    ) : void 0;
+    const updateManyInput = features.update && features.updateMany ? generateUpdateManyInput({ typeName, updatePrefix: prefixes.update, updateInput, tableFilters }) : void 0;
+    const updateManyGenerated = updateManyInput ? generateUpdateMany3(
+      db,
+      tableName,
+      schema[tableName],
+      tables,
+      eagerRelations,
+      updateManyInput,
+      updateManyFieldName,
+      typeName,
+      typeNameMapper,
+      filterCtx,
+      mutationTxCtx
     ) : void 0;
     const deleteGenerated = features.delete ? generateDelete3(
       db,
@@ -4742,7 +5294,8 @@ var generateSchemaData3 = (db, schema, relations, options) => {
       false,
       features.requireWhere,
       filterCtx,
-      { tableName, relationMap: namedRelations, tables }
+      { tableName, relationMap: namedRelations, tables },
+      mutationTxCtx
     ) : void 0;
     const deleteSingleGenerated = features.delete ? generateDelete3(
       db,
@@ -4754,7 +5307,8 @@ var generateSchemaData3 = (db, schema, relations, options) => {
       true,
       features.requireWhere,
       filterCtx,
-      { tableName, relationMap: namedRelations, tables }
+      { tableName, relationMap: namedRelations, tables },
+      mutationTxCtx
     ) : void 0;
     const aggregateType = features.aggregates ? generateAggregateTypes(schema[tableName], tableName, typeName, cacheCtx) : void 0;
     const aggregateGenerated = features.aggregates ? generateAggregate(
@@ -4842,6 +5396,14 @@ var generateSchemaData3 = (db, schema, relations, options) => {
         resolve: updateGenerated.resolver
       };
     }
+    if (updateManyGenerated) {
+      mutations[updateManyGenerated.name] = {
+        // Nullable items: a no-match entry yields `null` in its slot.
+        type: new import_graphql8.GraphQLNonNull(new import_graphql8.GraphQLList(singleTableItemOutput)),
+        args: updateManyGenerated.args,
+        resolve: updateManyGenerated.resolver
+      };
+    }
     if (updateSingleGenerated) {
       mutations[updateSingleGenerated.name] = {
         type: singleTableItemOutput,
@@ -4868,6 +5430,7 @@ var generateSchemaData3 = (db, schema, relations, options) => {
       ...features.insert || onConflictInput ? [insertInput] : [],
       ...onConflictInput ? [onConflictInput] : [],
       ...features.update ? [updateInput] : [],
+      ...updateManyInput ? [updateManyInput] : [],
       tableFilters,
       tableOrder
     ];
@@ -4884,6 +5447,11 @@ var generateSchemaData3 = (db, schema, relations, options) => {
       inputs[havingInput.name] = havingInput;
     }
   }
+  if (mutationTxCtx) {
+    for (const name of Object.keys(mutations)) {
+      mutationTxCtx.fieldNames.add(name);
+    }
+  }
   const fieldResolvers = {};
   for (const [tableName, tableRelations] of Object.entries(namedRelations)) {
     const relResolvers = {};
@@ -4930,6 +5498,7 @@ var buildSchema = (db, config) => {
     distinct: config?.features?.distinct ?? true,
     insert: config?.features?.insert ?? true,
     update: config?.features?.update ?? true,
+    updateMany: config?.features?.updateMany ?? true,
     delete: config?.features?.delete ?? true,
     upsert: config?.features?.upsert ?? false,
     requireWhere: config?.features?.requireWhere ?? false
@@ -4939,6 +5508,8 @@ var buildSchema = (db, config) => {
     defaultListSize: (complexityConfig === true ? void 0 : complexityConfig.defaultListSize) ?? 10,
     aggregateCost: (complexityConfig === true ? void 0 : complexityConfig.aggregateCost) ?? 10
   };
+  const transactionsOpt = config?.transactions;
+  const transactions = transactionsOpt === void 0 || transactionsOpt === "none" ? void 0 : { timeoutMs: (transactionsOpt === "auto" ? void 0 : transactionsOpt.timeoutMs) ?? 3e4 };
   const eagerOpt = config?.eagerLoadRelations;
   const shouldEagerLoad = eagerOpt === void 0 || eagerOpt === true ? () => true : eagerOpt === false ? () => false : eagerOpt;
   if (!typeNameMapper && suffixes.list === suffixes.single) {
@@ -4966,7 +5537,8 @@ var buildSchema = (db, config) => {
     typeNameMapper,
     shouldEagerLoad,
     features,
-    complexity
+    complexity,
+    transactions
   };
   let generatorOutput;
   if ((0, import_drizzle_orm8.is)(db, import_mysql_core3.MySqlDatabase)) {