@vantreeseba/drizzle-graphql 8.0.0 → 8.2.0

package/dist/index.js

@@ -1,5 +1,5 @@
 // src/index.ts
-import { is as is14 } from "drizzle-orm";
+import { is as is13 } from "drizzle-orm";
 import { MySqlDatabase as MySqlDatabase2 } from "drizzle-orm/mysql-core";
 import { PgAsyncDatabase as PgAsyncDatabase2 } from "drizzle-orm/pg-core";
 import { BaseSQLiteDatabase as BaseSQLiteDatabase2 } from "drizzle-orm/sqlite-core";
@@ -25,7 +25,12 @@ import { GraphQLEnumType as GraphQLEnumType3 } from "graphql";
 
 // src/util/builders/common/errors.ts
 import { GraphQLError } from "graphql";
-var drizzleError = (message, { code, ...context }) => new GraphQLError(message, {
+var drizzleError = (message, {
+  code,
+  nodes,
+  ...context
+}) => new GraphQLError(message, {
+  nodes,
   extensions: Object.keys(context).length ? { code, drizzle: context } : { code }
 });
 var withErrorContext = (error, context) => {
@@ -137,7 +142,6 @@ import {
 
 // src/util/data-mappers/index.ts
 import { getTableColumns as getTableColumns2, is as is2, One } from "drizzle-orm";
-import { GraphQLError as GraphQLError3 } from "graphql";
 
 // src/util/type-converter/index.ts
 import { extractExtendedColumnType, getTableColumns, is } from "drizzle-orm";
@@ -167,72 +171,77 @@ var singularizeMapper = (tableName) => ({
 });
 
 // src/util/scalars/index.ts
-import { GraphQLError as GraphQLError2, GraphQLScalarType, Kind } from "graphql";
+import { GraphQLScalarType, Kind } from "graphql";
 import { GraphQLDate, GraphQLDateTime, GraphQLJSON, GraphQLUUID } from "graphql-scalars";
-var asDecimalString = (value) => {
+var INVALID_INPUT = "DRIZZLE_INVALID_INPUT_VALUE";
+var UNREPRESENTABLE = "DRIZZLE_UNREPRESENTABLE_VALUE";
+var decimalString = (code) => (value) => {
   if (typeof value === "bigint") {
     return value.toString();
   }
   if (typeof value === "number") {
     if (!Number.isInteger(value)) {
-      throw new GraphQLError2(`BigInt cannot represent non-integer value: ${value}`);
+      throw drizzleError(`BigInt cannot represent non-integer value: ${value}`, { code });
     }
     if (!Number.isSafeInteger(value)) {
-      throw new GraphQLError2(
-        `BigInt cannot represent the number ${value} without precision loss \u2014 pass it as a string instead`
+      throw drizzleError(
+        `BigInt cannot represent the number ${value} without precision loss \u2014 pass it as a string instead`,
+        { code }
       );
     }
     return String(value);
   }
   if (typeof value === "string") {
     if (!/^-?\d+$/.test(value)) {
-      throw new GraphQLError2(`BigInt cannot represent non-integer value: "${value}"`);
+      throw drizzleError(`BigInt cannot represent non-integer value: "${value}"`, { code });
     }
     return value;
   }
-  throw new GraphQLError2(`BigInt cannot represent value: ${JSON.stringify(value)}`);
+  throw drizzleError(`BigInt cannot represent value: ${JSON.stringify(value)}`, { code });
 };
+var parseDecimal = decimalString(INVALID_INPUT);
 var GraphQLBigIntString = new GraphQLScalarType({
   name: "BigInt",
   description: "A 64-bit integer, transported as a decimal string so that values beyond JavaScript's safe integer range survive the round-trip intact.",
-  serialize: asDecimalString,
-  parseValue: asDecimalString,
+  serialize: decimalString(UNREPRESENTABLE),
+  parseValue: parseDecimal,
   parseLiteral: (ast) => {
     if (ast.kind !== Kind.STRING && ast.kind !== Kind.INT) {
-      throw new GraphQLError2(`BigInt cannot represent a ${ast.kind}`, { nodes: ast });
+      throw drizzleError(`BigInt cannot represent a ${ast.kind}`, { code: INVALID_INPUT, nodes: ast });
     }
-    return asDecimalString(ast.value);
+    return parseDecimal(ast.value);
   }
 });
 var numericStringPattern = /^[+-]?(\d+(\.\d*)?|\.\d+)([eE][+-]?\d+)?$/;
-var asNumericString = (value) => {
+var numericString = (code) => (value) => {
   if (typeof value === "bigint") {
     return value.toString();
   }
   if (typeof value === "number") {
     if (!Number.isFinite(value)) {
-      throw new GraphQLError2(`Decimal cannot represent non-finite value: ${value}`);
+      throw drizzleError(`Decimal cannot represent non-finite value: ${value}`, { code });
     }
     return String(value);
   }
   if (typeof value === "string") {
     if (!numericStringPattern.test(value)) {
-      throw new GraphQLError2(`Decimal cannot represent non-numeric value: "${value}"`);
+      throw drizzleError(`Decimal cannot represent non-numeric value: "${value}"`, { code });
     }
     return value;
   }
-  throw new GraphQLError2(`Decimal cannot represent value: ${JSON.stringify(value)}`);
+  throw drizzleError(`Decimal cannot represent value: ${JSON.stringify(value)}`, { code });
 };
+var parseNumeric = numericString(INVALID_INPUT);
 var GraphQLDecimalString = new GraphQLScalarType({
   name: "Decimal",
   description: "An arbitrary-precision decimal, transported as a numeric string so that values beyond JavaScript's double-precision range survive the round-trip intact.",
-  serialize: asNumericString,
-  parseValue: asNumericString,
+  serialize: numericString(UNREPRESENTABLE),
+  parseValue: parseNumeric,
   parseLiteral: (ast) => {
     if (ast.kind !== Kind.STRING && ast.kind !== Kind.INT && ast.kind !== Kind.FLOAT) {
-      throw new GraphQLError2(`Decimal cannot represent a ${ast.kind}`, { nodes: ast });
+      throw drizzleError(`Decimal cannot represent a ${ast.kind}`, { code: INVALID_INPUT, nodes: ast });
     }
-    return asNumericString(ast.value);
+    return parseNumeric(ast.value);
   }
 });
 
@@ -542,7 +551,7 @@ var remapFromGraphQLCore = (value, column, columnName) => {
   if (isTimestampColumn) {
     const formatted = new Date(value);
     if (Number.isNaN(formatted.getTime())) {
-      throw new GraphQLError3(`Field '${columnName}' is not a valid date!`);
+      throw drizzleError(`Field '${columnName}' is not a valid date!`, { code: "DRIZZLE_INVALID_INPUT_VALUE" });
     }
     return formatted;
   }
@@ -551,7 +560,7 @@ var remapFromGraphQLCore = (value, column, columnName) => {
     const dateOnly = value.includes("T") ? value.split("T")[0] : value;
     const check = new Date(dateOnly);
     if (Number.isNaN(check.getTime())) {
-      throw new GraphQLError3(`Field '${columnName}' is not a valid date!`);
+      throw drizzleError(`Field '${columnName}' is not a valid date!`, { code: "DRIZZLE_INVALID_INPUT_VALUE" });
     }
     return dateOnly;
   }
@@ -559,7 +568,7 @@ var remapFromGraphQLCore = (value, column, columnName) => {
     try {
       return BigInt(value);
     } catch {
-      throw new GraphQLError3(`Field '${columnName}' is not a BigInt!`);
+      throw drizzleError(`Field '${columnName}' is not a BigInt!`, { code: "DRIZZLE_INVALID_INPUT_VALUE" });
     }
   }
   if (dataType.includes("json") && column.columnType !== "PgGeometryObject") {
@@ -569,13 +578,13 @@ var remapFromGraphQLCore = (value, column, columnName) => {
     case "date": {
       const formatted = new Date(value);
       if (Number.isNaN(formatted.getTime())) {
-        throw new GraphQLError3(`Field '${columnName}' is not a valid date!`);
+        throw drizzleError(`Field '${columnName}' is not a valid date!`, { code: "DRIZZLE_INVALID_INPUT_VALUE" });
       }
       return formatted;
     }
     case "buffer": {
       if (!Array.isArray(value)) {
-        throw new GraphQLError3(`Field '${columnName}' is not an array!`);
+        throw drizzleError(`Field '${columnName}' is not an array!`, { code: "DRIZZLE_INVALID_INPUT_VALUE" });
       }
       return Buffer.from(value);
     }
@@ -586,19 +595,23 @@ var remapFromGraphQLCore = (value, column, columnName) => {
       try {
         return JSON.parse(value);
       } catch (e) {
-        throw new GraphQLError3(
+        throw drizzleError(
           `Invalid JSON in field '${columnName}':
-${e instanceof Error ? e.message : "Unknown error"}`
+${e instanceof Error ? e.message : "Unknown error"}`,
+          {
+            code: "DRIZZLE_INVALID_INPUT_VALUE"
+          }
         );
       }
     }
     case "array": {
       if (!Array.isArray(value)) {
-        throw new GraphQLError3(`Field '${columnName}' is not an array!`);
+        throw drizzleError(`Field '${columnName}' is not an array!`, { code: "DRIZZLE_INVALID_INPUT_VALUE" });
       }
       if (column.columnType === "PgGeometry" && value.length !== 2) {
-        throw new GraphQLError3(
-          `Invalid float tuple in field '${columnName}': expected array with length of 2, received ${value.length}`
+        throw drizzleError(
+          `Invalid float tuple in field '${columnName}': expected array with length of 2, received ${value.length}`,
+          { code: "DRIZZLE_INVALID_INPUT_VALUE" }
         );
       }
       return value;
@@ -607,7 +620,7 @@ ${e instanceof Error ? e.message : "Unknown error"}`
       try {
         return BigInt(value);
       } catch (_error) {
-        throw new GraphQLError3(`Field '${columnName}' is not a BigInt!`);
+        throw drizzleError(`Field '${columnName}' is not a BigInt!`, { code: "DRIZZLE_INVALID_INPUT_VALUE" });
       }
     }
     default: {
@@ -625,7 +638,7 @@ var remapFromGraphQLSingleInput = (queryInput, table) => {
     } else {
       const column = getTableColumns2(table)[key];
       if (!column) {
-        throw new GraphQLError3(`Unknown column: ${key}`);
+        throw drizzleError(`Unknown column: ${key}`, { code: "DRIZZLE_UNKNOWN_COLUMN" });
       }
       if (value === null && column.notNull) {
         delete queryInput[key];
@@ -4258,6 +4271,50 @@ var runWriteHook = (hooks, position, payload) => {
   return Promise.resolve(hook({ ...payload, position, rows: payload.rows ?? [] }));
 };
 
+// src/util/builders/common/write-scaffold.ts
+var writeResolver = ({
+  db,
+  tableName,
+  operation,
+  single,
+  fieldName,
+  args: queryArgs,
+  txCtx,
+  policies,
+  run
+}) => {
+  const hooks = policies?.onWrite?.(tableName, operation);
+  const errorCtx = { table: tableName, operation, field: fieldName };
+  return {
+    name: fieldName,
+    resolver: async (_source, args, context, info) => {
+      try {
+        return await runMutation(
+          db,
+          context,
+          info,
+          txCtx,
+          (executor) => {
+            const payload = { table: tableName, operation, single, args, context, info, tx: executor };
+            return run({
+              executor,
+              args,
+              context,
+              info,
+              before: () => runWriteHook(hooks, "before", payload),
+              after: (rows) => runWriteHook(hooks, "after", { ...payload, rows: rows ?? [] })
+            });
+          },
+          !!hooks
+        );
+      } catch (e) {
+        throw withErrorContext(toGraphQLError(e), errorCtx);
+      }
+    },
+    args: queryArgs
+  };
+};
+
 // src/util/features.ts
 var featureDefaults = {
   aggregates: true,
@@ -4616,16 +4673,19 @@ var resolveBuildConfig = (config, schema) => {
 };
 
 // src/util/builders/mysql.ts
-import { is as is10, One as One7 } from "drizzle-orm";
 import { getTableConfig, MySqlTable } from "drizzle-orm/mysql-core";
 import {
-  GraphQLBoolean as GraphQLBoolean5,
+  GraphQLBoolean as GraphQLBoolean6,
   GraphQLInt as GraphQLInt8,
-  GraphQLList as GraphQLList9,
-  GraphQLNonNull as GraphQLNonNull13,
+  GraphQLList as GraphQLList11,
+  GraphQLNonNull as GraphQLNonNull15,
   GraphQLObjectType as GraphQLObjectType4
 } from "graphql";
 
+// src/util/builders/build-context.ts
+import { is as is11, One as One8 } from "drizzle-orm";
+import { GraphQLList as GraphQLList10, GraphQLNonNull as GraphQLNonNull14 } from "graphql";
+
 // src/util/builders/aggregates.ts
 import {
   and as and10,
@@ -5148,1760 +5208,1628 @@ var generateGroupBy = (db, tableName, table, typeName, fieldName, filterArgs, gr
   };
 };
 
-// src/util/builders/select.ts
-import { parseResolveInfo as parseResolveInfo2 } from "graphql-parse-resolve-info";
-
-// src/util/builders/errors.ts
-var missingQueryBuilderError = (tableName) => new Error(
-  `Drizzle-GraphQL Error: Table '${tableName}' was passed to the drizzle constructor's schema but is missing from its relations config, so drizzle-orm exposes no query builder for it. Include it in the relations you pass to buildRelations/defineRelations, or drop it from the generated schema with config.exclude.tables.`
-);
-
-// src/util/builders/select.ts
-var queryBaseFor = (db, tableName) => {
-  const queryBase = db.query[tableName];
-  if (!queryBase) {
-    throw missingQueryBuilderError(tableName);
+// src/util/builders/nested-writes.ts
+import { and as and11, Column, eq as eq8, getColumns as getColumns16, inArray as inArray6, is as is10, One as One7 } from "drizzle-orm";
+import { GraphQLBoolean as GraphQLBoolean5, GraphQLInputObjectType as GraphQLInputObjectType11, GraphQLList as GraphQLList9, GraphQLNonNull as GraphQLNonNull13 } from "graphql";
+var isOptionalOnInsert = (column) => !column.notNull || !!column.hasDefault || !!column.defaultFn;
+var propNameOf = (table, column) => {
+  if (!column) {
+    return void 0;
   }
-  return queryBase;
+  for (const [propName, candidate] of Object.entries(getColumns16(table))) {
+    if (candidate === column) {
+      return propName;
+    }
+  }
+  return void 0;
 };
-var createSelectGenerators = (primaryKeyPropNames, nullOrdering) => {
-  const generateSelectArray2 = (db, tableName, tables, relationMap, orderArgs, filterArgs, fieldName, typeName, typeNameMapper, filterCtx, distinctEnabled = true, limits, policies, resolveName) => {
-    const queryBase = queryBaseFor(db, tableName);
-    const table = tables[tableName];
-    const limitPolicy = limits?.(tableName);
-    const pkNames = primaryKeyPropNames(table);
-    const errorCtx = { table: tableName, operation: "select", field: fieldName };
-    const queryArgs = selectArrayArgs(
-      orderArgs,
-      filterArgs,
-      distinctEnabled ? generateDistinctEnum(table, typeName, resolveName, tableName) : void 0,
-      policies?.softDelete,
-      tableName,
-      resolveName
-    );
-    const objectTypeName = resolveObjectTypeName(tableName, typeNameMapper, resolveName);
-    return {
-      name: fieldName,
-      resolver: async (_source, rawArgs, context, info) => {
-        const args = withDefaultOrderBy(rawArgs, tableName, policies?.defaultOrderBy);
-        try {
-          const parsedInfo = parseResolveInfo2(info, { deep: true });
-          const { executor, queryBase: requestQueryBase } = resolveQueryExecutor(db, context, tableName, queryBase);
-          return await runRelationalSelect({
-            queryBase: requestQueryBase,
-            tables,
-            tableName,
-            table,
-            relationMap,
-            typeName: objectTypeName,
-            typeNameMapper,
-            resolveName,
-            parsedInfo,
-            ...args,
-            limit: applyLimitPolicy(args.limit, limitPolicy),
-            single: false,
-            filterCtx,
-            limits,
-            defaultOrderBy: policies?.defaultOrderBy,
-            pkNames,
-            db: executor,
-            scope: policies?.scope?.(context),
-            nullOrdering
-          });
-        } catch (e) {
-          throw withErrorContext(toGraphQLError(e), errorCtx);
-        }
-      },
-      args: queryArgs
-    };
-  };
-  const generateSelectSingle2 = (db, tableName, tables, relationMap, orderArgs, filterArgs, fieldName, typeName, typeNameMapper, filterCtx, limits, policies, resolveName) => {
-    const queryBase = queryBaseFor(db, tableName);
-    const queryArgs = selectSingleArgs(orderArgs, filterArgs, policies?.softDelete, tableName, resolveName);
-    const objectTypeName = resolveObjectTypeName(tableName, typeNameMapper, resolveName);
-    const table = tables[tableName];
-    const pkNames = primaryKeyPropNames(table);
-    const errorCtx = { table: tableName, operation: "select", field: fieldName };
-    return {
-      name: fieldName,
-      resolver: async (_source, rawArgs, context, info) => {
-        const args = withDefaultOrderBy(rawArgs, tableName, policies?.defaultOrderBy);
-        try {
-          const parsedInfo = parseResolveInfo2(info, { deep: true });
-          const { executor, queryBase: requestQueryBase } = resolveQueryExecutor(db, context, tableName, queryBase);
-          return await runRelationalSelect({
-            queryBase: requestQueryBase,
-            tables,
-            tableName,
-            table,
-            relationMap,
-            typeName: objectTypeName,
-            typeNameMapper,
-            resolveName,
-            parsedInfo,
-            ...args,
-            single: true,
-            filterCtx,
-            limits,
-            defaultOrderBy: policies?.defaultOrderBy,
-            pkNames,
-            db: executor,
-            scope: policies?.scope?.(context)
-          });
-        } catch (e) {
-          throw withErrorContext(toGraphQLError(e), errorCtx);
-        }
-      },
-      args: queryArgs
-    };
+var throughColumn = (entry) => entry && is10(entry, Column) ? entry : entry?._?.column;
+var buildThroughPlan = (relationName, relation, table, targetTableName, targetTable) => {
+  if (is10(relation, One7)) {
+    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 = getColumns16(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 }
   };
-  return { generateSelectArray: generateSelectArray2, generateSelectSingle: generateSelectSingle2 };
 };
-
-// src/util/builders/mysql.ts
-var generateInsertArray = (db, tableName, table, baseType, fieldName, txCtx, policies) => {
-  const queryArgs = {
-    values: {
-      type: new GraphQLNonNull13(new GraphQLList9(new GraphQLNonNull13(baseType)))
+var buildNestedWritePlans = (tables, relationMap, resolveUniqueSets, resolvePrimaryKeys, extractJoinColumns) => {
+  const uniqueCache = /* @__PURE__ */ new Map();
+  const singleColumnUniques = (tableName, table) => {
+    let cached = uniqueCache.get(tableName);
+    if (!cached) {
+      cached = new Set(
+        resolveUniqueSets(table).filter((set) => set.length === 1).map((set) => set[0])
+      );
+      uniqueCache.set(tableName, cached);
     }
+    return cached;
   };
-  const hooks = policies?.onWrite?.(tableName, "insert");
-  const errorCtx = { table: tableName, operation: "insert", field: fieldName };
-  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 drizzleError("No values were provided!", { code: "DRIZZLE_NO_VALUES" });
-            }
-            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 withErrorContext(toGraphQLError(e), errorCtx);
-      }
-    },
-    args: queryArgs
-  };
-};
-var generateInsertSingle = (db, tableName, table, baseType, fieldName, txCtx, policies) => {
-  const queryArgs = {
-    values: {
-      type: new GraphQLNonNull13(baseType)
+  const pkCache = /* @__PURE__ */ new Map();
+  const singleColumnPk = (tableName, table) => {
+    if (!pkCache.has(tableName)) {
+      const pk = resolvePrimaryKeys(table);
+      pkCache.set(tableName, pk.length === 1 ? pk[0] : void 0);
     }
+    return pkCache.get(tableName);
   };
-  const hooks = policies?.onWrite?.(tableName, "insert");
-  const errorCtx = { table: tableName, operation: "insert", field: fieldName };
-  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 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 withErrorContext(toGraphQLError(e), errorCtx);
+  const plans = {};
+  for (const [tableName, relations] of Object.entries(relationMap)) {
+    const table = tables[tableName];
+    if (!table) {
+      continue;
+    }
+    const tablePlans = {};
+    for (const [relationName, relEntry] of Object.entries(relations)) {
+      const relation = relEntry.relation;
+      const targetTableName = relEntry.targetTableName;
+      const targetTable = tables[targetTableName];
+      if (!targetTable) {
+        continue;
       }
-    },
-    args: queryArgs
-  };
+      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;
+      }
+      const { localColPropName, foreignCol, foreignColPropName } = joinColumns;
+      const localCol = getColumns16(table)[localColPropName];
+      if (!localCol) {
+        continue;
+      }
+      const isOne = is10(relation, One7);
+      const localIsPk = singleColumnPk(tableName, table) === localColPropName;
+      const foreignIsPk = singleColumnPk(targetTableName, targetTable) === foreignColPropName;
+      const localIsUnique = singleColumnUniques(tableName, table).has(localColPropName);
+      const foreignIsUnique = singleColumnUniques(targetTableName, targetTable).has(foreignColPropName);
+      let fkSide;
+      if (!isOne) {
+        fkSide = "child";
+      } else if (foreignIsPk && !localIsPk) {
+        fkSide = "parent";
+      } else if (localIsPk) {
+        fkSide = "child";
+      } else if (foreignIsUnique) {
+        fkSide = "parent";
+      } else if (localIsUnique) {
+        fkSide = "child";
+      } else {
+        continue;
+      }
+      const fkColumn = fkSide === "child" ? foreignCol : localCol;
+      tablePlans[relationName] = {
+        relationName,
+        targetTableName,
+        targetTable,
+        localColPropName,
+        foreignColPropName,
+        foreignCol,
+        localCol,
+        isOne,
+        fkSide,
+        canDetach: !fkColumn.notNull
+      };
+    }
+    if (Object.keys(tablePlans).length) {
+      plans[tableName] = tablePlans;
+    }
+  }
+  return plans;
 };
-var generateUpsert = (db, tableName, table, baseType, onConflictType, fieldName, single, txCtx, policies) => {
-  const queryArgs = {
-    values: {
-      type: single ? new GraphQLNonNull13(baseType) : new GraphQLNonNull13(new GraphQLList9(new GraphQLNonNull13(baseType)))
-    },
-    onConflict: {
-      type: onConflictType,
-      description: "How a conflicting row is resolved. Defaults to overwriting it."
+var NO_COLUMNS = /* @__PURE__ */ new Set();
+var createNestedWriteTypes = (params) => {
+  const { plans, cacheCtx, typeNameMapper } = params;
+  const wrapperCache = /* @__PURE__ */ new Map();
+  const payloadCache = /* @__PURE__ */ new Map();
+  const payloadType = (tableName, typeName, plan) => {
+    const key = `${tableName}.${plan.relationName}`;
+    const cached = payloadCache.get(key);
+    if (cached) {
+      return cached;
     }
+    const omitted = plan.fkSide === "child" ? plan.foreignColPropName : void 0;
+    const contextColumns = cacheCtx.contextValuesOf?.(plan.targetTableName);
+    const fields = Object.fromEntries(
+      Object.entries(visibleColumns(plan.targetTable)).filter(([columnName]) => columnName !== omitted && !contextColumns?.[columnName]).map(([columnName, column]) => [
+        columnName,
+        drizzleColumnToGraphQLType(column, columnName, plan.targetTableName, false, true, true)
+      ])
+    );
+    const type = new GraphQLInputObjectType11({
+      name: cacheCtx.typeName({
+        kind: "nestedWriteInput",
+        defaultName: `${typeName}${capitalize(plan.relationName)}NestedCreatePayloadInput`,
+        table: tableName,
+        operation: plan.relationName
+      }),
+      description: omitted === void 0 ? `A new ${resolveTypeName(plan.targetTableName, typeNameMapper)} row for ${typeName}.${plan.relationName}` : `A new ${resolveTypeName(plan.targetTableName, typeNameMapper)} row for ${typeName}.${plan.relationName}. \`${omitted}\` is set from the ${typeName} row this is written with.`,
+      fields
+    });
+    payloadCache.set(key, type);
+    return type;
   };
-  const pkNames = mysqlPrimaryKeyPropNames(table);
-  const hooks = policies?.onWrite?.(tableName, "upsert");
-  const errorCtx = { table: tableName, operation: "upsert", field: fieldName };
-  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 drizzleError("No values were provided!", { code: "DRIZZLE_NO_VALUES" });
-            }
-            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 withErrorContext(toGraphQLError(e), errorCtx);
+  const targetFilters = (plan) => cacheCtx.filterTypeCache.get(plan.targetTable);
+  const listOf = (type) => new GraphQLList9(new GraphQLNonNull13(type));
+  const wrapperType = (tableName, typeName, plan, forUpdate) => {
+    const key = `${tableName}.${plan.relationName}.${forUpdate ? "update" : "create"}`;
+    const cached = wrapperCache.get(key);
+    if (cached) {
+      return cached;
+    }
+    const filters = targetFilters(plan);
+    const targetTypeName = resolveTypeName(plan.targetTableName, typeNameMapper);
+    const fields = {};
+    if (plan.through) {
+      if (!filters) {
+        return void 0;
       }
-    },
-    args: queryArgs
+      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,
+          description: `Attach the existing ${targetTypeName} row this matches. Must match exactly one row.`
+        };
+      }
+      if (forUpdate && plan.canDetach) {
+        fields["disconnect"] = {
+          type: GraphQLBoolean5,
+          description: `Detach the currently attached ${targetTypeName} row, leaving it in place`
+        };
+      }
+    } else {
+      fields["create"] = {
+        type: listOf(payloadType(tableName, typeName, plan)),
+        description: `Insert these ${targetTypeName} rows and attach them`
+      };
+      if (filters) {
+        fields["connect"] = {
+          type: listOf(filters),
+          description: `Attach every existing ${targetTypeName} row these match`
+        };
+        if (forUpdate && plan.canDetach) {
+          fields["disconnect"] = {
+            type: listOf(filters),
+            description: `Detach every attached ${targetTypeName} row these match, leaving the rows in place`
+          };
+          fields["set"] = {
+            type: listOf(filters),
+            description: `Replace the whole set: detach everything attached, then attach every ${targetTypeName} row these match. Applied before \`disconnect\`, \`connect\` and \`create\`.`
+          };
+        }
+      }
+    }
+    const type = new GraphQLInputObjectType11({
+      name: cacheCtx.typeName({
+        kind: "nestedWriteInput",
+        defaultName: `${typeName}${capitalize(plan.relationName)}Nested${forUpdate ? "Update" : "Create"}Input`,
+        table: tableName,
+        operation: plan.relationName
+      }),
+      description: `Writes through ${typeName}.${plan.relationName}`,
+      fields
+    });
+    wrapperCache.set(key, type);
+    return type;
   };
-};
-var generateUpdate = (db, tableName, table, setArgs, filterArgs, fieldName, single, requireWhere, filterCtx, txCtx, policies) => {
-  const queryArgs = {
-    set: {
-      type: new GraphQLNonNull13(setArgs)
-    },
-    where: {
-      type: single || requireWhere ? new GraphQLNonNull13(filterArgs) : filterArgs
+  const relationFields = (tableName, typeName, forUpdate) => {
+    const tablePlans = plans[tableName];
+    if (!tablePlans) {
+      return {};
     }
+    return Object.fromEntries(
+      Object.values(tablePlans).flatMap((plan) => {
+        const wrapper = wrapperType(tableName, typeName, plan, forUpdate);
+        return wrapper ? [[plan.relationName, { type: wrapper, description: `Writes through ${typeName}.${plan.relationName}` }]] : [];
+      })
+    );
   };
-  const hooks = policies?.onWrite?.(tableName, "update");
-  const errorCtx = { table: tableName, operation: "update", field: fieldName };
   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 drizzleError("Unable to update with no values specified!", { code: "DRIZZLE_NO_VALUES" });
-            }
-            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, relationCtx) : where ? extractFilters(table, tableName, where, relationCtx) : void 0
-            );
-            if (single) {
-              await assertSingleMatch(executor, table, filters);
-            }
-            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 withErrorContext(toGraphQLError(e), errorCtx);
+    createFields: (tableName, typeName) => relationFields(tableName, typeName, false),
+    updateFields: (tableName, typeName) => relationFields(tableName, typeName, true),
+    relaxedColumns: (tableName) => {
+      const tablePlans = plans[tableName];
+      if (!tablePlans) {
+        return NO_COLUMNS;
       }
-    },
-    args: queryArgs
+      const relaxed = /* @__PURE__ */ new Set();
+      for (const plan of Object.values(tablePlans)) {
+        if (plan.fkSide === "parent" && !isOptionalOnInsert(plan.localCol)) {
+          relaxed.add(plan.localColPropName);
+        }
+      }
+      return relaxed.size ? relaxed : NO_COLUMNS;
+    }
   };
 };
-var generateUpdateMany = (db, tableName, table, updateManyInput, fieldName, filterCtx, txCtx, policies) => {
-  const queryArgs = {
-    updates: {
-      type: new GraphQLNonNull13(new GraphQLList9(new GraphQLNonNull13(updateManyInput)))
+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, policies, contextValues } = params;
+  const conditionOf = (plan, filter, operation, scope) => {
+    const condition = extractFilters(
+      plan.targetTable,
+      plan.targetTableName,
+      filter,
+      relationFilterCtx(filterCtx, plan.targetTableName)
+    );
+    if (!condition) {
+      throw drizzleError(
+        `Drizzle-GraphQL Error: '${operation}' on '${plan.relationName}' needs a filter that selects rows \u2014 it was given one that matches everything.`,
+        { code: "DRIZZLE_NESTED_WRITE_INVALID" }
+      );
     }
+    return withScope(scope, plan.targetTableName, plan.targetTable, condition);
   };
-  const hooks = policies?.onWrite?.(tableName, "updateMany");
-  const errorCtx = { table: tableName, operation: "updateMany", field: fieldName };
-  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 drizzleError("No updates were provided!", { code: "DRIZZLE_NO_VALUES" });
-            }
-            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 drizzleError("Unable to update with no values specified!", { code: "DRIZZLE_NO_VALUES" });
-              }
-              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 withErrorContext(toGraphQLError(e), errorCtx);
-      }
-    },
-    args: queryArgs
+  const assertSingleOperation = (plan, op) => {
+    const supplied = ["create", "connect", "disconnect"].filter((key) => op[key] !== void 0 && op[key] !== null);
+    if (supplied.length > 1) {
+      throw drizzleError(
+        `Drizzle-GraphQL Error: '${plan.relationName}' takes one of ${supplied.join(", ")} at a time \u2014 it holds a single row.`,
+        { code: "DRIZZLE_NESTED_WRITE_INVALID" }
+      );
+    }
   };
-};
-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 canHardDelete = !restore && softDelete?.hardDelete === true;
-  const queryArgs = {
-    where: {
-      type: single || requireWhere ? new GraphQLNonNull13(filterArgs) : filterArgs
-    },
-    ...canHardDelete ? { hard: hardDeleteArg } : {}
+  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 hooks = policies?.onWrite?.(tableName, operation);
-  const errorCtx = { table: tableName, operation, field: fieldName };
-  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,
-              single,
-              args,
-              context,
-              info,
-              tx: executor
-            });
-            const { where } = args;
-            const hard = canHardDelete && args.hard === true;
-            const scope = policies?.scope?.(context);
-            const relationCtx = relationFilterCtx(filterCtx, tableName);
-            const filters = withScope(
-              scope,
-              tableName,
-              table,
-              single || requireWhere ? extractRequiredFilters(table, tableName, where, relationCtx) : where ? extractFilters(table, tableName, where, relationCtx) : void 0,
-              // A hard delete reads at INCLUDE: the rows it mostly exists to remove are the
-              // ones already marked, which the default EXCLUDE could not reach at all.
-              restore ? "ONLY" : hard ? "INCLUDE" : void 0
-            );
-            if (single) {
-              await assertSingleMatch(executor, table, filters);
-            }
-            let query = softDelete && !hard ? 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 withErrorContext(toGraphQLError(e), errorCtx);
+  const applyThroughOps = async (executor, plan, key, op, scope) => {
+    const through = plan.through;
+    const unlinkAll = () => executor.delete(through.table).where(eq8(through.sourceCol, key));
+    const link = async (operands, operation) => {
+      const existing = new Set(
+        (await executor.select().from(through.table).where(eq8(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(and11(eq8(through.sourceCol, key), inArray6(through.targetCol, targetKeys)));
+        }
       }
-    },
-    args: queryArgs
-  };
-};
-var mysqlPrimaryKeyPropNames = (table) => getPrimaryKeyPropNamesFromConfig(table, getTableConfig);
-var { generateSelectArray, generateSelectSingle } = createSelectGenerators(
-  mysqlPrimaryKeyPropNames,
-  "nulls-smallest"
-);
-var generateSchemaData = (db, schema, relations, options) => {
-  const { relationsDepthLimit, prefixes, suffixes, typeNameMapper, shouldEagerLoad, features, complexity, limits } = options;
-  const rawSchema = schema;
-  const schemaEntries = Object.entries(rawSchema);
-  const excludedTables = new Set(options.exclude?.tables ?? []);
-  const tableEntries = schemaEntries.filter(([key, value]) => is10(value, MySqlTable) && !excludedTables.has(key));
-  const tables = Object.fromEntries(tableEntries);
-  const featureOf = resolveTableFeatures(features);
-  const anyTable = (feature) => tableEntries.some(([name]) => featureOf(name)[feature]);
-  if (!tableEntries.length) {
-    throw new Error(
-      "Drizzle-GraphQL Error: No tables detected in Drizzle-ORM's database instance. Did you forget to pass schema to drizzle constructor?"
-    );
-  }
-  if (features.nestedWrites) {
-    throw new Error(
-      "Drizzle-GraphQL Error: features.nestedWrites is not supported on MySQL \u2014 a nested write needs the parent row it just inserted returned to it, and MySQL has no RETURNING clause."
-    );
-  }
-  registerScalarOverrides(tables, options);
-  registerEnumConfig(options);
-  registerColumnExclusions(tables, options.exclude);
-  const namedRelations = buildNamedRelations(relations ?? {}, tableEntries);
-  for (const excluded of excludedTables) {
-    delete namedRelations[excluded];
-  }
-  attachTargetPrimaryKeys(namedRelations, tables, mysqlPrimaryKeyPropNames);
-  const eagerRelations = pruneNonEagerRelations(namedRelations, shouldEagerLoad);
-  const uniqueKeys = {};
-  for (const [tableName, table] of tableEntries) {
-    if (!featureOf(tableName).uniqueKeyFilters) {
-      continue;
     }
-    const taken = /* @__PURE__ */ new Set([...Object.keys(visibleColumns(table)), ...Object.keys(namedRelations[tableName] ?? {})]);
-    const map = buildUniqueKeyMap(getUniqueColumnSets(table, getTableConfig), taken);
-    if (Object.keys(map).length) {
-      uniqueKeys[tableName] = map;
+    if (op["connect"] !== void 0 && op["connect"] !== null) {
+      await link(asArray(op["connect"]), "connect");
     }
-  }
-  const filterCtx = { tables, relationMap: namedRelations, uniqueKeys };
-  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,
-    tablePolicies
-  );
-  const cacheCtx = {
-    typeName: options.typeName ?? ((info) => info.defaultName),
-    genericFilterCache: /* @__PURE__ */ new Map(),
-    objectTypeCache: /* @__PURE__ */ new Map(),
-    relationFieldContainers: /* @__PURE__ */ new Map(),
-    fullyBuiltTables: /* @__PURE__ */ new Set(),
-    relationTypeCache: /* @__PURE__ */ new Map(),
-    selectFieldCache: /* @__PURE__ */ new WeakMap(),
-    filterFieldCache: /* @__PURE__ */ new WeakMap(),
-    orderTypeCache: /* @__PURE__ */ new WeakMap(),
-    filterTypeCache: /* @__PURE__ */ new WeakMap(),
-    listRelationFilterCache: /* @__PURE__ */ new Map(),
-    aggregateTypeCache: /* @__PURE__ */ new Map(),
-    complexity,
-    limits,
-    docs: options.docs ?? {},
-    primaryKeyOf: (name) => tables[name] ? mysqlPrimaryKeyPropNames(tables[name]) : [],
-    contextValuesOf,
-    softDeleteOf,
-    featureOf,
-    uniqueKeysOf: (tableName) => uniqueKeys[tableName]
   };
-  const relationAggregateFactory = anyTable("relationAggregates") ? createRelationAggregateFactory(db, tables, cacheCtx, typeNameMapper, filterCtx, tablePolicies) : void 0;
-  const queries = {};
-  const mutations = {};
-  const mutationTxCtx = createMutationTxCtx(options.transactions);
-  const gqlSchemaTypes = Object.fromEntries(
-    Object.entries(tables).map(([tableName, _table]) => [
-      tableName,
-      generateTableTypes(
-        tableName,
-        tables,
-        namedRelations,
-        false,
-        relationsDepthLimit,
-        cacheCtx,
-        typeNameMapper,
-        prefixes.insert,
-        prefixes.update,
-        resolverFactory,
-        featureOf(tableName).relationAggregates ? relationAggregateFactory : void 0
-      )
-    ])
-  );
-  const mutationReturnType = new GraphQLObjectType4({
-    name: cacheCtx.typeName({ kind: "shared", defaultName: "MutationReturn" }),
-    fields: {
-      isSuccess: {
-        type: new GraphQLNonNull13(GraphQLBoolean5)
+  const detachAll = async (executor, plan, key, scope) => executor.update(plan.targetTable).set({ [plan.foreignColPropName]: null }).where(withScope(scope, plan.targetTableName, plan.targetTable, eq8(plan.foreignCol, key)));
+  return {
+    enabled: (tableName) => !!plans[tableName],
+    split: (tableName, values) => {
+      const tablePlans = plans[tableName];
+      if (!tablePlans) {
+        return { columns: values, ops: {} };
       }
-    }
-  });
-  const inputs = {};
-  const outputs = {};
-  if (["insert", "upsert", "update", "delete"].some((feature) => anyTable(feature))) {
-    outputs["MutationReturn"] = mutationReturnType;
-  }
-  for (const [tableName, tableTypes] of Object.entries(gqlSchemaTypes)) {
-    const tableFeatures = featureOf(tableName);
-    const drizzleMeta = tableFieldExtensions(tableName, mysqlPrimaryKeyPropNames(schema[tableName]));
-    const { insertInput, updateInput, tableFilters, tableOrder } = tableTypes.inputs;
-    const { selectSingleOutput, selectArrOutput } = tableTypes.outputs;
-    const {
-      typeName,
-      listFieldName,
-      singleFieldName,
-      aggregateFieldName,
-      groupByFieldName,
-      createArrayFieldName,
-      createSingleFieldName,
-      upsertArrayFieldName,
-      upsertSingleFieldName,
-      updateFieldName,
-      updateManyFieldName,
-      updateSingleFieldName,
-      updateCountFieldName,
-      deleteFieldName,
-      deleteSingleFieldName,
-      restoreFieldName,
-      restoreSingleFieldName,
-      deleteCountFieldName
-    } = computeResolverFieldNames(tableName, typeNameMapper, prefixes, suffixes);
-    const softDeleteInfo = softDeleteOf?.(tableName);
-    const selectArrGenerated = generateSelectArray(
-      db,
-      tableName,
-      tables,
-      eagerRelations,
-      tableOrder,
-      tableFilters,
-      listFieldName,
-      typeName,
-      typeNameMapper,
-      filterCtx,
-      tableFeatures.distinct,
-      limits,
-      policies,
-      cacheCtx.typeName
-    );
-    const selectSingleGenerated = generateSelectSingle(
-      db,
-      tableName,
-      tables,
-      eagerRelations,
-      tableOrder,
-      tableFilters,
-      singleFieldName,
-      typeName,
-      typeNameMapper,
-      filterCtx,
-      limits,
-      policies,
-      cacheCtx.typeName
-    );
-    const insertArrGenerated = tableFeatures.insert ? generateInsertArray(
-      db,
-      tableName,
-      schema[tableName],
-      insertInput,
-      createArrayFieldName,
-      mutationTxCtx,
-      policies
-    ) : void 0;
-    const insertSingleGenerated = tableFeatures.insert ? generateInsertSingle(
-      db,
-      tableName,
-      schema[tableName],
-      insertInput,
-      createSingleFieldName,
-      mutationTxCtx,
-      policies
-    ) : void 0;
-    const onConflictInput = tableFeatures.upsert ? generateOnConflictInput({
-      table: schema[tableName],
-      tableName,
-      typeName,
-      uniqueSets: [],
-      tableFilters,
-      withTarget: false,
-      cacheCtx
-    }) : void 0;
-    const upsertArrGenerated = onConflictInput ? generateUpsert(
-      db,
-      tableName,
-      schema[tableName],
-      insertInput,
-      onConflictInput,
-      upsertArrayFieldName,
-      false,
-      mutationTxCtx,
-      policies
-    ) : void 0;
-    const upsertSingleGenerated = onConflictInput ? generateUpsert(
-      db,
-      tableName,
-      schema[tableName],
-      insertInput,
-      onConflictInput,
-      upsertSingleFieldName,
-      true,
-      mutationTxCtx,
-      policies
-    ) : void 0;
-    const updateGenerated = tableFeatures.update ? generateUpdate(
-      db,
-      tableName,
-      schema[tableName],
-      updateInput,
-      tableFilters,
-      updateFieldName,
-      false,
-      tableFeatures.requireWhere,
-      filterCtx,
-      mutationTxCtx,
-      policies
-    ) : void 0;
-    const updateSingleGenerated = tableFeatures.update ? generateUpdate(
-      db,
-      tableName,
-      schema[tableName],
-      updateInput,
-      tableFilters,
-      updateSingleFieldName,
-      true,
-      tableFeatures.requireWhere,
-      filterCtx,
-      mutationTxCtx,
-      policies
-    ) : void 0;
-    const updateManyInput = tableFeatures.update && tableFeatures.updateMany ? generateUpdateManyInput({
-      tableName,
-      typeName,
-      updatePrefix: prefixes.update,
-      updateInput,
-      tableFilters,
-      cacheCtx
-    }) : void 0;
-    const updateManyGenerated = updateManyInput ? generateUpdateMany(
-      db,
-      tableName,
-      schema[tableName],
-      updateManyInput,
-      updateManyFieldName,
-      filterCtx,
-      mutationTxCtx,
-      policies
-    ) : void 0;
-    const deleteGenerated = tableFeatures.delete ? generateDelete(
-      db,
-      tableName,
-      schema[tableName],
-      tableFilters,
-      deleteFieldName,
-      false,
-      tableFeatures.requireWhere,
-      filterCtx,
-      mutationTxCtx,
-      policies
-    ) : void 0;
-    const deleteSingleGenerated = tableFeatures.delete ? generateDelete(
-      db,
-      tableName,
-      schema[tableName],
-      tableFilters,
-      deleteSingleFieldName,
-      true,
-      tableFeatures.requireWhere,
-      filterCtx,
-      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,
-      table: schema[tableName],
-      kind: "update",
-      setArgs: updateInput,
-      filterArgs: tableFilters,
-      fieldName: updateCountFieldName,
-      requireWhere: tableFeatures.requireWhere,
-      filterCtx,
-      txCtx: mutationTxCtx
-    }) : void 0;
-    const deleteCountGenerated = tableFeatures.delete && tableFeatures.countMutations ? generateWriteCount({
-      db,
-      tableName,
-      table: schema[tableName],
-      kind: "delete",
-      filterArgs: tableFilters,
-      fieldName: deleteCountFieldName,
-      requireWhere: tableFeatures.requireWhere,
-      filterCtx,
-      txCtx: mutationTxCtx
-    }) : void 0;
-    const aggregateType = tableFeatures.aggregates ? generateAggregateTypes(schema[tableName], tableName, typeName, cacheCtx) : void 0;
-    const aggregateGenerated = tableFeatures.aggregates ? generateAggregate(
-      db,
-      tableName,
-      schema[tableName],
-      typeName,
-      aggregateFieldName,
-      tableFilters,
-      filterCtx,
-      tablePolicies,
-      cacheCtx.typeName
-    ) : void 0;
-    const groupByType = tableFeatures.aggregates && tableFeatures.groupBy ? generateGroupByType(schema[tableName], tableName, typeName, cacheCtx) : void 0;
-    const groupByEnum = groupByType ? generateGroupByEnum(schema[tableName], tableName, typeName, cacheCtx) : void 0;
-    const havingInput = groupByEnum ? generateHavingInput(schema[tableName], tableName, typeName, cacheCtx) : void 0;
-    const groupByGenerated = groupByType && groupByEnum && havingInput ? generateGroupBy(
-      db,
-      tableName,
-      schema[tableName],
-      typeName,
-      groupByFieldName,
-      tableFilters,
-      groupByEnum,
-      havingInput,
-      filterCtx,
-      tablePolicies,
-      cacheCtx.typeName
-    ) : void 0;
-    queries[selectArrGenerated.name] = {
-      type: selectArrOutput,
-      args: selectArrGenerated.args,
-      resolve: selectArrGenerated.resolver,
-      extensions: {
-        drizzle: drizzleMeta({ kind: "query", operation: "select", single: false, targetArg: "where" }),
-        ...complexity ? { complexity: listFieldComplexity(complexity, limits?.(tableName)) } : {}
+      const columns = {};
+      const ops = {};
+      for (const [key, value] of Object.entries(values)) {
+        if (tablePlans[key] && value !== void 0 && value !== null) {
+          ops[key] = value;
+        } else if (!tablePlans[key]) {
+          columns[key] = value;
+        }
       }
-    };
-    queries[selectSingleGenerated.name] = {
-      type: selectSingleOutput,
-      args: selectSingleGenerated.args,
-      resolve: selectSingleGenerated.resolver,
-      extensions: {
-        drizzle: drizzleMeta({ kind: "query", operation: "select", single: true, targetArg: "where" })
+      return { columns, ops };
+    },
+    hasOps: (ops) => Object.keys(ops).length > 0,
+    withJoinColumns: (tableName, ops, columns, table) => {
+      const tablePlans = plans[tableName];
+      if (!tablePlans) {
+        return columns;
       }
-    };
-    if (aggregateGenerated && aggregateType) {
-      queries[aggregateGenerated.name] = {
-        type: new GraphQLNonNull13(aggregateType),
-        args: aggregateGenerated.args,
-        resolve: aggregateGenerated.resolver,
-        extensions: {
-          drizzle: drizzleMeta({ kind: "aggregate", operation: "aggregate", single: true, targetArg: "where" }),
-          ...complexity ? { complexity: aggregateFieldComplexity(complexity) } : {}
-        }
-      };
-    }
-    if (groupByGenerated && groupByType) {
-      queries[groupByGenerated.name] = {
-        type: new GraphQLNonNull13(new GraphQLList9(new GraphQLNonNull13(groupByType))),
-        args: groupByGenerated.args,
-        resolve: groupByGenerated.resolver,
-        extensions: {
-          drizzle: drizzleMeta({ kind: "aggregate", operation: "groupBy", single: false, targetArg: "where" }),
-          ...complexity ? { complexity: aggregateFieldComplexity(complexity) } : {}
+      const allColumns = getColumns16(table);
+      for (const relationName of Object.keys(ops)) {
+        const plan = tablePlans[relationName];
+        if (plan?.fkSide === "child" && !(plan.localColPropName in columns) && allColumns[plan.localColPropName]) {
+          columns[plan.localColPropName] = allColumns[plan.localColPropName];
         }
-      };
-    }
-    const hardDeleteMeta = softDeleteInfo?.hardDelete ? { hardDelete: true } : {};
-    const generatedMutations = [
-      [insertArrGenerated, { operation: "insert", single: false, targetArg: "values" }],
-      [insertSingleGenerated, { operation: "insert", single: true, targetArg: "values" }],
-      [upsertArrGenerated, { operation: "upsert", single: false, targetArg: "values" }],
-      [upsertSingleGenerated, { operation: "upsert", single: true, targetArg: "values" }],
-      [updateGenerated, { operation: "update", single: false, targetArg: "where" }],
-      [updateManyGenerated, { operation: "updateMany", single: false, targetArg: "updates" }],
-      [updateSingleGenerated, { operation: "update", single: true, targetArg: "where" }],
-      [deleteGenerated, { operation: "delete", single: false, targetArg: "where", ...hardDeleteMeta }],
-      [deleteSingleGenerated, { operation: "delete", single: true, targetArg: "where", ...hardDeleteMeta }],
-      [restoreGenerated, { operation: "restore", single: false, targetArg: "where" }],
-      [restoreSingleGenerated, { operation: "restore", single: true, targetArg: "where" }]
-    ];
-    for (const [generated, meta] of generatedMutations) {
-      if (generated) {
-        mutations[generated.name] = {
-          type: mutationReturnType,
-          args: generated.args,
-          resolve: generated.resolver,
-          extensions: { drizzle: drizzleMeta({ kind: "mutation", ...meta }) }
-        };
       }
-    }
-    if (updateCountGenerated) {
-      mutations[updateCountGenerated.name] = {
-        type: new GraphQLNonNull13(GraphQLInt8),
-        args: updateCountGenerated.args,
-        resolve: updateCountGenerated.resolver,
-        description: "How many rows the update touched. The rows themselves are not read back, which is the point of this mutation."
-      };
-    }
-    if (deleteCountGenerated) {
-      mutations[deleteCountGenerated.name] = {
-        type: new GraphQLNonNull13(GraphQLInt8),
-        args: deleteCountGenerated.args,
-        resolve: deleteCountGenerated.resolver,
-        description: "How many rows the delete removed. The rows themselves are not read back, which is the point of this mutation."
-      };
-    }
-    const activeInputs = [
-      // The insert input types the upsert mutations too, so either feature keeps it.
-      ...tableFeatures.insert || onConflictInput ? [insertInput] : [],
-      ...onConflictInput ? [onConflictInput] : [],
-      ...tableFeatures.update ? [updateInput] : [],
-      ...updateManyInput ? [updateManyInput] : [],
-      tableFilters,
-      tableOrder
-    ];
-    activeInputs.forEach((e) => {
-      inputs[e.name] = e;
-    });
-    outputs[selectSingleOutput.name] = selectSingleOutput;
-    if (aggregateType) {
-      outputs[aggregateType.name] = aggregateType;
-    }
-    if (groupByType && havingInput) {
-      outputs[groupByType.name] = groupByType;
-      inputs[havingInput.name] = havingInput;
-    }
-  }
-  if (mutationTxCtx) {
-    for (const name of Object.keys(mutations)) {
-      mutationTxCtx.fieldNames.add(name);
-    }
-  }
-  const fieldResolvers = {};
-  for (const [tableName, tableRelations] of Object.entries(namedRelations)) {
-    const relResolvers = {};
-    for (const [relName, relEntry] of Object.entries(tableRelations)) {
-      const isOne = is10(relEntry.relation ?? relEntry, One7);
-      const resolver = resolverFactory({ tableName, relationName: relName, relEntry, isOne });
-      if (resolver) {
-        relResolvers[relName] = resolver;
+      return columns;
+    },
+    applyParentSide: async (executor, tableName, ops, context) => {
+      const tablePlans = plans[tableName];
+      const patch = {};
+      if (!tablePlans) {
+        return patch;
+      }
+      const scope = resolveScope(policies, context, filterCtx);
+      for (const [relationName, op] of Object.entries(ops)) {
+        const plan = tablePlans[relationName];
+        if (!plan || plan.fkSide !== "parent") {
+          continue;
+        }
+        assertSingleOperation(plan, op);
+        if (op["create"] !== void 0) {
+          const values = applyContextValues(
+            remapFromGraphQLSingleInput({ ...op["create"] }, plan.targetTable),
+            contextValues?.(plan.targetTableName),
+            context
+          );
+          const inserted = await executor.insert(plan.targetTable).values(values).returning();
+          const created = inserted[0];
+          if (!created) {
+            throw drizzleError(
+              `Drizzle-GraphQL Error: 'create' on '${relationName}' inserted no row, so there is nothing to attach.`,
+              { code: "DRIZZLE_NESTED_WRITE_INVALID" }
+            );
+          }
+          patch[plan.localColPropName] = created[plan.foreignColPropName];
+        } else if (op["connect"] !== void 0) {
+          const rows = await executor.select().from(plan.targetTable).where(conditionOf(plan, op["connect"], "connect", scope));
+          if (rows.length !== 1) {
+            throw drizzleError(
+              `Drizzle-GraphQL Error: 'connect' on '${relationName}' matched ${rows.length} rows \u2014 it attaches a single row, so its filter must match exactly one.`,
+              { code: "DRIZZLE_NESTED_WRITE_INVALID" }
+            );
+          }
+          patch[plan.localColPropName] = rows[0][plan.foreignColPropName];
+        } else if (op["disconnect"] === true) {
+          patch[plan.localColPropName] = null;
+        }
+      }
+      return patch;
+    },
+    applyChildSide: async (executor, tableName, ops, parentRows, context) => {
+      const tablePlans = plans[tableName];
+      if (!tablePlans) {
+        return;
+      }
+      const scope = resolveScope(policies, context, filterCtx);
+      for (const [relationName, op] of Object.entries(ops)) {
+        const plan = tablePlans[relationName];
+        if (!plan || plan.fkSide !== "child") {
+          continue;
+        }
+        if (plan.isOne) {
+          assertSingleOperation(plan, op);
+        }
+        for (const parentRow of parentRows) {
+          const key = parentRow?.[plan.localColPropName];
+          if (key === void 0 || key === null) {
+            throw drizzleError(
+              `Drizzle-GraphQL Error: cannot write through '${relationName}': the ${tableName} row has no '${plan.localColPropName}' value to attach to.`,
+              { code: "DRIZZLE_NESTED_WRITE_INVALID" }
+            );
+          }
+          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"])) {
+              await executor.update(plan.targetTable).set({ [plan.foreignColPropName]: key }).where(conditionOf(plan, filter, "set", scope));
+            }
+          }
+          if (op["disconnect"] !== void 0) {
+            if (plan.isOne) {
+              if (op["disconnect"] === true) {
+                await detachAll(executor, plan, key, scope);
+              }
+            } else {
+              for (const filter of asArray(op["disconnect"])) {
+                await executor.update(plan.targetTable).set({ [plan.foreignColPropName]: null }).where(and11(eq8(plan.foreignCol, key), conditionOf(plan, filter, "disconnect", scope)));
+              }
+            }
+          }
+          const attaches = op["connect"] !== void 0 || op["create"] !== void 0;
+          if (plan.isOne && attaches && plan.canDetach && op["set"] === void 0) {
+            await detachAll(executor, plan, key, scope);
+          }
+          if (op["connect"] !== void 0) {
+            for (const filter of asArray(op["connect"])) {
+              await executor.update(plan.targetTable).set({ [plan.foreignColPropName]: key }).where(conditionOf(plan, filter, "connect", scope));
+            }
+          }
+          if (op["create"] !== void 0) {
+            const rows = asArray(op["create"]).map((row) => ({
+              ...applyContextValues(
+                remapFromGraphQLSingleInput({ ...row }, plan.targetTable),
+                contextValues?.(plan.targetTableName),
+                context
+              ),
+              [plan.foreignColPropName]: key
+            }));
+            if (rows.length) {
+              await executor.insert(plan.targetTable).values(rows);
+            }
+          }
+        }
       }
     }
-    if (Object.keys(relResolvers).length > 0) {
-      fieldResolvers[tableName] = relResolvers;
+  };
+};
+var writeWithNestedOps = async (params) => {
+  const { executor, runtime, tableName, entries, remapValues, write, context } = params;
+  return executor.transaction(async (tx) => {
+    const rows = [];
+    for (const entry of entries) {
+      const patch = await runtime.applyParentSide(tx, tableName, entry.ops, context);
+      const written = await write(tx, { ...remapValues(entry.columns), ...patch });
+      await runtime.applyChildSide(tx, tableName, entry.ops, written, context);
+      rows.push(...written);
     }
-  }
-  return { queries, mutations, inputs, types: outputs, fieldResolvers };
+    return rows;
+  });
+};
+var updateWithNestedOps = async (params) => {
+  const { executor, runtime, tableName, columns, ops, remapValues, write, context } = params;
+  return executor.transaction(async (tx) => {
+    const patch = await runtime.applyParentSide(tx, tableName, ops, context);
+    const rows = await write(tx, { ...remapValues(columns), ...patch });
+    await runtime.applyChildSide(tx, tableName, ops, rows, context);
+    return rows;
+  });
 };
 
-// src/util/builders/pg.ts
-import { getTableConfig as getTableConfig2, PgTable } from "drizzle-orm/pg-core";
+// src/util/builders/select.ts
+import { parseResolveInfo as parseResolveInfo2 } from "graphql-parse-resolve-info";
 
-// src/util/builders/schema-data.ts
-import { is as is12, One as One9 } from "drizzle-orm";
-import { GraphQLInt as GraphQLInt9, GraphQLList as GraphQLList12, GraphQLNonNull as GraphQLNonNull16 } from "graphql";
+// src/util/builders/errors.ts
+var missingQueryBuilderError = (tableName) => new Error(
+  `Drizzle-GraphQL Error: Table '${tableName}' was passed to the drizzle constructor's schema but is missing from its relations config, so drizzle-orm exposes no query builder for it. Include it in the relations you pass to buildRelations/defineRelations, or drop it from the generated schema with config.exclude.tables.`
+);
 
-// src/util/builders/nested-writes.ts
-import { and as and11, Column, eq as eq8, getColumns as getColumns16, inArray as inArray6, is as is11, One as One8 } from "drizzle-orm";
-import { GraphQLBoolean as GraphQLBoolean6, GraphQLInputObjectType as GraphQLInputObjectType11, GraphQLList as GraphQLList10, GraphQLNonNull as GraphQLNonNull14 } 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(getColumns16(table))) {
-    if (candidate === column) {
-      return propName;
-    }
+// src/util/builders/select.ts
+var queryBaseFor = (db, tableName) => {
+  const queryBase = db.query[tableName];
+  if (!queryBase) {
+    throw missingQueryBuilderError(tableName);
   }
-  return void 0;
+  return queryBase;
 };
-var throughColumn = (entry) => entry && is11(entry, Column) ? entry : entry?._?.column;
-var buildThroughPlan = (relationName, relation, table, targetTableName, targetTable) => {
-  if (is11(relation, One8)) {
-    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 = getColumns16(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 createSelectGenerators = (primaryKeyPropNames, nullOrdering) => {
+  const generateSelectArray = (db, tableName, tables, relationMap, orderArgs, filterArgs, fieldName, typeName, typeNameMapper, filterCtx, distinctEnabled = true, limits, policies, resolveName) => {
+    const queryBase = queryBaseFor(db, tableName);
+    const table = tables[tableName];
+    const limitPolicy = limits?.(tableName);
+    const pkNames = primaryKeyPropNames(table);
+    const errorCtx = { table: tableName, operation: "select", field: fieldName };
+    const queryArgs = selectArrayArgs(
+      orderArgs,
+      filterArgs,
+      distinctEnabled ? generateDistinctEnum(table, typeName, resolveName, tableName) : void 0,
+      policies?.softDelete,
+      tableName,
+      resolveName
+    );
+    const objectTypeName = resolveObjectTypeName(tableName, typeNameMapper, resolveName);
+    return {
+      name: fieldName,
+      resolver: async (_source, rawArgs, context, info) => {
+        const args = withDefaultOrderBy(rawArgs, tableName, policies?.defaultOrderBy);
+        try {
+          const parsedInfo = parseResolveInfo2(info, { deep: true });
+          const { executor, queryBase: requestQueryBase } = resolveQueryExecutor(db, context, tableName, queryBase);
+          return await runRelationalSelect({
+            queryBase: requestQueryBase,
+            tables,
+            tableName,
+            table,
+            relationMap,
+            typeName: objectTypeName,
+            typeNameMapper,
+            resolveName,
+            parsedInfo,
+            ...args,
+            limit: applyLimitPolicy(args.limit, limitPolicy),
+            single: false,
+            filterCtx,
+            limits,
+            defaultOrderBy: policies?.defaultOrderBy,
+            pkNames,
+            db: executor,
+            scope: policies?.scope?.(context),
+            nullOrdering
+          });
+        } catch (e) {
+          throw withErrorContext(toGraphQLError(e), errorCtx);
+        }
+      },
+      args: queryArgs
+    };
+  };
+  const generateSelectSingle = (db, tableName, tables, relationMap, orderArgs, filterArgs, fieldName, typeName, typeNameMapper, filterCtx, limits, policies, resolveName) => {
+    const queryBase = queryBaseFor(db, tableName);
+    const queryArgs = selectSingleArgs(orderArgs, filterArgs, policies?.softDelete, tableName, resolveName);
+    const objectTypeName = resolveObjectTypeName(tableName, typeNameMapper, resolveName);
+    const table = tables[tableName];
+    const pkNames = primaryKeyPropNames(table);
+    const errorCtx = { table: tableName, operation: "select", field: fieldName };
+    return {
+      name: fieldName,
+      resolver: async (_source, rawArgs, context, info) => {
+        const args = withDefaultOrderBy(rawArgs, tableName, policies?.defaultOrderBy);
+        try {
+          const parsedInfo = parseResolveInfo2(info, { deep: true });
+          const { executor, queryBase: requestQueryBase } = resolveQueryExecutor(db, context, tableName, queryBase);
+          return await runRelationalSelect({
+            queryBase: requestQueryBase,
+            tables,
+            tableName,
+            table,
+            relationMap,
+            typeName: objectTypeName,
+            typeNameMapper,
+            resolveName,
+            parsedInfo,
+            ...args,
+            single: true,
+            filterCtx,
+            limits,
+            defaultOrderBy: policies?.defaultOrderBy,
+            pkNames,
+            db: executor,
+            scope: policies?.scope?.(context)
+          });
+        } catch (e) {
+          throw withErrorContext(toGraphQLError(e), errorCtx);
+        }
+      },
+      args: queryArgs
+    };
   };
+  return { generateSelectArray, generateSelectSingle };
 };
-var buildNestedWritePlans = (tables, relationMap, resolveUniqueSets, resolvePrimaryKeys, extractJoinColumns) => {
-  const uniqueCache = /* @__PURE__ */ new Map();
-  const singleColumnUniques = (tableName, table) => {
-    let cached = uniqueCache.get(tableName);
-    if (!cached) {
-      cached = new Set(
-        resolveUniqueSets(table).filter((set) => set.length === 1).map((set) => set[0])
+
+// src/util/builders/build-context.ts
+var createSchemaBuilder = (adapter) => {
+  const primaryKeyPropNames = adapter.primaryKeyPropNames;
+  const uniqueColumnSets = (table) => getUniqueColumnSets(table, adapter.getTableConfig);
+  const { generateSelectArray, generateSelectSingle } = createSelectGenerators(
+    primaryKeyPropNames,
+    adapter.nullOrdering
+  );
+  const prepareBuild2 = (db, schema, relations, options) => {
+    const { relationsDepthLimit, prefixes, typeNameMapper, shouldEagerLoad, features, complexity, limits } = options;
+    const schemaEntries = Object.entries(schema);
+    const excludedTables = new Set(options.exclude?.tables ?? []);
+    const tableEntries = schemaEntries.filter(
+      ([key, value]) => is11(value, adapter.tableClass) && !excludedTables.has(key)
+    );
+    const tables = Object.fromEntries(tableEntries);
+    const featureOf = resolveTableFeatures(features);
+    const anyTable = (feature) => tableEntries.some(([name]) => featureOf(name)[feature]);
+    if (!tableEntries.length) {
+      throw new Error(
+        "Drizzle-GraphQL Error: No tables detected in Drizzle-ORM's database instance. Did you forget to pass schema to drizzle constructor?"
       );
-      uniqueCache.set(tableName, cached);
-    }
-    return cached;
-  };
-  const pkCache = /* @__PURE__ */ new Map();
-  const singleColumnPk = (tableName, table) => {
-    if (!pkCache.has(tableName)) {
-      const pk = resolvePrimaryKeys(table);
-      pkCache.set(tableName, pk.length === 1 ? pk[0] : void 0);
     }
-    return pkCache.get(tableName);
-  };
-  const plans = {};
-  for (const [tableName, relations] of Object.entries(relationMap)) {
-    const table = tables[tableName];
-    if (!table) {
-      continue;
+    registerScalarOverrides(tables, options);
+    registerEnumConfig(options);
+    registerColumnExclusions(tables, options.exclude);
+    const namedRelations = buildNamedRelations(relations ?? {}, tableEntries);
+    for (const excluded of excludedTables) {
+      delete namedRelations[excluded];
     }
-    const tablePlans = {};
-    for (const [relationName, relEntry] of Object.entries(relations)) {
-      const relation = relEntry.relation;
-      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;
-      }
-      const { localColPropName, foreignCol, foreignColPropName } = joinColumns;
-      const localCol = getColumns16(table)[localColPropName];
-      if (!localCol) {
+    attachTargetPrimaryKeys(namedRelations, tables, (table) => primaryKeyPropNames(table));
+    const eagerRelations = pruneNonEagerRelations(namedRelations, shouldEagerLoad);
+    const uniqueKeys = {};
+    for (const [tableName, table] of tableEntries) {
+      if (!featureOf(tableName).uniqueKeyFilters) {
         continue;
       }
-      const isOne = is11(relation, One8);
-      const localIsPk = singleColumnPk(tableName, table) === localColPropName;
-      const foreignIsPk = singleColumnPk(targetTableName, targetTable) === foreignColPropName;
-      const localIsUnique = singleColumnUniques(tableName, table).has(localColPropName);
-      const foreignIsUnique = singleColumnUniques(targetTableName, targetTable).has(foreignColPropName);
-      let fkSide;
-      if (!isOne) {
-        fkSide = "child";
-      } else if (foreignIsPk && !localIsPk) {
-        fkSide = "parent";
-      } else if (localIsPk) {
-        fkSide = "child";
-      } else if (foreignIsUnique) {
-        fkSide = "parent";
-      } else if (localIsUnique) {
-        fkSide = "child";
-      } else {
-        continue;
+      const taken = /* @__PURE__ */ new Set([...Object.keys(visibleColumns(table)), ...Object.keys(namedRelations[tableName] ?? {})]);
+      const map = buildUniqueKeyMap(uniqueColumnSets(table), taken);
+      if (Object.keys(map).length) {
+        uniqueKeys[tableName] = map;
       }
-      const fkColumn = fkSide === "child" ? foreignCol : localCol;
-      tablePlans[relationName] = {
-        relationName,
-        targetTableName,
-        targetTable,
-        localColPropName,
-        foreignColPropName,
-        foreignCol,
-        localCol,
-        isOne,
-        fkSide,
-        canDetach: !fkColumn.notNull
-      };
-    }
-    if (Object.keys(tablePlans).length) {
-      plans[tableName] = tablePlans;
-    }
-  }
-  return plans;
-};
-var NO_COLUMNS = /* @__PURE__ */ new Set();
-var createNestedWriteTypes = (params) => {
-  const { plans, cacheCtx, typeNameMapper } = params;
-  const wrapperCache = /* @__PURE__ */ new Map();
-  const payloadCache = /* @__PURE__ */ new Map();
-  const payloadType = (tableName, typeName, plan) => {
-    const key = `${tableName}.${plan.relationName}`;
-    const cached = payloadCache.get(key);
-    if (cached) {
-      return cached;
     }
-    const omitted = plan.fkSide === "child" ? plan.foreignColPropName : void 0;
-    const contextColumns = cacheCtx.contextValuesOf?.(plan.targetTableName);
-    const fields = Object.fromEntries(
-      Object.entries(visibleColumns(plan.targetTable)).filter(([columnName]) => columnName !== omitted && !contextColumns?.[columnName]).map(([columnName, column]) => [
-        columnName,
-        drizzleColumnToGraphQLType(column, columnName, plan.targetTableName, false, true, true)
-      ])
+    const filterCtx = { tables, relationMap: namedRelations, uniqueKeys };
+    const tablePolicies = options.policies;
+    const contextValuesOf = tablePolicies?.contextValues;
+    const softDeleteOf = tablePolicies?.softDelete;
+    const policies = bindPolicies(tablePolicies, filterCtx);
+    const resolverFactory = createRelationResolverFactory(
+      db,
+      tables,
+      adapter.nullOrdering,
+      filterCtx,
+      limits,
+      tablePolicies
     );
-    const type = new GraphQLInputObjectType11({
-      name: cacheCtx.typeName({
-        kind: "nestedWriteInput",
-        defaultName: `${typeName}${capitalize(plan.relationName)}NestedCreatePayloadInput`,
-        table: tableName,
-        operation: plan.relationName
-      }),
-      description: omitted === void 0 ? `A new ${resolveTypeName(plan.targetTableName, typeNameMapper)} row for ${typeName}.${plan.relationName}` : `A new ${resolveTypeName(plan.targetTableName, typeNameMapper)} row for ${typeName}.${plan.relationName}. \`${omitted}\` is set from the ${typeName} row this is written with.`,
-      fields
-    });
-    payloadCache.set(key, type);
-    return type;
-  };
-  const targetFilters = (plan) => cacheCtx.filterTypeCache.get(plan.targetTable);
-  const listOf = (type) => new GraphQLList10(new GraphQLNonNull14(type));
-  const wrapperType = (tableName, typeName, plan, forUpdate) => {
-    const key = `${tableName}.${plan.relationName}.${forUpdate ? "update" : "create"}`;
-    const cached = wrapperCache.get(key);
-    if (cached) {
-      return cached;
-    }
-    const filters = targetFilters(plan);
-    const targetTypeName = resolveTypeName(plan.targetTableName, typeNameMapper);
-    const fields = {};
-    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,
-          description: `Attach the existing ${targetTypeName} row this matches. Must match exactly one row.`
-        };
+    const cacheCtx = {
+      typeName: options.typeName ?? ((info) => info.defaultName),
+      genericFilterCache: /* @__PURE__ */ new Map(),
+      objectTypeCache: /* @__PURE__ */ new Map(),
+      relationFieldContainers: /* @__PURE__ */ new Map(),
+      fullyBuiltTables: /* @__PURE__ */ new Set(),
+      relationTypeCache: /* @__PURE__ */ new Map(),
+      selectFieldCache: /* @__PURE__ */ new WeakMap(),
+      filterFieldCache: /* @__PURE__ */ new WeakMap(),
+      orderTypeCache: /* @__PURE__ */ new WeakMap(),
+      filterTypeCache: /* @__PURE__ */ new WeakMap(),
+      listRelationFilterCache: /* @__PURE__ */ new Map(),
+      aggregateTypeCache: /* @__PURE__ */ new Map(),
+      complexity,
+      limits,
+      docs: options.docs ?? {},
+      primaryKeyOf: (name) => tables[name] ? primaryKeyPropNames(tables[name]) : [],
+      contextValuesOf,
+      softDeleteOf,
+      featureOf,
+      uniqueKeysOf: (tableName) => uniqueKeys[tableName]
+    };
+    adapter.preflight?.(db, options);
+    const nestedPlans = features.nestedWrites ? buildNestedWritePlans(
+      tables,
+      namedRelations,
+      (target) => uniqueColumnSets(target),
+      (target) => primaryKeyPropNames(target),
+      extractRelationJoinColumns
+    ) : void 0;
+    const nestedTypes = nestedPlans ? createNestedWriteTypes({ plans: nestedPlans, cacheCtx, typeNameMapper }) : 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 gqlSchemaTypes = Object.fromEntries(
+      Object.entries(tables).map(([tableName, _table]) => [
+        tableName,
+        generateTableTypes(
+          tableName,
+          tables,
+          namedRelations,
+          adapter.returnsRows,
+          relationsDepthLimit,
+          cacheCtx,
+          typeNameMapper,
+          prefixes.insert,
+          prefixes.update,
+          resolverFactory,
+          featureOf(tableName).relationAggregates ? relationAggregateFactory : void 0,
+          nestedTypes
+        )
+      ])
+    );
+    return {
+      db,
+      schema,
+      options,
+      tables,
+      tableEntries,
+      featureOf,
+      anyTable,
+      namedRelations,
+      eagerRelations,
+      filterCtx,
+      tablePolicies,
+      policies,
+      softDeleteOf,
+      resolverFactory,
+      cacheCtx,
+      nestedRuntime,
+      nestedTypes,
+      // Shared per-request transaction machinery for multi-mutation documents; undefined
+      // unless `transactions: 'auto'`. Its field-name set is filled once all mutations exist.
+      mutationTxCtx: createMutationTxCtx(options.transactions),
+      gqlSchemaTypes,
+      queries: {},
+      mutations: {},
+      inputs: {},
+      outputs: {},
+      limits,
+      typeNameMapper
+    };
+  };
+  const addReadFields2 = (ctx, tableName, names, tableTypes, drizzleMeta) => {
+    const { db, tables, cacheCtx, filterCtx, eagerRelations, policies, tablePolicies, limits, typeNameMapper } = ctx;
+    const { complexity } = ctx.options;
+    const table = tables[tableName];
+    const tableFeatures = ctx.featureOf(tableName);
+    const { tableFilters, tableOrder } = tableTypes.inputs;
+    const { selectSingleOutput, selectArrOutput } = tableTypes.outputs;
+    const { typeName, listFieldName, singleFieldName, aggregateFieldName, groupByFieldName } = names;
+    const selectArrGenerated = generateSelectArray(
+      db,
+      tableName,
+      tables,
+      eagerRelations,
+      tableOrder,
+      tableFilters,
+      listFieldName,
+      typeName,
+      typeNameMapper,
+      filterCtx,
+      tableFeatures.distinct,
+      limits,
+      policies,
+      cacheCtx.typeName
+    );
+    const selectSingleGenerated = generateSelectSingle(
+      db,
+      tableName,
+      tables,
+      eagerRelations,
+      tableOrder,
+      tableFilters,
+      singleFieldName,
+      typeName,
+      typeNameMapper,
+      filterCtx,
+      limits,
+      policies,
+      cacheCtx.typeName
+    );
+    const aggregateType = tableFeatures.aggregates ? generateAggregateTypes(table, tableName, typeName, cacheCtx) : void 0;
+    const aggregateGenerated = tableFeatures.aggregates ? generateAggregate(
+      db,
+      tableName,
+      table,
+      typeName,
+      aggregateFieldName,
+      tableFilters,
+      filterCtx,
+      tablePolicies,
+      cacheCtx.typeName
+    ) : void 0;
+    const groupByType = tableFeatures.aggregates && tableFeatures.groupBy ? generateGroupByType(table, tableName, typeName, cacheCtx) : void 0;
+    const groupByEnum = groupByType ? generateGroupByEnum(table, tableName, typeName, cacheCtx) : void 0;
+    const havingInput = groupByEnum ? generateHavingInput(table, tableName, typeName, cacheCtx) : void 0;
+    const groupByGenerated = groupByType && groupByEnum && havingInput ? generateGroupBy(
+      db,
+      tableName,
+      table,
+      typeName,
+      groupByFieldName,
+      tableFilters,
+      groupByEnum,
+      havingInput,
+      filterCtx,
+      tablePolicies,
+      cacheCtx.typeName
+    ) : void 0;
+    ctx.queries[selectArrGenerated.name] = {
+      type: selectArrOutput,
+      args: selectArrGenerated.args,
+      resolve: selectArrGenerated.resolver,
+      extensions: {
+        drizzle: drizzleMeta({ kind: "query", operation: "select", single: false, targetArg: "where" }),
+        ...complexity ? { complexity: listFieldComplexity(complexity, limits?.(tableName)) } : {}
       }
-      if (forUpdate && plan.canDetach) {
-        fields["disconnect"] = {
-          type: GraphQLBoolean6,
-          description: `Detach the currently attached ${targetTypeName} row, leaving it in place`
-        };
+    };
+    ctx.queries[selectSingleGenerated.name] = {
+      type: selectSingleOutput,
+      args: selectSingleGenerated.args,
+      resolve: selectSingleGenerated.resolver,
+      extensions: {
+        drizzle: drizzleMeta({ kind: "query", operation: "select", single: true, targetArg: "where" })
       }
-    } else {
-      fields["create"] = {
-        type: listOf(payloadType(tableName, typeName, plan)),
-        description: `Insert these ${targetTypeName} rows and attach them`
-      };
-      if (filters) {
-        fields["connect"] = {
-          type: listOf(filters),
-          description: `Attach every existing ${targetTypeName} row these match`
-        };
-        if (forUpdate && plan.canDetach) {
-          fields["disconnect"] = {
-            type: listOf(filters),
-            description: `Detach every attached ${targetTypeName} row these match, leaving the rows in place`
-          };
-          fields["set"] = {
-            type: listOf(filters),
-            description: `Replace the whole set: detach everything attached, then attach every ${targetTypeName} row these match. Applied before \`disconnect\`, \`connect\` and \`create\`.`
-          };
+    };
+    if (aggregateGenerated && aggregateType) {
+      ctx.queries[aggregateGenerated.name] = {
+        type: new GraphQLNonNull14(aggregateType),
+        args: aggregateGenerated.args,
+        resolve: aggregateGenerated.resolver,
+        extensions: {
+          drizzle: drizzleMeta({ kind: "aggregate", operation: "aggregate", single: true, targetArg: "where" }),
+          ...complexity ? { complexity: aggregateFieldComplexity(complexity) } : {}
         }
-      }
+      };
     }
-    const type = new GraphQLInputObjectType11({
-      name: cacheCtx.typeName({
-        kind: "nestedWriteInput",
-        defaultName: `${typeName}${capitalize(plan.relationName)}Nested${forUpdate ? "Update" : "Create"}Input`,
-        table: tableName,
-        operation: plan.relationName
-      }),
-      description: `Writes through ${typeName}.${plan.relationName}`,
-      fields
-    });
-    wrapperCache.set(key, type);
-    return type;
-  };
-  const relationFields = (tableName, typeName, forUpdate) => {
-    const tablePlans = plans[tableName];
-    if (!tablePlans) {
-      return {};
+    if (groupByGenerated && groupByType) {
+      ctx.queries[groupByGenerated.name] = {
+        type: new GraphQLNonNull14(new GraphQLList10(new GraphQLNonNull14(groupByType))),
+        args: groupByGenerated.args,
+        resolve: groupByGenerated.resolver,
+        extensions: {
+          drizzle: drizzleMeta({ kind: "aggregate", operation: "groupBy", single: false, targetArg: "where" }),
+          ...complexity ? { complexity: aggregateFieldComplexity(complexity) } : {}
+        }
+      };
     }
-    return Object.fromEntries(
-      Object.values(tablePlans).flatMap((plan) => {
-        const wrapper = wrapperType(tableName, typeName, plan, forUpdate);
-        return wrapper ? [[plan.relationName, { type: wrapper, description: `Writes through ${typeName}.${plan.relationName}` }]] : [];
-      })
-    );
+    return { aggregateType, groupByType, havingInput };
   };
-  return {
-    createFields: (tableName, typeName) => relationFields(tableName, typeName, false),
-    updateFields: (tableName, typeName) => relationFields(tableName, typeName, true),
-    relaxedColumns: (tableName) => {
-      const tablePlans = plans[tableName];
-      if (!tablePlans) {
-        return NO_COLUMNS;
+  const finalizeBuild2 = (ctx) => {
+    if (ctx.mutationTxCtx) {
+      for (const name of Object.keys(ctx.mutations)) {
+        ctx.mutationTxCtx.fieldNames.add(name);
       }
-      const relaxed = /* @__PURE__ */ new Set();
-      for (const plan of Object.values(tablePlans)) {
-        if (plan.fkSide === "parent" && !isOptionalOnInsert(plan.localCol)) {
-          relaxed.add(plan.localColPropName);
+    }
+    const fieldResolvers = {};
+    for (const [tableName, tableRelations] of Object.entries(ctx.namedRelations)) {
+      const relResolvers = {};
+      for (const [relName, relEntry] of Object.entries(tableRelations)) {
+        const isOne = is11(relEntry.relation ?? relEntry, One8);
+        const resolver = ctx.resolverFactory({ tableName, relationName: relName, relEntry, isOne });
+        if (resolver) {
+          relResolvers[relName] = resolver;
         }
       }
-      return relaxed.size ? relaxed : NO_COLUMNS;
+      if (Object.keys(relResolvers).length > 0) {
+        fieldResolvers[tableName] = relResolvers;
+      }
     }
-  };
+    return {
+      queries: ctx.queries,
+      mutations: ctx.mutations,
+      inputs: ctx.inputs,
+      types: ctx.outputs,
+      fieldResolvers
+    };
+  };
+  return { primaryKeyPropNames, uniqueColumnSets, prepareBuild: prepareBuild2, addReadFields: addReadFields2, finalizeBuild: finalizeBuild2 };
 };
-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, policies, contextValues } = params;
-  const conditionOf = (plan, filter, operation, scope) => {
-    const condition = extractFilters(
-      plan.targetTable,
-      plan.targetTableName,
-      filter,
-      relationFilterCtx(filterCtx, plan.targetTableName)
+
+// src/util/builders/mysql.ts
+var isSuccess = { isSuccess: true };
+var generateInsertArray = (db, tableName, table, baseType, fieldName, txCtx, policies) => writeResolver({
+  db,
+  tableName,
+  operation: "insert",
+  single: false,
+  fieldName,
+  txCtx,
+  policies,
+  args: {
+    values: {
+      type: new GraphQLNonNull15(new GraphQLList11(new GraphQLNonNull15(baseType)))
+    }
+  },
+  run: async ({ executor, args, context, before, after }) => {
+    const input = applyContextValuesAll(
+      remapFromGraphQLArrayInput(args.values, table),
+      policies?.contextValues?.(tableName),
+      context
     );
-    if (!condition) {
-      throw drizzleError(
-        `Drizzle-GraphQL Error: '${operation}' on '${plan.relationName}' needs a filter that selects rows \u2014 it was given one that matches everything.`,
-        { code: "DRIZZLE_NESTED_WRITE_INVALID" }
-      );
+    if (!input.length) {
+      throw drizzleError("No values were provided!", { code: "DRIZZLE_NO_VALUES" });
     }
-    return withScope(scope, plan.targetTableName, plan.targetTable, condition);
-  };
-  const assertSingleOperation = (plan, op) => {
-    const supplied = ["create", "connect", "disconnect"].filter((key) => op[key] !== void 0 && op[key] !== null);
-    if (supplied.length > 1) {
-      throw drizzleError(
-        `Drizzle-GraphQL Error: '${plan.relationName}' takes one of ${supplied.join(", ")} at a time \u2014 it holds a single row.`,
-        { code: "DRIZZLE_NESTED_WRITE_INVALID" }
-      );
+    await before();
+    await executor.insert(table).values(input);
+    await after();
+    return isSuccess;
+  }
+});
+var generateInsertSingle = (db, tableName, table, baseType, fieldName, txCtx, policies) => writeResolver({
+  db,
+  tableName,
+  operation: "insert",
+  single: true,
+  fieldName,
+  txCtx,
+  policies,
+  args: {
+    values: {
+      type: new GraphQLNonNull15(baseType)
     }
-  };
-  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(eq8(through.sourceCol, key));
-    const link = async (operands, operation) => {
-      const existing = new Set(
-        (await executor.select().from(through.table).where(eq8(through.sourceCol, key))).map(
-          (row) => row[through.targetColPropName]
-        )
+  },
+  run: async ({ executor, args, context, before, after }) => {
+    await before();
+    const input = applyContextValues(
+      remapFromGraphQLSingleInput(args.values, table),
+      policies?.contextValues?.(tableName),
+      context
+    );
+    await executor.insert(table).values(input);
+    await after();
+    return isSuccess;
+  }
+});
+var generateUpsert = (db, tableName, table, baseType, onConflictType, fieldName, single, txCtx, policies) => {
+  const pkNames = mysqlPrimaryKeyPropNames(table);
+  return writeResolver({
+    db,
+    tableName,
+    operation: "upsert",
+    single,
+    fieldName,
+    txCtx,
+    policies,
+    args: {
+      values: {
+        type: single ? new GraphQLNonNull15(baseType) : new GraphQLNonNull15(new GraphQLList11(new GraphQLNonNull15(baseType)))
+      },
+      onConflict: {
+        type: onConflictType,
+        description: "How a conflicting row is resolved. Defaults to overwriting it."
+      }
+    },
+    run: async ({ executor, args, context, before, after }) => {
+      const input = applyContextValuesAll(
+        single ? [remapFromGraphQLSingleInput(args.values, table)] : remapFromGraphQLArrayInput(args.values, table),
+        policies?.contextValues?.(tableName),
+        context
       );
-      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 (!input.length) {
+        throw drizzleError("No values were provided!", { code: "DRIZZLE_NO_VALUES" });
       }
-      if (rows.length) {
-        await executor.insert(through.table).values(rows);
+      await before();
+      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 });
       }
-    };
-    if (op["set"] !== void 0 && op["set"] !== null) {
-      await unlinkAll();
-      await link(asArray(op["set"]), "set");
+      await after();
+      return isSuccess;
     }
-    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(and11(eq8(through.sourceCol, key), inArray6(through.targetCol, targetKeys)));
-        }
-      }
+  });
+};
+var generateUpdate = (db, tableName, table, setArgs, filterArgs, fieldName, single, requireWhere, filterCtx, txCtx, policies) => writeResolver({
+  db,
+  tableName,
+  operation: "update",
+  single,
+  fieldName,
+  txCtx,
+  policies,
+  args: {
+    set: {
+      type: new GraphQLNonNull15(setArgs)
+    },
+    where: {
+      type: single || requireWhere ? new GraphQLNonNull15(filterArgs) : filterArgs
     }
-    if (op["connect"] !== void 0 && op["connect"] !== null) {
-      await link(asArray(op["connect"]), "connect");
+  },
+  run: async ({ executor, args, context, before, after }) => {
+    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 drizzleError("Unable to update with no values specified!", { code: "DRIZZLE_NO_VALUES" });
+    }
+    await before();
+    const relationCtx = relationFilterCtx(filterCtx, tableName);
+    const filters = withScope(
+      scope,
+      tableName,
+      table,
+      single || requireWhere ? extractRequiredFilters(table, tableName, where, relationCtx) : where ? extractFilters(table, tableName, where, relationCtx) : void 0
+    );
+    if (single) {
+      await assertSingleMatch(executor, table, filters);
     }
-  };
-  const detachAll = async (executor, plan, key, scope) => executor.update(plan.targetTable).set({ [plan.foreignColPropName]: null }).where(withScope(scope, plan.targetTableName, plan.targetTable, eq8(plan.foreignCol, key)));
-  return {
-    enabled: (tableName) => !!plans[tableName],
-    split: (tableName, values) => {
-      const tablePlans = plans[tableName];
-      if (!tablePlans) {
-        return { columns: values, ops: {} };
-      }
-      const columns = {};
-      const ops = {};
-      for (const [key, value] of Object.entries(values)) {
-        if (tablePlans[key] && value !== void 0 && value !== null) {
-          ops[key] = value;
-        } else if (!tablePlans[key]) {
-          columns[key] = value;
-        }
-      }
-      return { columns, ops };
-    },
-    hasOps: (ops) => Object.keys(ops).length > 0,
-    withJoinColumns: (tableName, ops, columns, table) => {
-      const tablePlans = plans[tableName];
-      if (!tablePlans) {
-        return columns;
+    let query = executor.update(table).set(input);
+    if (filters) {
+      query = query.where(filters);
+    }
+    await query;
+    await after();
+    return isSuccess;
+  }
+});
+var generateUpdateMany = (db, tableName, table, updateManyInput, fieldName, filterCtx, txCtx, policies) => writeResolver({
+  db,
+  tableName,
+  operation: "updateMany",
+  single: false,
+  fieldName,
+  txCtx,
+  policies,
+  args: {
+    updates: {
+      type: new GraphQLNonNull15(new GraphQLList11(new GraphQLNonNull15(updateManyInput)))
+    }
+  },
+  run: async ({ executor, args, context, before, after }) => {
+    const { updates } = args;
+    if (!updates.length) {
+      throw drizzleError("No updates were provided!", { code: "DRIZZLE_NO_VALUES" });
+    }
+    await before();
+    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 drizzleError("Unable to update with no values specified!", { code: "DRIZZLE_NO_VALUES" });
       }
-      const allColumns = getColumns16(table);
-      for (const relationName of Object.keys(ops)) {
-        const plan = tablePlans[relationName];
-        if (plan?.fkSide === "child" && !(plan.localColPropName in columns) && allColumns[plan.localColPropName]) {
-          columns[plan.localColPropName] = allColumns[plan.localColPropName];
+      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;
       }
-      return columns;
+    });
+    await after();
+    return isSuccess;
+  }
+});
+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 canHardDelete = !restore && softDelete?.hardDelete === true;
+  return writeResolver({
+    db,
+    tableName,
+    operation,
+    single,
+    fieldName,
+    txCtx,
+    policies,
+    args: {
+      where: {
+        type: single || requireWhere ? new GraphQLNonNull15(filterArgs) : filterArgs
+      },
+      ...canHardDelete ? { hard: hardDeleteArg } : {}
     },
-    applyParentSide: async (executor, tableName, ops, context) => {
-      const tablePlans = plans[tableName];
-      const patch = {};
-      if (!tablePlans) {
-        return patch;
+    run: async ({ executor, args, context, before, after }) => {
+      await before();
+      const { where } = args;
+      const hard = canHardDelete && args.hard === true;
+      const scope = policies?.scope?.(context);
+      const relationCtx = relationFilterCtx(filterCtx, tableName);
+      const filters = withScope(
+        scope,
+        tableName,
+        table,
+        single || requireWhere ? extractRequiredFilters(table, tableName, where, relationCtx) : where ? extractFilters(table, tableName, where, relationCtx) : void 0,
+        // A hard delete reads at INCLUDE: the rows it mostly exists to remove are the
+        // ones already marked, which the default EXCLUDE could not reach at all.
+        restore ? "ONLY" : hard ? "INCLUDE" : void 0
+      );
+      if (single) {
+        await assertSingleMatch(executor, table, filters);
       }
-      const scope = resolveScope(policies, context, filterCtx);
-      for (const [relationName, op] of Object.entries(ops)) {
-        const plan = tablePlans[relationName];
-        if (!plan || plan.fkSide !== "parent") {
-          continue;
-        }
-        assertSingleOperation(plan, op);
-        if (op["create"] !== void 0) {
-          const values = applyContextValues(
-            remapFromGraphQLSingleInput({ ...op["create"] }, plan.targetTable),
-            contextValues?.(plan.targetTableName),
-            context
-          );
-          const inserted = await executor.insert(plan.targetTable).values(values).returning();
-          const created = inserted[0];
-          if (!created) {
-            throw drizzleError(
-              `Drizzle-GraphQL Error: 'create' on '${relationName}' inserted no row, so there is nothing to attach.`,
-              { code: "DRIZZLE_NESTED_WRITE_INVALID" }
-            );
-          }
-          patch[plan.localColPropName] = created[plan.foreignColPropName];
-        } else if (op["connect"] !== void 0) {
-          const rows = await executor.select().from(plan.targetTable).where(conditionOf(plan, op["connect"], "connect", scope));
-          if (rows.length !== 1) {
-            throw drizzleError(
-              `Drizzle-GraphQL Error: 'connect' on '${relationName}' matched ${rows.length} rows \u2014 it attaches a single row, so its filter must match exactly one.`,
-              { code: "DRIZZLE_NESTED_WRITE_INVALID" }
-            );
-          }
-          patch[plan.localColPropName] = rows[0][plan.foreignColPropName];
-        } else if (op["disconnect"] === true) {
-          patch[plan.localColPropName] = null;
-        }
+      let query = softDelete && !hard ? executor.update(table).set({ [softDelete.columnName]: restore ? softDelete.writeRestored : softDelete.writeDeleted() }) : executor.delete(table);
+      if (filters) {
+        query = query.where(filters);
       }
-      return patch;
-    },
-    applyChildSide: async (executor, tableName, ops, parentRows, context) => {
-      const tablePlans = plans[tableName];
-      if (!tablePlans) {
-        return;
+      await query;
+      await after();
+      return isSuccess;
+    }
+  });
+};
+var mysqlPrimaryKeyPropNames = (table) => getPrimaryKeyPropNamesFromConfig(table, getTableConfig);
+var { prepareBuild, addReadFields, finalizeBuild } = createSchemaBuilder({
+  tableClass: MySqlTable,
+  getTableConfig,
+  primaryKeyPropNames: mysqlPrimaryKeyPropNames,
+  nullOrdering: "nulls-smallest",
+  returnsRows: false,
+  // A nested write reads the key of the row it just wrote back out of the statement that
+  // wrote it, which MySQL has no RETURNING clause for.
+  preflight: (_db, options) => {
+    if (options.features.nestedWrites) {
+      throw new Error(
+        "Drizzle-GraphQL Error: features.nestedWrites is not supported on MySQL \u2014 a nested write needs the parent row it just inserted returned to it, and MySQL has no RETURNING clause."
+      );
+    }
+  }
+});
+var generateSchemaData = (db, schema, relations, options) => {
+  const { prefixes, suffixes, typeNameMapper } = options;
+  const ctx = prepareBuild(db, schema, relations, options);
+  const {
+    featureOf,
+    anyTable,
+    filterCtx,
+    policies,
+    softDeleteOf,
+    cacheCtx,
+    mutationTxCtx,
+    gqlSchemaTypes,
+    mutations,
+    inputs,
+    outputs
+  } = ctx;
+  const mutationReturnType = new GraphQLObjectType4({
+    name: cacheCtx.typeName({ kind: "shared", defaultName: "MutationReturn" }),
+    fields: {
+      isSuccess: {
+        type: new GraphQLNonNull15(GraphQLBoolean6)
       }
-      const scope = resolveScope(policies, context, filterCtx);
-      for (const [relationName, op] of Object.entries(ops)) {
-        const plan = tablePlans[relationName];
-        if (!plan || plan.fkSide !== "child") {
-          continue;
-        }
-        if (plan.isOne) {
-          assertSingleOperation(plan, op);
-        }
-        for (const parentRow of parentRows) {
-          const key = parentRow?.[plan.localColPropName];
-          if (key === void 0 || key === null) {
-            throw drizzleError(
-              `Drizzle-GraphQL Error: cannot write through '${relationName}': the ${tableName} row has no '${plan.localColPropName}' value to attach to.`,
-              { code: "DRIZZLE_NESTED_WRITE_INVALID" }
-            );
-          }
-          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"])) {
-              await executor.update(plan.targetTable).set({ [plan.foreignColPropName]: key }).where(conditionOf(plan, filter, "set", scope));
-            }
-          }
-          if (op["disconnect"] !== void 0) {
-            if (plan.isOne) {
-              if (op["disconnect"] === true) {
-                await detachAll(executor, plan, key, scope);
-              }
-            } else {
-              for (const filter of asArray(op["disconnect"])) {
-                await executor.update(plan.targetTable).set({ [plan.foreignColPropName]: null }).where(and11(eq8(plan.foreignCol, key), conditionOf(plan, filter, "disconnect", scope)));
-              }
-            }
-          }
-          const attaches = op["connect"] !== void 0 || op["create"] !== void 0;
-          if (plan.isOne && attaches && plan.canDetach && op["set"] === void 0) {
-            await detachAll(executor, plan, key, scope);
-          }
-          if (op["connect"] !== void 0) {
-            for (const filter of asArray(op["connect"])) {
-              await executor.update(plan.targetTable).set({ [plan.foreignColPropName]: key }).where(conditionOf(plan, filter, "connect", scope));
-            }
-          }
-          if (op["create"] !== void 0) {
-            const rows = asArray(op["create"]).map((row) => ({
-              ...applyContextValues(
-                remapFromGraphQLSingleInput({ ...row }, plan.targetTable),
-                contextValues?.(plan.targetTableName),
-                context
-              ),
-              [plan.foreignColPropName]: key
-            }));
-            if (rows.length) {
-              await executor.insert(plan.targetTable).values(rows);
-            }
-          }
-        }
+    }
+  });
+  if (["insert", "upsert", "update", "delete"].some((feature) => anyTable(feature))) {
+    outputs["MutationReturn"] = mutationReturnType;
+  }
+  for (const [tableName, tableTypes] of Object.entries(gqlSchemaTypes)) {
+    const tableFeatures = featureOf(tableName);
+    const drizzleMeta = tableFieldExtensions(tableName, mysqlPrimaryKeyPropNames(schema[tableName]));
+    const { insertInput, updateInput, tableFilters, tableOrder } = tableTypes.inputs;
+    const { selectSingleOutput } = tableTypes.outputs;
+    const names = computeResolverFieldNames(tableName, typeNameMapper, prefixes, suffixes);
+    const {
+      typeName,
+      createArrayFieldName,
+      createSingleFieldName,
+      upsertArrayFieldName,
+      upsertSingleFieldName,
+      updateFieldName,
+      updateManyFieldName,
+      updateSingleFieldName,
+      updateCountFieldName,
+      deleteFieldName,
+      deleteSingleFieldName,
+      restoreFieldName,
+      restoreSingleFieldName,
+      deleteCountFieldName
+    } = names;
+    const softDeleteInfo = softDeleteOf?.(tableName);
+    const { aggregateType, groupByType, havingInput } = addReadFields(ctx, tableName, names, tableTypes, drizzleMeta);
+    const insertArrGenerated = tableFeatures.insert ? generateInsertArray(
+      db,
+      tableName,
+      schema[tableName],
+      insertInput,
+      createArrayFieldName,
+      mutationTxCtx,
+      policies
+    ) : void 0;
+    const insertSingleGenerated = tableFeatures.insert ? generateInsertSingle(
+      db,
+      tableName,
+      schema[tableName],
+      insertInput,
+      createSingleFieldName,
+      mutationTxCtx,
+      policies
+    ) : void 0;
+    const onConflictInput = tableFeatures.upsert ? generateOnConflictInput({
+      table: schema[tableName],
+      tableName,
+      typeName,
+      uniqueSets: [],
+      tableFilters,
+      withTarget: false,
+      cacheCtx
+    }) : void 0;
+    const upsertArrGenerated = onConflictInput ? generateUpsert(
+      db,
+      tableName,
+      schema[tableName],
+      insertInput,
+      onConflictInput,
+      upsertArrayFieldName,
+      false,
+      mutationTxCtx,
+      policies
+    ) : void 0;
+    const upsertSingleGenerated = onConflictInput ? generateUpsert(
+      db,
+      tableName,
+      schema[tableName],
+      insertInput,
+      onConflictInput,
+      upsertSingleFieldName,
+      true,
+      mutationTxCtx,
+      policies
+    ) : void 0;
+    const updateGenerated = tableFeatures.update ? generateUpdate(
+      db,
+      tableName,
+      schema[tableName],
+      updateInput,
+      tableFilters,
+      updateFieldName,
+      false,
+      tableFeatures.requireWhere,
+      filterCtx,
+      mutationTxCtx,
+      policies
+    ) : void 0;
+    const updateSingleGenerated = tableFeatures.update ? generateUpdate(
+      db,
+      tableName,
+      schema[tableName],
+      updateInput,
+      tableFilters,
+      updateSingleFieldName,
+      true,
+      tableFeatures.requireWhere,
+      filterCtx,
+      mutationTxCtx,
+      policies
+    ) : void 0;
+    const updateManyInput = tableFeatures.update && tableFeatures.updateMany ? generateUpdateManyInput({
+      tableName,
+      typeName,
+      updatePrefix: prefixes.update,
+      updateInput,
+      tableFilters,
+      cacheCtx
+    }) : void 0;
+    const updateManyGenerated = updateManyInput ? generateUpdateMany(
+      db,
+      tableName,
+      schema[tableName],
+      updateManyInput,
+      updateManyFieldName,
+      filterCtx,
+      mutationTxCtx,
+      policies
+    ) : void 0;
+    const deleteGenerated = tableFeatures.delete ? generateDelete(
+      db,
+      tableName,
+      schema[tableName],
+      tableFilters,
+      deleteFieldName,
+      false,
+      tableFeatures.requireWhere,
+      filterCtx,
+      mutationTxCtx,
+      policies
+    ) : void 0;
+    const deleteSingleGenerated = tableFeatures.delete ? generateDelete(
+      db,
+      tableName,
+      schema[tableName],
+      tableFilters,
+      deleteSingleFieldName,
+      true,
+      tableFeatures.requireWhere,
+      filterCtx,
+      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,
+      table: schema[tableName],
+      kind: "update",
+      setArgs: updateInput,
+      filterArgs: tableFilters,
+      fieldName: updateCountFieldName,
+      requireWhere: tableFeatures.requireWhere,
+      filterCtx,
+      txCtx: mutationTxCtx
+    }) : void 0;
+    const deleteCountGenerated = tableFeatures.delete && tableFeatures.countMutations ? generateWriteCount({
+      db,
+      tableName,
+      table: schema[tableName],
+      kind: "delete",
+      filterArgs: tableFilters,
+      fieldName: deleteCountFieldName,
+      requireWhere: tableFeatures.requireWhere,
+      filterCtx,
+      txCtx: mutationTxCtx
+    }) : void 0;
+    const hardDeleteMeta = softDeleteInfo?.hardDelete ? { hardDelete: true } : {};
+    const generatedMutations = [
+      [insertArrGenerated, { operation: "insert", single: false, targetArg: "values" }],
+      [insertSingleGenerated, { operation: "insert", single: true, targetArg: "values" }],
+      [upsertArrGenerated, { operation: "upsert", single: false, targetArg: "values" }],
+      [upsertSingleGenerated, { operation: "upsert", single: true, targetArg: "values" }],
+      [updateGenerated, { operation: "update", single: false, targetArg: "where" }],
+      [updateManyGenerated, { operation: "updateMany", single: false, targetArg: "updates" }],
+      [updateSingleGenerated, { operation: "update", single: true, targetArg: "where" }],
+      [deleteGenerated, { operation: "delete", single: false, targetArg: "where", ...hardDeleteMeta }],
+      [deleteSingleGenerated, { operation: "delete", single: true, targetArg: "where", ...hardDeleteMeta }],
+      [restoreGenerated, { operation: "restore", single: false, targetArg: "where" }],
+      [restoreSingleGenerated, { operation: "restore", single: true, targetArg: "where" }]
+    ];
+    for (const [generated, meta] of generatedMutations) {
+      if (generated) {
+        mutations[generated.name] = {
+          type: mutationReturnType,
+          args: generated.args,
+          resolve: generated.resolver,
+          extensions: { drizzle: drizzleMeta({ kind: "mutation", ...meta }) }
+        };
       }
     }
-  };
-};
-var writeWithNestedOps = async (params) => {
-  const { executor, runtime, tableName, entries, remapValues, write, context } = params;
-  return executor.transaction(async (tx) => {
-    const rows = [];
-    for (const entry of entries) {
-      const patch = await runtime.applyParentSide(tx, tableName, entry.ops, context);
-      const written = await write(tx, { ...remapValues(entry.columns), ...patch });
-      await runtime.applyChildSide(tx, tableName, entry.ops, written, context);
-      rows.push(...written);
+    if (updateCountGenerated) {
+      mutations[updateCountGenerated.name] = {
+        type: new GraphQLNonNull15(GraphQLInt8),
+        args: updateCountGenerated.args,
+        resolve: updateCountGenerated.resolver,
+        description: "How many rows the update touched. The rows themselves are not read back, which is the point of this mutation."
+      };
     }
-    return rows;
-  });
-};
-var updateWithNestedOps = async (params) => {
-  const { executor, runtime, tableName, columns, ops, remapValues, write, context } = params;
-  return executor.transaction(async (tx) => {
-    const patch = await runtime.applyParentSide(tx, tableName, ops, context);
-    const rows = await write(tx, { ...remapValues(columns), ...patch });
-    await runtime.applyChildSide(tx, tableName, ops, rows, context);
-    return rows;
-  });
+    if (deleteCountGenerated) {
+      mutations[deleteCountGenerated.name] = {
+        type: new GraphQLNonNull15(GraphQLInt8),
+        args: deleteCountGenerated.args,
+        resolve: deleteCountGenerated.resolver,
+        description: "How many rows the delete removed. The rows themselves are not read back, which is the point of this mutation."
+      };
+    }
+    const activeInputs = [
+      // The insert input types the upsert mutations too, so either feature keeps it.
+      ...tableFeatures.insert || onConflictInput ? [insertInput] : [],
+      ...onConflictInput ? [onConflictInput] : [],
+      ...tableFeatures.update ? [updateInput] : [],
+      ...updateManyInput ? [updateManyInput] : [],
+      tableFilters,
+      tableOrder
+    ];
+    activeInputs.forEach((e) => {
+      inputs[e.name] = e;
+    });
+    outputs[selectSingleOutput.name] = selectSingleOutput;
+    if (aggregateType) {
+      outputs[aggregateType.name] = aggregateType;
+    }
+    if (groupByType && havingInput) {
+      outputs[groupByType.name] = groupByType;
+      inputs[havingInput.name] = havingInput;
+    }
+  }
+  return finalizeBuild(ctx);
 };
 
+// src/util/builders/pg.ts
+import { getTableConfig as getTableConfig2, PgTable } from "drizzle-orm/pg-core";
+
+// src/util/builders/schema-data.ts
+import { GraphQLInt as GraphQLInt9, GraphQLList as GraphQLList13, GraphQLNonNull as GraphQLNonNull17 } from "graphql";
+
 // src/util/builders/write-resolvers.ts
-import { GraphQLList as GraphQLList11, GraphQLNonNull as GraphQLNonNull15 } from "graphql";
+import { GraphQLList as GraphQLList12, GraphQLNonNull as GraphQLNonNull16 } from "graphql";
 import { parseResolveInfo as parseResolveInfo3 } from "graphql-parse-resolve-info";
 var buildWriteResolvers = (primaryKeyPropNames) => {
   const generateInsertArray2 = (db, tableName, table, tables, relationMap, baseType, fieldName, typeName, typeNameMapper, conflictDoNothing = false, txCtx, nested, limits, policies, resolveName) => {
     const queryArgs = {
       values: {
-        type: new GraphQLNonNull15(new GraphQLList11(new GraphQLNonNull15(baseType)))
+        type: new GraphQLNonNull16(new GraphQLList12(new GraphQLNonNull16(baseType)))
       }
     };
     const pkNames = primaryKeyPropNames(table);
-    const hooks = policies?.onWrite?.(tableName, "insert");
-    const errorCtx = { table: tableName, operation: "insert", field: fieldName };
-    return {
-      name: fieldName,
-      resolver: async (_source, args, context, info) => {
-        try {
-          return await runMutation(
-            db,
-            context,
-            info,
-            txCtx,
-            async (executor) => {
-              if (!args.values.length) {
-                throw drizzleError("No values were provided!", { code: "DRIZZLE_NO_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,
-                resolveName,
-                table,
-                pkNames,
-                parsedInfo,
-                limits,
-                scope,
-                defaultOrderBy: policies?.defaultOrderBy
-              });
-              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 withErrorContext(toGraphQLError(e), errorCtx);
+    return writeResolver({
+      db,
+      tableName,
+      operation: "insert",
+      single: false,
+      fieldName,
+      txCtx,
+      policies,
+      args: queryArgs,
+      run: async ({ executor, args, context, info, before, after }) => {
+        if (!args.values.length) {
+          throw drizzleError("No values were provided!", { code: "DRIZZLE_NO_VALUES" });
         }
-      },
-      args: queryArgs
-    };
+        await before();
+        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,
+          resolveName,
+          table,
+          pkNames,
+          parsedInfo,
+          limits,
+          scope,
+          defaultOrderBy: policies?.defaultOrderBy
+        });
+        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 after(result);
+        const enriched = hasRelations ? await eagerLoadMutationRelations(executor, tableName, result, pkNames, withParams) : result;
+        return remapToGraphQLArrayOutput(enriched, tableName, table, relationMap);
+      }
+    });
   };
   const generateInsertSingle2 = (db, tableName, table, tables, relationMap, baseType, fieldName, typeName, typeNameMapper, conflictDoNothing = false, txCtx, nested, limits, policies, resolveName) => {
     const queryArgs = {
       values: {
-        type: new GraphQLNonNull15(baseType)
+        type: new GraphQLNonNull16(baseType)
       }
     };
     const pkNames = primaryKeyPropNames(table);
-    const hooks = policies?.onWrite?.(tableName, "insert");
-    const errorCtx = { table: tableName, operation: "insert", field: fieldName };
-    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 = parseResolveInfo3(info, {
-                deep: true
-              });
-              const { columns, hasRelations, withParams } = prepareMutationRelationColumns({
-                relationMap,
-                tables,
-                tableName,
-                typeName,
-                typeNameMapper,
-                resolveName,
-                table,
-                pkNames,
-                parsedInfo,
-                limits,
-                scope,
-                defaultOrderBy: policies?.defaultOrderBy
-              });
-              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 drizzleError("The insert returned no row.", { code: "DRIZZLE_NO_ROW_RETURNED" });
-                }
-                return void 0;
-              }
-              const enriched = hasRelations ? await eagerLoadMutationRelations(executor, tableName, result, pkNames, withParams) : result;
-              return remapToGraphQLSingleOutput(enriched[0], tableName, table, relationMap);
-            },
-            !!hooks
-          );
-        } catch (e) {
-          throw withErrorContext(toGraphQLError(e), errorCtx);
+    return writeResolver({
+      db,
+      tableName,
+      operation: "insert",
+      single: true,
+      fieldName,
+      txCtx,
+      policies,
+      args: queryArgs,
+      run: async ({ executor, args, context, info, before, after }) => {
+        await before();
+        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,
+          resolveName,
+          table,
+          pkNames,
+          parsedInfo,
+          limits,
+          scope,
+          defaultOrderBy: policies?.defaultOrderBy
+        });
+        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 after(result);
+        if (!result[0]) {
+          if (!conflictDoNothing) {
+            throw drizzleError("The insert returned no row.", { code: "DRIZZLE_NO_ROW_RETURNED" });
+          }
+          return void 0;
         }
-      },
-      args: queryArgs
-    };
+        const enriched = hasRelations ? await eagerLoadMutationRelations(executor, tableName, result, pkNames, withParams) : result;
+        return remapToGraphQLSingleOutput(enriched[0], tableName, table, relationMap);
+      }
+    });
   };
   const generateUpsert2 = (db, tableName, table, tables, relationMap, baseType, onConflictType, uniqueSets, fieldName, typeName, single, typeNameMapper, filterCtx, txCtx, nested, limits, policies, resolveName) => {
     const queryArgs = {
       values: {
-        type: single ? new GraphQLNonNull15(baseType) : new GraphQLNonNull15(new GraphQLList11(new GraphQLNonNull15(baseType)))
+        type: single ? new GraphQLNonNull16(baseType) : new GraphQLNonNull16(new GraphQLList12(new GraphQLNonNull16(baseType)))
       },
       onConflict: {
         type: onConflictType,
@@ -6909,311 +6837,233 @@ var buildWriteResolvers = (primaryKeyPropNames) => {
       }
     };
     const pkNames = primaryKeyPropNames(table);
-    const hooks = policies?.onWrite?.(tableName, "upsert");
-    const errorCtx = { table: tableName, operation: "upsert", field: fieldName };
-    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 drizzleError("No values were provided!", { code: "DRIZZLE_NO_VALUES" });
-              }
-              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,
-                resolveName,
-                table,
-                pkNames,
-                parsedInfo,
-                limits,
-                scope,
-                defaultOrderBy: policies?.defaultOrderBy
-              });
-              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 withErrorContext(toGraphQLError(e), errorCtx);
+    return writeResolver({
+      db,
+      tableName,
+      operation: "upsert",
+      single,
+      fieldName,
+      txCtx,
+      policies,
+      args: queryArgs,
+      run: async ({ executor, args, context, info, before, after }) => {
+        const supplied = single ? [args.values] : args.values;
+        if (!supplied.length) {
+          throw drizzleError("No values were provided!", { code: "DRIZZLE_NO_VALUES" });
         }
-      },
-      args: queryArgs
-    };
+        await before();
+        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,
+          resolveName,
+          table,
+          pkNames,
+          parsedInfo,
+          limits,
+          scope,
+          defaultOrderBy: policies?.defaultOrderBy
+        });
+        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 after(result);
+        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 generateUpdate2 = (db, tableName, table, tables, relationMap, setArgs, filterArgs, fieldName, typeName, single, requireWhere, typeNameMapper, filterCtx, txCtx, nested, limits, policies, resolveName) => {
     const queryArgs = {
       set: {
-        type: new GraphQLNonNull15(setArgs)
+        type: new GraphQLNonNull16(setArgs)
       },
       where: {
-        type: single || requireWhere ? new GraphQLNonNull15(filterArgs) : filterArgs
+        type: single || requireWhere ? new GraphQLNonNull16(filterArgs) : filterArgs
       }
     };
     const pkNames = primaryKeyPropNames(table);
-    const hooks = policies?.onWrite?.(tableName, "update");
-    const errorCtx = { table: tableName, operation: "update", field: fieldName };
-    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);
-              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,
-                resolveName,
-                table,
-                pkNames,
-                parsedInfo,
-                limits,
-                scope,
-                defaultOrderBy: policies?.defaultOrderBy
-              });
-              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 drizzleError("Unable to update with no values specified!", { code: "DRIZZLE_NO_VALUES" });
-              }
-              const relationCtx = relationFilterCtx(filterCtx, tableName);
-              const filters = withScope(
-                scope,
-                tableName,
-                table,
-                single || requireWhere ? extractRequiredFilters(table, tableName, where, relationCtx) : where ? extractFilters(table, tableName, where, relationCtx) : void 0
-              );
-              if (single) {
-                await assertSingleMatch(executor, table, filters);
-              }
-              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 drizzleError("'where' matched more than one row!", { code: "DRIZZLE_MULTI_ROW_MATCH" });
-              }
-              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 withErrorContext(toGraphQLError(e), errorCtx);
+    return writeResolver({
+      db,
+      tableName,
+      operation: "update",
+      single,
+      fieldName,
+      txCtx,
+      policies,
+      args: queryArgs,
+      run: async ({ executor, args, context, info, before, after }) => {
+        const { where, set } = args;
+        const scope = policies?.scope?.(context);
+        await before();
+        const parsedInfo = parseResolveInfo3(info, {
+          deep: true
+        });
+        const { columns, hasRelations, withParams } = prepareMutationRelationColumns({
+          relationMap,
+          tables,
+          tableName,
+          typeName,
+          typeNameMapper,
+          resolveName,
+          table,
+          pkNames,
+          parsedInfo,
+          limits,
+          scope,
+          defaultOrderBy: policies?.defaultOrderBy
+        });
+        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 drizzleError("Unable to update with no values specified!", { code: "DRIZZLE_NO_VALUES" });
+        }
+        const relationCtx = relationFilterCtx(filterCtx, tableName);
+        const filters = withScope(
+          scope,
+          tableName,
+          table,
+          single || requireWhere ? extractRequiredFilters(table, tableName, where, relationCtx) : where ? extractFilters(table, tableName, where, relationCtx) : void 0
+        );
+        if (single) {
+          await assertSingleMatch(executor, table, filters);
+        }
+        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 after(result);
+        if (single && result.length > 1) {
+          throw drizzleError("'where' matched more than one row!", { code: "DRIZZLE_MULTI_ROW_MATCH" });
+        }
+        if (single && !result[0]) {
+          return void 0;
         }
-      },
-      args: queryArgs
-    };
+        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 generateDelete2 = (db, tableName, table, filterArgs, fieldName, typeName, single, requireWhere, filterCtx, selectionCtx, txCtx, policies, restore = false, resolveName) => {
     const softDelete = policies?.softDelete?.(tableName);
     const operation = restore ? "restore" : "delete";
-    const hooks = policies?.onWrite?.(tableName, operation);
-    const errorCtx = { table: tableName, operation, field: fieldName };
     const canHardDelete = !restore && softDelete?.hardDelete === true;
     const queryArgs = {
       where: {
-        type: single || requireWhere ? new GraphQLNonNull15(filterArgs) : filterArgs
+        type: single || requireWhere ? new GraphQLNonNull16(filterArgs) : filterArgs
       },
       ...canHardDelete ? { hard: hardDeleteArg } : {}
     };
-    return {
-      name: fieldName,
-      resolver: async (_source, args, context, info) => {
-        try {
-          return await runMutation(
-            db,
-            context,
-            info,
-            txCtx,
-            async (executor) => {
-              const { where } = args;
-              const hard = canHardDelete && args.hard === true;
-              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[applyObjectTypeName(typeName, tableName, resolveName)],
-                table,
-                selectionCtx
-              );
-              const relationCtx = relationFilterCtx(filterCtx, tableName);
-              const filters = withScope(
-                scope,
-                tableName,
-                table,
-                single || requireWhere ? extractRequiredFilters(table, tableName, where, relationCtx) : where ? extractFilters(table, tableName, where, relationCtx) : void 0,
-                // A hard delete reads at INCLUDE: the rows it mostly exists to remove are the
-                // ones already marked, which the default EXCLUDE could not reach at all.
-                restore ? "ONLY" : hard ? "INCLUDE" : void 0
-              );
-              if (single) {
-                await assertSingleMatch(executor, table, filters);
-              }
-              let query = softDelete && !hard ? 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 drizzleError("'where' matched more than one row!", { code: "DRIZZLE_MULTI_ROW_MATCH" });
-              }
-              if (single) {
-                return result[0] ? remapToGraphQLSingleOutput(result[0], tableName, table) : void 0;
-              }
-              return remapToGraphQLArrayOutput(result, tableName, table);
-            },
-            !!hooks
-          );
-        } catch (e) {
-          throw withErrorContext(toGraphQLError(e), errorCtx);
+    return writeResolver({
+      db,
+      tableName,
+      operation,
+      single,
+      fieldName,
+      txCtx,
+      policies,
+      args: queryArgs,
+      run: async ({ executor, args, context, info, before, after }) => {
+        const { where } = args;
+        const hard = canHardDelete && args.hard === true;
+        const scope = policies?.scope?.(context);
+        await before();
+        const parsedInfo = parseResolveInfo3(info, {
+          deep: true
+        });
+        const columns = extractSelectedColumnsFromTreeSQLFormat(
+          parsedInfo.fieldsByTypeName[applyObjectTypeName(typeName, tableName, resolveName)],
+          table,
+          selectionCtx
+        );
+        const relationCtx = relationFilterCtx(filterCtx, tableName);
+        const filters = withScope(
+          scope,
+          tableName,
+          table,
+          single || requireWhere ? extractRequiredFilters(table, tableName, where, relationCtx) : where ? extractFilters(table, tableName, where, relationCtx) : void 0,
+          // A hard delete reads at INCLUDE: the rows it mostly exists to remove are the
+          // ones already marked, which the default EXCLUDE could not reach at all.
+          restore ? "ONLY" : hard ? "INCLUDE" : void 0
+        );
+        if (single) {
+          await assertSingleMatch(executor, table, filters);
         }
-      },
-      args: queryArgs
-    };
+        let query = softDelete && !hard ? 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 after(result);
+        if (single && result.length > 1) {
+          throw drizzleError("'where' matched more than one row!", { code: "DRIZZLE_MULTI_ROW_MATCH" });
+        }
+        if (single) {
+          return result[0] ? remapToGraphQLSingleOutput(result[0], tableName, table) : void 0;
+        }
+        return remapToGraphQLArrayOutput(result, tableName, table);
+      }
+    });
   };
   return { generateInsertArray: generateInsertArray2, generateInsertSingle: generateInsertSingle2, generateUpsert: generateUpsert2, generateUpdate: generateUpdate2, generateDelete: generateDelete2 };
 };
@@ -7223,141 +7073,34 @@ var createSchemaDataGenerator = (adapter) => {
   const primaryKeyPropNames = adapter.primaryKeyPropNames;
   const uniqueColumnSets = (table) => getUniqueColumnSets(table, adapter.getTableConfig);
   const { generateInsertArray: generateInsertArray2, generateInsertSingle: generateInsertSingle2, generateUpsert: generateUpsert2, generateUpdate: generateUpdate2, generateDelete: generateDelete2 } = buildWriteResolvers(primaryKeyPropNames);
-  const { generateSelectArray: generateSelectArray2, generateSelectSingle: generateSelectSingle2 } = createSelectGenerators(
-    primaryKeyPropNames,
-    adapter.nullOrdering
-  );
+  const { prepareBuild: prepareBuild2, addReadFields: addReadFields2, finalizeBuild: finalizeBuild2 } = createSchemaBuilder(adapter);
   return (db, schema, relations, options) => {
+    const { prefixes, suffixes, conflictDoNothing, typeNameMapper, limits } = options;
+    const ctx = prepareBuild2(db, schema, relations, options);
     const {
-      relationsDepthLimit,
-      prefixes,
-      suffixes,
-      conflictDoNothing,
-      typeNameMapper,
-      shouldEagerLoad,
-      features,
-      complexity,
-      limits
-    } = options;
-    const schemaEntries = Object.entries(schema);
-    const excludedTables = new Set(options.exclude?.tables ?? []);
-    const tableEntries = schemaEntries.filter(
-      ([key, value]) => is12(value, adapter.tableClass) && !excludedTables.has(key)
-    );
-    const tables = Object.fromEntries(tableEntries);
-    const featureOf = resolveTableFeatures(features);
-    const anyTable = (feature) => tableEntries.some(([name]) => featureOf(name)[feature]);
-    if (!tableEntries.length) {
-      throw new Error(
-        "Drizzle-GraphQL Error: No tables detected in Drizzle-ORM's database instance. Did you forget to pass schema to drizzle constructor?"
-      );
-    }
-    registerScalarOverrides(tables, options);
-    registerEnumConfig(options);
-    registerColumnExclusions(tables, options.exclude);
-    const namedRelations = buildNamedRelations(relations ?? {}, tableEntries);
-    for (const excluded of excludedTables) {
-      delete namedRelations[excluded];
-    }
-    attachTargetPrimaryKeys(namedRelations, tables, (table) => primaryKeyPropNames(table));
-    const eagerRelations = pruneNonEagerRelations(namedRelations, shouldEagerLoad);
-    const uniqueKeys = {};
-    for (const [tableName, table] of tableEntries) {
-      if (!featureOf(tableName).uniqueKeyFilters) {
-        continue;
-      }
-      const taken = /* @__PURE__ */ new Set([...Object.keys(visibleColumns(table)), ...Object.keys(namedRelations[tableName] ?? {})]);
-      const map = buildUniqueKeyMap(uniqueColumnSets(table), taken);
-      if (Object.keys(map).length) {
-        uniqueKeys[tableName] = map;
-      }
-    }
-    const filterCtx = { tables, relationMap: namedRelations, uniqueKeys };
-    const tablePolicies = options.policies;
-    const contextValuesOf = tablePolicies?.contextValues;
-    const softDeleteOf = tablePolicies?.softDelete;
-    const policies = bindPolicies(tablePolicies, filterCtx);
-    const resolverFactory = createRelationResolverFactory(
-      db,
       tables,
-      adapter.nullOrdering,
+      featureOf,
+      eagerRelations,
       filterCtx,
-      limits,
-      tablePolicies
-    );
-    const cacheCtx = {
-      typeName: options.typeName ?? ((info) => info.defaultName),
-      genericFilterCache: /* @__PURE__ */ new Map(),
-      objectTypeCache: /* @__PURE__ */ new Map(),
-      relationFieldContainers: /* @__PURE__ */ new Map(),
-      fullyBuiltTables: /* @__PURE__ */ new Set(),
-      relationTypeCache: /* @__PURE__ */ new Map(),
-      selectFieldCache: /* @__PURE__ */ new WeakMap(),
-      filterFieldCache: /* @__PURE__ */ new WeakMap(),
-      orderTypeCache: /* @__PURE__ */ new WeakMap(),
-      filterTypeCache: /* @__PURE__ */ new WeakMap(),
-      listRelationFilterCache: /* @__PURE__ */ new Map(),
-      aggregateTypeCache: /* @__PURE__ */ new Map(),
-      complexity,
-      limits,
-      docs: options.docs ?? {},
-      primaryKeyOf: (name) => tables[name] ? primaryKeyPropNames(tables[name]) : [],
-      contextValuesOf,
+      policies,
       softDeleteOf,
-      featureOf,
-      uniqueKeysOf: (tableName) => uniqueKeys[tableName]
-    };
-    adapter.preflight?.(db, options);
-    const nestedPlans = features.nestedWrites ? buildNestedWritePlans(
-      tables,
       namedRelations,
-      (target) => uniqueColumnSets(target),
-      (target) => primaryKeyPropNames(target),
-      extractRelationJoinColumns
-    ) : void 0;
-    const nestedTypes = nestedPlans ? createNestedWriteTypes({ plans: nestedPlans, cacheCtx, typeNameMapper }) : 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);
-    const gqlSchemaTypes = Object.fromEntries(
-      Object.entries(tables).map(([tableName, _table]) => [
-        tableName,
-        generateTableTypes(
-          tableName,
-          tables,
-          namedRelations,
-          true,
-          relationsDepthLimit,
-          cacheCtx,
-          typeNameMapper,
-          prefixes.insert,
-          prefixes.update,
-          resolverFactory,
-          featureOf(tableName).relationAggregates ? relationAggregateFactory : void 0,
-          nestedTypes
-        )
-      ])
-    );
-    const inputs = {};
-    const outputs = {};
+      cacheCtx,
+      nestedRuntime,
+      mutationTxCtx,
+      gqlSchemaTypes,
+      mutations,
+      inputs,
+      outputs
+    } = ctx;
     for (const [tableName, tableTypes] of Object.entries(gqlSchemaTypes)) {
       const tableFeatures = featureOf(tableName);
       const drizzleMeta = tableFieldExtensions(tableName, primaryKeyPropNames(schema[tableName]));
       const { insertInput, updateInput, tableFilters, tableOrder } = tableTypes.inputs;
-      const { selectSingleOutput, selectArrOutput, singleTableItemOutput, arrTableItemOutput } = tableTypes.outputs;
+      const { selectSingleOutput, singleTableItemOutput, arrTableItemOutput } = tableTypes.outputs;
+      const names = computeResolverFieldNames(tableName, typeNameMapper, prefixes, suffixes);
       const {
         typeName,
-        listFieldName,
-        singleFieldName,
-        aggregateFieldName,
-        groupByFieldName,
         createArrayFieldName,
         createSingleFieldName,
         upsertArrayFieldName,
@@ -7371,39 +7114,9 @@ var createSchemaDataGenerator = (adapter) => {
         restoreFieldName,
         restoreSingleFieldName,
         deleteCountFieldName
-      } = computeResolverFieldNames(tableName, typeNameMapper, prefixes, suffixes);
+      } = names;
       const softDeleteInfo = softDeleteOf?.(tableName);
-      const selectArrGenerated = generateSelectArray2(
-        db,
-        tableName,
-        tables,
-        eagerRelations,
-        tableOrder,
-        tableFilters,
-        listFieldName,
-        typeName,
-        typeNameMapper,
-        filterCtx,
-        tableFeatures.distinct,
-        limits,
-        policies,
-        cacheCtx.typeName
-      );
-      const selectSingleGenerated = generateSelectSingle2(
-        db,
-        tableName,
-        tables,
-        eagerRelations,
-        tableOrder,
-        tableFilters,
-        singleFieldName,
-        typeName,
-        typeNameMapper,
-        filterCtx,
-        limits,
-        policies,
-        cacheCtx.typeName
-      );
+      const { aggregateType, groupByType, havingInput } = addReadFields2(ctx, tableName, names, tableTypes, drizzleMeta);
       const insertArrGenerated = tableFeatures.insert ? generateInsertArray2(
         db,
         tableName,
@@ -7641,73 +7354,6 @@ var createSchemaDataGenerator = (adapter) => {
         filterCtx,
         txCtx: mutationTxCtx
       }) : void 0;
-      const aggregateType = tableFeatures.aggregates ? generateAggregateTypes(schema[tableName], tableName, typeName, cacheCtx) : void 0;
-      const aggregateGenerated = tableFeatures.aggregates ? generateAggregate(
-        db,
-        tableName,
-        schema[tableName],
-        typeName,
-        aggregateFieldName,
-        tableFilters,
-        filterCtx,
-        tablePolicies,
-        cacheCtx.typeName
-      ) : void 0;
-      const groupByType = tableFeatures.aggregates && tableFeatures.groupBy ? generateGroupByType(schema[tableName], tableName, typeName, cacheCtx) : void 0;
-      const groupByEnum = groupByType ? generateGroupByEnum(schema[tableName], tableName, typeName, cacheCtx) : void 0;
-      const havingInput = groupByEnum ? generateHavingInput(schema[tableName], tableName, typeName, cacheCtx) : void 0;
-      const groupByGenerated = groupByType && groupByEnum && havingInput ? generateGroupBy(
-        db,
-        tableName,
-        schema[tableName],
-        typeName,
-        groupByFieldName,
-        tableFilters,
-        groupByEnum,
-        havingInput,
-        filterCtx,
-        tablePolicies,
-        cacheCtx.typeName
-      ) : void 0;
-      queries[selectArrGenerated.name] = {
-        type: selectArrOutput,
-        args: selectArrGenerated.args,
-        resolve: selectArrGenerated.resolver,
-        extensions: {
-          drizzle: drizzleMeta({ kind: "query", operation: "select", single: false, targetArg: "where" }),
-          ...complexity ? { complexity: listFieldComplexity(complexity, limits?.(tableName)) } : {}
-        }
-      };
-      queries[selectSingleGenerated.name] = {
-        type: selectSingleOutput,
-        args: selectSingleGenerated.args,
-        resolve: selectSingleGenerated.resolver,
-        extensions: {
-          drizzle: drizzleMeta({ kind: "query", operation: "select", single: true, targetArg: "where" })
-        }
-      };
-      if (aggregateGenerated && aggregateType) {
-        queries[aggregateGenerated.name] = {
-          type: new GraphQLNonNull16(aggregateType),
-          args: aggregateGenerated.args,
-          resolve: aggregateGenerated.resolver,
-          extensions: {
-            drizzle: drizzleMeta({ kind: "aggregate", operation: "aggregate", single: true, targetArg: "where" }),
-            ...complexity ? { complexity: aggregateFieldComplexity(complexity) } : {}
-          }
-        };
-      }
-      if (groupByGenerated && groupByType) {
-        queries[groupByGenerated.name] = {
-          type: new GraphQLNonNull16(new GraphQLList12(new GraphQLNonNull16(groupByType))),
-          args: groupByGenerated.args,
-          resolve: groupByGenerated.resolver,
-          extensions: {
-            drizzle: drizzleMeta({ kind: "aggregate", operation: "groupBy", single: false, targetArg: "where" }),
-            ...complexity ? { complexity: aggregateFieldComplexity(complexity) } : {}
-          }
-        };
-      }
       if (insertArrGenerated) {
         mutations[insertArrGenerated.name] = {
           type: arrTableItemOutput,
@@ -7722,7 +7368,7 @@ var createSchemaDataGenerator = (adapter) => {
         mutations[insertSingleGenerated.name] = {
           // An insert either returns the row it inserted or throws — the one path to `null` is
           // `conflictDoNothing` swallowing the insert, so the field is nullable only there.
-          type: conflictDoNothing ? singleTableItemOutput : new GraphQLNonNull16(singleTableItemOutput),
+          type: conflictDoNothing ? singleTableItemOutput : new GraphQLNonNull17(singleTableItemOutput),
           args: insertSingleGenerated.args,
           resolve: insertSingleGenerated.resolver,
           extensions: {
@@ -7762,7 +7408,7 @@ var createSchemaDataGenerator = (adapter) => {
       }
       if (updateManyGenerated) {
         mutations[updateManyGenerated.name] = {
-          type: new GraphQLNonNull16(new GraphQLList12(singleTableItemOutput)),
+          type: new GraphQLNonNull17(new GraphQLList13(singleTableItemOutput)),
           args: updateManyGenerated.args,
           resolve: updateManyGenerated.resolver,
           extensions: {
@@ -7838,7 +7484,7 @@ var createSchemaDataGenerator = (adapter) => {
       }
       if (updateCountGenerated) {
         mutations[updateCountGenerated.name] = {
-          type: new GraphQLNonNull16(GraphQLInt9),
+          type: new GraphQLNonNull17(GraphQLInt9),
           args: updateCountGenerated.args,
           resolve: updateCountGenerated.resolver,
           description: "How many rows the update touched. The rows themselves are not read back, which is the point of this mutation."
@@ -7846,7 +7492,7 @@ var createSchemaDataGenerator = (adapter) => {
       }
       if (deleteCountGenerated) {
         mutations[deleteCountGenerated.name] = {
-          type: new GraphQLNonNull16(GraphQLInt9),
+          type: new GraphQLNonNull17(GraphQLInt9),
           args: deleteCountGenerated.args,
           resolve: deleteCountGenerated.resolver,
           description: "How many rows the delete removed. The rows themselves are not read back, which is the point of this mutation."
@@ -7874,31 +7520,12 @@ var createSchemaDataGenerator = (adapter) => {
         inputs[havingInput.name] = havingInput;
       }
     }
-    if (mutationTxCtx) {
-      for (const name of Object.keys(mutations)) {
-        mutationTxCtx.fieldNames.add(name);
-      }
-    }
-    const fieldResolvers = {};
-    for (const [tableName, tableRelations] of Object.entries(namedRelations)) {
-      const relResolvers = {};
-      for (const [relName, relEntry] of Object.entries(tableRelations)) {
-        const isOne = is12(relEntry.relation ?? relEntry, One9);
-        const resolver = resolverFactory({ tableName, relationName: relName, relEntry, isOne });
-        if (resolver) {
-          relResolvers[relName] = resolver;
-        }
-      }
-      if (Object.keys(relResolvers).length > 0) {
-        fieldResolvers[tableName] = relResolvers;
-      }
-    }
-    return { queries, mutations, inputs, types: outputs, fieldResolvers };
+    return finalizeBuild2(ctx);
   };
 };
 
 // src/util/builders/update-many.ts
-import { GraphQLList as GraphQLList13, GraphQLNonNull as GraphQLNonNull17 } from "graphql";
+import { GraphQLList as GraphQLList14, GraphQLNonNull as GraphQLNonNull18 } from "graphql";
 import { parseResolveInfo as parseResolveInfo4 } from "graphql-parse-resolve-info";
 var runUpdateManyBatch = ({
   executor,
@@ -7929,126 +7556,100 @@ var createUpdateManyGenerator = (primaryKeyPropNames, runBatch = runUpdateManyBa
   return (db, tableName, table, tables, relationMap, updateManyInput, fieldName, typeName, typeNameMapper, filterCtx, txCtx, nested, limits, policies, resolveName) => {
     const queryArgs = {
       updates: {
-        type: new GraphQLNonNull17(new GraphQLList13(new GraphQLNonNull17(updateManyInput)))
+        type: new GraphQLNonNull18(new GraphQLList14(new GraphQLNonNull18(updateManyInput)))
       }
     };
     const pkNames = primaryKeyPropNames(table);
-    const hooks = policies?.onWrite?.(tableName, "updateMany");
-    const errorCtx = { table: tableName, operation: "updateMany", field: fieldName };
-    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 drizzleError("No updates were provided!", { code: "DRIZZLE_NO_VALUES" });
-              }
-              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,
-                resolveName,
-                table,
-                pkNames,
-                parsedInfo,
-                limits,
-                scope,
-                defaultOrderBy: policies?.defaultOrderBy
-              });
-              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 drizzleError("Unable to update with no values specified!", { code: "DRIZZLE_NO_VALUES" });
-                }
-                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 perEntry = await runBatch({
-                executor,
-                entries,
-                table,
-                returning,
-                anyNested,
-                nested,
-                tableName,
-                context
-              });
-              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;
-              }
-              return output;
-            },
-            !!hooks
+    return writeResolver({
+      db,
+      tableName,
+      operation: "updateMany",
+      single: false,
+      fieldName,
+      txCtx,
+      policies,
+      args: queryArgs,
+      run: async ({ executor, args, context, info, before, after }) => {
+        const { updates } = args;
+        if (!updates.length) {
+          throw drizzleError("No updates were provided!", { code: "DRIZZLE_NO_VALUES" });
+        }
+        await before();
+        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,
+          resolveName,
+          table,
+          pkNames,
+          parsedInfo,
+          limits,
+          scope,
+          defaultOrderBy: policies?.defaultOrderBy
+        });
+        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
           );
-        } catch (e) {
-          throw withErrorContext(toGraphQLError(e), errorCtx);
+          if (!Object.keys(input).length && !ops) {
+            throw drizzleError("Unable to update with no values specified!", { code: "DRIZZLE_NO_VALUES" });
+          }
+          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 perEntry = await runBatch({
+          executor,
+          entries,
+          table,
+          returning,
+          anyNested,
+          nested,
+          tableName,
+          context
+        });
+        const flatRows = perEntry.flat();
+        await after(flatRows);
+        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;
         }
-      },
-      args: queryArgs
-    };
+        return output;
+      }
+    });
   };
 };
 
@@ -8061,6 +7662,8 @@ var pgSchemaData = createSchemaDataGenerator({
   primaryKeyPropNames: pgPrimaryKeyPropNames,
   // PostgreSQL sorts NULLs as the largest values (last in ASC).
   nullOrdering: "nulls-largest",
+  // Writes come back with their rows, so the table types carry the `${Table}Item` outputs.
+  returnsRows: true,
   generateUpdateMany: generateUpdateMany2
 });
 var generateSchemaData2 = (db, schema, relations, options) => pgSchemaData(db, schema, relations, options);
@@ -8132,6 +7735,8 @@ var sqliteSchemaData = createSchemaDataGenerator({
   primaryKeyPropNames: sqlitePrimaryKeyPropNames,
   // SQLite sorts NULLs as the smallest values (first in ASC).
   nullOrdering: "nulls-smallest",
+  // Writes come back with their rows, so the table types carry the `${Table}Item` outputs.
+  returnsRows: true,
   // A synchronous driver (e.g. better-sqlite3) commits the moment its transaction callback
   // returns, so it can neither interleave awaited statements inside one transaction nor hold
   // one open across resolver calls — which is what both of these features require.
@@ -8152,20 +7757,20 @@ var sqliteSchemaData = createSchemaDataGenerator({
 var generateSchemaData3 = (db, schema, relations, options) => sqliteSchemaData(db, schema, relations, options);
 
 // src/util/selection.ts
-import { is as is13, Table as Table2 } from "drizzle-orm";
+import { is as is12, Table as Table2 } from "drizzle-orm";
 import { getTableConfig as getMySqlTableConfig, MySqlDatabase } from "drizzle-orm/mysql-core";
 import { getTableConfig as getPgTableConfig, PgAsyncDatabase } from "drizzle-orm/pg-core";
 import { BaseSQLiteDatabase, getTableConfig as getSQLiteTableConfig } from "drizzle-orm/sqlite-core";
 import { parseResolveInfo as parseResolveInfo5 } from "graphql-parse-resolve-info";
 var contextCache = /* @__PURE__ */ new WeakMap();
 var tableConfigFor = (db) => {
-  if (is13(db, MySqlDatabase)) {
+  if (is12(db, MySqlDatabase)) {
     return getMySqlTableConfig;
   }
-  if (is13(db, PgAsyncDatabase)) {
+  if (is12(db, PgAsyncDatabase)) {
     return getPgTableConfig;
   }
-  if (is13(db, BaseSQLiteDatabase)) {
+  if (is12(db, BaseSQLiteDatabase)) {
     return getSQLiteTableConfig;
   }
   throw new Error("Drizzle-GraphQL Error: unsupported database instance \u2014 expected a PostgreSQL, MySQL or SQLite one.");
@@ -8179,7 +7784,7 @@ var contextFor = (db) => {
   const schema = db._.fullSchema ?? Object.fromEntries(
     Object.entries(relations).filter(([, config]) => config?.table != null).map(([key, config]) => [key, config.table])
   );
-  const tableEntries = Object.entries(schema).filter(([, value]) => is13(value, Table2));
+  const tableEntries = Object.entries(schema).filter(([, value]) => is12(value, Table2));
   if (!tableEntries.length) {
     throw new Error(
       "Drizzle-GraphQL Error: Schema not found in drizzle instance. Pass relations (from buildRelations/defineRelations) to the drizzle constructor so drizzle-graphql can read your tables."
@@ -8311,11 +7916,11 @@ var buildSchema = (db, config) => {
   }
   const generatorOptions = resolveBuildConfig(config, schema);
   let generatorOutput;
-  if (is14(db, MySqlDatabase2)) {
+  if (is13(db, MySqlDatabase2)) {
     generatorOutput = generateSchemaData(db, schema, relations, generatorOptions);
-  } else if (is14(db, PgAsyncDatabase2)) {
+  } else if (is13(db, PgAsyncDatabase2)) {
     generatorOutput = generateSchemaData2(db, schema, relations, generatorOptions);
-  } else if (is14(db, BaseSQLiteDatabase2)) {
+  } else if (is13(db, BaseSQLiteDatabase2)) {
     generatorOutput = generateSchemaData3(db, schema, relations, generatorOptions);
   } else {
     throw new Error("Drizzle-GraphQL Error: Unknown database instance type");