@vantreeseba/drizzle-graphql 7.6.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 = [
@@ -1155,7 +1173,7 @@ var batchedPaginatedRelationQuery = async (db, targetTable, foreignCol, whereCon
   }
   return rows;
 };
-var createRelationResolverFactory = (db, tables, nullOrdering, filterCtx, limits, scopes) => ({ tableName, relationName, relEntry, isOne }) => {
+var createRelationResolverFactory = (db, tables, nullOrdering, filterCtx, limits, policies) => ({ tableName, relationName, relEntry, isOne }) => {
   const parentTable = tables[tableName];
   const targetTableName = relEntry.targetTableName;
   const targetTable = tables[targetTableName];
@@ -1177,7 +1195,14 @@ var createRelationResolverFactory = (db, tables, nullOrdering, filterCtx, limits
     if (localValue == null) {
       return isOne ? null : [];
     }
-    const { where: whereArg, orderBy: orderByArg, limit: requestedLimit, offset, after } = args ?? {};
+    const {
+      where: whereArg,
+      orderBy: orderByArg,
+      limit: requestedLimit,
+      offset,
+      after,
+      deleted
+    } = args ?? {};
     const limit = applyLimitPolicy(requestedLimit, limitPolicy, `${tableName}.${relationName}`);
     const distinct = (args ?? {}).distinct?.length ? (args ?? {}).distinct : void 0;
     const cursorSelected = !isOne && !!info && selectsCursorField(info, targetTable);
@@ -1208,6 +1233,7 @@ var createRelationResolverFactory = (db, tables, nullOrdering, filterCtx, limits
       orderBy: orderByArg ?? null,
       limit: limit ?? null,
       offset: offset ?? null,
+      deleted: deleted ?? null,
       after: after ?? null,
       distinct: distinct ?? null,
       cursor: cursorEntries ? 1 : 0
@@ -1216,7 +1242,7 @@ var createRelationResolverFactory = (db, tables, nullOrdering, filterCtx, limits
     const loader = getOrCreateLoader(context, loaderKey, async (parentIds) => {
       const executor = resolveExecutor(db, context);
       const uniqueIds = [...new Set(parentIds)];
-      const scope = resolveScope(scopes, context, filterCtx);
+      const scope = resolveScope(policies, context, filterCtx);
       let whereCondition = withScope(
         scope,
         targetTableName,
@@ -1225,7 +1251,8 @@ var createRelationResolverFactory = (db, tables, nullOrdering, filterCtx, limits
           inArray(foreignCol, uniqueIds),
           whereArg ? extractFilters(targetTable, targetTableName, whereArg, relationFilterCtx(filterCtx, targetTableName)) : void 0,
           cursorValues ? buildCursorCondition(targetTable, cursorEntries, cursorValues, nullOrdering) : void 0
-        )
+        ),
+        deleted
       );
       if (distinct) {
         const keys = await selectDistinctKeys({
@@ -2030,7 +2057,8 @@ var generateSelectFields = (tables, tableName, relationMap, fromTableName, fromR
           {
             type: isRequired ? new GraphQLNonNull3(relType) : relType,
             args: {
-              where: { type: relSelectData.filters }
+              where: { type: relSelectData.filters },
+              ...deletedArg(cacheCtx.softDeleteOf, targetTableName)
             },
             resolve,
             ...relationDocs,
@@ -2049,6 +2077,7 @@ var generateSelectFields = (tables, tableName, relationMap, fromTableName, fromR
             orderBy: { type: relSelectData.order },
             offset: { type: GraphQLInt3 },
             limit: { type: GraphQLInt3 },
+            ...deletedArg(cacheCtx.softDeleteOf, targetTableName),
             after: {
               type: GraphQLString2,
               description: "Keyset pagination: only return related rows strictly after this cursor (a row's `cursor` field from a previous page of this relation, under the same orderBy)."
@@ -2076,7 +2105,8 @@ var generateSelectFields = (tables, tableName, relationMap, fromTableName, fromR
             {
               type: new GraphQLNonNull3(relationAggregate.type),
               args: {
-                where: { type: relSelectData.filters }
+                where: { type: relSelectData.filters },
+                ...deletedArg(cacheCtx.softDeleteOf, targetTableName)
               },
               resolve: relationAggregate.resolve,
               extensions: {
@@ -2132,7 +2162,10 @@ var generateTableTypes = (tableName, tables, relationMap, withReturning, relatio
   const columns = visibleColumns(table);
   const columnEntries = Object.entries(columns);
   const contextColumns = cacheCtx.contextValuesOf?.(tableName);
-  const writableEntries = contextColumns ? columnEntries.filter(([columnName]) => !(columnName in contextColumns)) : columnEntries;
+  const markerColumn = cacheCtx.softDeleteOf?.(tableName)?.columnName;
+  const writableEntries = contextColumns || markerColumn ? columnEntries.filter(
+    ([columnName]) => !(contextColumns && columnName in contextColumns) && columnName !== markerColumn
+  ) : columnEntries;
   const relaxedColumns = nestedWrites?.relaxedColumns(tableName);
   const insertFields = Object.fromEntries(
     writableEntries.map(([columnName, column]) => {
@@ -2674,40 +2707,104 @@ var extractFilters = (table, tableName, filters, relationCtx) => {
   }
   return variants.length ? variants.length > 1 ? and(...variants) : variants[0] : void 0;
 };
-var resolveScope = (scopes, context, filterCtx) => {
-  if (!scopes) {
+var deletedFilterEnum = new GraphQLEnumType2({
+  name: "DeletedFilter",
+  description: "Which rows a read over a soft-deleting table returns.",
+  values: {
+    EXCLUDE: { value: "EXCLUDE", description: "Only rows that are not marked deleted. The default." },
+    INCLUDE: { value: "INCLUDE", description: "Marked and unmarked rows alike." },
+    ONLY: { value: "ONLY", description: "Only rows that are marked deleted \u2014 a trash view." }
+  }
+});
+var resolveSoftDeleteInfo = (table, tableName, declaration) => {
+  const config = typeof declaration === "string" ? { column: declaration } : declaration;
+  const columnName = config?.column;
+  if (typeof columnName !== "string" || !columnName) {
+    throw new Error(
+      `Drizzle-GraphQL Error: config.softDelete.${tableName} must be a column name or an object with a 'column' property.`
+    );
+  }
+  const column = getColumns2(table)[columnName];
+  if (!column) {
+    throw new Error(
+      `Drizzle-GraphQL Error: config.softDelete names '${tableName}.${columnName}', which is not a column of that table.`
+    );
+  }
+  const nullable = !column.notNull;
+  const { type: baseType, constraint } = extractExtendedColumnType2(column);
+  const hasDeleted = "deletedValue" in config && config.deletedValue !== void 0;
+  const writeDeleted = hasDeleted ? typeof config.deletedValue === "function" ? config.deletedValue : () => config.deletedValue : constraint === "date" && baseType === "object" ? () => /* @__PURE__ */ new Date() : baseType === "string" ? () => (/* @__PURE__ */ new Date()).toISOString() : baseType === "number" ? () => Date.now() : baseType === "bigint" ? () => BigInt(Date.now()) : () => true;
+  let marker;
+  if (!nullable) {
+    if (hasDeleted && typeof config.deletedValue !== "function") {
+      marker = config.deletedValue;
+    } else if (!hasDeleted && baseType === "boolean") {
+      marker = true;
+    } else {
+      throw new Error(
+        `Drizzle-GraphQL Error: config.softDelete.${tableName} marks a NOT NULL column ('${columnName}'), so 'deletedValue' must be a constant that means deleted \u2014 not a function, and not omitted for a non-boolean column.`
+      );
+    }
+  }
+  const hasRestored = "restoredValue" in config;
+  const writeRestored = hasRestored ? config.restoredValue : nullable ? null : baseType === "boolean" ? false : void 0;
+  if (!nullable && writeRestored === void 0) {
+    throw new Error(
+      `Drizzle-GraphQL Error: config.softDelete.${tableName} marks a NOT NULL column ('${columnName}'), so 'restoredValue' must say what restoring writes back.`
+    );
+  }
+  return { columnName, column, nullable, writeDeleted, writeRestored, marker };
+};
+var softDeletePredicate = (info, table, mode) => {
+  if (mode === "INCLUDE") {
+    return void 0;
+  }
+  const column = table?.[info.columnName] ?? info.column;
+  if (info.nullable) {
+    return mode === "ONLY" ? isNotNull(column) : isNull(column);
+  }
+  return mode === "ONLY" ? eq(column, info.marker) : ne(column, info.marker);
+};
+var resolveScope = (policies, context, filterCtx) => {
+  const scopes = policies?.scope;
+  const softDelete = policies?.softDelete;
+  if (!scopes && !softDelete) {
     return void 0;
   }
   return {
-    has: (tableName) => !!scopes(tableName),
-    on: (tableName, table) => {
-      const hook = scopes(tableName);
+    has: (tableName, mode) => !!scopes?.(tableName) || !!softDelete?.(tableName) && (mode ?? "EXCLUDE") !== "INCLUDE",
+    on: (tableName, table, mode) => {
+      const marked = softDelete?.(tableName);
+      const deleted = marked ? softDeletePredicate(marked, table, mode ?? "EXCLUDE") : void 0;
+      const hook = scopes?.(tableName);
       if (!hook) {
-        return void 0;
+        return deleted;
       }
       const predicate = hook(context, table);
       if (predicate === void 0 || predicate === null) {
-        return void 0;
+        return deleted;
       }
       if (is3(predicate, SQL)) {
-        return predicate;
+        return and(deleted, predicate);
       }
       if (typeof predicate !== "object") {
         throw new GraphQLError4(
           `Drizzle-GraphQL Error: the scope for '${tableName}' returned a ${typeof predicate}. A scope returns a filter object, a Drizzle SQL expression, or undefined.`
         );
       }
-      return extractFilters(table, tableName, predicate, relationFilterCtx(filterCtx, tableName));
+      return and(deleted, extractFilters(table, tableName, predicate, relationFilterCtx(filterCtx, tableName)));
     }
   };
 };
-var withScope = (scope, tableName, table, condition) => {
-  const predicate = scope?.on(tableName, table);
+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 ? {
-  scope: policies.scope ? (context) => resolveScope(policies.scope, context, filterCtx) : void 0,
-  contextValues: policies.contextValues
+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,
+  onWrite: policies.onWrite
 } : void 0;
 var applyContextValues = (values, hooks, context) => {
   if (!hooks) {
@@ -2782,12 +2879,14 @@ var extractRelationsParamsInner = (relationMap, tables, tableName, typeName, ori
     const offset = relationArgs?.offset ?? void 0;
     const limit = is3(relEntry.relation, One2) ? relationArgs?.limit ?? void 0 : applyLimitPolicy(relationArgs?.limit, limits?.(targetTableName), `${tableName}.${relName}`);
     const relWhere = relationArgs?.where;
-    thisRecord.where = relWhere || scope?.has(targetTableName) ? {
+    const relDeleted = relationArgs?.deleted;
+    thisRecord.where = relWhere || scope?.has(targetTableName, relDeleted) ? {
       RAW: (aliasedTable2) => withScope(
         scope,
         targetTableName,
         aliasedTable2,
-        relWhere ? extractFilters(aliasedTable2, relName, relWhere, relationFilterCtx(filterCtx, targetTableName)) : void 0
+        relWhere ? extractFilters(aliasedTable2, relName, relWhere, relationFilterCtx(filterCtx, targetTableName)) : void 0,
+        relDeleted
       )
     } : void 0;
     const hasPagination = offset != null || limit != null;
@@ -3313,9 +3412,11 @@ var computeResolverFieldNames = (tableName, typeNameMapper, prefixes, suffixes)
   const updateFieldName = `${prefixes.update}${mapped ? capitalize(mapped.singular) : capitalize(tableName)}`;
   const updateManyFieldName = `${prefixes.update}${mapped ? capitalize(mapped.plural) : capitalize(tableName)}Many`;
   const deleteFieldName = `${prefixes.delete}${mapped ? capitalize(mapped.singular) : capitalize(tableName)}`;
+  const restoreFieldName = `${prefixes.restore ?? "restore"}${mapped ? capitalize(mapped.singular) : capitalize(tableName)}`;
   const writeSingleSuffix = suffixes.single === "" ? "Single" : suffixes.single;
   const updateSingleFieldName = `${updateFieldName}${writeSingleSuffix}`;
   const deleteSingleFieldName = `${deleteFieldName}${writeSingleSuffix}`;
+  const restoreSingleFieldName = `${restoreFieldName}${writeSingleSuffix}`;
   const pluralNoun = mapped ? capitalize(mapped.plural) : capitalize(tableName);
   const updateCountFieldName = `${prefixes.update}${pluralNoun}Count`;
   const deleteCountFieldName = `${prefixes.delete}${pluralNoun}Count`;
@@ -3335,6 +3436,8 @@ var computeResolverFieldNames = (tableName, typeNameMapper, prefixes, suffixes)
     updateCountFieldName,
     deleteFieldName,
     deleteSingleFieldName,
+    restoreFieldName,
+    restoreSingleFieldName,
     deleteCountFieldName
   };
 };
@@ -3439,7 +3542,13 @@ var generateWriteCount = ({
     args: queryArgs
   };
 };
-var selectArrayArgs = (orderArgs, filterArgs, distinctEnum) => ({
+var deletedArg = (softDelete, tableName) => softDelete?.(tableName) ? {
+  deleted: {
+    type: deletedFilterEnum,
+    description: "Whether rows marked deleted are returned. Defaults to EXCLUDE."
+  }
+} : {};
+var selectArrayArgs = (orderArgs, filterArgs, distinctEnum, softDelete, tableName) => ({
   offset: { type: GraphQLInt3 },
   limit: { type: GraphQLInt3 },
   orderBy: { type: orderArgs },
@@ -3448,12 +3557,14 @@ var selectArrayArgs = (orderArgs, filterArgs, distinctEnum) => ({
     type: GraphQLString2,
     description: "Keyset pagination: only return rows strictly after this cursor (a row's `cursor` field from a previous page, under the same orderBy)."
   },
-  ...distinctEnum ? { distinct: { type: new GraphQLList3(new GraphQLNonNull3(distinctEnum)) } } : {}
+  ...distinctEnum ? { distinct: { type: new GraphQLList3(new GraphQLNonNull3(distinctEnum)) } } : {},
+  ...deletedArg(softDelete, tableName)
 });
-var selectSingleArgs = (orderArgs, filterArgs) => ({
+var selectSingleArgs = (orderArgs, filterArgs, softDelete, tableName) => ({
   offset: { type: GraphQLInt3 },
   orderBy: { type: orderArgs },
-  where: { type: filterArgs }
+  where: { type: filterArgs },
+  ...deletedArg(softDelete, tableName)
 });
 var runRelationalSelect = async (opts) => {
   const {
@@ -3472,7 +3583,8 @@ var runRelationalSelect = async (opts) => {
     filterCtx,
     pkNames,
     after,
-    scope
+    scope,
+    deleted
   } = opts;
   const distinct = opts.distinct?.length ? opts.distinct : void 0;
   const cursorSelected = !single && isCursorFieldSelected(parsedInfo.fieldsByTypeName[typeName], table);
@@ -3508,7 +3620,8 @@ var runRelationalSelect = async (opts) => {
         scope,
         tableName,
         table,
-        where ? extractFilters(table, tableName, where, relationFilterCtx(filterCtx, tableName)) : void 0
+        where ? extractFilters(table, tableName, where, relationFilterCtx(filterCtx, tableName)) : void 0,
+        deleted
       ),
       orderBy,
       limit: single ? 1 : opts.limit,
@@ -3539,7 +3652,7 @@ var runRelationalSelect = async (opts) => {
     where: distinctKeys ? (
       // The distinct pass already ran inside the scope, so the keys it picked are in it.
       { RAW: (aliasedTable2) => primaryKeyRestriction(aliasedTable2, pkNames, distinctKeys) }
-    ) : where || cursorValues || scope?.has(tableName) ? {
+    ) : where || cursorValues || scope?.has(tableName, deleted) ? {
       RAW: (aliasedTable2) => withScope(
         scope,
         tableName,
@@ -3552,7 +3665,8 @@ var runRelationalSelect = async (opts) => {
             cursorValues,
             opts.nullOrdering ?? "nulls-smallest"
           ) : void 0
-        )
+        ),
+        deleted
       )
     } : void 0,
     with: relationMap[tableName] ? extractRelationsParams(
@@ -3901,10 +4015,11 @@ var assembleAggregateRow = (row, request, target) => {
   }
   return result;
 };
-var generateAggregate = (db, tableName, table, typeName, fieldName, filterArgs, filterCtx, scopes) => {
+var generateAggregate = (db, tableName, table, typeName, fieldName, filterArgs, filterCtx, policies) => {
   const target = aggregateTarget(table, tableName, typeName);
   const queryArgs = {
-    where: { type: filterArgs }
+    where: { type: filterArgs },
+    ...deletedArg(policies?.softDelete, tableName)
   };
   return {
     name: fieldName,
@@ -3916,10 +4031,11 @@ var generateAggregate = (db, tableName, table, typeName, fieldName, filterArgs,
         }
         let query = resolveExecutor(db, context).select(request.selection).from(table);
         const where = withScope(
-          resolveScope(scopes, context, filterCtx),
+          resolveScope(policies, context, filterCtx),
           tableName,
           table,
-          args.where ? extractFilters(table, tableName, args.where, relationFilterCtx(filterCtx, tableName)) : void 0
+          args.where ? extractFilters(table, tableName, args.where, relationFilterCtx(filterCtx, tableName)) : void 0,
+          args.deleted
         );
         if (where) {
           query = query.where(where);
@@ -3934,7 +4050,7 @@ var generateAggregate = (db, tableName, table, typeName, fieldName, filterArgs,
   };
 };
 var GROUP_KEY = "__dgql_group_key";
-var createRelationAggregateFactory = (db, tables, cacheCtx, typeNameMapper, filterCtx, scopes) => {
+var createRelationAggregateFactory = (db, tables, cacheCtx, typeNameMapper, filterCtx, policies) => {
   return ({ tableName, relationName, relEntry }) => {
     const parentTable = tables[tableName];
     const targetTableName = relEntry.targetTableName;
@@ -3961,8 +4077,10 @@ var createRelationAggregateFactory = (db, tables, cacheCtx, typeNameMapper, filt
           return assembleAggregateRow({}, request, target);
         }
         const whereArg = args?.where;
+        const deleted = args?.deleted;
         const argsKey = JSON.stringify({
           where: whereArg ?? null,
+          deleted: deleted ?? null,
           selection: Object.keys(request.selection).sort()
         });
         const loaderKey = `${tableName}::${relationName}::aggregate::${argsKey}`;
@@ -3970,13 +4088,14 @@ var createRelationAggregateFactory = (db, tables, cacheCtx, typeNameMapper, filt
           const executor = resolveExecutor(db, context);
           const uniqueIds = [...new Set(parentIds)];
           const whereCondition = withScope(
-            resolveScope(scopes, context, filterCtx),
+            resolveScope(policies, context, filterCtx),
             targetTableName,
             targetTable,
             and2(
               inArray2(foreignCol, uniqueIds),
               whereArg ? extractFilters(targetTable, targetTableName, whereArg, relationFilterCtx(filterCtx, targetTableName)) : void 0
-            )
+            ),
+            deleted
           );
           const rows = await executor.select({ [GROUP_KEY]: foreignCol, ...request.selection }).from(targetTable).where(whereCondition).groupBy(foreignCol);
           const byKey = new Map(rows.map((row) => [row[GROUP_KEY], row]));
@@ -4109,7 +4228,7 @@ var buildHavingCondition = (having, columns) => {
   }
   return conditions.length ? and2(...conditions) : void 0;
 };
-var generateGroupBy = (db, tableName, table, typeName, fieldName, filterArgs, groupByEnum, havingInput, filterCtx, scopes) => {
+var generateGroupBy = (db, tableName, table, typeName, fieldName, filterArgs, groupByEnum, havingInput, filterCtx, policies) => {
   const target = aggregateTarget(table, tableName, typeName);
   const groupable = groupableColumns(table, tableName);
   const columns = getColumns3(table);
@@ -4120,7 +4239,8 @@ var generateGroupBy = (db, tableName, table, typeName, fieldName, filterArgs, gr
       description: "Columns to group by. One result row per distinct combination of their values."
     },
     where: { type: filterArgs, description: "Filters the rows before they are grouped." },
-    having: { type: havingInput, description: "Filters the groups after they are aggregated." }
+    having: { type: havingInput, description: "Filters the groups after they are aggregated." },
+    ...deletedArg(policies?.softDelete, tableName)
   };
   return {
     name: fieldName,
@@ -4144,10 +4264,11 @@ var generateGroupBy = (db, tableName, table, typeName, fieldName, filterArgs, gr
         };
         let query = resolveExecutor(db, context).select(selection).from(table);
         const where = withScope(
-          resolveScope(scopes, context, filterCtx),
+          resolveScope(policies, context, filterCtx),
           tableName,
           table,
-          args.where ? extractFilters(table, tableName, args.where, relationFilterCtx(filterCtx, tableName)) : void 0
+          args.where ? extractFilters(table, tableName, args.where, relationFilterCtx(filterCtx, tableName)) : void 0,
+          args.deleted
         );
         if (where) {
           query = query.where(where);
@@ -4189,7 +4310,9 @@ var generateSelectArray = (db, tableName, tables, relationMap, orderArgs, filter
   const queryArgs = selectArrayArgs(
     orderArgs,
     filterArgs,
-    distinctEnabled ? generateDistinctEnum(table, typeName) : void 0
+    distinctEnabled ? generateDistinctEnum(table, typeName) : void 0,
+    policies?.softDelete,
+    tableName
   );
   return {
     name: fieldName,
@@ -4231,7 +4354,7 @@ var generateSelectSingle = (db, tableName, tables, relationMap, orderArgs, filte
       `Drizzle-GraphQL Error: Table ${tableName} not found in drizzle instance. Did you forget to pass schema to drizzle constructor?`
     );
   }
-  const queryArgs = selectSingleArgs(orderArgs, filterArgs);
+  const queryArgs = selectSingleArgs(orderArgs, filterArgs, policies?.softDelete, tableName);
   const table = tables[tableName];
   const pkNames = mysqlPrimaryKeyPropNames(table);
   return {
@@ -4270,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);
       }
@@ -4299,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);
       }
@@ -4330,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);
       }
@@ -4375,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);
       }
@@ -4419,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);
       }
@@ -4463,36 +4721,66 @@ var generateUpdateMany = (db, tableName, table, updateManyInput, fieldName, filt
     args: queryArgs
   };
 };
-var generateDelete = (db, tableName, table, filterArgs, fieldName, single, requireWhere, filterCtx, txCtx, policies) => {
+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
-          );
-          if (single) {
-            await assertSingleMatch(executor, table, filters, fieldName);
-          }
-          let query = executor.delete(table);
-          if (filters) {
-            query = query.where(filters);
-          }
-          await query;
-          return { isSuccess: true };
-        });
+        return await runMutation(
+          db,
+          context,
+          info,
+          txCtx,
+          async (executor) => {
+            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);
       }
@@ -4530,16 +4818,17 @@ var generateSchemaData = (db, schema, relations, options) => {
   attachTargetPrimaryKeys(namedRelations, tables, mysqlPrimaryKeyPropNames);
   const eagerRelations = pruneNonEagerRelations(namedRelations, shouldEagerLoad);
   const filterCtx = { tables, relationMap: namedRelations };
-  const scopes = options.policies?.scope;
-  const contextValuesOf = options.policies?.contextValues;
-  const policies = bindPolicies(options.policies, filterCtx);
+  const tablePolicies = options.policies;
+  const contextValuesOf = tablePolicies?.contextValues;
+  const softDeleteOf = tablePolicies?.softDelete;
+  const policies = bindPolicies(tablePolicies, filterCtx);
   const resolverFactory = createRelationResolverFactory(
     db,
     tables,
     "nulls-smallest",
     filterCtx,
     limits,
-    scopes
+    tablePolicies
   );
   const cacheCtx = {
     genericFilterCache: /* @__PURE__ */ new Map(),
@@ -4558,9 +4847,10 @@ var generateSchemaData = (db, schema, relations, options) => {
     docs: options.docs ?? {},
     primaryKeyOf: (name) => tables[name] ? mysqlPrimaryKeyPropNames(tables[name]) : [],
     contextValuesOf,
+    softDeleteOf,
     featureOf
   };
-  const relationAggregateFactory = anyTable("relationAggregates") ? createRelationAggregateFactory(db, tables, cacheCtx, typeNameMapper, filterCtx, scopes) : void 0;
+  const relationAggregateFactory = anyTable("relationAggregates") ? createRelationAggregateFactory(db, tables, cacheCtx, typeNameMapper, filterCtx, tablePolicies) : void 0;
   const queries = {};
   const mutations = {};
   const mutationTxCtx = createMutationTxCtx(options.transactions);
@@ -4616,8 +4906,11 @@ var generateSchemaData = (db, schema, relations, options) => {
       updateCountFieldName,
       deleteFieldName,
       deleteSingleFieldName,
+      restoreFieldName,
+      restoreSingleFieldName,
       deleteCountFieldName
     } = computeResolverFieldNames(tableName, typeNameMapper, prefixes, suffixes);
+    const softDeleteInfo = softDeleteOf?.(tableName);
     const selectArrGenerated = generateSelectArray(
       db,
       tableName,
@@ -4755,6 +5048,32 @@ var generateSchemaData = (db, schema, relations, options) => {
       mutationTxCtx,
       policies
     ) : void 0;
+    const restoreGenerated = softDeleteInfo ? generateDelete(
+      db,
+      tableName,
+      schema[tableName],
+      tableFilters,
+      restoreFieldName,
+      false,
+      tableFeatures.requireWhere,
+      filterCtx,
+      mutationTxCtx,
+      policies,
+      true
+    ) : void 0;
+    const restoreSingleGenerated = softDeleteInfo ? generateDelete(
+      db,
+      tableName,
+      schema[tableName],
+      tableFilters,
+      restoreSingleFieldName,
+      true,
+      tableFeatures.requireWhere,
+      filterCtx,
+      mutationTxCtx,
+      policies,
+      true
+    ) : void 0;
     const updateCountGenerated = tableFeatures.update && tableFeatures.countMutations ? generateWriteCount({
       db,
       tableName,
@@ -4787,7 +5106,7 @@ var generateSchemaData = (db, schema, relations, options) => {
       aggregateFieldName,
       tableFilters,
       filterCtx,
-      scopes
+      tablePolicies
     ) : void 0;
     const groupByType = tableFeatures.aggregates && tableFeatures.groupBy ? generateGroupByType(schema[tableName], tableName, typeName, cacheCtx) : void 0;
     const groupByEnum = groupByType ? generateGroupByEnum(schema[tableName], tableName, typeName) : void 0;
@@ -4802,7 +5121,7 @@ var generateSchemaData = (db, schema, relations, options) => {
       groupByEnum,
       havingInput,
       filterCtx,
-      scopes
+      tablePolicies
     ) : void 0;
     queries[selectArrGenerated.name] = {
       type: selectArrOutput,
@@ -4852,7 +5171,9 @@ var generateSchemaData = (db, schema, relations, options) => {
       [updateManyGenerated, { operation: "updateMany", single: false, targetArg: "updates" }],
       [updateSingleGenerated, { operation: "update", single: true, targetArg: "where" }],
       [deleteGenerated, { operation: "delete", single: false, targetArg: "where" }],
-      [deleteSingleGenerated, { operation: "delete", single: true, targetArg: "where" }]
+      [deleteSingleGenerated, { operation: "delete", single: true, targetArg: "where" }],
+      [restoreGenerated, { operation: "restore", single: false, targetArg: "where" }],
+      [restoreSingleGenerated, { operation: "restore", single: true, targetArg: "where" }]
     ];
     for (const [generated, meta] of generatedMutations) {
       if (generated) {
@@ -4935,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,
@@ -4944,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) => {
@@ -4973,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;
@@ -5065,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,
@@ -5083,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),
@@ -5142,7 +5548,7 @@ var createNestedWriteTypes = (params) => {
 var mergedOps = (entries) => Object.assign({}, ...entries.map((entry) => entry.ops));
 var asArray = (value) => Array.isArray(value) ? value : value === void 0 ? [] : [value];
 var createNestedWriteRuntime = (params) => {
-  const { plans, filterCtx, scopes, contextValues } = params;
+  const { plans, filterCtx, policies, contextValues } = params;
   const conditionOf = (plan, filter, operation, scope) => {
     const condition = extractFilters(
       plan.targetTable,
@@ -5165,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],
@@ -5205,7 +5653,7 @@ var createNestedWriteRuntime = (params) => {
       if (!tablePlans) {
         return patch;
       }
-      const scope = resolveScope(scopes, context, filterCtx);
+      const scope = resolveScope(policies, context, filterCtx);
       for (const [relationName, op] of Object.entries(ops)) {
         const plan = tablePlans[relationName];
         if (!plan || plan.fkSide !== "parent") {
@@ -5245,7 +5693,7 @@ var createNestedWriteRuntime = (params) => {
       if (!tablePlans) {
         return;
       }
-      const scope = resolveScope(scopes, context, filterCtx);
+      const scope = resolveScope(policies, context, filterCtx);
       for (const [relationName, op] of Object.entries(ops)) {
         const plan = tablePlans[relationName];
         if (!plan || plan.fkSide !== "child") {
@@ -5261,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"])) {
@@ -5337,7 +5789,9 @@ var generateSelectArray2 = (db, tableName, tables, relationMap, orderArgs, filte
   const queryArgs = selectArrayArgs(
     orderArgs,
     filterArgs,
-    distinctEnabled ? generateDistinctEnum(table, typeName) : void 0
+    distinctEnabled ? generateDistinctEnum(table, typeName) : void 0,
+    policies?.softDelete,
+    tableName
   );
   return {
     name: fieldName,
@@ -5369,7 +5823,7 @@ var generateSelectArray2 = (db, tableName, tables, relationMap, orderArgs, filte
             nullOrdering: "nulls-largest"
           });
         }
-        const { offset, orderBy, where, distinct, after } = args;
+        const { offset, orderBy, where, distinct, after, deleted } = args;
         const selectedColumnsSql = extractSelectedColumnsFromTreeSQLFormat(
           parsedInfo.fieldsByTypeName[typeName],
           table,
@@ -5407,7 +5861,8 @@ var generateSelectArray2 = (db, tableName, tables, relationMap, orderArgs, filte
           scope,
           tableName,
           table,
-          where ? extractFilters(table, tableName, where, relationFilterCtx(filterCtx, tableName)) : void 0
+          where ? extractFilters(table, tableName, where, relationFilterCtx(filterCtx, tableName)) : void 0,
+          deleted
         );
         const whereSql = cursorCondition ? and4(baseWhereSql, cursorCondition) : baseWhereSql;
         let distinctKeys;
@@ -5465,7 +5920,7 @@ var generateSelectArray2 = (db, tableName, tables, relationMap, orderArgs, filte
 };
 var generateSelectSingle2 = (db, tableName, tables, relationMap, orderArgs, filterArgs, fieldName, typeName, typeNameMapper, filterCtx, limits, policies) => {
   const queryBase = db.query[tableName];
-  const queryArgs = selectSingleArgs(orderArgs, filterArgs);
+  const queryArgs = selectSingleArgs(orderArgs, filterArgs, policies?.softDelete, tableName);
   const table = tables[tableName];
   const pkNames = pgPrimaryKeyPropNames(table);
   return {
@@ -5494,7 +5949,7 @@ var generateSelectSingle2 = (db, tableName, tables, relationMap, orderArgs, filt
             scope
           });
         }
-        const { offset, orderBy, where } = args;
+        const { offset, orderBy, where, deleted } = args;
         const selectedColumnsSql = extractSelectedColumnsFromTreeSQLFormat(
           parsedInfo.fieldsByTypeName[typeName],
           table,
@@ -5505,7 +5960,8 @@ var generateSelectSingle2 = (db, tableName, tables, relationMap, orderArgs, filt
           scope,
           tableName,
           table,
-          where ? extractFilters(table, tableName, where, relationFilterCtx(filterCtx, tableName)) : void 0
+          where ? extractFilters(table, tableName, where, relationFilterCtx(filterCtx, tableName)) : void 0,
+          deleted
         );
         if (whereSql) {
           q = q.where(whereSql);
@@ -5536,127 +5992,181 @@ 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);
-        });
-      } catch (e) {
-        throw toGraphQLError(e);
-      }
-    },
-    args: queryArgs
-  };
-};
-var generateInsertSingle2 = (db, tableName, table, tables, relationMap, baseType, fieldName, typeName, typeNameMapper, conflictDoNothing = false, txCtx, nested, limits, policies) => {
-  const queryArgs = {
-    values: {
+            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);
+      }
+    },
+    args: queryArgs
+  };
+};
+var generateInsertSingle2 = (db, tableName, table, tables, relationMap, baseType, fieldName, typeName, typeNameMapper, conflictDoNothing = false, txCtx, nested, limits, policies) => {
+  const queryArgs = {
+    values: {
       type: new GraphQLNonNull7(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);
       }
@@ -5675,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({
+        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,
-              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);
       }
@@ -5755,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);
       }
@@ -5838,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);
       }
@@ -5933,7 +6524,10 @@ var generateUpdateMany2 = (db, tableName, table, tables, relationMap, updateMany
     args: queryArgs
   };
 };
-var generateDelete2 = (db, tableName, table, filterArgs, fieldName, typeName, single, requireWhere, filterCtx, selectionCtx, txCtx, policies) => {
+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
@@ -5943,41 +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
-          );
-          if (single) {
-            await assertSingleMatch(executor, table, filters, fieldName);
-          }
-          let query = executor.delete(table);
-          if (filters) {
-            query = query.where(filters);
-          }
-          query = query.returning(columns);
-          const result = await query;
-          if (single && result.length > 1) {
-            throw new 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);
       }
@@ -6018,16 +6639,17 @@ function generateSchemaData2(db, schema, relations, options) {
   attachTargetPrimaryKeys(namedRelations, tables, pgPrimaryKeyPropNames);
   const eagerRelations = pruneNonEagerRelations(namedRelations, shouldEagerLoad);
   const filterCtx = { tables, relationMap: namedRelations };
-  const scopes = options.policies?.scope;
-  const contextValuesOf = options.policies?.contextValues;
-  const policies = bindPolicies(options.policies, filterCtx);
+  const tablePolicies = options.policies;
+  const contextValuesOf = tablePolicies?.contextValues;
+  const softDeleteOf = tablePolicies?.softDelete;
+  const policies = bindPolicies(tablePolicies, filterCtx);
   const resolverFactory = createRelationResolverFactory(
     db,
     tables,
     "nulls-largest",
     filterCtx,
     limits,
-    scopes
+    tablePolicies
   );
   const cacheCtx = {
     genericFilterCache: /* @__PURE__ */ new Map(),
@@ -6046,6 +6668,7 @@ function generateSchemaData2(db, schema, relations, options) {
     docs: options.docs ?? {},
     primaryKeyOf: (name) => tables[name] ? pgPrimaryKeyPropNames(tables[name]) : [],
     contextValuesOf,
+    softDeleteOf,
     featureOf
   };
   const nestedPlans = features.nestedWrites ? buildNestedWritePlans(
@@ -6056,8 +6679,13 @@ function generateSchemaData2(db, schema, relations, options) {
     extractRelationJoinColumns
   ) : void 0;
   const nestedTypes = nestedPlans ? createNestedWriteTypes({ plans: nestedPlans, cacheCtx, typeNameMapper, insertPrefix: prefixes.insert }) : void 0;
-  const nestedRuntime = nestedPlans ? createNestedWriteRuntime({ plans: nestedPlans, filterCtx, scopes, contextValues: contextValuesOf }) : void 0;
-  const relationAggregateFactory = anyTable("relationAggregates") ? createRelationAggregateFactory(db, tables, cacheCtx, typeNameMapper, filterCtx, scopes) : void 0;
+  const nestedRuntime = nestedPlans ? createNestedWriteRuntime({
+    plans: nestedPlans,
+    filterCtx,
+    policies: tablePolicies,
+    contextValues: contextValuesOf
+  }) : void 0;
+  const relationAggregateFactory = anyTable("relationAggregates") ? createRelationAggregateFactory(db, tables, cacheCtx, typeNameMapper, filterCtx, tablePolicies) : void 0;
   const queries = {};
   const mutations = {};
   const mutationTxCtx = createMutationTxCtx(options.transactions);
@@ -6103,8 +6731,11 @@ function generateSchemaData2(db, schema, relations, options) {
       updateCountFieldName,
       deleteFieldName,
       deleteSingleFieldName,
+      restoreFieldName,
+      restoreSingleFieldName,
       deleteCountFieldName
     } = computeResolverFieldNames(tableName, typeNameMapper, prefixes, suffixes);
+    const softDeleteInfo = softDeleteOf?.(tableName);
     const selectArrGenerated = generateSelectArray2(
       db,
       tableName,
@@ -6295,6 +6926,36 @@ function generateSchemaData2(db, schema, relations, options) {
       mutationTxCtx,
       policies
     ) : void 0;
+    const restoreGenerated = softDeleteInfo ? generateDelete2(
+      db,
+      tableName,
+      schema[tableName],
+      tableFilters,
+      restoreFieldName,
+      typeName,
+      false,
+      tableFeatures.requireWhere,
+      filterCtx,
+      { tableName, relationMap: namedRelations, tables },
+      mutationTxCtx,
+      policies,
+      true
+    ) : void 0;
+    const restoreSingleGenerated = softDeleteInfo ? generateDelete2(
+      db,
+      tableName,
+      schema[tableName],
+      tableFilters,
+      restoreSingleFieldName,
+      typeName,
+      true,
+      tableFeatures.requireWhere,
+      filterCtx,
+      { tableName, relationMap: namedRelations, tables },
+      mutationTxCtx,
+      policies,
+      true
+    ) : void 0;
     const updateCountGenerated = tableFeatures.update && tableFeatures.countMutations ? generateWriteCount({
       db,
       tableName,
@@ -6328,7 +6989,7 @@ function generateSchemaData2(db, schema, relations, options) {
       aggregateFieldName,
       tableFilters,
       filterCtx,
-      scopes
+      tablePolicies
     ) : void 0;
     const groupByType = tableFeatures.aggregates && tableFeatures.groupBy ? generateGroupByType(schema[tableName], tableName, typeName, cacheCtx) : void 0;
     const groupByEnum = groupByType ? generateGroupByEnum(schema[tableName], tableName, typeName) : void 0;
@@ -6343,7 +7004,7 @@ function generateSchemaData2(db, schema, relations, options) {
       groupByEnum,
       havingInput,
       filterCtx,
-      scopes
+      tablePolicies
     ) : void 0;
     queries[selectArrGenerated.name] = {
       type: selectArrOutput,
@@ -6480,6 +7141,26 @@ function generateSchemaData2(db, schema, relations, options) {
         }
       };
     }
+    if (restoreGenerated) {
+      mutations[restoreGenerated.name] = {
+        type: arrTableItemOutput,
+        args: restoreGenerated.args,
+        resolve: restoreGenerated.resolver,
+        extensions: {
+          drizzle: drizzleMeta({ kind: "mutation", operation: "restore", single: false, targetArg: "where" })
+        }
+      };
+    }
+    if (restoreSingleGenerated) {
+      mutations[restoreSingleGenerated.name] = {
+        type: singleTableItemOutput,
+        args: restoreSingleGenerated.args,
+        resolve: restoreSingleGenerated.resolver,
+        extensions: {
+          drizzle: drizzleMeta({ kind: "mutation", operation: "restore", single: true, targetArg: "where" })
+        }
+      };
+    }
     if (updateCountGenerated) {
       mutations[updateCountGenerated.name] = {
         type: new GraphQLNonNull7(GraphQLInt6),
@@ -6563,7 +7244,9 @@ var generateSelectArray3 = (db, tableName, tables, relationMap, orderArgs, filte
   const queryArgs = selectArrayArgs(
     orderArgs,
     filterArgs,
-    distinctEnabled ? generateDistinctEnum(table, typeName) : void 0
+    distinctEnabled ? generateDistinctEnum(table, typeName) : void 0,
+    policies?.softDelete,
+    tableName
   );
   return {
     name: fieldName,
@@ -6605,7 +7288,7 @@ var generateSelectSingle3 = (db, tableName, tables, relationMap, orderArgs, filt
       `Drizzle-GraphQL Error: Table ${tableName} not found in drizzle instance. Did you forget to pass schema to drizzle constructor?`
     );
   }
-  const queryArgs = selectSingleArgs(orderArgs, filterArgs);
+  const queryArgs = selectSingleArgs(orderArgs, filterArgs, policies?.softDelete, tableName);
   const table = tables[tableName];
   const pkNames = sqlitePrimaryKeyPropNames(table);
   return {
@@ -6646,127 +7329,181 @@ 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);
       }
     },
     args: queryArgs
   };
-};
-var generateInsertSingle3 = (db, tableName, table, tables, relationMap, baseType, fieldName, typeName, typeNameMapper, conflictDoNothing = false, txCtx, nested, limits, policies) => {
-  const queryArgs = {
-    values: {
-      type: new GraphQLNonNull8(baseType)
-    }
-  };
-  const pkNames = sqlitePrimaryKeyPropNames(table);
-  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.`);
+};
+var generateInsertSingle3 = (db, tableName, table, tables, relationMap, baseType, fieldName, typeName, typeNameMapper, conflictDoNothing = false, txCtx, nested, limits, policies) => {
+  const queryArgs = {
+    values: {
+      type: new GraphQLNonNull8(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) => {
+            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);
       }
@@ -6785,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);
       }
@@ -6865,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);
       }
@@ -6948,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);
       }
@@ -7071,51 +7889,81 @@ var generateUpdateMany3 = (db, tableName, table, tables, relationMap, updateMany
     args: queryArgs
   };
 };
-var generateDelete3 = (db, tableName, table, filterArgs, fieldName, typeName, single, requireWhere, filterCtx, selectionCtx, txCtx, policies) => {
+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
-          );
-          if (single) {
-            await assertSingleMatch(executor, table, filters, fieldName);
-          }
-          let query = executor.delete(table);
-          if (filters) {
-            query = query.where(filters);
-          }
-          query = query.returning(columns);
-          const result = await query;
-          if (single && result.length > 1) {
-            throw new 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);
       }
@@ -7157,16 +8005,17 @@ var generateSchemaData3 = (db, schema, relations, options) => {
   attachTargetPrimaryKeys(namedRelations, tables, sqlitePrimaryKeyPropNames);
   const eagerRelations = pruneNonEagerRelations(namedRelations, shouldEagerLoad);
   const filterCtx = { tables, relationMap: namedRelations };
-  const scopes = options.policies?.scope;
-  const contextValuesOf = options.policies?.contextValues;
-  const policies = bindPolicies(options.policies, filterCtx);
+  const tablePolicies = options.policies;
+  const contextValuesOf = tablePolicies?.contextValues;
+  const softDeleteOf = tablePolicies?.softDelete;
+  const policies = bindPolicies(tablePolicies, filterCtx);
   const resolverFactory = createRelationResolverFactory(
     db,
     tables,
     "nulls-smallest",
     filterCtx,
     limits,
-    scopes
+    tablePolicies
   );
   const cacheCtx = {
     genericFilterCache: /* @__PURE__ */ new Map(),
@@ -7185,6 +8034,7 @@ var generateSchemaData3 = (db, schema, relations, options) => {
     docs: options.docs ?? {},
     primaryKeyOf: (name) => tables[name] ? sqlitePrimaryKeyPropNames(tables[name]) : [],
     contextValuesOf,
+    softDeleteOf,
     featureOf
   };
   if (features.nestedWrites && db.resultKind === "sync") {
@@ -7200,8 +8050,13 @@ var generateSchemaData3 = (db, schema, relations, options) => {
     extractRelationJoinColumns
   ) : void 0;
   const nestedTypes = nestedPlans ? createNestedWriteTypes({ plans: nestedPlans, cacheCtx, typeNameMapper, insertPrefix: prefixes.insert }) : void 0;
-  const nestedRuntime = nestedPlans ? createNestedWriteRuntime({ plans: nestedPlans, filterCtx, scopes, contextValues: contextValuesOf }) : void 0;
-  const relationAggregateFactory = anyTable("relationAggregates") ? createRelationAggregateFactory(db, tables, cacheCtx, typeNameMapper, filterCtx, scopes) : void 0;
+  const nestedRuntime = nestedPlans ? createNestedWriteRuntime({
+    plans: nestedPlans,
+    filterCtx,
+    policies: tablePolicies,
+    contextValues: contextValuesOf
+  }) : void 0;
+  const relationAggregateFactory = anyTable("relationAggregates") ? createRelationAggregateFactory(db, tables, cacheCtx, typeNameMapper, filterCtx, tablePolicies) : void 0;
   const queries = {};
   const mutations = {};
   if (options.transactions && db.resultKind === "sync") {
@@ -7252,8 +8107,11 @@ var generateSchemaData3 = (db, schema, relations, options) => {
       updateCountFieldName,
       deleteFieldName,
       deleteSingleFieldName,
+      restoreFieldName,
+      restoreSingleFieldName,
       deleteCountFieldName
     } = computeResolverFieldNames(tableName, typeNameMapper, prefixes, suffixes);
+    const softDeleteInfo = softDeleteOf?.(tableName);
     const selectArrGenerated = generateSelectArray3(
       db,
       tableName,
@@ -7444,6 +8302,36 @@ var generateSchemaData3 = (db, schema, relations, options) => {
       mutationTxCtx,
       policies
     ) : void 0;
+    const restoreGenerated = softDeleteInfo ? generateDelete3(
+      db,
+      tableName,
+      schema[tableName],
+      tableFilters,
+      restoreFieldName,
+      typeName,
+      false,
+      tableFeatures.requireWhere,
+      filterCtx,
+      { tableName, relationMap: namedRelations, tables },
+      mutationTxCtx,
+      policies,
+      true
+    ) : void 0;
+    const restoreSingleGenerated = softDeleteInfo ? generateDelete3(
+      db,
+      tableName,
+      schema[tableName],
+      tableFilters,
+      restoreSingleFieldName,
+      typeName,
+      true,
+      tableFeatures.requireWhere,
+      filterCtx,
+      { tableName, relationMap: namedRelations, tables },
+      mutationTxCtx,
+      policies,
+      true
+    ) : void 0;
     const updateCountGenerated = tableFeatures.update && tableFeatures.countMutations ? generateWriteCount({
       db,
       tableName,
@@ -7477,7 +8365,7 @@ var generateSchemaData3 = (db, schema, relations, options) => {
       aggregateFieldName,
       tableFilters,
       filterCtx,
-      scopes
+      tablePolicies
     ) : void 0;
     const groupByType = tableFeatures.aggregates && tableFeatures.groupBy ? generateGroupByType(schema[tableName], tableName, typeName, cacheCtx) : void 0;
     const groupByEnum = groupByType ? generateGroupByEnum(schema[tableName], tableName, typeName) : void 0;
@@ -7492,7 +8380,7 @@ var generateSchemaData3 = (db, schema, relations, options) => {
       groupByEnum,
       havingInput,
       filterCtx,
-      scopes
+      tablePolicies
     ) : void 0;
     queries[selectArrGenerated.name] = {
       type: selectArrOutput,
@@ -7629,6 +8517,26 @@ var generateSchemaData3 = (db, schema, relations, options) => {
         }
       };
     }
+    if (restoreGenerated) {
+      mutations[restoreGenerated.name] = {
+        type: arrTableItemOutput,
+        args: restoreGenerated.args,
+        resolve: restoreGenerated.resolver,
+        extensions: {
+          drizzle: drizzleMeta({ kind: "mutation", operation: "restore", single: false, targetArg: "where" })
+        }
+      };
+    }
+    if (restoreSingleGenerated) {
+      mutations[restoreSingleGenerated.name] = {
+        type: singleTableItemOutput,
+        args: restoreSingleGenerated.args,
+        resolve: restoreSingleGenerated.resolver,
+        extensions: {
+          drizzle: drizzleMeta({ kind: "mutation", operation: "restore", single: true, targetArg: "where" })
+        }
+      };
+    }
     if (updateCountGenerated) {
       mutations[updateCountGenerated.name] = {
         type: new GraphQLNonNull8(GraphQLInt7),
@@ -7839,7 +8747,8 @@ var buildSchema = (db, config) => {
     insert: config?.prefixes?.insert ?? "create",
     delete: config?.prefixes?.delete ?? "delete",
     update: config?.prefixes?.update ?? "update",
-    upsert: config?.prefixes?.upsert ?? "upsert"
+    upsert: config?.prefixes?.upsert ?? "upsert",
+    restore: config?.prefixes?.restore ?? "restore"
   };
   const suffixes = {
     list: config?.suffixes?.list ?? "",
@@ -7917,9 +8826,58 @@ var buildSchema = (db, config) => {
       }
     }
   }
-  const policies = scopeConfig || contextValuesConfig ? {
+  const softDeleteConfig = config?.softDelete;
+  const softDeleteInfos = /* @__PURE__ */ new Map();
+  if (softDeleteConfig) {
+    if (typeof softDeleteConfig === "function") {
+      for (const tableName of tableKeys) {
+        const declaration = softDeleteConfig(schema[tableName], tableName);
+        if (declaration) {
+          softDeleteInfos.set(tableName, resolveSoftDeleteInfo(schema[tableName], tableName, declaration));
+        }
+      }
+    } else {
+      const tableNames = new Set(tableKeys);
+      for (const [tableName, declaration] of Object.entries(softDeleteConfig)) {
+        if (!tableNames.has(tableName)) {
+          throw new Error(
+            `Drizzle-GraphQL Error: config.softDelete names '${tableName}', which is not a table in the Drizzle schema.`
+          );
+        }
+        softDeleteInfos.set(tableName, resolveSoftDeleteInfo(schema[tableName], tableName, declaration));
+      }
+    }
+  }
+  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
+    contextValues: contextValuesConfig ? (tableName) => contextValuesConfig[tableName] : void 0,
+    softDelete: softDeleteInfos.size ? (tableName) => softDeleteInfos.get(tableName) : void 0,
+    onWrite
   } : void 0;
   const exclude = config?.exclude;
   if (exclude) {