@vantreeseba/drizzle-graphql 7.6.0 → 7.8.0

package/dist/index.d.cts

@@ -237,6 +237,43 @@ type RelationResolverFactory = (params: {
  * both end up loaded in one process.
  */
 declare const drizzleExecutorKey: unique symbol;
+/** The write a hook is attached to. `restore` only exists for a soft-deleting table. */
+type WriteOperation = 'insert' | 'update' | 'updateMany' | 'upsert' | 'delete' | 'restore';
+/** What a write hook is handed. See {@link BuildSchemaConfig.onWrite}. */
+type WriteHookPayload = {
+    /** Drizzle schema key of the table being written. */
+    table: string;
+    operation: WriteOperation;
+    /** `'before'` runs ahead of the statement, `'after'` once it has returned. */
+    position: 'before' | 'after';
+    /** Whether the field writes a single row (`createUsersSingle`) or a list. */
+    single: boolean;
+    /** The field's GraphQL arguments, exactly as the resolver received them. */
+    args: any;
+    /**
+     * The rows the write produced, as the database returned them — before the output mapper,
+     * so values are database-shaped. Empty at the `before` position, and on MySQL, whose
+     * mutations return no rows.
+     */
+    rows: any[];
+    context: any;
+    info: any;
+    /** The executor the mutation itself ran on. Throwing from the hook rolls it back. */
+    tx: any;
+};
+type WriteHook = (payload: WriteHookPayload) => void | Promise<void>;
+type WriteHookPositions = {
+    before?: WriteHook;
+    after?: WriteHook;
+};
+type WriteHooks = WriteHook | WriteHookPositions;
+/** Resolved, per-field hooks: `undefined` when the table registered none. */
+type ResolvedWriteHooks = {
+    before?: WriteHook;
+    after?: WriteHook;
+};
+/** Build-time lookup of a table's hooks, installed on {@link TablePolicies}. */
+type WriteHookFor = (tableName: string, operation: WriteOperation) => ResolvedWriteHooks | undefined;
 /**
  * Creates a RelationResolverFactory that generates field-level resolvers for each relation.
  * Each resolver:
@@ -251,7 +288,7 @@ declare const drizzleExecutorKey: unique symbol;
  * each dialect builder states it: `'nulls-largest'` for PostgreSQL, `'nulls-smallest'` for
  * MySQL and SQLite.
  */
-declare const createRelationResolverFactory: (db: any, tables: Record<string, Table>, nullOrdering: NullOrdering, filterCtx?: RelationFilterBase, limits?: LimitPolicyFor, scopes?: ScopeFor) => RelationResolverFactory;
+declare const createRelationResolverFactory: (db: any, tables: Record<string, Table>, nullOrdering: NullOrdering, filterCtx?: RelationFilterBase, limits?: LimitPolicyFor, policies?: TablePolicies) => RelationResolverFactory;
 /** {@link BuildSchemaConfig.limits} resolved for one table. `undefined` means no policy. */
 type ResolvedLimitPolicy = {
     defaultLimit: number | undefined;
@@ -321,6 +358,48 @@ declare const extractFilters: <TTable extends Table>(table: TTable, tableName: s
 type ScopeHook<TContext = any> = (context: TContext, table: any) => SQL | Record<string, any> | undefined | null;
 /** Build-time lookup: the scope configured for a table, if any. */
 type ScopeFor = (tableName: string) => ScopeHook | undefined;
+/**
+ * One table's soft-delete convention, resolved against the real column at build time.
+ *
+ * `nullable` picks the shape of the predicate. A nullable column marks a row deleted by
+ * holding a value at all (`deletedAt IS NOT NULL`), which is the common timestamp form; a
+ * non-nullable one marks it by holding `marker` (`isDeleted = true`), so the column has to
+ * have a constant that means "deleted" and another that means "not deleted".
+ */
+type SoftDeleteInfo = {
+    /** Property name of the column on the drizzle table — also the key on an aliased proxy. */
+    columnName: string;
+    column: Column;
+    nullable: boolean;
+    /** Evaluated per delete, so a timestamp form stamps the moment of the delete. */
+    writeDeleted: () => any;
+    /** Written by the restore mutation. */
+    writeRestored: any;
+    /** Non-nullable form only: the constant that means "this row is deleted". */
+    marker?: any;
+};
+/** Build-time lookup: the soft-delete convention of a table, if it declares one. */
+type SoftDeleteFor = (tableName: string) => SoftDeleteInfo | undefined;
+/** Produces one column's value from the GraphQL context. See `BuildSchemaConfig.contextValues`. */
+type ContextValueHook<TContext = any> = (context: TContext) => any;
+/** Build-time lookup: the context-derived columns of a table, keyed by column property name. */
+type ContextValuesFor = (tableName: string) => Record<string, ContextValueHook> | undefined;
+/**
+ * The two request-time policies a generated resolver applies, passed to the dialect
+ * generators as one value so a table's read scope and its server-owned columns travel
+ * together. Both stay `undefined` when nothing is configured, and every call site checks
+ * before doing any work — an unconfigured build generates exactly the SQL it did before.
+ */
+type TablePolicies = {
+    /** See `BuildSchemaConfig.scope`. */
+    scope?: ScopeFor;
+    /** See `BuildSchemaConfig.contextValues`. */
+    contextValues?: ContextValuesFor;
+    /** See `BuildSchemaConfig.softDelete`. */
+    softDelete?: SoftDeleteFor;
+    /** See `BuildSchemaConfig.onWrite`. */
+    onWrite?: WriteHookFor;
+};
 /**
  * Where a dialect's default sort places NULLs relative to non-NULL values:
  * - `nulls-largest` — PostgreSQL: NULLs sort as the largest values (last in ASC, first in DESC).
@@ -719,8 +798,14 @@ type SchemaFeatures = {
      * Each relation field offers `create` and `connect`; the update input adds `disconnect`
      * and, for a to-many relation, `set` (replace the whole set). `disconnect` and `set` are
      * generated only when the foreign key is nullable — there is no way to detach a row whose
-     * key is NOT NULL — and many-to-many (`.through()`) relations are not written through at
-     * all. Nesting is one level deep: the row a nested `create` inserts takes columns only.
+     * key is NOT NULL. Nesting is one level deep: the row a nested `create` inserts takes
+     * columns only.
+     *
+     * A many-to-many (`.through()`) relation is written as junction rows: `connect` on the
+     * create input, and `connect` / `disconnect` / `set` on the update input, all
+     * unconditional, since unlinking deletes a junction row rather than nulling a column.
+     * It offers no `create` — inserting a row and linking it are two writes to two tables —
+     * and `set: []` clears the relation.
      *
      * The whole tree runs in one transaction (a savepoint when the request already carries
      * one), and a column a relation fills in (`authorId`, when `author: { create: … }` is
@@ -863,6 +948,38 @@ type ScopeConfig<TContext = any> = Record<string, RowScope<TContext>>;
  * request context, keyed by Drizzle schema key and then by column property name.
  */
 type ContextValuesConfig<TContext = any> = Record<string, Record<string, (context: TContext) => any>>;
+/**
+ * How one table marks a row deleted: the column's property name, or that name plus the values
+ * written on delete and on restore. See {@link BuildSchemaConfig.softDelete}.
+ */
+type SoftDeleteColumn = string | {
+    /** Property name of the column that marks a row deleted. */
+    column: string;
+    /**
+     * Written when a row is deleted. A function is evaluated per delete. Defaults by column
+     * type: `new Date()` for a timestamp, an ISO string for text, `Date.now()` for a number,
+     * `true` for a boolean. Required, as a constant, when the column is NOT NULL and not a
+     * boolean — the predicate that hides marked rows has to compare against it.
+     */
+    deletedValue?: any;
+    /**
+     * Written when a row is restored. Defaults to `null` for a nullable column and `false`
+     * for a NOT NULL boolean; required for any other NOT NULL column.
+     */
+    restoredValue?: any;
+};
+
+/**
+ * Write hooks, either applied to every table (a bare function, or an object naming the
+ * positions) or registered per table by Drizzle schema key. See
+ * {@link BuildSchemaConfig.onWrite}.
+ */
+type OnWriteConfig = WriteHooks | Record<string, WriteHooks>;
+/**
+ * Per-table soft-delete declarations, either keyed by Drizzle schema key or as a rule applied
+ * to every table. See {@link BuildSchemaConfig.softDelete}.
+ */
+type SoftDeleteConfig = Record<string, SoftDeleteColumn> | ((table: any, tableName: string) => SoftDeleteColumn | undefined | null);
 /**
  * {@link BuildSchemaConfig.exclude} — tables and columns to keep out of the generated schema.
  *
@@ -921,6 +1038,11 @@ type BuildSchemaConfig = {
         update?: string;
         /** Prefix for upsert mutations (e.g., 'users' -> 'upsertUsers') */
         upsert?: string;
+        /**
+         * Prefix for the restore mutations of a soft-deleting table (e.g., 'users' ->
+         * 'restoreUsers'). Only used when {@link BuildSchemaConfig.softDelete} names the table.
+         */
+        restore?: string;
     };
     /**
      * Customizes query name suffixes for generated GraphQL operations.
@@ -1151,6 +1273,83 @@ type BuildSchemaConfig = {
      *   name), the same keying {@link BuildSchemaConfig.exclude} uses.
      */
     contextValues?: ContextValuesConfig;
+    /**
+     * Tables that mark rows deleted instead of removing them.
+     *
+     * ```ts
+     * buildSchema(db, {
+     *   softDelete: {
+     *     users: 'deletedAt',                          // nullable timestamp: stamped on delete
+     *     posts: { column: 'isDeleted', deletedValue: true, restoredValue: false },
+     *   },
+     * });
+     *
+     * // or as a convention across the whole schema:
+     * buildSchema(db, { softDelete: (table) => ('deletedAt' in table ? 'deletedAt' : undefined) });
+     * ```
+     *
+     * For a table that declares one:
+     *
+     * - `delete<Table>` and `delete<Table>Single` issue an `UPDATE` of the marker column
+     *   instead of a `DELETE`, and return the rows as they now stand.
+     * - `restore<Table>` and `restore<Table>Single` are generated alongside them, matching only
+     *   marked rows and writing the restored value. The prefix is configurable through
+     *   {@link BuildSchemaConfig.prefixes}.
+     * - Every generated read hides marked rows: list and single queries, aggregates, `groupBy`,
+     *   relation fields on both the eager and the batched path, and relation aggregates. Each
+     *   of those fields takes a `deleted: EXCLUDE | INCLUDE | ONLY` argument (default
+     *   `EXCLUDE`); `ONLY` is a trash view.
+     * - Every generated write skips them too: an `update`, a `delete`, or a nested `connect`
+     *   cannot reach a row that is already marked.
+     * - The marker column is removed from the create and update inputs, so the only ways to set
+     *   or clear it are the delete and restore mutations.
+     * - The predicate is ANDed on before {@link BuildSchemaConfig.scope}, and both are ANDed
+     *   after the client's `where` — a request can only ever narrow them.
+     *
+     * Two consequences of the pattern itself, which this does not paper over:
+     *
+     * - A marked row still occupies its unique keys, so inserting a row that reuses the natural
+     *   key of a deleted one still fails on the constraint.
+     * - An upsert whose conflict target hits a marked row updates nothing on PostgreSQL and
+     *   SQLite (the conflict predicate excludes it) but revives it on MySQL, whose
+     *   `ON DUPLICATE KEY UPDATE` takes no predicate.
+     *
+     * Marking a parent deleted does not mark its children — a cascade is a schema decision.
+     */
+    softDelete?: SoftDeleteConfig;
+    /**
+     * A hook that runs **inside the mutation's transaction**, so its writes commit or roll back
+     * with the mutation itself — the position an audit row, an outbox row, or a denormalized
+     * counter needs, and the one a `graphql-middleware` wrapper cannot occupy.
+     *
+     * ```ts
+     * buildSchema(db, {
+     *   onWrite: {
+     *     posts: async ({ table, operation, rows, tx }) => {
+     *       await tx.insert(auditLog).values(rows.map((row) => ({ table, operation, rowId: row.id })));
+     *     },
+     *   },
+     * });
+     * ```
+     *
+     * A bare function is the **`after`** hook — the position that has rows. `{ before, after }`
+     * names them explicitly; `before` receives the field's args ahead of the statement, for a
+     * check that has to read inside the same snapshot. Registering a bare function (or a
+     * positions object) at the top level applies it to every table; anything else is read as a
+     * table map keyed by Drizzle schema key, and an unknown name fails the build.
+     *
+     * - **`tx` is the executor the mutation ran on** — a caller-supplied executor under
+     *   `drizzleExecutorKey`, the request's auto-transaction, or, for a field that would
+     *   otherwise have run unwrapped, a transaction opened for it because the hook is there.
+     * - **Throwing rolls the mutation back.** That is the point of the position.
+     * - **`rows` are the post-write rows as the database returned them**, before the output
+     *   mapper. Empty at the `before` position, and on MySQL, whose mutations return no rows.
+     * - The hook fires for the **mutation field's own table**. Rows a nested write creates in
+     *   another table do not fire that table's hook.
+     *
+     * Off by default, and a build without it opens exactly the transactions it did before.
+     */
+    onWrite?: OnWriteConfig;
     /**
      * Tables and columns to leave out of the generated schema entirely.
      *
@@ -1439,7 +1638,7 @@ type DrizzleFieldKind = 'query' | 'mutation' | 'relation' | 'aggregate' | 'type'
  * What the field does. Arity is carried separately by `single`, so `select` covers both
  * the list query and its `…Single` sibling rather than being spelled twice.
  */
-type DrizzleFieldOperation = 'select' | 'insert' | 'update' | 'updateMany' | 'upsert' | 'delete' | 'aggregate' | 'groupBy' | 'relation' | 'relationAggregate';
+type DrizzleFieldOperation = 'select' | 'insert' | 'update' | 'updateMany' | 'upsert' | 'delete' | 'restore' | 'aggregate' | 'groupBy' | 'relation' | 'relationAggregate';
 /** The argument holding the rows a field is about, when it has one. */
 type DrizzleTargetArg = 'where' | 'values' | 'updates';
 /** `extensions.drizzle` on a generated field. */
@@ -1613,4 +1812,4 @@ declare const resolveSelection: (info: GraphQLResolveInfo | ResolveTree, options
 
 declare const buildSchema: <TDbClient extends AnyDrizzleDB<any>>(db: TDbClient, config?: BuildSchemaConfig) => GeneratedData<TDbClient>;
 
-export { type AggregateResolver, type AnyDrizzleDB, type BuildSchemaConfig, type ColumnDeprecator, type ColumnDescriber, type ColumnDocInfo, type ColumnTypeMapper, type ColumnTypeMapperInfo, type ComplexityConfig, type ContextValuesConfig, type DeleteResolver, type DeleteSingleResolver, type DrizzleExtension, type DrizzleFieldExtension, type DrizzleFieldKind, type DrizzleFieldOperation, type DrizzleTargetArg, type DrizzleTypeExtension, type EnumNameInfo, type EnumNameMapper, type ExtractRelations, type ExtractTableByName, type ExtractTableRelations, type ExtractTables, type FeatureSwitch, type GeneratedData, type GeneratedEntities, type GeneratedInputs, type GeneratedOutputs, GraphQLBigIntString, GraphQLDecimalString, type IdentifiedRows, type InsertArrResolver, type InsertResolver, type LimitsConfig, type MutationReturnlessResult, type MutationsCore, type QueriesCore, type RelationDescriber, type RelationResolverFactory, type ResolveSelectionOptions, type RowScope, type RowScopeFilter, type ScalarOverride, type ScalarOverridesConfig, type SchemaDocs, type SchemaExclusions, type SchemaFeatures, type ScopeConfig, type SelectResolver, type SelectSingleResolver, type SelectionOptions, type TableDescriber, type TableLimitPolicy, type TableNamedRelations, type UpdateManyArgs, type UpdateManyEntry, type UpdateManyResolver, type UpdateResolver, type UpdateSingleResolver, type UpsertArgs, type UpsertArrResolver, type UpsertConflictArgs, type UpsertResolver, buildSchema, createRelationResolverFactory, defaultErrorMapper, drizzleExecutorKey, drizzleExtension, extractFilters, extractOrderBy, extractRelationJoinColumns, identifyRows, isDrizzleFieldExtension, resolveSelection, selectionToWith, singularizeMapper };
+export { type AggregateResolver, type AnyDrizzleDB, type BuildSchemaConfig, type ColumnDeprecator, type ColumnDescriber, type ColumnDocInfo, type ColumnTypeMapper, type ColumnTypeMapperInfo, type ComplexityConfig, type ContextValuesConfig, type DeleteResolver, type DeleteSingleResolver, type DrizzleExtension, type DrizzleFieldExtension, type DrizzleFieldKind, type DrizzleFieldOperation, type DrizzleTargetArg, type DrizzleTypeExtension, type EnumNameInfo, type EnumNameMapper, type ExtractRelations, type ExtractTableByName, type ExtractTableRelations, type ExtractTables, type FeatureSwitch, type GeneratedData, type GeneratedEntities, type GeneratedInputs, type GeneratedOutputs, GraphQLBigIntString, GraphQLDecimalString, type IdentifiedRows, type InsertArrResolver, type InsertResolver, type LimitsConfig, type MutationReturnlessResult, type MutationsCore, type OnWriteConfig, type QueriesCore, type RelationDescriber, type RelationResolverFactory, type ResolveSelectionOptions, type RowScope, type RowScopeFilter, type ScalarOverride, type ScalarOverridesConfig, type SchemaDocs, type SchemaExclusions, type SchemaFeatures, type ScopeConfig, type SelectResolver, type SelectSingleResolver, type SelectionOptions, type SoftDeleteColumn, type SoftDeleteConfig, type TableDescriber, type TableLimitPolicy, type TableNamedRelations, type UpdateManyArgs, type UpdateManyEntry, type UpdateManyResolver, type UpdateResolver, type UpdateSingleResolver, type UpsertArgs, type UpsertArrResolver, type UpsertConflictArgs, type UpsertResolver, type WriteHook, type WriteHookPayload, type WriteHookPositions, type WriteHooks, type WriteOperation, buildSchema, createRelationResolverFactory, defaultErrorMapper, drizzleExecutorKey, drizzleExtension, extractFilters, extractOrderBy, extractRelationJoinColumns, identifyRows, isDrizzleFieldExtension, resolveSelection, selectionToWith, singularizeMapper };

package/dist/index.d.ts

@@ -237,6 +237,43 @@ type RelationResolverFactory = (params: {
  * both end up loaded in one process.
  */
 declare const drizzleExecutorKey: unique symbol;
+/** The write a hook is attached to. `restore` only exists for a soft-deleting table. */
+type WriteOperation = 'insert' | 'update' | 'updateMany' | 'upsert' | 'delete' | 'restore';
+/** What a write hook is handed. See {@link BuildSchemaConfig.onWrite}. */
+type WriteHookPayload = {
+    /** Drizzle schema key of the table being written. */
+    table: string;
+    operation: WriteOperation;
+    /** `'before'` runs ahead of the statement, `'after'` once it has returned. */
+    position: 'before' | 'after';
+    /** Whether the field writes a single row (`createUsersSingle`) or a list. */
+    single: boolean;
+    /** The field's GraphQL arguments, exactly as the resolver received them. */
+    args: any;
+    /**
+     * The rows the write produced, as the database returned them — before the output mapper,
+     * so values are database-shaped. Empty at the `before` position, and on MySQL, whose
+     * mutations return no rows.
+     */
+    rows: any[];
+    context: any;
+    info: any;
+    /** The executor the mutation itself ran on. Throwing from the hook rolls it back. */
+    tx: any;
+};
+type WriteHook = (payload: WriteHookPayload) => void | Promise<void>;
+type WriteHookPositions = {
+    before?: WriteHook;
+    after?: WriteHook;
+};
+type WriteHooks = WriteHook | WriteHookPositions;
+/** Resolved, per-field hooks: `undefined` when the table registered none. */
+type ResolvedWriteHooks = {
+    before?: WriteHook;
+    after?: WriteHook;
+};
+/** Build-time lookup of a table's hooks, installed on {@link TablePolicies}. */
+type WriteHookFor = (tableName: string, operation: WriteOperation) => ResolvedWriteHooks | undefined;
 /**
  * Creates a RelationResolverFactory that generates field-level resolvers for each relation.
  * Each resolver:
@@ -251,7 +288,7 @@ declare const drizzleExecutorKey: unique symbol;
  * each dialect builder states it: `'nulls-largest'` for PostgreSQL, `'nulls-smallest'` for
  * MySQL and SQLite.
  */
-declare const createRelationResolverFactory: (db: any, tables: Record<string, Table>, nullOrdering: NullOrdering, filterCtx?: RelationFilterBase, limits?: LimitPolicyFor, scopes?: ScopeFor) => RelationResolverFactory;
+declare const createRelationResolverFactory: (db: any, tables: Record<string, Table>, nullOrdering: NullOrdering, filterCtx?: RelationFilterBase, limits?: LimitPolicyFor, policies?: TablePolicies) => RelationResolverFactory;
 /** {@link BuildSchemaConfig.limits} resolved for one table. `undefined` means no policy. */
 type ResolvedLimitPolicy = {
     defaultLimit: number | undefined;
@@ -321,6 +358,48 @@ declare const extractFilters: <TTable extends Table>(table: TTable, tableName: s
 type ScopeHook<TContext = any> = (context: TContext, table: any) => SQL | Record<string, any> | undefined | null;
 /** Build-time lookup: the scope configured for a table, if any. */
 type ScopeFor = (tableName: string) => ScopeHook | undefined;
+/**
+ * One table's soft-delete convention, resolved against the real column at build time.
+ *
+ * `nullable` picks the shape of the predicate. A nullable column marks a row deleted by
+ * holding a value at all (`deletedAt IS NOT NULL`), which is the common timestamp form; a
+ * non-nullable one marks it by holding `marker` (`isDeleted = true`), so the column has to
+ * have a constant that means "deleted" and another that means "not deleted".
+ */
+type SoftDeleteInfo = {
+    /** Property name of the column on the drizzle table — also the key on an aliased proxy. */
+    columnName: string;
+    column: Column;
+    nullable: boolean;
+    /** Evaluated per delete, so a timestamp form stamps the moment of the delete. */
+    writeDeleted: () => any;
+    /** Written by the restore mutation. */
+    writeRestored: any;
+    /** Non-nullable form only: the constant that means "this row is deleted". */
+    marker?: any;
+};
+/** Build-time lookup: the soft-delete convention of a table, if it declares one. */
+type SoftDeleteFor = (tableName: string) => SoftDeleteInfo | undefined;
+/** Produces one column's value from the GraphQL context. See `BuildSchemaConfig.contextValues`. */
+type ContextValueHook<TContext = any> = (context: TContext) => any;
+/** Build-time lookup: the context-derived columns of a table, keyed by column property name. */
+type ContextValuesFor = (tableName: string) => Record<string, ContextValueHook> | undefined;
+/**
+ * The two request-time policies a generated resolver applies, passed to the dialect
+ * generators as one value so a table's read scope and its server-owned columns travel
+ * together. Both stay `undefined` when nothing is configured, and every call site checks
+ * before doing any work — an unconfigured build generates exactly the SQL it did before.
+ */
+type TablePolicies = {
+    /** See `BuildSchemaConfig.scope`. */
+    scope?: ScopeFor;
+    /** See `BuildSchemaConfig.contextValues`. */
+    contextValues?: ContextValuesFor;
+    /** See `BuildSchemaConfig.softDelete`. */
+    softDelete?: SoftDeleteFor;
+    /** See `BuildSchemaConfig.onWrite`. */
+    onWrite?: WriteHookFor;
+};
 /**
  * Where a dialect's default sort places NULLs relative to non-NULL values:
  * - `nulls-largest` — PostgreSQL: NULLs sort as the largest values (last in ASC, first in DESC).
@@ -719,8 +798,14 @@ type SchemaFeatures = {
      * Each relation field offers `create` and `connect`; the update input adds `disconnect`
      * and, for a to-many relation, `set` (replace the whole set). `disconnect` and `set` are
      * generated only when the foreign key is nullable — there is no way to detach a row whose
-     * key is NOT NULL — and many-to-many (`.through()`) relations are not written through at
-     * all. Nesting is one level deep: the row a nested `create` inserts takes columns only.
+     * key is NOT NULL. Nesting is one level deep: the row a nested `create` inserts takes
+     * columns only.
+     *
+     * A many-to-many (`.through()`) relation is written as junction rows: `connect` on the
+     * create input, and `connect` / `disconnect` / `set` on the update input, all
+     * unconditional, since unlinking deletes a junction row rather than nulling a column.
+     * It offers no `create` — inserting a row and linking it are two writes to two tables —
+     * and `set: []` clears the relation.
      *
      * The whole tree runs in one transaction (a savepoint when the request already carries
      * one), and a column a relation fills in (`authorId`, when `author: { create: … }` is
@@ -863,6 +948,38 @@ type ScopeConfig<TContext = any> = Record<string, RowScope<TContext>>;
  * request context, keyed by Drizzle schema key and then by column property name.
  */
 type ContextValuesConfig<TContext = any> = Record<string, Record<string, (context: TContext) => any>>;
+/**
+ * How one table marks a row deleted: the column's property name, or that name plus the values
+ * written on delete and on restore. See {@link BuildSchemaConfig.softDelete}.
+ */
+type SoftDeleteColumn = string | {
+    /** Property name of the column that marks a row deleted. */
+    column: string;
+    /**
+     * Written when a row is deleted. A function is evaluated per delete. Defaults by column
+     * type: `new Date()` for a timestamp, an ISO string for text, `Date.now()` for a number,
+     * `true` for a boolean. Required, as a constant, when the column is NOT NULL and not a
+     * boolean — the predicate that hides marked rows has to compare against it.
+     */
+    deletedValue?: any;
+    /**
+     * Written when a row is restored. Defaults to `null` for a nullable column and `false`
+     * for a NOT NULL boolean; required for any other NOT NULL column.
+     */
+    restoredValue?: any;
+};
+
+/**
+ * Write hooks, either applied to every table (a bare function, or an object naming the
+ * positions) or registered per table by Drizzle schema key. See
+ * {@link BuildSchemaConfig.onWrite}.
+ */
+type OnWriteConfig = WriteHooks | Record<string, WriteHooks>;
+/**
+ * Per-table soft-delete declarations, either keyed by Drizzle schema key or as a rule applied
+ * to every table. See {@link BuildSchemaConfig.softDelete}.
+ */
+type SoftDeleteConfig = Record<string, SoftDeleteColumn> | ((table: any, tableName: string) => SoftDeleteColumn | undefined | null);
 /**
  * {@link BuildSchemaConfig.exclude} — tables and columns to keep out of the generated schema.
  *
@@ -921,6 +1038,11 @@ type BuildSchemaConfig = {
         update?: string;
         /** Prefix for upsert mutations (e.g., 'users' -> 'upsertUsers') */
         upsert?: string;
+        /**
+         * Prefix for the restore mutations of a soft-deleting table (e.g., 'users' ->
+         * 'restoreUsers'). Only used when {@link BuildSchemaConfig.softDelete} names the table.
+         */
+        restore?: string;
     };
     /**
      * Customizes query name suffixes for generated GraphQL operations.
@@ -1151,6 +1273,83 @@ type BuildSchemaConfig = {
      *   name), the same keying {@link BuildSchemaConfig.exclude} uses.
      */
     contextValues?: ContextValuesConfig;
+    /**
+     * Tables that mark rows deleted instead of removing them.
+     *
+     * ```ts
+     * buildSchema(db, {
+     *   softDelete: {
+     *     users: 'deletedAt',                          // nullable timestamp: stamped on delete
+     *     posts: { column: 'isDeleted', deletedValue: true, restoredValue: false },
+     *   },
+     * });
+     *
+     * // or as a convention across the whole schema:
+     * buildSchema(db, { softDelete: (table) => ('deletedAt' in table ? 'deletedAt' : undefined) });
+     * ```
+     *
+     * For a table that declares one:
+     *
+     * - `delete<Table>` and `delete<Table>Single` issue an `UPDATE` of the marker column
+     *   instead of a `DELETE`, and return the rows as they now stand.
+     * - `restore<Table>` and `restore<Table>Single` are generated alongside them, matching only
+     *   marked rows and writing the restored value. The prefix is configurable through
+     *   {@link BuildSchemaConfig.prefixes}.
+     * - Every generated read hides marked rows: list and single queries, aggregates, `groupBy`,
+     *   relation fields on both the eager and the batched path, and relation aggregates. Each
+     *   of those fields takes a `deleted: EXCLUDE | INCLUDE | ONLY` argument (default
+     *   `EXCLUDE`); `ONLY` is a trash view.
+     * - Every generated write skips them too: an `update`, a `delete`, or a nested `connect`
+     *   cannot reach a row that is already marked.
+     * - The marker column is removed from the create and update inputs, so the only ways to set
+     *   or clear it are the delete and restore mutations.
+     * - The predicate is ANDed on before {@link BuildSchemaConfig.scope}, and both are ANDed
+     *   after the client's `where` — a request can only ever narrow them.
+     *
+     * Two consequences of the pattern itself, which this does not paper over:
+     *
+     * - A marked row still occupies its unique keys, so inserting a row that reuses the natural
+     *   key of a deleted one still fails on the constraint.
+     * - An upsert whose conflict target hits a marked row updates nothing on PostgreSQL and
+     *   SQLite (the conflict predicate excludes it) but revives it on MySQL, whose
+     *   `ON DUPLICATE KEY UPDATE` takes no predicate.
+     *
+     * Marking a parent deleted does not mark its children — a cascade is a schema decision.
+     */
+    softDelete?: SoftDeleteConfig;
+    /**
+     * A hook that runs **inside the mutation's transaction**, so its writes commit or roll back
+     * with the mutation itself — the position an audit row, an outbox row, or a denormalized
+     * counter needs, and the one a `graphql-middleware` wrapper cannot occupy.
+     *
+     * ```ts
+     * buildSchema(db, {
+     *   onWrite: {
+     *     posts: async ({ table, operation, rows, tx }) => {
+     *       await tx.insert(auditLog).values(rows.map((row) => ({ table, operation, rowId: row.id })));
+     *     },
+     *   },
+     * });
+     * ```
+     *
+     * A bare function is the **`after`** hook — the position that has rows. `{ before, after }`
+     * names them explicitly; `before` receives the field's args ahead of the statement, for a
+     * check that has to read inside the same snapshot. Registering a bare function (or a
+     * positions object) at the top level applies it to every table; anything else is read as a
+     * table map keyed by Drizzle schema key, and an unknown name fails the build.
+     *
+     * - **`tx` is the executor the mutation ran on** — a caller-supplied executor under
+     *   `drizzleExecutorKey`, the request's auto-transaction, or, for a field that would
+     *   otherwise have run unwrapped, a transaction opened for it because the hook is there.
+     * - **Throwing rolls the mutation back.** That is the point of the position.
+     * - **`rows` are the post-write rows as the database returned them**, before the output
+     *   mapper. Empty at the `before` position, and on MySQL, whose mutations return no rows.
+     * - The hook fires for the **mutation field's own table**. Rows a nested write creates in
+     *   another table do not fire that table's hook.
+     *
+     * Off by default, and a build without it opens exactly the transactions it did before.
+     */
+    onWrite?: OnWriteConfig;
     /**
      * Tables and columns to leave out of the generated schema entirely.
      *
@@ -1439,7 +1638,7 @@ type DrizzleFieldKind = 'query' | 'mutation' | 'relation' | 'aggregate' | 'type'
  * What the field does. Arity is carried separately by `single`, so `select` covers both
  * the list query and its `…Single` sibling rather than being spelled twice.
  */
-type DrizzleFieldOperation = 'select' | 'insert' | 'update' | 'updateMany' | 'upsert' | 'delete' | 'aggregate' | 'groupBy' | 'relation' | 'relationAggregate';
+type DrizzleFieldOperation = 'select' | 'insert' | 'update' | 'updateMany' | 'upsert' | 'delete' | 'restore' | 'aggregate' | 'groupBy' | 'relation' | 'relationAggregate';
 /** The argument holding the rows a field is about, when it has one. */
 type DrizzleTargetArg = 'where' | 'values' | 'updates';
 /** `extensions.drizzle` on a generated field. */
@@ -1613,4 +1812,4 @@ declare const resolveSelection: (info: GraphQLResolveInfo | ResolveTree, options
 
 declare const buildSchema: <TDbClient extends AnyDrizzleDB<any>>(db: TDbClient, config?: BuildSchemaConfig) => GeneratedData<TDbClient>;
 
-export { type AggregateResolver, type AnyDrizzleDB, type BuildSchemaConfig, type ColumnDeprecator, type ColumnDescriber, type ColumnDocInfo, type ColumnTypeMapper, type ColumnTypeMapperInfo, type ComplexityConfig, type ContextValuesConfig, type DeleteResolver, type DeleteSingleResolver, type DrizzleExtension, type DrizzleFieldExtension, type DrizzleFieldKind, type DrizzleFieldOperation, type DrizzleTargetArg, type DrizzleTypeExtension, type EnumNameInfo, type EnumNameMapper, type ExtractRelations, type ExtractTableByName, type ExtractTableRelations, type ExtractTables, type FeatureSwitch, type GeneratedData, type GeneratedEntities, type GeneratedInputs, type GeneratedOutputs, GraphQLBigIntString, GraphQLDecimalString, type IdentifiedRows, type InsertArrResolver, type InsertResolver, type LimitsConfig, type MutationReturnlessResult, type MutationsCore, type QueriesCore, type RelationDescriber, type RelationResolverFactory, type ResolveSelectionOptions, type RowScope, type RowScopeFilter, type ScalarOverride, type ScalarOverridesConfig, type SchemaDocs, type SchemaExclusions, type SchemaFeatures, type ScopeConfig, type SelectResolver, type SelectSingleResolver, type SelectionOptions, type TableDescriber, type TableLimitPolicy, type TableNamedRelations, type UpdateManyArgs, type UpdateManyEntry, type UpdateManyResolver, type UpdateResolver, type UpdateSingleResolver, type UpsertArgs, type UpsertArrResolver, type UpsertConflictArgs, type UpsertResolver, buildSchema, createRelationResolverFactory, defaultErrorMapper, drizzleExecutorKey, drizzleExtension, extractFilters, extractOrderBy, extractRelationJoinColumns, identifyRows, isDrizzleFieldExtension, resolveSelection, selectionToWith, singularizeMapper };
+export { type AggregateResolver, type AnyDrizzleDB, type BuildSchemaConfig, type ColumnDeprecator, type ColumnDescriber, type ColumnDocInfo, type ColumnTypeMapper, type ColumnTypeMapperInfo, type ComplexityConfig, type ContextValuesConfig, type DeleteResolver, type DeleteSingleResolver, type DrizzleExtension, type DrizzleFieldExtension, type DrizzleFieldKind, type DrizzleFieldOperation, type DrizzleTargetArg, type DrizzleTypeExtension, type EnumNameInfo, type EnumNameMapper, type ExtractRelations, type ExtractTableByName, type ExtractTableRelations, type ExtractTables, type FeatureSwitch, type GeneratedData, type GeneratedEntities, type GeneratedInputs, type GeneratedOutputs, GraphQLBigIntString, GraphQLDecimalString, type IdentifiedRows, type InsertArrResolver, type InsertResolver, type LimitsConfig, type MutationReturnlessResult, type MutationsCore, type OnWriteConfig, type QueriesCore, type RelationDescriber, type RelationResolverFactory, type ResolveSelectionOptions, type RowScope, type RowScopeFilter, type ScalarOverride, type ScalarOverridesConfig, type SchemaDocs, type SchemaExclusions, type SchemaFeatures, type ScopeConfig, type SelectResolver, type SelectSingleResolver, type SelectionOptions, type SoftDeleteColumn, type SoftDeleteConfig, type TableDescriber, type TableLimitPolicy, type TableNamedRelations, type UpdateManyArgs, type UpdateManyEntry, type UpdateManyResolver, type UpdateResolver, type UpdateSingleResolver, type UpsertArgs, type UpsertArrResolver, type UpsertConflictArgs, type UpsertResolver, type WriteHook, type WriteHookPayload, type WriteHookPositions, type WriteHooks, type WriteOperation, buildSchema, createRelationResolverFactory, defaultErrorMapper, drizzleExecutorKey, drizzleExtension, extractFilters, extractOrderBy, extractRelationJoinColumns, identifyRows, isDrizzleFieldExtension, resolveSelection, selectionToWith, singularizeMapper };