@vantreeseba/drizzle-graphql 7.7.0 → 7.8.0

package/dist/index.js

@@ -1106,7 +1106,7 @@ var runOnSharedTx = async (state, body) => {
     throw e;
   }
 };
-var runMutation = async (db, context, info, txCtx, body) => {
+var runMutation = async (db, context, info, txCtx, body, forceTx) => {
   const contextIsObject = context !== null && (typeof context === "object" || typeof context === "function");
   const stateKey = contextIsObject ? context : info.operation;
   let state = txCtx?.states.get(stateKey);
@@ -1115,7 +1115,7 @@ var runMutation = async (db, context, info, txCtx, body) => {
       return body(context[drizzleExecutorKey]);
     }
     if (!txCtx || info.operation.operation !== "mutation") {
-      return body(db);
+      return forceTx ? db.transaction((tx) => body(tx)) : body(db);
     }
     const keys = /* @__PURE__ */ new Set();
     const allKnown = collectRootMutationKeys(
@@ -1130,10 +1130,28 @@ var runMutation = async (db, context, info, txCtx, body) => {
     txCtx.states.set(stateKey, state);
   }
   if (state.kind === "passthrough") {
-    return body(resolveExecutor(db, context));
+    const executor = resolveExecutor(db, context);
+    return forceTx && executor === db ? db.transaction((tx) => body(tx)) : body(executor);
   }
   return runOnSharedTx(state, body);
 };
+var normalizeWriteHooks = (hooks) => {
+  if (!hooks) {
+    return void 0;
+  }
+  if (typeof hooks === "function") {
+    return { after: hooks };
+  }
+  const resolved = { before: hooks.before, after: hooks.after };
+  return resolved.before || resolved.after ? resolved : void 0;
+};
+var runWriteHook = (hooks, position, payload) => {
+  const hook = position === "before" ? hooks?.before : hooks?.after;
+  if (!hook) {
+    return void 0;
+  }
+  return Promise.resolve(hook({ ...payload, position, rows: payload.rows ?? [] }));
+};
 var batchedPaginatedRelationQuery = async (db, targetTable, foreignCol, whereCondition, orderByArg, limit, offset, pkNames, orderCtx, whereArgs) => {
   const cols = getColumns2(targetTable);
   const orderExprs = [
@@ -2782,10 +2800,11 @@ var withScope = (scope, tableName, table, condition, mode) => {
   const predicate = scope?.on(tableName, table, mode);
   return predicate ? and(condition, predicate) : condition;
 };
-var bindPolicies = (policies, filterCtx) => policies?.scope || policies?.contextValues || policies?.softDelete ? {
+var bindPolicies = (policies, filterCtx) => policies?.scope || policies?.contextValues || policies?.softDelete || policies?.onWrite ? {
   scope: policies.scope || policies.softDelete ? (context) => resolveScope(policies, context, filterCtx) : void 0,
   contextValues: policies.contextValues,
-  softDelete: policies.softDelete
+  softDelete: policies.softDelete,
+  onWrite: policies.onWrite
 } : void 0;
 var applyContextValues = (values, hooks, context) => {
   if (!hooks) {
@@ -4374,22 +4393,49 @@ var generateInsertArray = (db, tableName, table, baseType, fieldName, txCtx, pol
       type: new GraphQLNonNull5(new GraphQLList5(new GraphQLNonNull5(baseType)))
     }
   };
+  const hooks = policies?.onWrite?.(tableName, "insert");
   return {
     name: fieldName,
     resolver: async (_source, args, context, info) => {
       try {
-        return await runMutation(db, context, info, txCtx, async (executor) => {
-          const input = applyContextValuesAll(
-            remapFromGraphQLArrayInput(args.values, table),
-            policies?.contextValues?.(tableName),
-            context
-          );
-          if (!input.length) {
-            throw new GraphQLError6("No values were provided!");
-          }
-          await executor.insert(table).values(input);
-          return { isSuccess: true };
-        });
+        return await runMutation(
+          db,
+          context,
+          info,
+          txCtx,
+          async (executor) => {
+            const input = applyContextValuesAll(
+              remapFromGraphQLArrayInput(args.values, table),
+              policies?.contextValues?.(tableName),
+              context
+            );
+            if (!input.length) {
+              throw new GraphQLError6("No values were provided!");
+            }
+            await runWriteHook(hooks, "before", {
+              table: tableName,
+              operation: "insert",
+              single: false,
+              args,
+              context,
+              info,
+              tx: executor
+            });
+            await executor.insert(table).values(input);
+            await runWriteHook(hooks, "after", {
+              table: tableName,
+              operation: "insert",
+              single: false,
+              args,
+              rows: [],
+              context,
+              info,
+              tx: executor
+            });
+            return { isSuccess: true };
+          },
+          !!hooks
+        );
       } catch (e) {
         throw toGraphQLError(e);
       }
@@ -4403,19 +4449,46 @@ var generateInsertSingle = (db, tableName, table, baseType, fieldName, txCtx, po
       type: new GraphQLNonNull5(baseType)
     }
   };
+  const hooks = policies?.onWrite?.(tableName, "insert");
   return {
     name: fieldName,
     resolver: async (_source, args, context, info) => {
       try {
-        return await runMutation(db, context, info, txCtx, async (executor) => {
-          const input = applyContextValues(
-            remapFromGraphQLSingleInput(args.values, table),
-            policies?.contextValues?.(tableName),
-            context
-          );
-          await executor.insert(table).values(input);
-          return { isSuccess: true };
-        });
+        return await runMutation(
+          db,
+          context,
+          info,
+          txCtx,
+          async (executor) => {
+            await runWriteHook(hooks, "before", {
+              table: tableName,
+              operation: "insert",
+              single: true,
+              args,
+              context,
+              info,
+              tx: executor
+            });
+            const input = applyContextValues(
+              remapFromGraphQLSingleInput(args.values, table),
+              policies?.contextValues?.(tableName),
+              context
+            );
+            await executor.insert(table).values(input);
+            await runWriteHook(hooks, "after", {
+              table: tableName,
+              operation: "insert",
+              single: true,
+              args,
+              rows: [],
+              context,
+              info,
+              tx: executor
+            });
+            return { isSuccess: true };
+          },
+          !!hooks
+        );
       } catch (e) {
         throw toGraphQLError(e);
       }
@@ -4434,35 +4507,62 @@ var generateUpsert = (db, tableName, table, baseType, onConflictType, fieldName,
     }
   };
   const pkNames = mysqlPrimaryKeyPropNames(table);
+  const hooks = policies?.onWrite?.(tableName, "upsert");
   return {
     name: fieldName,
     resolver: async (_source, args, context, info) => {
       try {
-        return await runMutation(db, context, info, txCtx, async (executor) => {
-          const input = applyContextValuesAll(
-            single ? [remapFromGraphQLSingleInput(args.values, table)] : remapFromGraphQLArrayInput(args.values, table),
-            policies?.contextValues?.(tableName),
-            context
-          );
-          if (!input.length) {
-            throw new GraphQLError6("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 };
-        });
+        return await runMutation(
+          db,
+          context,
+          info,
+          txCtx,
+          async (executor) => {
+            const input = applyContextValuesAll(
+              single ? [remapFromGraphQLSingleInput(args.values, table)] : remapFromGraphQLArrayInput(args.values, table),
+              policies?.contextValues?.(tableName),
+              context
+            );
+            if (!input.length) {
+              throw new GraphQLError6("No values were provided!");
+            }
+            await runWriteHook(hooks, "before", {
+              table: tableName,
+              operation: "upsert",
+              single,
+              args,
+              context,
+              info,
+              tx: executor
+            });
+            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 });
+            }
+            await runWriteHook(hooks, "after", {
+              table: tableName,
+              operation: "upsert",
+              single,
+              args,
+              rows: [],
+              context,
+              info,
+              tx: executor
+            });
+            return { isSuccess: true };
+          },
+          !!hooks
+        );
       } catch (e) {
         throw toGraphQLError(e);
       }
@@ -4479,37 +4579,64 @@ var generateUpdate = (db, tableName, table, setArgs, filterArgs, fieldName, sing
       type: single || requireWhere ? new GraphQLNonNull5(filterArgs) : filterArgs
     }
   };
+  const hooks = policies?.onWrite?.(tableName, "update");
   return {
     name: fieldName,
     resolver: async (_source, args, context, info) => {
       try {
-        return await runMutation(db, context, info, txCtx, async (executor) => {
-          const { where, set } = args;
-          const scope = policies?.scope?.(context);
-          const input = stripContextValues(
-            remapUpdateInput(set, table, tableName),
-            policies?.contextValues?.(tableName)
-          );
-          if (!Object.keys(input).length) {
-            throw new GraphQLError6("Unable to update with no values specified!");
-          }
-          const relationCtx = relationFilterCtx(filterCtx, tableName);
-          const filters = withScope(
-            scope,
-            tableName,
-            table,
-            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 };
-        });
+        return await runMutation(
+          db,
+          context,
+          info,
+          txCtx,
+          async (executor) => {
+            const { where, set } = args;
+            const scope = policies?.scope?.(context);
+            const input = stripContextValues(
+              remapUpdateInput(set, table, tableName),
+              policies?.contextValues?.(tableName)
+            );
+            if (!Object.keys(input).length) {
+              throw new GraphQLError6("Unable to update with no values specified!");
+            }
+            await runWriteHook(hooks, "before", {
+              table: tableName,
+              operation: "update",
+              single,
+              args,
+              context,
+              info,
+              tx: executor
+            });
+            const relationCtx = relationFilterCtx(filterCtx, tableName);
+            const filters = withScope(
+              scope,
+              tableName,
+              table,
+              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;
+            await runWriteHook(hooks, "after", {
+              table: tableName,
+              operation: "update",
+              single,
+              args,
+              rows: [],
+              context,
+              info,
+              tx: executor
+            });
+            return { isSuccess: true };
+          },
+          !!hooks
+        );
       } catch (e) {
         throw toGraphQLError(e);
       }
@@ -4523,43 +4650,70 @@ var generateUpdateMany = (db, tableName, table, updateManyInput, fieldName, filt
       type: new GraphQLNonNull5(new GraphQLList5(new GraphQLNonNull5(updateManyInput)))
     }
   };
+  const hooks = policies?.onWrite?.(tableName, "updateMany");
   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 GraphQLError6("No updates were provided!");
-          }
-          const scope = policies?.scope?.(context);
-          const contextColumns = policies?.contextValues?.(tableName);
-          const entries = updates.map(({ where, set }) => {
-            const input = stripContextValues(remapUpdateInput(set, table, tableName), contextColumns);
-            if (!Object.keys(input).length) {
-              throw new GraphQLError6("Unable to update with no values specified!");
+        return await runMutation(
+          db,
+          context,
+          info,
+          txCtx,
+          async (executor) => {
+            const { updates } = args;
+            if (!updates.length) {
+              throw new GraphQLError6("No updates were provided!");
             }
-            return {
-              set: input,
-              filters: withScope(
-                scope,
-                tableName,
-                table,
-                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 runWriteHook(hooks, "before", {
+              table: tableName,
+              operation: "updateMany",
+              single: false,
+              args,
+              context,
+              info,
+              tx: executor
+            });
+            const scope = policies?.scope?.(context);
+            const contextColumns = policies?.contextValues?.(tableName);
+            const entries = updates.map(({ where, set }) => {
+              const input = stripContextValues(remapUpdateInput(set, table, tableName), contextColumns);
+              if (!Object.keys(input).length) {
+                throw new GraphQLError6("Unable to update with no values specified!");
               }
-              await query;
-            }
-          });
-          return { isSuccess: true };
-        });
+              return {
+                set: input,
+                filters: withScope(
+                  scope,
+                  tableName,
+                  table,
+                  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;
+              }
+            });
+            await runWriteHook(hooks, "after", {
+              table: tableName,
+              operation: "updateMany",
+              single: false,
+              args,
+              rows: [],
+              context,
+              info,
+              tx: executor
+            });
+            return { isSuccess: true };
+          },
+          !!hooks
+        );
       } catch (e) {
         throw toGraphQLError(e);
       }
@@ -4569,36 +4723,64 @@ var generateUpdateMany = (db, tableName, table, updateManyInput, fieldName, filt
 };
 var generateDelete = (db, tableName, table, filterArgs, fieldName, single, requireWhere, filterCtx, txCtx, policies, restore = false) => {
   const softDelete = policies?.softDelete?.(tableName);
+  const operation = restore ? "restore" : "delete";
   const queryArgs = {
     where: {
       type: single || requireWhere ? new GraphQLNonNull5(filterArgs) : filterArgs
     }
   };
+  const hooks = policies?.onWrite?.(tableName, operation);
   return {
     name: fieldName,
     resolver: async (_source, args, context, info) => {
       try {
-        return await runMutation(db, context, info, txCtx, async (executor) => {
-          const { where } = args;
-          const scope = policies?.scope?.(context);
-          const relationCtx = relationFilterCtx(filterCtx, tableName);
-          const filters = withScope(
-            scope,
-            tableName,
-            table,
-            single || requireWhere ? extractRequiredFilters(table, tableName, where, fieldName, relationCtx) : where ? extractFilters(table, tableName, where, relationCtx) : void 0,
-            restore ? "ONLY" : void 0
-          );
-          if (single) {
-            await assertSingleMatch(executor, table, filters, fieldName);
-          }
-          let query = softDelete ? executor.update(table).set({ [softDelete.columnName]: restore ? softDelete.writeRestored : softDelete.writeDeleted() }) : executor.delete(table);
-          if (filters) {
-            query = query.where(filters);
-          }
-          await query;
-          return { isSuccess: true };
-        });
+        return await runMutation(
+          db,
+          context,
+          info,
+          txCtx,
+          async (executor) => {
+            await runWriteHook(hooks, "before", {
+              table: tableName,
+              operation,
+              single,
+              args,
+              context,
+              info,
+              tx: executor
+            });
+            const { where } = args;
+            const scope = policies?.scope?.(context);
+            const relationCtx = relationFilterCtx(filterCtx, tableName);
+            const filters = withScope(
+              scope,
+              tableName,
+              table,
+              single || requireWhere ? extractRequiredFilters(table, tableName, where, fieldName, relationCtx) : where ? extractFilters(table, tableName, where, relationCtx) : void 0,
+              restore ? "ONLY" : void 0
+            );
+            if (single) {
+              await assertSingleMatch(executor, table, filters, fieldName);
+            }
+            let query = softDelete ? executor.update(table).set({ [softDelete.columnName]: restore ? softDelete.writeRestored : softDelete.writeDeleted() }) : executor.delete(table);
+            if (filters) {
+              query = query.where(filters);
+            }
+            await query;
+            await runWriteHook(hooks, "after", {
+              table: tableName,
+              operation,
+              single,
+              args,
+              rows: [],
+              context,
+              info,
+              tx: executor
+            });
+            return { isSuccess: true };
+          },
+          !!hooks
+        );
       } catch (e) {
         throw toGraphQLError(e);
       }
@@ -5074,7 +5256,7 @@ import {
 import { parseResolveInfo as parseResolveInfo3 } from "graphql-parse-resolve-info";
 
 // src/util/builders/nested-writes.ts
-import { and as and3, eq as eq3, getColumns as getColumns4, is as is5, One as One4 } from "drizzle-orm";
+import { and as and3, Column, eq as eq3, getColumns as getColumns4, inArray as inArray3, is as is5, One as One4 } from "drizzle-orm";
 import {
   GraphQLBoolean as GraphQLBoolean4,
   GraphQLError as GraphQLError7,
@@ -5083,6 +5265,64 @@ import {
   GraphQLNonNull as GraphQLNonNull6
 } from "graphql";
 var isOptionalOnInsert = (column) => !column.notNull || !!column.hasDefault || !!column.defaultFn;
+var propNameOf = (table, column) => {
+  if (!column) {
+    return void 0;
+  }
+  for (const [propName, candidate] of Object.entries(getColumns4(table))) {
+    if (candidate === column) {
+      return propName;
+    }
+  }
+  return void 0;
+};
+var throughColumn = (entry) => entry && is5(entry, Column) ? entry : entry?._?.column;
+var buildThroughPlan = (relationName, relation, table, targetTableName, targetTable) => {
+  if (is5(relation, One4)) {
+    return void 0;
+  }
+  const junction = relation.throughTable;
+  const sourceEntries = relation.through?.source;
+  const targetEntries = relation.through?.target;
+  if (!junction || sourceEntries?.length !== 1 || targetEntries?.length !== 1) {
+    return void 0;
+  }
+  if (relation.sourceColumns?.length !== 1 || relation.targetColumns?.length !== 1) {
+    return void 0;
+  }
+  const localCol = relation.sourceColumns[0];
+  const foreignCol = relation.targetColumns[0];
+  const localColPropName = propNameOf(table, localCol);
+  const foreignColPropName = propNameOf(targetTable, foreignCol);
+  const sourceColPropName = propNameOf(junction, throughColumn(sourceEntries[0]));
+  const targetColPropName = propNameOf(junction, throughColumn(targetEntries[0]));
+  if (!localColPropName || !foreignColPropName || !sourceColPropName || !targetColPropName) {
+    return void 0;
+  }
+  const junctionColumns = getColumns4(junction);
+  const sourceCol = junctionColumns[sourceColPropName];
+  const targetCol = junctionColumns[targetColPropName];
+  const unsuppliable = Object.entries(junctionColumns).some(
+    ([propName, column]) => propName !== sourceColPropName && propName !== targetColPropName && !isOptionalOnInsert(column)
+  );
+  if (unsuppliable) {
+    return void 0;
+  }
+  return {
+    relationName,
+    targetTableName,
+    targetTable,
+    localColPropName,
+    foreignColPropName,
+    foreignCol,
+    localCol,
+    isOne: false,
+    // The link is written after the parent row exists, exactly like a child-side foreign key.
+    fkSide: "child",
+    canDetach: true,
+    through: { table: junction, sourceColPropName, targetColPropName, sourceCol, targetCol }
+  };
+};
 var buildNestedWritePlans = (tables, relationMap, resolveUniqueSets, resolvePrimaryKeys, extractJoinColumns) => {
   const uniqueCache = /* @__PURE__ */ new Map();
   const singleColumnUniques = (tableName, table) => {
@@ -5112,14 +5352,18 @@ var buildNestedWritePlans = (tables, relationMap, resolveUniqueSets, resolvePrim
     const tablePlans = {};
     for (const [relationName, relEntry] of Object.entries(relations)) {
       const relation = relEntry.relation;
-      if (relation.through) {
-        continue;
-      }
       const targetTableName = relEntry.targetTableName;
       const targetTable = tables[targetTableName];
       if (!targetTable) {
         continue;
       }
+      if (relation.through) {
+        const throughPlan = buildThroughPlan(relationName, relation, table, targetTableName, targetTable);
+        if (throughPlan) {
+          tablePlans[relationName] = throughPlan;
+        }
+        continue;
+      }
       const joinColumns = extractJoinColumns(relEntry, table, targetTable);
       if (!joinColumns) {
         continue;
@@ -5204,11 +5448,31 @@ var createNestedWriteTypes = (params) => {
       return cached;
     }
     const filters = targetFilters(plan);
-    const payload = payloadType(tableName, typeName, plan);
     const targetTypeName = resolveTypeName(plan.targetTableName, typeNameMapper);
     const fields = {};
-    if (plan.isOne) {
-      fields["create"] = { type: payload, description: `Insert a ${targetTypeName} row and attach it` };
+    if (plan.through) {
+      if (!filters) {
+        return void 0;
+      }
+      fields["connect"] = {
+        type: listOf(filters),
+        description: `Link every existing ${targetTypeName} row these match. Already-linked rows are left alone.`
+      };
+      if (forUpdate) {
+        fields["disconnect"] = {
+          type: listOf(filters),
+          description: `Unlink every linked ${targetTypeName} row these match, leaving the rows in place`
+        };
+        fields["set"] = {
+          type: listOf(filters),
+          description: `Replace the whole set: unlink everything linked, then link every ${targetTypeName} row these match. \`set: []\` clears the relation. Applied before \`disconnect\` and \`connect\`.`
+        };
+      }
+    } else if (plan.isOne) {
+      fields["create"] = {
+        type: payloadType(tableName, typeName, plan),
+        description: `Insert a ${targetTypeName} row and attach it`
+      };
       if (filters) {
         fields["connect"] = {
           type: filters,
@@ -5222,7 +5486,10 @@ var createNestedWriteTypes = (params) => {
         };
       }
     } else {
-      fields["create"] = { type: listOf(payload), description: `Insert these ${targetTypeName} rows and attach them` };
+      fields["create"] = {
+        type: listOf(payloadType(tableName, typeName, plan)),
+        description: `Insert these ${targetTypeName} rows and attach them`
+      };
       if (filters) {
         fields["connect"] = {
           type: listOf(filters),
@@ -5304,6 +5571,48 @@ var createNestedWriteRuntime = (params) => {
       );
     }
   };
+  const selectedTargetKeys = async (executor, plan, filter, operation, scope) => {
+    const rows = await executor.select().from(plan.targetTable).where(conditionOf(plan, filter, operation, scope));
+    return rows.map((row) => row[plan.foreignColPropName]).filter((value) => value !== void 0 && value !== null);
+  };
+  const applyThroughOps = async (executor, plan, key, op, scope) => {
+    const through = plan.through;
+    const unlinkAll = () => executor.delete(through.table).where(eq3(through.sourceCol, key));
+    const link = async (operands, operation) => {
+      const existing = new Set(
+        (await executor.select().from(through.table).where(eq3(through.sourceCol, key))).map(
+          (row) => row[through.targetColPropName]
+        )
+      );
+      const rows = [];
+      for (const filter of operands) {
+        for (const targetKey of await selectedTargetKeys(executor, plan, filter, operation, scope)) {
+          if (!existing.has(targetKey)) {
+            existing.add(targetKey);
+            rows.push({ [through.sourceColPropName]: key, [through.targetColPropName]: targetKey });
+          }
+        }
+      }
+      if (rows.length) {
+        await executor.insert(through.table).values(rows);
+      }
+    };
+    if (op["set"] !== void 0 && op["set"] !== null) {
+      await unlinkAll();
+      await link(asArray(op["set"]), "set");
+    }
+    if (op["disconnect"] !== void 0 && op["disconnect"] !== null) {
+      for (const filter of asArray(op["disconnect"])) {
+        const targetKeys = await selectedTargetKeys(executor, plan, filter, "disconnect", scope);
+        if (targetKeys.length) {
+          await executor.delete(through.table).where(and3(eq3(through.sourceCol, key), inArray3(through.targetCol, targetKeys)));
+        }
+      }
+    }
+    if (op["connect"] !== void 0 && op["connect"] !== null) {
+      await link(asArray(op["connect"]), "connect");
+    }
+  };
   const detachAll = async (executor, plan, key, scope) => executor.update(plan.targetTable).set({ [plan.foreignColPropName]: null }).where(withScope(scope, plan.targetTableName, plan.targetTable, eq3(plan.foreignCol, key)));
   return {
     enabled: (tableName) => !!plans[tableName],
@@ -5400,6 +5709,10 @@ var createNestedWriteRuntime = (params) => {
               `Drizzle-GraphQL Error: cannot write through '${relationName}': the ${tableName} row has no '${plan.localColPropName}' value to attach to.`
             );
           }
+          if (plan.through) {
+            await applyThroughOps(executor, plan, key, op, scope);
+            continue;
+          }
           if (op["set"] !== void 0) {
             await detachAll(executor, plan, key, scope);
             for (const filter of asArray(op["set"])) {
@@ -5679,58 +5992,85 @@ var generateInsertArray2 = (db, tableName, table, tables, relationMap, baseType,
     }
   };
   const pkNames = pgPrimaryKeyPropNames(table);
+  const hooks = policies?.onWrite?.(tableName, "insert");
   return {
     name: fieldName,
     resolver: async (_source, args, context, info) => {
       try {
-        return await runMutation(db, context, info, txCtx, async (executor) => {
-          if (!args.values.length) {
-            throw new GraphQLError8("No values were provided!");
-          }
-          const entries = nested?.enabled(tableName) ? args.values.map((values) => nested.split(tableName, values)) : void 0;
-          const nestedEntries = entries?.some((entry) => nested.hasOps(entry.ops)) ? entries : void 0;
-          const contextColumns = policies?.contextValues?.(tableName);
-          const scope = policies?.scope?.(context);
-          const input = nestedEntries ? [] : applyContextValuesAll(
-            remapFromGraphQLArrayInput(entries ? entries.map((entry) => entry.columns) : args.values, table),
-            contextColumns,
-            context
-          );
-          const parsedInfo = parseResolveInfo3(info, {
-            deep: true
-          });
-          const { columns, hasRelations, withParams } = prepareMutationRelationColumns({
-            relationMap,
-            tables,
-            tableName,
-            typeName,
-            typeNameMapper,
-            table,
-            pkNames,
-            parsedInfo,
-            limits,
-            scope
-          });
-          const returning = nestedEntries ? nested.withJoinColumns(tableName, mergedOps(nestedEntries), { ...columns }, table) : columns;
-          const runInsert = async (target, values) => {
-            let query = target.insert(table).values(values).returning(returning);
-            if (conflictDoNothing) {
-              query = query.onConflictDoNothing();
+        return await runMutation(
+          db,
+          context,
+          info,
+          txCtx,
+          async (executor) => {
+            if (!args.values.length) {
+              throw new GraphQLError8("No values were provided!");
             }
-            return await query;
-          };
-          const result = nestedEntries ? await writeWithNestedOps({
-            executor,
-            runtime: nested,
-            tableName,
-            entries: nestedEntries,
-            remapValues: (values) => applyContextValues(remapFromGraphQLSingleInput(values, table), contextColumns, context),
-            write: (tx, values) => runInsert(tx, [values]),
-            context
-          }) : await runInsert(executor, input);
-          const enriched = hasRelations ? await eagerLoadMutationRelations(executor, tableName, result, pkNames, withParams) : result;
-          return remapToGraphQLArrayOutput(enriched, tableName, table, relationMap);
-        });
+            await runWriteHook(hooks, "before", {
+              table: tableName,
+              operation: "insert",
+              single: false,
+              args,
+              context,
+              info,
+              tx: executor
+            });
+            const entries = nested?.enabled(tableName) ? args.values.map((values) => nested.split(tableName, values)) : void 0;
+            const nestedEntries = entries?.some((entry) => nested.hasOps(entry.ops)) ? entries : void 0;
+            const contextColumns = policies?.contextValues?.(tableName);
+            const scope = policies?.scope?.(context);
+            const input = nestedEntries ? [] : applyContextValuesAll(
+              remapFromGraphQLArrayInput(entries ? entries.map((entry) => entry.columns) : args.values, table),
+              contextColumns,
+              context
+            );
+            const parsedInfo = parseResolveInfo3(info, {
+              deep: true
+            });
+            const { columns, hasRelations, withParams } = prepareMutationRelationColumns({
+              relationMap,
+              tables,
+              tableName,
+              typeName,
+              typeNameMapper,
+              table,
+              pkNames,
+              parsedInfo,
+              limits,
+              scope
+            });
+            const returning = nestedEntries ? nested.withJoinColumns(tableName, mergedOps(nestedEntries), { ...columns }, table) : columns;
+            const runInsert = async (target, values) => {
+              let query = target.insert(table).values(values).returning(returning);
+              if (conflictDoNothing) {
+                query = query.onConflictDoNothing();
+              }
+              return await query;
+            };
+            const result = nestedEntries ? await writeWithNestedOps({
+              executor,
+              runtime: nested,
+              tableName,
+              entries: nestedEntries,
+              remapValues: (values) => applyContextValues(remapFromGraphQLSingleInput(values, table), contextColumns, context),
+              write: (tx, values) => runInsert(tx, [values]),
+              context
+            }) : await runInsert(executor, input);
+            await runWriteHook(hooks, "after", {
+              table: tableName,
+              operation: "insert",
+              single: false,
+              args,
+              rows: result,
+              context,
+              info,
+              tx: executor
+            });
+            const enriched = hasRelations ? await eagerLoadMutationRelations(executor, tableName, result, pkNames, withParams) : result;
+            return remapToGraphQLArrayOutput(enriched, tableName, table, relationMap);
+          },
+          !!hooks
+        );
       } catch (e) {
         throw toGraphQLError(e);
       }
@@ -5745,61 +6085,88 @@ var generateInsertSingle2 = (db, tableName, table, tables, relationMap, baseType
     }
   };
   const pkNames = pgPrimaryKeyPropNames(table);
+  const hooks = policies?.onWrite?.(tableName, "insert");
   return {
     name: fieldName,
     resolver: async (_source, args, context, info) => {
       try {
-        return await runMutation(db, context, info, txCtx, async (executor) => {
-          const entry = nested?.enabled(tableName) ? nested.split(tableName, args.values) : void 0;
-          const nestedEntry = entry && nested.hasOps(entry.ops) ? entry : void 0;
-          const contextColumns = policies?.contextValues?.(tableName);
-          const scope = policies?.scope?.(context);
-          const input = nestedEntry ? {} : applyContextValues(
-            remapFromGraphQLSingleInput(entry ? entry.columns : args.values, table),
-            contextColumns,
-            context
-          );
-          const parsedInfo = parseResolveInfo3(info, {
-            deep: true
-          });
-          const { columns, hasRelations, withParams } = prepareMutationRelationColumns({
-            relationMap,
-            tables,
-            tableName,
-            typeName,
-            typeNameMapper,
-            table,
-            pkNames,
-            parsedInfo,
-            limits,
-            scope
-          });
-          const returning = nestedEntry ? nested.withJoinColumns(tableName, nestedEntry.ops, { ...columns }, table) : columns;
-          const runInsert = async (target, values) => {
-            let query = target.insert(table).values(values).returning(returning);
-            if (conflictDoNothing) {
-              query = query.onConflictDoNothing();
-            }
-            return await query;
-          };
-          const result = nestedEntry ? await writeWithNestedOps({
-            executor,
-            runtime: nested,
-            tableName,
-            entries: [nestedEntry],
-            remapValues: (values) => applyContextValues(remapFromGraphQLSingleInput(values, table), contextColumns, context),
-            write: runInsert,
-            context
-          }) : await runInsert(executor, input);
-          if (!result[0]) {
-            if (!conflictDoNothing) {
-              throw new GraphQLError8(`${fieldName}: the insert returned no row.`);
+        return await runMutation(
+          db,
+          context,
+          info,
+          txCtx,
+          async (executor) => {
+            await runWriteHook(hooks, "before", {
+              table: tableName,
+              operation: "insert",
+              single: true,
+              args,
+              context,
+              info,
+              tx: executor
+            });
+            const entry = nested?.enabled(tableName) ? nested.split(tableName, args.values) : void 0;
+            const nestedEntry = entry && nested.hasOps(entry.ops) ? entry : void 0;
+            const contextColumns = policies?.contextValues?.(tableName);
+            const scope = policies?.scope?.(context);
+            const input = nestedEntry ? {} : applyContextValues(
+              remapFromGraphQLSingleInput(entry ? entry.columns : args.values, table),
+              contextColumns,
+              context
+            );
+            const parsedInfo = parseResolveInfo3(info, {
+              deep: true
+            });
+            const { columns, hasRelations, withParams } = prepareMutationRelationColumns({
+              relationMap,
+              tables,
+              tableName,
+              typeName,
+              typeNameMapper,
+              table,
+              pkNames,
+              parsedInfo,
+              limits,
+              scope
+            });
+            const returning = nestedEntry ? nested.withJoinColumns(tableName, nestedEntry.ops, { ...columns }, table) : columns;
+            const runInsert = async (target, values) => {
+              let query = target.insert(table).values(values).returning(returning);
+              if (conflictDoNothing) {
+                query = query.onConflictDoNothing();
+              }
+              return await query;
+            };
+            const result = nestedEntry ? await writeWithNestedOps({
+              executor,
+              runtime: nested,
+              tableName,
+              entries: [nestedEntry],
+              remapValues: (values) => applyContextValues(remapFromGraphQLSingleInput(values, table), contextColumns, context),
+              write: runInsert,
+              context
+            }) : await runInsert(executor, input);
+            await runWriteHook(hooks, "after", {
+              table: tableName,
+              operation: "insert",
+              single: true,
+              args,
+              rows: result,
+              context,
+              info,
+              tx: executor
+            });
+            if (!result[0]) {
+              if (!conflictDoNothing) {
+                throw new GraphQLError8(`${fieldName}: the insert returned no row.`);
+              }
+              return void 0;
             }
-            return void 0;
-          }
-          const enriched = hasRelations ? await eagerLoadMutationRelations(executor, tableName, result, pkNames, withParams) : result;
-          return remapToGraphQLSingleOutput(enriched[0], tableName, table, relationMap);
-        });
+            const enriched = hasRelations ? await eagerLoadMutationRelations(executor, tableName, result, pkNames, withParams) : result;
+            return remapToGraphQLSingleOutput(enriched[0], tableName, table, relationMap);
+          },
+          !!hooks
+        );
       } catch (e) {
         throw toGraphQLError(e);
       }
@@ -5818,69 +6185,96 @@ var generateUpsert2 = (db, tableName, table, tables, relationMap, baseType, onCo
     }
   };
   const pkNames = pgPrimaryKeyPropNames(table);
+  const hooks = policies?.onWrite?.(tableName, "upsert");
   return {
     name: fieldName,
     resolver: async (_source, args, context, info) => {
       try {
-        return await runMutation(db, context, info, txCtx, async (executor) => {
-          const supplied = single ? [args.values] : args.values;
-          if (!supplied.length) {
-            throw new GraphQLError8("No values were provided!");
-          }
-          const entries = nested?.enabled(tableName) ? supplied.map((values) => nested.split(tableName, values)) : void 0;
-          const nestedEntries = entries?.some((entry) => nested.hasOps(entry.ops)) ? entries : void 0;
-          const contextColumns = policies?.contextValues?.(tableName);
-          const scope = policies?.scope?.(context);
-          const input = nestedEntries ? [] : applyContextValuesAll(
-            remapFromGraphQLArrayInput(entries ? entries.map((entry) => entry.columns) : supplied, table),
-            contextColumns,
-            context
-          );
-          const parsedInfo = parseResolveInfo3(info, { deep: true });
-          const { columns, hasRelations, withParams } = prepareMutationRelationColumns({
-            relationMap,
-            tables,
-            tableName,
-            typeName,
-            typeNameMapper,
-            table,
-            pkNames,
-            parsedInfo,
-            limits,
-            scope
-          });
-          const returning = nestedEntries ? nested.withJoinColumns(tableName, mergedOps(nestedEntries), { ...columns }, table) : columns;
-          const runUpsert = async (target, values) => {
-            const plan = resolveConflictPlan({
-              table,
-              values,
-              onConflict: args.onConflict,
+        return await runMutation(
+          db,
+          context,
+          info,
+          txCtx,
+          async (executor) => {
+            const supplied = single ? [args.values] : args.values;
+            if (!supplied.length) {
+              throw new GraphQLError8("No values were provided!");
+            }
+            await runWriteHook(hooks, "before", {
+              table: tableName,
+              operation: "upsert",
+              single,
+              args,
+              context,
+              info,
+              tx: executor
+            });
+            const entries = nested?.enabled(tableName) ? supplied.map((values) => nested.split(tableName, values)) : void 0;
+            const nestedEntries = entries?.some((entry) => nested.hasOps(entry.ops)) ? entries : void 0;
+            const contextColumns = policies?.contextValues?.(tableName);
+            const scope = policies?.scope?.(context);
+            const input = nestedEntries ? [] : applyContextValuesAll(
+              remapFromGraphQLArrayInput(entries ? entries.map((entry) => entry.columns) : supplied, table),
+              contextColumns,
+              context
+            );
+            const parsedInfo = parseResolveInfo3(info, { deep: true });
+            const { columns, hasRelations, withParams } = prepareMutationRelationColumns({
+              relationMap,
+              tables,
+              tableName,
+              typeName,
+              typeNameMapper,
+              table,
               pkNames,
-              uniqueSets,
-              excludedRef: excludedColumnRef,
-              withTarget: true,
-              buildWhere: (where) => extractFilters(table, tableName, where, relationFilterCtx(filterCtx, tableName))
+              parsedInfo,
+              limits,
+              scope
             });
-            let query = target.insert(table).values(values).returning(returning);
-            const setWhere = withScope(scope, tableName, table, plan.setWhere);
-            query = plan.action === "NOTHING" ? query.onConflictDoNothing(plan.target ? { target: plan.target } : void 0) : query.onConflictDoUpdate({ target: plan.target, set: plan.set, setWhere });
-            return await query;
-          };
-          const result = nestedEntries ? await writeWithNestedOps({
-            executor,
-            runtime: nested,
-            tableName,
-            entries: nestedEntries,
-            remapValues: (values) => applyContextValues(remapFromGraphQLSingleInput(values, table), contextColumns, context),
-            write: (tx, values) => runUpsert(tx, [values]),
-            context
-          }) : await runUpsert(executor, input);
-          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 returning = nestedEntries ? nested.withJoinColumns(tableName, mergedOps(nestedEntries), { ...columns }, table) : columns;
+            const runUpsert = async (target, values) => {
+              const plan = resolveConflictPlan({
+                table,
+                values,
+                onConflict: args.onConflict,
+                pkNames,
+                uniqueSets,
+                excludedRef: excludedColumnRef,
+                withTarget: true,
+                buildWhere: (where) => extractFilters(table, tableName, where, relationFilterCtx(filterCtx, tableName))
+              });
+              let query = target.insert(table).values(values).returning(returning);
+              const setWhere = withScope(scope, tableName, table, plan.setWhere);
+              query = plan.action === "NOTHING" ? query.onConflictDoNothing(plan.target ? { target: plan.target } : void 0) : query.onConflictDoUpdate({ target: plan.target, set: plan.set, setWhere });
+              return await query;
+            };
+            const result = nestedEntries ? await writeWithNestedOps({
+              executor,
+              runtime: nested,
+              tableName,
+              entries: nestedEntries,
+              remapValues: (values) => applyContextValues(remapFromGraphQLSingleInput(values, table), contextColumns, context),
+              write: (tx, values) => runUpsert(tx, [values]),
+              context
+            }) : await runUpsert(executor, input);
+            await runWriteHook(hooks, "after", {
+              table: tableName,
+              operation: "upsert",
+              single,
+              args,
+              rows: result,
+              context,
+              info,
+              tx: executor
+            });
+            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);
+          },
+          !!hooks
+        );
       } catch (e) {
         throw toGraphQLError(e);
       }
@@ -5898,75 +6292,102 @@ var generateUpdate2 = (db, tableName, table, tables, relationMap, setArgs, filte
     }
   };
   const pkNames = pgPrimaryKeyPropNames(table);
+  const hooks = policies?.onWrite?.(tableName, "update");
   return {
     name: fieldName,
     resolver: async (_source, args, context, info) => {
       try {
-        return await runMutation(db, context, info, txCtx, async (executor) => {
-          const { where, set } = args;
-          const scope = policies?.scope?.(context);
-          const parsedInfo = parseResolveInfo3(info, {
-            deep: true
-          });
-          const { columns, hasRelations, withParams } = prepareMutationRelationColumns({
-            relationMap,
-            tables,
-            tableName,
-            typeName,
-            typeNameMapper,
-            table,
-            pkNames,
-            parsedInfo,
-            limits,
-            scope
-          });
-          const entry = nested?.enabled(tableName) ? nested.split(tableName, set) : void 0;
-          const nestedOps = entry && nested.hasOps(entry.ops) ? entry.ops : void 0;
-          const input = stripContextValues(
-            remapUpdateInput(entry ? entry.columns : set, table, tableName),
-            policies?.contextValues?.(tableName)
-          );
-          if (!Object.keys(input).length && !nestedOps) {
-            throw new GraphQLError8("Unable to update with no values specified!");
-          }
-          const relationCtx = relationFilterCtx(filterCtx, tableName);
-          const filters = withScope(
-            scope,
-            tableName,
-            table,
-            single || requireWhere ? extractRequiredFilters(table, tableName, where, fieldName, relationCtx) : where ? extractFilters(table, tableName, where, relationCtx) : void 0
-          );
-          if (single) {
-            await assertSingleMatch(executor, table, filters, fieldName);
-          }
-          const returning = nestedOps ? nested.withJoinColumns(tableName, nestedOps, { ...columns }, table) : columns;
-          const runUpdate = async (target, values) => {
-            const writes = Object.keys(values).length > 0;
-            let query = writes ? target.update(table).set(values) : target.select(returning).from(table);
-            if (filters) {
-              query = query.where(filters);
+        return await runMutation(
+          db,
+          context,
+          info,
+          txCtx,
+          async (executor) => {
+            const { where, set } = args;
+            const scope = policies?.scope?.(context);
+            await runWriteHook(hooks, "before", {
+              table: tableName,
+              operation: "update",
+              single,
+              args,
+              context,
+              info,
+              tx: executor
+            });
+            const parsedInfo = parseResolveInfo3(info, {
+              deep: true
+            });
+            const { columns, hasRelations, withParams } = prepareMutationRelationColumns({
+              relationMap,
+              tables,
+              tableName,
+              typeName,
+              typeNameMapper,
+              table,
+              pkNames,
+              parsedInfo,
+              limits,
+              scope
+            });
+            const entry = nested?.enabled(tableName) ? nested.split(tableName, set) : void 0;
+            const nestedOps = entry && nested.hasOps(entry.ops) ? entry.ops : void 0;
+            const input = stripContextValues(
+              remapUpdateInput(entry ? entry.columns : set, table, tableName),
+              policies?.contextValues?.(tableName)
+            );
+            if (!Object.keys(input).length && !nestedOps) {
+              throw new GraphQLError8("Unable to update with no values specified!");
             }
-            return await (writes ? query.returning(returning) : query);
-          };
-          const result = nestedOps ? await updateWithNestedOps({
-            executor,
-            runtime: nested,
-            tableName,
-            columns: input,
-            ops: nestedOps,
-            remapValues: (values) => values,
-            write: runUpdate,
-            context
-          }) : await runUpdate(executor, input);
-          if (single && result.length > 1) {
-            throw new GraphQLError8(`${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 relationCtx = relationFilterCtx(filterCtx, tableName);
+            const filters = withScope(
+              scope,
+              tableName,
+              table,
+              single || requireWhere ? extractRequiredFilters(table, tableName, where, fieldName, relationCtx) : where ? extractFilters(table, tableName, where, relationCtx) : void 0
+            );
+            if (single) {
+              await assertSingleMatch(executor, table, filters, fieldName);
+            }
+            const returning = nestedOps ? nested.withJoinColumns(tableName, nestedOps, { ...columns }, table) : columns;
+            const runUpdate = async (target, values) => {
+              const writes = Object.keys(values).length > 0;
+              let query = writes ? target.update(table).set(values) : target.select(returning).from(table);
+              if (filters) {
+                query = query.where(filters);
+              }
+              return await (writes ? query.returning(returning) : query);
+            };
+            const result = nestedOps ? await updateWithNestedOps({
+              executor,
+              runtime: nested,
+              tableName,
+              columns: input,
+              ops: nestedOps,
+              remapValues: (values) => values,
+              write: runUpdate,
+              context
+            }) : await runUpdate(executor, input);
+            await runWriteHook(hooks, "after", {
+              table: tableName,
+              operation: "update",
+              single,
+              args,
+              rows: result,
+              context,
+              info,
+              tx: executor
+            });
+            if (single && result.length > 1) {
+              throw new GraphQLError8(`${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);
+          },
+          !!hooks
+        );
       } catch (e) {
         throw toGraphQLError(e);
       }
@@ -5981,94 +6402,121 @@ var generateUpdateMany2 = (db, tableName, table, tables, relationMap, updateMany
     }
   };
   const pkNames = pgPrimaryKeyPropNames(table);
+  const hooks = policies?.onWrite?.(tableName, "updateMany");
   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 GraphQLError8("No updates were provided!");
-          }
-          const scope = policies?.scope?.(context);
-          const contextColumns = policies?.contextValues?.(tableName);
-          const parsedInfo = parseResolveInfo3(info, {
-            deep: true
-          });
-          const { columns, hasRelations, withParams } = prepareMutationRelationColumns({
-            relationMap,
-            tables,
-            tableName,
-            typeName,
-            typeNameMapper,
-            table,
-            pkNames,
-            parsedInfo,
-            limits,
-            scope
-          });
-          const entries = updates.map(({ where, set }) => {
-            const split = nested?.enabled(tableName) ? nested.split(tableName, set) : void 0;
-            const ops = split && nested.hasOps(split.ops) ? split.ops : void 0;
-            const input = stripContextValues(
-              remapUpdateInput(split ? split.columns : set, table, tableName),
-              contextColumns
-            );
-            if (!Object.keys(input).length && !ops) {
-              throw new GraphQLError8("Unable to update with no values specified!");
+        return await runMutation(
+          db,
+          context,
+          info,
+          txCtx,
+          async (executor) => {
+            const { updates } = args;
+            if (!updates.length) {
+              throw new GraphQLError8("No updates were provided!");
             }
-            return {
-              set: input,
-              ops,
-              filters: withScope(
-                scope,
-                tableName,
-                table,
-                where ? extractFilters(table, tableName, where, relationFilterCtx(filterCtx, tableName)) : void 0
-              )
-            };
-          });
-          const returning = entries.some((entry) => entry.ops) ? nested.withJoinColumns(
-            tableName,
-            mergedOps(entries.map((entry) => ({ ops: entry.ops ?? {} }))),
-            {
-              ...columns
-            },
-            table
-          ) : columns;
-          const perEntry = await executor.transaction(async (tx) => {
-            const results = [];
-            for (const entry of entries) {
-              const values = entry.ops ? { ...entry.set, ...await nested.applyParentSide(tx, tableName, entry.ops, context) } : entry.set;
-              const writes = Object.keys(values).length > 0;
-              let query = writes ? tx.update(table).set(values) : tx.select(returning).from(table);
-              if (entry.filters) {
-                query = query.where(entry.filters);
+            await runWriteHook(hooks, "before", {
+              table: tableName,
+              operation: "updateMany",
+              single: false,
+              args,
+              context,
+              info,
+              tx: executor
+            });
+            const scope = policies?.scope?.(context);
+            const contextColumns = policies?.contextValues?.(tableName);
+            const parsedInfo = parseResolveInfo3(info, {
+              deep: true
+            });
+            const { columns, hasRelations, withParams } = prepareMutationRelationColumns({
+              relationMap,
+              tables,
+              tableName,
+              typeName,
+              typeNameMapper,
+              table,
+              pkNames,
+              parsedInfo,
+              limits,
+              scope
+            });
+            const entries = updates.map(({ where, set }) => {
+              const split = nested?.enabled(tableName) ? nested.split(tableName, set) : void 0;
+              const ops = split && nested.hasOps(split.ops) ? split.ops : void 0;
+              const input = stripContextValues(
+                remapUpdateInput(split ? split.columns : set, table, tableName),
+                contextColumns
+              );
+              if (!Object.keys(input).length && !ops) {
+                throw new GraphQLError8("Unable to update with no values specified!");
               }
-              const rows = await (writes ? query.returning(returning) : query);
-              if (entry.ops) {
-                await nested.applyChildSide(tx, tableName, entry.ops, rows, context);
+              return {
+                set: input,
+                ops,
+                filters: withScope(
+                  scope,
+                  tableName,
+                  table,
+                  where ? extractFilters(table, tableName, where, relationFilterCtx(filterCtx, tableName)) : void 0
+                )
+              };
+            });
+            const returning = entries.some((entry) => entry.ops) ? nested.withJoinColumns(
+              tableName,
+              mergedOps(entries.map((entry) => ({ ops: entry.ops ?? {} }))),
+              {
+                ...columns
+              },
+              table
+            ) : columns;
+            const perEntry = await executor.transaction(async (tx) => {
+              const results = [];
+              for (const entry of entries) {
+                const values = entry.ops ? { ...entry.set, ...await nested.applyParentSide(tx, tableName, entry.ops, context) } : entry.set;
+                const writes = Object.keys(values).length > 0;
+                let query = writes ? tx.update(table).set(values) : tx.select(returning).from(table);
+                if (entry.filters) {
+                  query = query.where(entry.filters);
+                }
+                const rows = await (writes ? query.returning(returning) : query);
+                if (entry.ops) {
+                  await nested.applyChildSide(tx, tableName, entry.ops, rows, context);
+                }
+                results.push(rows);
               }
-              results.push(rows);
-            }
-            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));
+              return results;
+            });
+            const flatRows = perEntry.flat();
+            await runWriteHook(hooks, "after", {
+              table: tableName,
+              operation: "updateMany",
+              single: false,
+              args,
+              rows: flatRows,
+              context,
+              info,
+              tx: executor
+            });
+            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;
             }
-            offset += rows.length;
-          }
-          return output;
-        });
+            return output;
+          },
+          !!hooks
+        );
       } catch (e) {
         throw toGraphQLError(e);
       }
@@ -6078,6 +6526,8 @@ var generateUpdateMany2 = (db, tableName, table, tables, relationMap, updateMany
 };
 var generateDelete2 = (db, tableName, table, filterArgs, fieldName, typeName, single, requireWhere, filterCtx, selectionCtx, txCtx, policies, restore = false) => {
   const softDelete = policies?.softDelete?.(tableName);
+  const operation = restore ? "restore" : "delete";
+  const hooks = policies?.onWrite?.(tableName, operation);
   const queryArgs = {
     where: {
       type: single || requireWhere ? new GraphQLNonNull7(filterArgs) : filterArgs
@@ -6087,42 +6537,68 @@ var generateDelete2 = (db, tableName, table, filterArgs, fieldName, typeName, si
     name: fieldName,
     resolver: async (_source, args, context, info) => {
       try {
-        return await runMutation(db, context, info, txCtx, async (executor) => {
-          const { where } = args;
-          const scope = policies?.scope?.(context);
-          const parsedInfo = parseResolveInfo3(info, {
-            deep: true
-          });
-          const columns = extractSelectedColumnsFromTreeSQLFormat(
-            parsedInfo.fieldsByTypeName[typeName],
-            table,
-            selectionCtx
-          );
-          const relationCtx = relationFilterCtx(filterCtx, tableName);
-          const filters = withScope(
-            scope,
-            tableName,
-            table,
-            single || requireWhere ? extractRequiredFilters(table, tableName, where, fieldName, relationCtx) : where ? extractFilters(table, tableName, where, relationCtx) : void 0,
-            restore ? "ONLY" : void 0
-          );
-          if (single) {
-            await assertSingleMatch(executor, table, filters, fieldName);
-          }
-          let query = softDelete ? executor.update(table).set({ [softDelete.columnName]: restore ? softDelete.writeRestored : softDelete.writeDeleted() }) : executor.delete(table);
-          if (filters) {
-            query = query.where(filters);
-          }
-          query = query.returning(columns);
-          const result = await query;
-          if (single && result.length > 1) {
-            throw new GraphQLError8(`${fieldName}: 'where' matched more than one row!`);
-          }
-          if (single) {
-            return result[0] ? remapToGraphQLSingleOutput(result[0], tableName, table) : void 0;
-          }
-          return remapToGraphQLArrayOutput(result, tableName, table);
-        });
+        return await runMutation(
+          db,
+          context,
+          info,
+          txCtx,
+          async (executor) => {
+            const { where } = args;
+            const scope = policies?.scope?.(context);
+            await runWriteHook(hooks, "before", {
+              table: tableName,
+              operation,
+              single,
+              args,
+              context,
+              info,
+              tx: executor
+            });
+            const parsedInfo = parseResolveInfo3(info, {
+              deep: true
+            });
+            const columns = extractSelectedColumnsFromTreeSQLFormat(
+              parsedInfo.fieldsByTypeName[typeName],
+              table,
+              selectionCtx
+            );
+            const relationCtx = relationFilterCtx(filterCtx, tableName);
+            const filters = withScope(
+              scope,
+              tableName,
+              table,
+              single || requireWhere ? extractRequiredFilters(table, tableName, where, fieldName, relationCtx) : where ? extractFilters(table, tableName, where, relationCtx) : void 0,
+              restore ? "ONLY" : void 0
+            );
+            if (single) {
+              await assertSingleMatch(executor, table, filters, fieldName);
+            }
+            let query = softDelete ? executor.update(table).set({ [softDelete.columnName]: restore ? softDelete.writeRestored : softDelete.writeDeleted() }) : executor.delete(table);
+            if (filters) {
+              query = query.where(filters);
+            }
+            query = query.returning(columns);
+            const result = await query;
+            await runWriteHook(hooks, "after", {
+              table: tableName,
+              operation,
+              single,
+              args,
+              rows: result,
+              context,
+              info,
+              tx: executor
+            });
+            if (single && result.length > 1) {
+              throw new GraphQLError8(`${fieldName}: 'where' matched more than one row!`);
+            }
+            if (single) {
+              return result[0] ? remapToGraphQLSingleOutput(result[0], tableName, table) : void 0;
+            }
+            return remapToGraphQLArrayOutput(result, tableName, table);
+          },
+          !!hooks
+        );
       } catch (e) {
         throw toGraphQLError(e);
       }
@@ -6853,58 +7329,85 @@ var generateInsertArray3 = (db, tableName, table, tables, relationMap, baseType,
     }
   };
   const pkNames = sqlitePrimaryKeyPropNames(table);
+  const hooks = policies?.onWrite?.(tableName, "insert");
   return {
     name: fieldName,
     resolver: async (_source, args, context, info) => {
       try {
-        return await runMutation(db, context, info, txCtx, async (executor) => {
-          if (!args.values.length) {
-            throw new GraphQLError9("No values were provided!");
-          }
-          const entries = nested?.enabled(tableName) ? args.values.map((values) => nested.split(tableName, values)) : void 0;
-          const nestedEntries = entries?.some((entry) => nested.hasOps(entry.ops)) ? entries : void 0;
-          const contextColumns = policies?.contextValues?.(tableName);
-          const scope = policies?.scope?.(context);
-          const input = nestedEntries ? [] : applyContextValuesAll(
-            remapFromGraphQLArrayInput(entries ? entries.map((entry) => entry.columns) : args.values, table),
-            contextColumns,
-            context
-          );
-          const parsedInfo = parseResolveInfo4(info, {
-            deep: true
-          });
-          const { columns, hasRelations, withParams } = prepareMutationRelationColumns({
-            relationMap,
-            tables,
-            tableName,
-            typeName,
-            typeNameMapper,
-            table,
-            pkNames,
-            parsedInfo,
-            limits,
-            scope
-          });
-          const returning = nestedEntries ? nested.withJoinColumns(tableName, mergedOps(nestedEntries), { ...columns }, table) : columns;
-          const runInsert = async (target, values) => {
-            let query = target.insert(table).values(values).returning(returning);
-            if (conflictDoNothing) {
-              query = query.onConflictDoNothing();
+        return await runMutation(
+          db,
+          context,
+          info,
+          txCtx,
+          async (executor) => {
+            if (!args.values.length) {
+              throw new GraphQLError9("No values were provided!");
             }
-            return await query;
-          };
-          const result = nestedEntries ? await writeWithNestedOps({
-            executor,
-            runtime: nested,
-            tableName,
-            entries: nestedEntries,
-            remapValues: (values) => applyContextValues(remapFromGraphQLSingleInput(values, table), contextColumns, context),
-            write: (tx, values) => runInsert(tx, [values]),
-            context
-          }) : await runInsert(executor, input);
-          const enriched = hasRelations ? await eagerLoadMutationRelations(executor, tableName, result, pkNames, withParams) : result;
-          return remapToGraphQLArrayOutput(enriched, tableName, table, relationMap);
-        });
+            await runWriteHook(hooks, "before", {
+              table: tableName,
+              operation: "insert",
+              single: false,
+              args,
+              context,
+              info,
+              tx: executor
+            });
+            const entries = nested?.enabled(tableName) ? args.values.map((values) => nested.split(tableName, values)) : void 0;
+            const nestedEntries = entries?.some((entry) => nested.hasOps(entry.ops)) ? entries : void 0;
+            const contextColumns = policies?.contextValues?.(tableName);
+            const scope = policies?.scope?.(context);
+            const input = nestedEntries ? [] : applyContextValuesAll(
+              remapFromGraphQLArrayInput(entries ? entries.map((entry) => entry.columns) : args.values, table),
+              contextColumns,
+              context
+            );
+            const parsedInfo = parseResolveInfo4(info, {
+              deep: true
+            });
+            const { columns, hasRelations, withParams } = prepareMutationRelationColumns({
+              relationMap,
+              tables,
+              tableName,
+              typeName,
+              typeNameMapper,
+              table,
+              pkNames,
+              parsedInfo,
+              limits,
+              scope
+            });
+            const returning = nestedEntries ? nested.withJoinColumns(tableName, mergedOps(nestedEntries), { ...columns }, table) : columns;
+            const runInsert = async (target, values) => {
+              let query = target.insert(table).values(values).returning(returning);
+              if (conflictDoNothing) {
+                query = query.onConflictDoNothing();
+              }
+              return await query;
+            };
+            const result = nestedEntries ? await writeWithNestedOps({
+              executor,
+              runtime: nested,
+              tableName,
+              entries: nestedEntries,
+              remapValues: (values) => applyContextValues(remapFromGraphQLSingleInput(values, table), contextColumns, context),
+              write: (tx, values) => runInsert(tx, [values]),
+              context
+            }) : await runInsert(executor, input);
+            await runWriteHook(hooks, "after", {
+              table: tableName,
+              operation: "insert",
+              single: false,
+              args,
+              rows: result,
+              context,
+              info,
+              tx: executor
+            });
+            const enriched = hasRelations ? await eagerLoadMutationRelations(executor, tableName, result, pkNames, withParams) : result;
+            return remapToGraphQLArrayOutput(enriched, tableName, table, relationMap);
+          },
+          !!hooks
+        );
       } catch (e) {
         throw toGraphQLError(e);
       }
@@ -6919,61 +7422,88 @@ var generateInsertSingle3 = (db, tableName, table, tables, relationMap, baseType
     }
   };
   const pkNames = sqlitePrimaryKeyPropNames(table);
+  const hooks = policies?.onWrite?.(tableName, "insert");
   return {
     name: fieldName,
     resolver: async (_source, args, context, info) => {
       try {
-        return await runMutation(db, context, info, txCtx, async (executor) => {
-          const entry = nested?.enabled(tableName) ? nested.split(tableName, args.values) : void 0;
-          const nestedEntry = entry && nested.hasOps(entry.ops) ? entry : void 0;
-          const contextColumns = policies?.contextValues?.(tableName);
-          const scope = policies?.scope?.(context);
-          const input = nestedEntry ? {} : applyContextValues(
-            remapFromGraphQLSingleInput(entry ? entry.columns : args.values, table),
-            contextColumns,
-            context
-          );
-          const parsedInfo = parseResolveInfo4(info, {
-            deep: true
-          });
-          const { columns, hasRelations, withParams } = prepareMutationRelationColumns({
-            relationMap,
-            tables,
-            tableName,
-            typeName,
-            typeNameMapper,
-            table,
-            pkNames,
-            parsedInfo,
-            limits,
-            scope
-          });
-          const returning = nestedEntry ? nested.withJoinColumns(tableName, nestedEntry.ops, { ...columns }, table) : columns;
-          const runInsert = async (target, values) => {
-            let query = target.insert(table).values(values).returning(returning);
-            if (conflictDoNothing) {
-              query = query.onConflictDoNothing();
-            }
-            return await query;
-          };
-          const result = nestedEntry ? await writeWithNestedOps({
-            executor,
-            runtime: nested,
-            tableName,
-            entries: [nestedEntry],
-            remapValues: (values) => applyContextValues(remapFromGraphQLSingleInput(values, table), contextColumns, context),
-            write: runInsert,
-            context
-          }) : await runInsert(executor, input);
-          if (!result[0]) {
-            if (!conflictDoNothing) {
-              throw new GraphQLError9(`${fieldName}: the insert returned no row.`);
+        return await runMutation(
+          db,
+          context,
+          info,
+          txCtx,
+          async (executor) => {
+            await runWriteHook(hooks, "before", {
+              table: tableName,
+              operation: "insert",
+              single: true,
+              args,
+              context,
+              info,
+              tx: executor
+            });
+            const entry = nested?.enabled(tableName) ? nested.split(tableName, args.values) : void 0;
+            const nestedEntry = entry && nested.hasOps(entry.ops) ? entry : void 0;
+            const contextColumns = policies?.contextValues?.(tableName);
+            const scope = policies?.scope?.(context);
+            const input = nestedEntry ? {} : applyContextValues(
+              remapFromGraphQLSingleInput(entry ? entry.columns : args.values, table),
+              contextColumns,
+              context
+            );
+            const parsedInfo = parseResolveInfo4(info, {
+              deep: true
+            });
+            const { columns, hasRelations, withParams } = prepareMutationRelationColumns({
+              relationMap,
+              tables,
+              tableName,
+              typeName,
+              typeNameMapper,
+              table,
+              pkNames,
+              parsedInfo,
+              limits,
+              scope
+            });
+            const returning = nestedEntry ? nested.withJoinColumns(tableName, nestedEntry.ops, { ...columns }, table) : columns;
+            const runInsert = async (target, values) => {
+              let query = target.insert(table).values(values).returning(returning);
+              if (conflictDoNothing) {
+                query = query.onConflictDoNothing();
+              }
+              return await query;
+            };
+            const result = nestedEntry ? await writeWithNestedOps({
+              executor,
+              runtime: nested,
+              tableName,
+              entries: [nestedEntry],
+              remapValues: (values) => applyContextValues(remapFromGraphQLSingleInput(values, table), contextColumns, context),
+              write: runInsert,
+              context
+            }) : await runInsert(executor, input);
+            await runWriteHook(hooks, "after", {
+              table: tableName,
+              operation: "insert",
+              single: true,
+              args,
+              rows: result,
+              context,
+              info,
+              tx: executor
+            });
+            if (!result[0]) {
+              if (!conflictDoNothing) {
+                throw new GraphQLError9(`${fieldName}: the insert returned no row.`);
+              }
+              return void 0;
             }
-            return void 0;
-          }
-          const enriched = hasRelations ? await eagerLoadMutationRelations(executor, tableName, result, pkNames, withParams) : result;
-          return remapToGraphQLSingleOutput(enriched[0], tableName, table, relationMap);
-        });
+            const enriched = hasRelations ? await eagerLoadMutationRelations(executor, tableName, result, pkNames, withParams) : result;
+            return remapToGraphQLSingleOutput(enriched[0], tableName, table, relationMap);
+          },
+          !!hooks
+        );
       } catch (e) {
         throw toGraphQLError(e);
       }
@@ -6992,69 +7522,96 @@ var generateUpsert3 = (db, tableName, table, tables, relationMap, baseType, onCo
     }
   };
   const pkNames = sqlitePrimaryKeyPropNames(table);
+  const hooks = policies?.onWrite?.(tableName, "upsert");
   return {
     name: fieldName,
     resolver: async (_source, args, context, info) => {
       try {
-        return await runMutation(db, context, info, txCtx, async (executor) => {
-          const supplied = single ? [args.values] : args.values;
-          if (!supplied.length) {
-            throw new GraphQLError9("No values were provided!");
-          }
-          const entries = nested?.enabled(tableName) ? supplied.map((values) => nested.split(tableName, values)) : void 0;
-          const nestedEntries = entries?.some((entry) => nested.hasOps(entry.ops)) ? entries : void 0;
-          const contextColumns = policies?.contextValues?.(tableName);
-          const scope = policies?.scope?.(context);
-          const input = nestedEntries ? [] : applyContextValuesAll(
-            remapFromGraphQLArrayInput(entries ? entries.map((entry) => entry.columns) : supplied, table),
-            contextColumns,
-            context
-          );
-          const parsedInfo = parseResolveInfo4(info, { deep: true });
-          const { columns, hasRelations, withParams } = prepareMutationRelationColumns({
-            relationMap,
-            tables,
-            tableName,
-            typeName,
-            typeNameMapper,
-            table,
-            pkNames,
-            parsedInfo,
-            limits,
-            scope
-          });
-          const returning = nestedEntries ? nested.withJoinColumns(tableName, mergedOps(nestedEntries), { ...columns }, table) : columns;
-          const runUpsert = async (target, values) => {
-            const plan = resolveConflictPlan({
+        return await runMutation(
+          db,
+          context,
+          info,
+          txCtx,
+          async (executor) => {
+            const supplied = single ? [args.values] : args.values;
+            if (!supplied.length) {
+              throw new GraphQLError9("No values were provided!");
+            }
+            await runWriteHook(hooks, "before", {
+              table: tableName,
+              operation: "upsert",
+              single,
+              args,
+              context,
+              info,
+              tx: executor
+            });
+            const entries = nested?.enabled(tableName) ? supplied.map((values) => nested.split(tableName, values)) : void 0;
+            const nestedEntries = entries?.some((entry) => nested.hasOps(entry.ops)) ? entries : void 0;
+            const contextColumns = policies?.contextValues?.(tableName);
+            const scope = policies?.scope?.(context);
+            const input = nestedEntries ? [] : applyContextValuesAll(
+              remapFromGraphQLArrayInput(entries ? entries.map((entry) => entry.columns) : supplied, table),
+              contextColumns,
+              context
+            );
+            const parsedInfo = parseResolveInfo4(info, { deep: true });
+            const { columns, hasRelations, withParams } = prepareMutationRelationColumns({
+              relationMap,
+              tables,
+              tableName,
+              typeName,
+              typeNameMapper,
               table,
-              values,
-              onConflict: args.onConflict,
               pkNames,
-              uniqueSets,
-              excludedRef: excludedColumnRef,
-              withTarget: true,
-              buildWhere: (where) => extractFilters(table, tableName, where, relationFilterCtx(filterCtx, tableName))
+              parsedInfo,
+              limits,
+              scope
             });
-            let query = target.insert(table).values(values).returning(returning);
-            const setWhere = withScope(scope, tableName, table, plan.setWhere);
-            query = plan.action === "NOTHING" ? query.onConflictDoNothing(plan.target ? { target: plan.target } : void 0) : query.onConflictDoUpdate({ target: plan.target, set: plan.set, setWhere });
-            return await query;
-          };
-          const result = nestedEntries ? await writeWithNestedOps({
-            executor,
-            runtime: nested,
-            tableName,
-            entries: nestedEntries,
-            remapValues: (values) => applyContextValues(remapFromGraphQLSingleInput(values, table), contextColumns, context),
-            write: (tx, values) => runUpsert(tx, [values]),
-            context
-          }) : await runUpsert(executor, input);
-          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 returning = nestedEntries ? nested.withJoinColumns(tableName, mergedOps(nestedEntries), { ...columns }, table) : columns;
+            const runUpsert = async (target, values) => {
+              const plan = resolveConflictPlan({
+                table,
+                values,
+                onConflict: args.onConflict,
+                pkNames,
+                uniqueSets,
+                excludedRef: excludedColumnRef,
+                withTarget: true,
+                buildWhere: (where) => extractFilters(table, tableName, where, relationFilterCtx(filterCtx, tableName))
+              });
+              let query = target.insert(table).values(values).returning(returning);
+              const setWhere = withScope(scope, tableName, table, plan.setWhere);
+              query = plan.action === "NOTHING" ? query.onConflictDoNothing(plan.target ? { target: plan.target } : void 0) : query.onConflictDoUpdate({ target: plan.target, set: plan.set, setWhere });
+              return await query;
+            };
+            const result = nestedEntries ? await writeWithNestedOps({
+              executor,
+              runtime: nested,
+              tableName,
+              entries: nestedEntries,
+              remapValues: (values) => applyContextValues(remapFromGraphQLSingleInput(values, table), contextColumns, context),
+              write: (tx, values) => runUpsert(tx, [values]),
+              context
+            }) : await runUpsert(executor, input);
+            await runWriteHook(hooks, "after", {
+              table: tableName,
+              operation: "upsert",
+              single,
+              args,
+              rows: result,
+              context,
+              info,
+              tx: executor
+            });
+            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);
+          },
+          !!hooks
+        );
       } catch (e) {
         throw toGraphQLError(e);
       }
@@ -7072,75 +7629,102 @@ var generateUpdate3 = (db, tableName, table, tables, relationMap, setArgs, filte
     }
   };
   const pkNames = sqlitePrimaryKeyPropNames(table);
+  const hooks = policies?.onWrite?.(tableName, "update");
   return {
     name: fieldName,
     resolver: async (_source, args, context, info) => {
       try {
-        return await runMutation(db, context, info, txCtx, async (executor) => {
-          const { where, set } = args;
-          const scope = policies?.scope?.(context);
-          const parsedInfo = parseResolveInfo4(info, {
-            deep: true
-          });
-          const { columns, hasRelations, withParams } = prepareMutationRelationColumns({
-            relationMap,
-            tables,
-            tableName,
-            typeName,
-            typeNameMapper,
-            table,
-            pkNames,
-            parsedInfo,
-            limits,
-            scope
-          });
-          const entry = nested?.enabled(tableName) ? nested.split(tableName, set) : void 0;
-          const nestedOps = entry && nested.hasOps(entry.ops) ? entry.ops : void 0;
-          const input = stripContextValues(
-            remapUpdateInput(entry ? entry.columns : set, table, tableName),
-            policies?.contextValues?.(tableName)
-          );
-          if (!Object.keys(input).length && !nestedOps) {
-            throw new GraphQLError9("Unable to update with no values specified!");
-          }
-          const relationCtx = relationFilterCtx(filterCtx, tableName);
-          const filters = withScope(
-            scope,
-            tableName,
-            table,
-            single || requireWhere ? extractRequiredFilters(table, tableName, where, fieldName, relationCtx) : where ? extractFilters(table, tableName, where, relationCtx) : void 0
-          );
-          if (single) {
-            await assertSingleMatch(executor, table, filters, fieldName);
-          }
-          const returning = nestedOps ? nested.withJoinColumns(tableName, nestedOps, { ...columns }, table) : columns;
-          const runUpdate = async (target, values) => {
-            const writes = Object.keys(values).length > 0;
-            let query = writes ? target.update(table).set(values) : target.select(returning).from(table);
-            if (filters) {
-              query = query.where(filters);
+        return await runMutation(
+          db,
+          context,
+          info,
+          txCtx,
+          async (executor) => {
+            await runWriteHook(hooks, "before", {
+              table: tableName,
+              operation: "update",
+              single,
+              args,
+              context,
+              info,
+              tx: executor
+            });
+            const { where, set } = args;
+            const scope = policies?.scope?.(context);
+            const parsedInfo = parseResolveInfo4(info, {
+              deep: true
+            });
+            const { columns, hasRelations, withParams } = prepareMutationRelationColumns({
+              relationMap,
+              tables,
+              tableName,
+              typeName,
+              typeNameMapper,
+              table,
+              pkNames,
+              parsedInfo,
+              limits,
+              scope
+            });
+            const entry = nested?.enabled(tableName) ? nested.split(tableName, set) : void 0;
+            const nestedOps = entry && nested.hasOps(entry.ops) ? entry.ops : void 0;
+            const input = stripContextValues(
+              remapUpdateInput(entry ? entry.columns : set, table, tableName),
+              policies?.contextValues?.(tableName)
+            );
+            if (!Object.keys(input).length && !nestedOps) {
+              throw new GraphQLError9("Unable to update with no values specified!");
             }
-            return await (writes ? query.returning(returning) : query);
-          };
-          const result = nestedOps ? await updateWithNestedOps({
-            executor,
-            runtime: nested,
-            tableName,
-            columns: input,
-            ops: nestedOps,
-            remapValues: (values) => values,
-            write: runUpdate,
-            context
-          }) : await runUpdate(executor, input);
-          if (single && result.length > 1) {
-            throw new GraphQLError9(`${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 relationCtx = relationFilterCtx(filterCtx, tableName);
+            const filters = withScope(
+              scope,
+              tableName,
+              table,
+              single || requireWhere ? extractRequiredFilters(table, tableName, where, fieldName, relationCtx) : where ? extractFilters(table, tableName, where, relationCtx) : void 0
+            );
+            if (single) {
+              await assertSingleMatch(executor, table, filters, fieldName);
+            }
+            const returning = nestedOps ? nested.withJoinColumns(tableName, nestedOps, { ...columns }, table) : columns;
+            const runUpdate = async (target, values) => {
+              const writes = Object.keys(values).length > 0;
+              let query = writes ? target.update(table).set(values) : target.select(returning).from(table);
+              if (filters) {
+                query = query.where(filters);
+              }
+              return await (writes ? query.returning(returning) : query);
+            };
+            const result = nestedOps ? await updateWithNestedOps({
+              executor,
+              runtime: nested,
+              tableName,
+              columns: input,
+              ops: nestedOps,
+              remapValues: (values) => values,
+              write: runUpdate,
+              context
+            }) : await runUpdate(executor, input);
+            await runWriteHook(hooks, "after", {
+              table: tableName,
+              operation: "update",
+              single,
+              args,
+              rows: result,
+              context,
+              info,
+              tx: executor
+            });
+            if (single && result.length > 1) {
+              throw new GraphQLError9(`${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);
+          },
+          !!hooks
+        );
       } catch (e) {
         throw toGraphQLError(e);
       }
@@ -7155,122 +7739,149 @@ var generateUpdateMany3 = (db, tableName, table, tables, relationMap, updateMany
     }
   };
   const pkNames = sqlitePrimaryKeyPropNames(table);
+  const hooks = policies?.onWrite?.(tableName, "updateMany");
   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 GraphQLError9("No updates were provided!");
-          }
-          const scope = policies?.scope?.(context);
-          const contextColumns = policies?.contextValues?.(tableName);
-          const parsedInfo = parseResolveInfo4(info, {
-            deep: true
-          });
-          const { columns, hasRelations, withParams } = prepareMutationRelationColumns({
-            relationMap,
-            tables,
-            tableName,
-            typeName,
-            typeNameMapper,
-            table,
-            pkNames,
-            parsedInfo,
-            limits,
-            scope
-          });
-          const entries = updates.map(({ where, set }) => {
-            const split = nested?.enabled(tableName) ? nested.split(tableName, set) : void 0;
-            const ops = split && nested.hasOps(split.ops) ? split.ops : void 0;
-            const input = stripContextValues(
-              remapUpdateInput(split ? split.columns : set, table, tableName),
-              contextColumns
-            );
-            if (!Object.keys(input).length && !ops) {
-              throw new GraphQLError9("Unable to update with no values specified!");
+        return await runMutation(
+          db,
+          context,
+          info,
+          txCtx,
+          async (executor) => {
+            const { updates } = args;
+            if (!updates.length) {
+              throw new GraphQLError9("No updates were provided!");
             }
-            return {
-              set: input,
-              ops,
-              filters: withScope(
-                scope,
-                tableName,
-                table,
-                where ? extractFilters(table, tableName, where, relationFilterCtx(filterCtx, tableName)) : void 0
-              )
+            await runWriteHook(hooks, "before", {
+              table: tableName,
+              operation: "updateMany",
+              single: false,
+              args,
+              context,
+              info,
+              tx: executor
+            });
+            const scope = policies?.scope?.(context);
+            const contextColumns = policies?.contextValues?.(tableName);
+            const parsedInfo = parseResolveInfo4(info, {
+              deep: true
+            });
+            const { columns, hasRelations, withParams } = prepareMutationRelationColumns({
+              relationMap,
+              tables,
+              tableName,
+              typeName,
+              typeNameMapper,
+              table,
+              pkNames,
+              parsedInfo,
+              limits,
+              scope
+            });
+            const entries = updates.map(({ where, set }) => {
+              const split = nested?.enabled(tableName) ? nested.split(tableName, set) : void 0;
+              const ops = split && nested.hasOps(split.ops) ? split.ops : void 0;
+              const input = stripContextValues(
+                remapUpdateInput(split ? split.columns : set, table, tableName),
+                contextColumns
+              );
+              if (!Object.keys(input).length && !ops) {
+                throw new GraphQLError9("Unable to update with no values specified!");
+              }
+              return {
+                set: input,
+                ops,
+                filters: withScope(
+                  scope,
+                  tableName,
+                  table,
+                  where ? extractFilters(table, tableName, where, relationFilterCtx(filterCtx, tableName)) : void 0
+                )
+              };
+            });
+            const anyNested = entries.some((entry) => entry.ops);
+            const returning = anyNested ? nested.withJoinColumns(
+              tableName,
+              mergedOps(entries.map((entry) => ({ ops: entry.ops ?? {} }))),
+              { ...columns },
+              table
+            ) : columns;
+            const runEntry = (tx, entry) => {
+              let query = tx.update(table).set(entry.set);
+              if (entry.filters) {
+                query = query.where(entry.filters);
+              }
+              return query.returning(returning).all();
             };
-          });
-          const anyNested = entries.some((entry) => entry.ops);
-          const returning = anyNested ? nested.withJoinColumns(
-            tableName,
-            mergedOps(entries.map((entry) => ({ ops: entry.ops ?? {} }))),
-            { ...columns },
-            table
-          ) : columns;
-          const runEntry = (tx, entry) => {
-            let query = tx.update(table).set(entry.set);
-            if (entry.filters) {
-              query = query.where(entry.filters);
-            }
-            return query.returning(returning).all();
-          };
-          const runNestedEntry = async (tx, entry) => {
-            const values = entry.ops ? { ...entry.set, ...await nested.applyParentSide(tx, tableName, entry.ops, context) } : entry.set;
-            const writes = Object.keys(values).length > 0;
-            let query = writes ? tx.update(table).set(values) : tx.select(returning).from(table);
-            if (entry.filters) {
-              query = query.where(entry.filters);
-            }
-            const rows = await (writes ? query.returning(returning) : query);
-            if (entry.ops) {
-              await nested.applyChildSide(tx, tableName, entry.ops, rows, context);
-            }
-            return rows;
-          };
-          const perEntry = await executor.transaction((tx) => {
-            if (anyNested) {
-              return (async () => {
-                const results2 = [];
-                for (const entry of entries) {
-                  results2.push(await runNestedEntry(tx, entry));
-                }
-                return results2;
-              })();
-            }
-            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));
+            const runNestedEntry = async (tx, entry) => {
+              const values = entry.ops ? { ...entry.set, ...await nested.applyParentSide(tx, tableName, entry.ops, context) } : entry.set;
+              const writes = Object.keys(values).length > 0;
+              let query = writes ? tx.update(table).set(values) : tx.select(returning).from(table);
+              if (entry.filters) {
+                query = query.where(entry.filters);
+              }
+              const rows = await (writes ? query.returning(returning) : query);
+              if (entry.ops) {
+                await nested.applyChildSide(tx, tableName, entry.ops, rows, context);
+              }
+              return rows;
+            };
+            const perEntry = await executor.transaction((tx) => {
+              if (anyNested) {
+                return (async () => {
+                  const results2 = [];
+                  for (const entry of entries) {
+                    results2.push(await runNestedEntry(tx, entry));
+                  }
+                  return results2;
+                })();
+              }
+              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();
+            await runWriteHook(hooks, "after", {
+              table: tableName,
+              operation: "updateMany",
+              single: false,
+              args,
+              rows: flatRows,
+              context,
+              info,
+              tx: executor
+            });
+            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;
             }
-            offset += rows.length;
-          }
-          return output;
-        });
+            return output;
+          },
+          !!hooks
+        );
       } catch (e) {
         throw toGraphQLError(e);
       }
@@ -7280,51 +7891,79 @@ var generateUpdateMany3 = (db, tableName, table, tables, relationMap, updateMany
 };
 var generateDelete3 = (db, tableName, table, filterArgs, fieldName, typeName, single, requireWhere, filterCtx, selectionCtx, txCtx, policies, restore = false) => {
   const softDelete = policies?.softDelete?.(tableName);
+  const operation = restore ? "restore" : "delete";
   const queryArgs = {
     where: {
       type: single || requireWhere ? new GraphQLNonNull8(filterArgs) : filterArgs
     }
   };
+  const hooks = policies?.onWrite?.(tableName, operation);
   return {
     name: fieldName,
     resolver: async (_source, args, context, info) => {
       try {
-        return await runMutation(db, context, info, txCtx, async (executor) => {
-          const { where } = args;
-          const scope = policies?.scope?.(context);
-          const parsedInfo = parseResolveInfo4(info, {
-            deep: true
-          });
-          const columns = extractSelectedColumnsFromTreeSQLFormat(
-            parsedInfo.fieldsByTypeName[typeName],
-            table,
-            selectionCtx
-          );
-          const relationCtx = relationFilterCtx(filterCtx, tableName);
-          const filters = withScope(
-            scope,
-            tableName,
-            table,
-            single || requireWhere ? extractRequiredFilters(table, tableName, where, fieldName, relationCtx) : where ? extractFilters(table, tableName, where, relationCtx) : void 0,
-            restore ? "ONLY" : void 0
-          );
-          if (single) {
-            await assertSingleMatch(executor, table, filters, fieldName);
-          }
-          let query = softDelete ? executor.update(table).set({ [softDelete.columnName]: restore ? softDelete.writeRestored : softDelete.writeDeleted() }) : executor.delete(table);
-          if (filters) {
-            query = query.where(filters);
-          }
-          query = query.returning(columns);
-          const result = await query;
-          if (single && result.length > 1) {
-            throw new GraphQLError9(`${fieldName}: 'where' matched more than one row!`);
-          }
-          if (single) {
-            return result[0] ? remapToGraphQLSingleOutput(result[0], tableName, table) : void 0;
-          }
-          return remapToGraphQLArrayOutput(result, tableName, table);
-        });
+        return await runMutation(
+          db,
+          context,
+          info,
+          txCtx,
+          async (executor) => {
+            await runWriteHook(hooks, "before", {
+              table: tableName,
+              operation,
+              single,
+              args,
+              context,
+              info,
+              tx: executor
+            });
+            const { where } = args;
+            const scope = policies?.scope?.(context);
+            const parsedInfo = parseResolveInfo4(info, {
+              deep: true
+            });
+            const columns = extractSelectedColumnsFromTreeSQLFormat(
+              parsedInfo.fieldsByTypeName[typeName],
+              table,
+              selectionCtx
+            );
+            const relationCtx = relationFilterCtx(filterCtx, tableName);
+            const filters = withScope(
+              scope,
+              tableName,
+              table,
+              single || requireWhere ? extractRequiredFilters(table, tableName, where, fieldName, relationCtx) : where ? extractFilters(table, tableName, where, relationCtx) : void 0,
+              restore ? "ONLY" : void 0
+            );
+            if (single) {
+              await assertSingleMatch(executor, table, filters, fieldName);
+            }
+            let query = softDelete ? executor.update(table).set({ [softDelete.columnName]: restore ? softDelete.writeRestored : softDelete.writeDeleted() }) : executor.delete(table);
+            if (filters) {
+              query = query.where(filters);
+            }
+            query = query.returning(columns);
+            const result = await query;
+            await runWriteHook(hooks, "after", {
+              table: tableName,
+              operation,
+              single,
+              args,
+              rows: result,
+              context,
+              info,
+              tx: executor
+            });
+            if (single && result.length > 1) {
+              throw new GraphQLError9(`${fieldName}: 'where' matched more than one row!`);
+            }
+            if (single) {
+              return result[0] ? remapToGraphQLSingleOutput(result[0], tableName, table) : void 0;
+            }
+            return remapToGraphQLArrayOutput(result, tableName, table);
+          },
+          !!hooks
+        );
       } catch (e) {
         throw toGraphQLError(e);
       }
@@ -8209,10 +8848,36 @@ var buildSchema = (db, config) => {
       }
     }
   }
-  const policies = scopeConfig || contextValuesConfig || softDeleteInfos.size ? {
+  const onWriteConfig = config?.onWrite;
+  const writeHooks = /* @__PURE__ */ new Map();
+  let globalWriteHooks;
+  if (onWriteConfig) {
+    const isGlobal = typeof onWriteConfig === "function" || typeof onWriteConfig.before === "function" || typeof onWriteConfig.after === "function";
+    if (isGlobal) {
+      globalWriteHooks = normalizeWriteHooks(onWriteConfig);
+    } else {
+      const tableNames = new Set(tableKeys);
+      for (const [tableName, hooks] of Object.entries(onWriteConfig)) {
+        if (!tableNames.has(tableName)) {
+          throw new Error(
+            `Drizzle-GraphQL Error: config.onWrite names '${tableName}', which is not a table in the Drizzle schema.`
+          );
+        }
+        if (typeof hooks !== "function" && typeof hooks !== "object") {
+          throw new Error(
+            `Drizzle-GraphQL Error: config.onWrite.${tableName} must be a function or an object with 'before' and/or 'after'.`
+          );
+        }
+        writeHooks.set(tableName, normalizeWriteHooks(hooks));
+      }
+    }
+  }
+  const onWrite = globalWriteHooks || writeHooks.size ? (tableName) => globalWriteHooks ?? writeHooks.get(tableName) : void 0;
+  const policies = scopeConfig || contextValuesConfig || softDeleteInfos.size || onWrite ? {
     scope: scopeConfig ? (tableName) => scopeConfig[tableName] : void 0,
     contextValues: contextValuesConfig ? (tableName) => contextValuesConfig[tableName] : void 0,
-    softDelete: softDeleteInfos.size ? (tableName) => softDeleteInfos.get(tableName) : void 0
+    softDelete: softDeleteInfos.size ? (tableName) => softDeleteInfos.get(tableName) : void 0,
+    onWrite
   } : void 0;
   const exclude = config?.exclude;
   if (exclude) {