@vantreeseba/drizzle-graphql 5.6.0 → 7.0.0

package/dist/index.js

@@ -1,5 +1,5 @@
 // src/index.ts
-import { is as is7 } from "drizzle-orm";
+import { is as is8 } from "drizzle-orm";
 import { MySqlDatabase } from "drizzle-orm/mysql-core";
 import { PgAsyncDatabase } from "drizzle-orm/pg-core";
 import { BaseSQLiteDatabase } from "drizzle-orm/sqlite-core";
@@ -18,7 +18,7 @@ import {
   desc,
   eq,
   extractExtendedColumnType as extractExtendedColumnType2,
-  getColumns,
+  getColumns as getColumns2,
   getTableAsAliasSQL,
   gt,
   gte,
@@ -38,17 +38,17 @@ import {
   One as One2,
   or,
   relationsFilterToSQL,
-  sql
+  sql as sql2
 } from "drizzle-orm";
 import {
   GraphQLBoolean as GraphQLBoolean2,
   GraphQLEnumType as GraphQLEnumType2,
-  GraphQLError as GraphQLError3,
-  GraphQLFloat as GraphQLFloat2,
-  GraphQLInputObjectType as GraphQLInputObjectType2,
-  GraphQLInt as GraphQLInt2,
-  GraphQLList as GraphQLList2,
-  GraphQLNonNull as GraphQLNonNull2,
+  GraphQLError as GraphQLError4,
+  GraphQLFloat as GraphQLFloat3,
+  GraphQLInputObjectType as GraphQLInputObjectType3,
+  GraphQLInt as GraphQLInt3,
+  GraphQLList as GraphQLList3,
+  GraphQLNonNull as GraphQLNonNull3,
   GraphQLObjectType as GraphQLObjectType2,
   GraphQLString as GraphQLString2
 } from "graphql";
@@ -198,15 +198,42 @@ var GraphQLDecimalString = new GraphQLScalarType({
 
 // src/util/type-converter/index.ts
 var allowedNameChars = /^[a-zA-Z0-9_]+$/;
-var enumMap = /* @__PURE__ */ new WeakMap();
+var declaredEnum = (column) => {
+  const declared = column.enum;
+  return typeof declared?.enumName === "string" ? { enumName: declared.enumName, schema: typeof declared.schema === "string" ? declared.schema : void 0 } : void 0;
+};
+var pascalize = (input) => input.split(/[^a-zA-Z0-9]+/).filter(Boolean).map((part) => capitalize(part)).join("");
+var enumValuesKey = (values) => JSON.stringify(values);
+var enumNamesInUse = /* @__PURE__ */ new Map();
+var enumNameMapper;
+var registerEnumConfig = (config) => {
+  enumNameMapper = config.enumNameMapper;
+  enumNamesInUse = /* @__PURE__ */ new Map();
+};
 var generateEnumCached = (column, columnName, tableName) => {
-  if (enumMap.has(column)) {
-    return enumMap.get(column);
+  const declared = declaredEnum(column);
+  const values = column.enumValues;
+  const name = enumNameMapper?.({
+    enumName: declared?.enumName,
+    schema: declared?.schema,
+    tableName,
+    columnName,
+    values
+  }) ?? (declared ? `${pascalize(declared.enumName)}Enum` : `${capitalize(tableName)}${capitalize(columnName)}Enum`);
+  const valuesKey = enumValuesKey(values);
+  const claimed = enumNamesInUse.get(name);
+  if (claimed) {
+    if (claimed.valuesKey !== valuesKey) {
+      throw new Error(
+        `Drizzle-GraphQL Error: Two different enums both map to the GraphQL type name '${name}' (most recently '${tableName}.${columnName}'). Give one of them a different name via config.enumNameMapper.`
+      );
+    }
+    return claimed.type;
   }
   const gqlEnum = new GraphQLEnumType({
-    name: `${capitalize(tableName)}${capitalize(columnName)}Enum`,
+    name,
     values: Object.fromEntries(
-      column.enumValues.map((e, index) => [
+      values.map((e, index) => [
         allowedNameChars.test(e) ? e : `Option${index}`,
         {
           value: e,
@@ -215,7 +242,7 @@ var generateEnumCached = (column, columnName, tableName) => {
       ])
     )
   });
-  enumMap.set(column, gqlEnum);
+  enumNamesInUse.set(name, { type: gqlEnum, valuesKey });
   return gqlEnum;
 };
 var geoXyType = new GraphQLObjectType({
@@ -236,14 +263,14 @@ var columnToGraphQLCore = (column, columnName, tableName, isInput) => {
   const dimensions = column.dimensions;
   if (dimensions !== void 0 && dimensions > 0) {
     const inner = columnBaseToGraphQLCore(column, columnName, tableName, isInput);
-    const innerDesc = inner.description ?? inner.type.name;
+    const innerLabel = inner.typeLabel ?? inner.type.name;
     let type = inner.type;
-    let description = innerDesc;
+    let typeLabel = innerLabel;
     for (let i = 0; i < dimensions; i++) {
       type = new GraphQLList(new GraphQLNonNull(type));
-      description = `Array<${description}>`;
+      typeLabel = `Array<${typeLabel}>`;
     }
-    return { type, description };
+    return { type, typeLabel };
   }
   return columnBaseToGraphQLCore(column, columnName, tableName, isInput);
 };
@@ -251,51 +278,51 @@ var columnBaseToGraphQLCore = (column, columnName, tableName, isInput) => {
   const { type: baseType, constraint } = extractExtendedColumnType(column);
   switch (baseType) {
     case "boolean":
-      return { type: GraphQLBoolean, description: "Boolean" };
+      return { type: GraphQLBoolean, typeLabel: "Boolean" };
     case "object":
       if (column instanceof PgTimestamp || column instanceof PgDate) {
-        return { type: GraphQLDateTime, description: "DateTime" };
+        return { type: GraphQLDateTime, typeLabel: "DateTime" };
       }
       return column.columnType === "PgGeometryObject" ? {
         type: isInput ? geoXyInputType : geoXyType,
-        description: "Geometry points XY"
+        typeLabel: "Geometry points XY"
       } : column.columnType === "PgBytea" ? {
         type: new GraphQLList(new GraphQLNonNull(GraphQLInt)),
-        description: "Buffer"
-      } : { type: GraphQLJSON, description: "JSON" };
+        typeLabel: "Buffer"
+      } : { type: GraphQLJSON, typeLabel: "JSON" };
     case "string":
       if (column.enumValues?.length) {
         return { type: generateEnumCached(column, columnName, tableName) };
       }
       if (constraint === "numeric" && !column.dimensions) {
-        return { type: GraphQLDecimalString, description: "Decimal" };
+        return { type: GraphQLDecimalString, typeLabel: "Decimal" };
       }
       if (column instanceof PgTimestamp || column instanceof PgTimestampString) {
-        return { type: GraphQLDateTime, description: "DateTime" };
+        return { type: GraphQLDateTime, typeLabel: "DateTime" };
       }
       if (column instanceof PgUUID) {
-        return { type: GraphQLUUID, description: "UUID" };
+        return { type: GraphQLUUID, typeLabel: "UUID" };
       }
       if (column instanceof PgDateString) {
-        return isInput ? { type: GraphQLString, description: "Date" } : { type: GraphQLDate, description: "Date" };
+        return isInput ? { type: GraphQLString, typeLabel: "Date" } : { type: GraphQLDate, typeLabel: "Date" };
       }
-      return { type: GraphQLString, description: "String" };
+      return { type: GraphQLString, typeLabel: "String" };
     case "bigint":
-      return { type: GraphQLBigIntString, description: "BigInt" };
+      return { type: GraphQLBigIntString, typeLabel: "BigInt" };
     case "number": {
-      return is(column, PgInteger) || is(column, PgSerial) || is(column, MySqlInt) || is(column, MySqlSerial) || is(column, SQLiteInteger) ? { type: GraphQLInt, description: "Integer" } : { type: GraphQLFloat, description: "Float" };
+      return is(column, PgInteger) || is(column, PgSerial) || is(column, MySqlInt) || is(column, MySqlSerial) || is(column, SQLiteInteger) ? { type: GraphQLInt, typeLabel: "Integer" } : { type: GraphQLFloat, typeLabel: "Float" };
     }
     case "array": {
       if (column.columnType === "PgVector") {
         return {
           type: new GraphQLList(new GraphQLNonNull(GraphQLFloat)),
-          description: "Array<Float>"
+          typeLabel: "Array<Float>"
         };
       }
       if (column.columnType === "PgGeometry") {
         return {
           type: new GraphQLList(new GraphQLNonNull(GraphQLFloat)),
-          description: "Tuple<[Float, Float]>"
+          typeLabel: "Tuple<[Float, Float]>"
         };
       }
       const innerType = columnToGraphQLCore(
@@ -306,7 +333,7 @@ var columnBaseToGraphQLCore = (column, columnName, tableName, isInput) => {
       );
       return {
         type: new GraphQLList(new GraphQLNonNull(innerType.type)),
-        description: `Array<${innerType.description}>`
+        typeLabel: `Array<${innerType.typeLabel}>`
       };
     }
     default:
@@ -362,24 +389,14 @@ var registerScalarOverrides = (tables, config) => {
 };
 var drizzleColumnToGraphQLType = (column, columnName, tableName, forceNullable = false, defaultIsNullable = false, isInput = false) => {
   const override = getColumnScalarOverride(column, isInput);
-  let typeDesc;
-  if (override) {
-    typeDesc = { type: override, description: override.name };
-  } else {
-    typeDesc = columnToGraphQLCore(column, columnName, tableName, isInput);
-    const noDesc = ["string", "boolean", "number"];
-    const { type: baseType } = extractExtendedColumnType(column);
-    if (noDesc.find((e) => e === baseType)) {
-      delete typeDesc.description;
-    }
-  }
+  const typeDesc = override ? { type: override, typeLabel: override.name } : columnToGraphQLCore(column, columnName, tableName, isInput);
   if (forceNullable) {
     return typeDesc;
   }
   if (column.notNull && !(defaultIsNullable && (column.hasDefault || column.defaultFn))) {
     return {
       type: new GraphQLNonNull(typeDesc.type),
-      description: typeDesc.description
+      typeLabel: typeDesc.typeLabel
     };
   }
   return typeDesc;
@@ -585,6 +602,131 @@ var remapFromGraphQLArrayInput = (queryInput, table) => {
   return queryInput;
 };
 
+// src/util/builders/field-updates.ts
+import { getColumns, sql } from "drizzle-orm";
+import {
+  GraphQLError as GraphQLError3,
+  GraphQLFloat as GraphQLFloat2,
+  GraphQLInputObjectType as GraphQLInputObjectType2,
+  GraphQLInt as GraphQLInt2,
+  GraphQLList as GraphQLList2,
+  GraphQLNonNull as GraphQLNonNull2
+} from "graphql";
+var NUMERIC_SCALARS = /* @__PURE__ */ new Set([
+  GraphQLInt2,
+  GraphQLFloat2,
+  GraphQLBigIntString,
+  GraphQLDecimalString
+]);
+var NON_LIST_ARRAY_COLUMNS = /* @__PURE__ */ new Set(["PgVector", "PgGeometry", "PgBytea"]);
+var kindCache = /* @__PURE__ */ new WeakMap();
+var fieldUpdateKind = (column, columnName, tableName) => {
+  const cached = kindCache.get(column);
+  if (cached) {
+    return cached;
+  }
+  let kind = "none";
+  if (!getColumnScalarOverride(column, true)) {
+    const { type } = drizzleColumnToGraphQLType(column, columnName, tableName, true, false, true);
+    if (NUMERIC_SCALARS.has(type)) {
+      kind = "numeric";
+    } else if (type instanceof GraphQLList2 && !NON_LIST_ARRAY_COLUMNS.has(column.columnType)) {
+      kind = "list";
+    }
+  }
+  kindCache.set(column, kind);
+  return kind;
+};
+var inputCache = /* @__PURE__ */ new Map();
+var namedFieldUpdateInput = (name, fields, description) => {
+  const cached = inputCache.get(name);
+  if (cached) {
+    return cached;
+  }
+  const input = new GraphQLInputObjectType2({ name, description, fields: fields() });
+  inputCache.set(name, input);
+  return input;
+};
+var fieldUpdateInputType = (column, columnName, tableName) => {
+  const kind = fieldUpdateKind(column, columnName, tableName);
+  if (kind === "none") {
+    return void 0;
+  }
+  const { type } = drizzleColumnToGraphQLType(column, columnName, tableName, true, false, true);
+  if (kind === "numeric") {
+    const scalar = type;
+    return namedFieldUpdateInput(
+      `${scalar.name}FieldUpdate`,
+      () => ({
+        set: { type: scalar, description: "Replace the current value with this one" },
+        increment: { type: scalar, description: "Add this to the current value (SQL `column + value`)" },
+        decrement: { type: scalar, description: "Subtract this from the current value (SQL `column - value`)" },
+        multiply: { type: scalar, description: "Multiply the current value by this (SQL `column * value`)" },
+        divide: {
+          type: scalar,
+          description: "Divide the current value by this (SQL `column / value`), rounding as the database does"
+        }
+      }),
+      `An update to a ${scalar.name} column: exactly one of these operations`
+    );
+  }
+  const list = type;
+  const element = list.ofType;
+  const elementName = element instanceof GraphQLNonNull2 ? String(element.ofType) : String(element);
+  return namedFieldUpdateInput(
+    `${elementName}ListFieldUpdate`,
+    () => ({
+      set: { type: list, description: "Replace the current array with this one" },
+      push: { type: list, description: "Append these elements to the current array" }
+    }),
+    `An update to a ${elementName} array column: exactly one of these operations`
+  );
+};
+var OPERATIONS = ["set", "increment", "decrement", "multiply", "divide", "push"];
+var singleOperation = (value, columnName) => {
+  const given = OPERATIONS.filter((operation) => value[operation] !== void 0);
+  if (given.length === 1) {
+    return [given[0], value[given[0]]];
+  }
+  throw new GraphQLError3(
+    given.length ? `Field '${columnName}' takes exactly one update operation, but ${given.length} were given (${given.join(", ")}).` : `Field '${columnName}' was given no update operation. Pass exactly one of ${OPERATIONS.join(", ")}.`
+  );
+};
+var splitFieldUpdateOperations = (values, table, tableName) => {
+  const cols = getColumns(table);
+  const columns = {};
+  const expressions = {};
+  for (const [columnName, value] of Object.entries(values)) {
+    const column = cols[columnName];
+    if (!column || value === null || value === void 0) {
+      columns[columnName] = value;
+      continue;
+    }
+    const isOperations = typeof value === "object" && !Array.isArray(value) && !(value instanceof Date);
+    if (!isOperations || fieldUpdateKind(column, columnName, tableName) === "none") {
+      columns[columnName] = value;
+      continue;
+    }
+    const [operation, operand] = singleOperation(value, columnName);
+    if (operation === "set") {
+      columns[columnName] = operand;
+      continue;
+    }
+    const param = sql.param(remapFromGraphQLCore(operand, column, columnName), column);
+    expressions[columnName] = operation === "increment" ? sql`${column} + ${param}` : operation === "decrement" ? sql`${column} - ${param}` : operation === "multiply" ? sql`${column} * ${param}` : operation === "divide" ? sql`${column} / ${param}` : (
+      // `push`: array concatenation, which is the only dialect-specific operation
+      // here — and arrays are a PostgreSQL column type to begin with.
+      sql`${column} || ${param}`
+    );
+  }
+  return { columns, expressions };
+};
+var remapUpdateInput = (values, table, tableName) => {
+  const { columns, expressions } = splitFieldUpdateOperations(values, table, tableName);
+  const remapped = remapFromGraphQLSingleInput(columns, table);
+  return Object.keys(expressions).length ? { ...remapped, ...expressions } : remapped;
+};
+
 // src/util/builders/common.ts
 var rqbCrashTypes = ["SQLiteBigInt", "SQLiteBlobJson", "SQLiteBlobBuffer"];
 var resolveTypeName = (name, typeNameMapper) => {
@@ -647,9 +789,9 @@ var extractRelationJoinColumns = (relEntry, parentTable, targetTable) => {
   }
   const sourceCol = sourceColumns[0];
   const targetCol = targetColumns[0];
-  const parentCols = getColumns(parentTable);
+  const parentCols = getColumns2(parentTable);
   const localColPropName = Object.entries(parentCols).find(([, c]) => c === sourceCol)?.[0];
-  const targetCols = getColumns(targetTable);
+  const targetCols = getColumns2(targetTable);
   const foreignColPropName = Object.entries(targetCols).find(([, c]) => c === targetCol)?.[0];
   if (!localColPropName || !foreignColPropName) {
     return void 0;
@@ -731,7 +873,7 @@ var collectRootMutationKeys = (selectionSet, fragments, variables, known, keys,
   }
   return true;
 };
-var abortedBatchError = () => new GraphQLError3(
+var abortedBatchError = () => new GraphQLError4(
   "Drizzle-GraphQL Error: Mutation was not executed because an earlier mutation in the same request failed and the shared transaction was rolled back."
 );
 var openSharedTx = (db, context, txCtx, stateKey, expected) => {
@@ -789,7 +931,7 @@ var openSharedTx = (db, context, txCtx, stateKey, expected) => {
       }
       timer = setTimeout(() => {
         state.abort(
-          new GraphQLError3(
+          new GraphQLError4(
             `Drizzle-GraphQL Error: Shared mutation transaction timed out after ${txCtx.timeoutMs}ms waiting for the remaining mutation fields; rolling back.`
           )
         );
@@ -871,14 +1013,14 @@ var runMutation = async (db, context, info, txCtx, body) => {
   return runOnSharedTx(state, body);
 };
 var batchedPaginatedRelationQuery = async (db, targetTable, foreignCol, whereCondition, orderByArg, limit, offset, pkNames, orderCtx) => {
-  const cols = getColumns(targetTable);
+  const cols = getColumns2(targetTable);
   const orderExprs = [
     ...orderByArg ? extractOrderBy(targetTable, orderByArg, orderCtx) : [],
     ...primaryKeyOrderExprs(targetTable, pkNames)
   ];
-  const orderClause = orderExprs.length ? sql` order by ${sql.join(orderExprs, sql`, `)}` : sql``;
+  const orderClause = orderExprs.length ? sql2` order by ${sql2.join(orderExprs, sql2`, `)}` : sql2``;
   const RN = "__drizzle_graphql_rn";
-  const rowNumber = sql`row_number() over (partition by ${foreignCol}${orderClause})`.as(RN);
+  const rowNumber = sql2`row_number() over (partition by ${foreignCol}${orderClause})`.as(RN);
   const sub = db.select({ ...cols, [RN]: rowNumber }).from(targetTable).where(whereCondition).as("__paginated");
   const lower = offset ?? 0;
   const windowConds = [gt(sub[RN], lower)];
@@ -891,7 +1033,7 @@ var batchedPaginatedRelationQuery = async (db, targetTable, foreignCol, whereCon
   }
   return rows;
 };
-var createRelationResolverFactory = (db, tables, filterCtx) => ({ tableName, relationName, relEntry, isOne }) => {
+var createRelationResolverFactory = (db, tables, nullOrdering, filterCtx) => ({ tableName, relationName, relEntry, isOne }) => {
   const parentTable = tables[tableName];
   const targetTableName = relEntry.targetTableName;
   const targetTable = tables[targetTableName];
@@ -904,7 +1046,7 @@ var createRelationResolverFactory = (db, tables, filterCtx) => ({ tableName, rel
   }
   const { localColPropName, foreignCol, foreignColPropName } = joinCols;
   const targetPkNames = relEntry.targetPkNames ?? [];
-  return async (parent, args, context) => {
+  return async (parent, args, context, info) => {
     if (parent[relationName] !== void 0) {
       return parent[relationName];
     }
@@ -912,21 +1054,65 @@ var createRelationResolverFactory = (db, tables, filterCtx) => ({ tableName, rel
     if (localValue == null) {
       return isOne ? null : [];
     }
-    const { where: whereArg, orderBy: orderByArg, limit, offset } = args ?? {};
+    const { where: whereArg, orderBy: orderByArg, limit, offset, after } = args ?? {};
+    const distinct = (args ?? {}).distinct?.length ? (args ?? {}).distinct : void 0;
+    const cursorSelected = !isOne && !!info && selectsCursorField(info, targetTable);
+    let cursorEntries;
+    if (!isOne && (after != null || cursorSelected)) {
+      if (after != null && distinct) {
+        throw new GraphQLError4("'after' cannot be combined with 'distinct'.");
+      }
+      if (orderByHasRelationEntry(orderByArg)) {
+        if (after != null) {
+          throw new GraphQLError4(
+            "'after' cannot be combined with an orderBy that orders through a relation \u2014 a related row's value cannot be encoded into a cursor."
+          );
+        }
+      } else if (!targetPkNames.length) {
+        if (after != null) {
+          throw new GraphQLError4(
+            `Table ${targetTableName} has no primary key, so cursor pagination cannot be used on it.`
+          );
+        }
+      } else {
+        cursorEntries = cursorOrderingEntries(orderByArg, targetPkNames);
+      }
+    }
+    const cursorValues = after != null && cursorEntries ? decodeCursor(after, cursorEntries) : void 0;
     const argsKey = JSON.stringify({
       where: whereArg ?? null,
       orderBy: orderByArg ?? null,
       limit: limit ?? null,
-      offset: offset ?? null
+      offset: offset ?? null,
+      after: after ?? null,
+      distinct: distinct ?? null,
+      cursor: cursorEntries ? 1 : 0
     });
     const loaderKey = `${tableName}::${relationName}::${argsKey}`;
     const loader = getOrCreateLoader(context, loaderKey, async (parentIds) => {
       const executor = resolveExecutor(db, context);
       const uniqueIds = [...new Set(parentIds)];
-      const whereCondition = and(
+      let whereCondition = and(
         inArray(foreignCol, uniqueIds),
-        whereArg ? extractFilters(targetTable, targetTableName, whereArg, relationFilterCtx(filterCtx, targetTableName)) : void 0
+        whereArg ? extractFilters(targetTable, targetTableName, whereArg, relationFilterCtx(filterCtx, targetTableName)) : void 0,
+        cursorValues ? buildCursorCondition(targetTable, cursorEntries, cursorValues, nullOrdering) : void 0
       );
+      if (distinct) {
+        const keys = await selectDistinctKeys({
+          db: executor,
+          table: targetTable,
+          tableName: targetTableName,
+          distinct,
+          pkNames: targetPkNames,
+          where: whereCondition,
+          orderBy: orderByArg,
+          partitionBy: [foreignCol]
+        });
+        if (!keys.length) {
+          return parentIds.map(() => isOne ? null : []);
+        }
+        whereCondition = and(whereCondition, primaryKeyRestriction(targetTable, targetPkNames, keys));
+      }
       let rows;
       if (limit != null || offset != null) {
         rows = await batchedPaginatedRelationQuery(
@@ -942,11 +1128,15 @@ var createRelationResolverFactory = (db, tables, filterCtx) => ({ tableName, rel
         );
       } else {
         let q = executor.select().from(targetTable).where(whereCondition);
-        if (orderByArg) {
-          q = q.orderBy(...extractOrderBy(targetTable, orderByArg, relationFilterCtx(filterCtx, targetTableName)));
+        const orderExprs = cursorEntries ? cursorOrderExprs(targetTable, cursorEntries) : orderByArg ? extractOrderBy(targetTable, orderByArg, relationFilterCtx(filterCtx, targetTableName)) : [];
+        if (orderExprs.length) {
+          q = q.orderBy(...orderExprs);
         }
         rows = await q;
       }
+      if (cursorEntries) {
+        attachRowCursors(rows, cursorEntries);
+      }
       if (isOne) {
         const byKey = new Map(rows.map((row) => [String(row[foreignColPropName]), row]));
         remapToGraphQLArrayOutput(rows, targetTableName, targetTable);
@@ -962,6 +1152,22 @@ var createRelationResolverFactory = (db, tables, filterCtx) => ({ tableName, rel
     return loader.load(localValue);
   };
 };
+var columnDocs = (docs, column, tableName, columnName) => {
+  const description = docs.describeColumn?.(column, { tableName, columnName });
+  const deprecationReason = docs.deprecateColumn?.(column, { tableName, columnName });
+  return {
+    ...description !== void 0 ? { description } : {},
+    ...deprecationReason !== void 0 ? { deprecationReason } : {}
+  };
+};
+var inputFieldDocs = (docs, column, tableName, columnName, fieldType) => {
+  const resolved = columnDocs(docs, column, tableName, columnName);
+  if (resolved.deprecationReason !== void 0 && fieldType instanceof GraphQLNonNull3) {
+    const { deprecationReason: _dropped, ...rest } = resolved;
+    return rest;
+  }
+  return resolved;
+};
 var listFieldComplexity = (options) => ({ args, childComplexity }) => {
   const limit = args["limit"];
   const rows = typeof limit === "number" && limit > 0 ? limit : options.defaultListSize;
@@ -969,18 +1175,21 @@ var listFieldComplexity = (options) => ({ args, childComplexity }) => {
 };
 var aggregateFieldComplexity = (options) => ({ childComplexity }) => options.aggregateCost + childComplexity;
 var AGGREGATE_FIELD_SUFFIX = "Aggregate";
-var relationAggregateJoinColumns = (tree, table, selectionCtx) => {
-  const relations = selectionCtx?.relationMap[selectionCtx.tableName];
-  if (!relations || !selectionCtx) {
+var relationJoinColumns = (tree, table, selectionCtx) => {
+  if (!selectionCtx) {
+    return [];
+  }
+  const relations = (selectionCtx.allRelations ?? selectionCtx.relationMap)[selectionCtx.tableName] ?? selectionCtx.relationMap[selectionCtx.tableName];
+  if (!relations) {
     return [];
   }
-  const tableColumns = getColumns(table);
+  const tableColumns = getColumns2(table);
   const needed = [];
   for (const fieldData of Object.values(tree)) {
-    if (tableColumns[fieldData.name] || !fieldData.name.endsWith(AGGREGATE_FIELD_SUFFIX)) {
+    if (tableColumns[fieldData.name]) {
       continue;
     }
-    const relEntry = relations[fieldData.name.slice(0, -AGGREGATE_FIELD_SUFFIX.length)];
+    const relEntry = fieldData.name.endsWith(AGGREGATE_FIELD_SUFFIX) ? relations[fieldData.name.slice(0, -AGGREGATE_FIELD_SUFFIX.length)] : relations[fieldData.name];
     const targetTable = relEntry ? selectionCtx.tables[relEntry.targetTableName] : void 0;
     if (!relEntry || !targetTable) {
       continue;
@@ -993,7 +1202,7 @@ var relationAggregateJoinColumns = (tree, table, selectionCtx) => {
   return needed;
 };
 var extractSelectedColumnsFromTree = (tree, table, selectionCtx) => {
-  const tableColumns = getColumns(table);
+  const tableColumns = getColumns2(table);
   const treeEntries = Object.entries(tree);
   const selectedColumns = [];
   for (const [_fieldName, fieldData] of treeEntries) {
@@ -1002,7 +1211,7 @@ var extractSelectedColumnsFromTree = (tree, table, selectionCtx) => {
     }
     selectedColumns.push([fieldData.name, true]);
   }
-  for (const columnName of relationAggregateJoinColumns(tree, table, selectionCtx)) {
+  for (const columnName of relationJoinColumns(tree, table, selectionCtx)) {
     selectedColumns.push([columnName, true]);
   }
   if (!selectedColumns.length) {
@@ -1013,7 +1222,7 @@ var extractSelectedColumnsFromTree = (tree, table, selectionCtx) => {
   return Object.fromEntries(selectedColumns);
 };
 var extractSelectedColumnsFromTreeSQLFormat = (tree, table, selectionCtx) => {
-  const tableColumns = getColumns(table);
+  const tableColumns = getColumns2(table);
   const treeEntries = Object.entries(tree);
   const selectedColumns = [];
   for (const [_fieldName, fieldData] of treeEntries) {
@@ -1022,7 +1231,7 @@ var extractSelectedColumnsFromTreeSQLFormat = (tree, table, selectionCtx) => {
     }
     selectedColumns.push([fieldData.name, tableColumns[fieldData.name]]);
   }
-  for (const columnName of relationAggregateJoinColumns(tree, table, selectionCtx)) {
+  for (const columnName of relationJoinColumns(tree, table, selectionCtx)) {
     selectedColumns.push([columnName, tableColumns[columnName]]);
   }
   if (!selectedColumns.length) {
@@ -1046,11 +1255,11 @@ var orderNulls = new GraphQLEnumType2({
     }
   }
 });
-var innerOrder = new GraphQLInputObjectType2({
+var innerOrder = new GraphQLInputObjectType3({
   name: "InnerOrder",
   fields: {
     direction: {
-      type: new GraphQLNonNull2(
+      type: new GraphQLNonNull3(
         new GraphQLEnumType2({
           name: "OrderDirection",
           description: "Order by direction",
@@ -1068,7 +1277,7 @@ var innerOrder = new GraphQLInputObjectType2({
       )
     },
     priority: {
-      type: new GraphQLNonNull2(GraphQLInt2),
+      type: new GraphQLNonNull3(GraphQLInt3),
       description: "Priority of current field"
     },
     nulls: {
@@ -1094,9 +1303,9 @@ var resolveGenericFilterDescriptor = (column, columnGraphQLType) => {
   if (columnGraphQLType.type === GraphQLJSON) {
     return { name: "JSON", kind: "json" };
   }
-  if (columnGraphQLType.type instanceof GraphQLList2) {
+  if (columnGraphQLType.type instanceof GraphQLList3) {
     let element = columnGraphQLType.type.ofType;
-    if (element instanceof GraphQLNonNull2) {
+    if (element instanceof GraphQLNonNull3) {
       element = element.ofType;
     }
     return { name: `${element.name}Array`, kind: "array" };
@@ -1120,10 +1329,10 @@ var resolveGenericFilterDescriptor = (column, columnGraphQLType) => {
   if (ct === "PgTimestamp" || ct === "PgTimestampString" || ct === "PgDate") {
     return { name: "DateTime", kind: "scalar" };
   }
-  if (columnGraphQLType.type === GraphQLInt2) {
+  if (columnGraphQLType.type === GraphQLInt3) {
     return { name: "Int", kind: "scalar" };
   }
-  if (columnGraphQLType.type === GraphQLFloat2) {
+  if (columnGraphQLType.type === GraphQLFloat3) {
     return { name: "Float", kind: "scalar" };
   }
   return { name: "String", kind: "scalar" };
@@ -1143,21 +1352,23 @@ var jsonFilterFields = (column, colType) => {
     isNotNull: { type: GraphQLBoolean2 }
   };
 };
-var arrayFilterFields = (colType, colArr, colDesc) => {
+var IN_ARRAY_DESCRIPTION = "Matches any one of these values (SQL `IN`)";
+var NOT_IN_ARRAY_DESCRIPTION = "Matches none of these values (SQL `NOT IN`)";
+var arrayFilterFields = (colType, colArr) => {
   let element = colType.ofType;
-  if (element instanceof GraphQLNonNull2) {
+  if (element instanceof GraphQLNonNull3) {
     element = element.ofType;
   }
-  const elementList = new GraphQLList2(new GraphQLNonNull2(element));
+  const elementList = new GraphQLList3(new GraphQLNonNull3(element));
   return {
-    eq: { type: colType, description: colDesc },
-    ne: { type: colType, description: colDesc },
+    eq: { type: colType, description: "The whole array equals this array" },
+    ne: { type: colType, description: "The whole array differs from this array" },
     has: { type: element, description: "Array contains this element" },
     hasSome: { type: elementList, description: "Array contains at least one of these elements (overlap, `&&`)" },
     hasEvery: { type: elementList, description: "Array contains every one of these elements (containment, `@>`)" },
     isEmpty: { type: GraphQLBoolean2, description: "When true, matches arrays with no elements" },
-    inArray: { type: colArr, description: `Array<${colDesc}>` },
-    notInArray: { type: colArr, description: `Array<${colDesc}>` },
+    inArray: { type: colArr, description: IN_ARRAY_DESCRIPTION },
+    notInArray: { type: colArr, description: NOT_IN_ARRAY_DESCRIPTION },
     isNull: { type: GraphQLBoolean2 },
     isNotNull: { type: GraphQLBoolean2 }
   };
@@ -1165,8 +1376,8 @@ var arrayFilterFields = (colType, colArr, colDesc) => {
 var FILTERS_WITHOUT_STRING_OPS = /* @__PURE__ */ new Set(["Id", "Int", "Float", "BigInt", "Decimal"]);
 var BUILTIN_FILTER_SCALARS = /* @__PURE__ */ new Set([
   GraphQLString2,
-  GraphQLInt2,
-  GraphQLFloat2,
+  GraphQLInt3,
+  GraphQLFloat3,
   GraphQLBoolean2,
   GraphQLBigIntString,
   GraphQLDecimalString,
@@ -1193,18 +1404,17 @@ var generateColumnFilterValues = (column, tableName, columnName, cacheCtx) => {
     return cached;
   }
   const colType = columnGraphQLType.type;
-  const colDesc = columnGraphQLType.description;
-  const colArr = new GraphQLList2(new GraphQLNonNull2(colType));
+  const colArr = new GraphQLList3(new GraphQLNonNull3(colType));
   const customOverrideFilter = inputOverride !== void 0 && !BUILTIN_FILTER_SCALARS.has(inputOverride);
   const underlying = extractExtendedColumnType2(column);
   const omitStringOps = customOverrideFilter ? underlying.type !== "string" || underlying.constraint === "numeric" : FILTERS_WITHOUT_STRING_OPS.has(genericName);
-  const baseFields = kind === "json" ? jsonFilterFields(column, colType) : kind === "array" ? arrayFilterFields(colType, colArr, colDesc) : {
-    eq: { type: colType, description: colDesc },
-    ne: { type: colType, description: colDesc },
-    lt: { type: colType, description: colDesc },
-    lte: { type: colType, description: colDesc },
-    gt: { type: colType, description: colDesc },
-    gte: { type: colType, description: colDesc },
+  const baseFields = kind === "json" ? jsonFilterFields(column, colType) : kind === "array" ? arrayFilterFields(colType, colArr) : {
+    eq: { type: colType, description: "Equal to" },
+    ne: { type: colType, description: "Not equal to" },
+    lt: { type: colType, description: "Less than" },
+    lte: { type: colType, description: "Less than or equal to" },
+    gt: { type: colType, description: "Greater than" },
+    gte: { type: colType, description: "Greater than or equal to" },
     ...omitStringOps ? {} : {
       like: { type: GraphQLString2 },
       notLike: { type: GraphQLString2 },
@@ -1235,21 +1445,21 @@ var generateColumnFilterValues = (column, tableName, columnName, cacheCtx) => {
         description: "Case-insensitive `contains`."
       }
     },
-    inArray: { type: colArr, description: `Array<${colDesc}>` },
-    notInArray: { type: colArr, description: `Array<${colDesc}>` },
-    isNull: { type: GraphQLBoolean2 },
-    isNotNull: { type: GraphQLBoolean2 }
+    inArray: { type: colArr, description: IN_ARRAY_DESCRIPTION },
+    notInArray: { type: colArr, description: NOT_IN_ARRAY_DESCRIPTION },
+    isNull: { type: GraphQLBoolean2, description: "When true, matches rows where the column is NULL" },
+    isNotNull: { type: GraphQLBoolean2, description: "When true, matches rows where the column is not NULL" }
   };
-  const mainType = new GraphQLInputObjectType2({
+  const mainType = new GraphQLInputObjectType3({
     name: `${genericName}Filter`,
     fields: () => ({
       ...baseFields,
       OR: {
-        type: new GraphQLList2(new GraphQLNonNull2(mainType)),
+        type: new GraphQLList3(new GraphQLNonNull3(mainType)),
         description: "At least one branch matches; ANDed with any sibling operators"
       },
       AND: {
-        type: new GraphQLList2(new GraphQLNonNull2(mainType)),
+        type: new GraphQLList3(new GraphQLNonNull3(mainType)),
         description: "Every branch matches"
       },
       NOT: {
@@ -1268,7 +1478,7 @@ var generateTableOrderCached = (table) => {
   }
   let remapped = {};
   try {
-    const columns = getColumns(table);
+    const columns = getColumns2(table);
     const columnEntries = Object.entries(columns);
     remapped = Object.fromEntries(
       columnEntries.map(([columnName, _columnDescription]) => [columnName, { type: innerOrder }])
@@ -1282,13 +1492,17 @@ var generateTableFilterValuesCached = (table, tableName, cacheCtx) => {
   if (cacheCtx.filterFieldCache.has(table)) {
     return cacheCtx.filterFieldCache.get(table);
   }
-  const columns = getColumns(table);
+  const columns = getColumns2(table);
   const columnEntries = Object.entries(columns);
   const remapped = Object.fromEntries(
-    columnEntries.map(([columnName, columnDescription]) => [
+    columnEntries.map(([columnName, column]) => [
       columnName,
       {
-        type: generateColumnFilterValues(columnDescription, tableName, columnName, cacheCtx)
+        type: generateColumnFilterValues(column, tableName, columnName, cacheCtx),
+        // A filter field is the same column, so it carries the same documentation. Deprecation
+        // is not propagated: filtering on a deprecated column is how a caller finds the rows
+        // that still use it.
+        ...cacheCtx.docs.describeColumn ? { description: cacheCtx.docs.describeColumn(column, { tableName, columnName }) } : {}
       }
     ])
   );
@@ -1299,12 +1513,15 @@ var generateTableSelectTypeFieldsCached = (table, tableName, cacheCtx) => {
   if (cacheCtx.selectFieldCache.has(table)) {
     return cacheCtx.selectFieldCache.get(table);
   }
-  const columns = getColumns(table);
+  const columns = getColumns2(table);
   const columnEntries = Object.entries(columns);
   const remapped = Object.fromEntries(
-    columnEntries.map(([columnName, columnDescription]) => [
+    columnEntries.map(([columnName, column]) => [
       columnName,
-      drizzleColumnToGraphQLType(columnDescription, columnName, tableName)
+      {
+        ...drizzleColumnToGraphQLType(column, columnName, tableName),
+        ...columnDocs(cacheCtx.docs, column, tableName, columnName)
+      }
     ])
   );
   if (!remapped[CURSOR_FIELD_NAME]) {
@@ -1351,7 +1568,7 @@ var generateTableOrderTypeCached = (table, tableName, typeNameMapper, cacheCtx,
   if (cacheCtx.orderTypeCache.has(table)) {
     return cacheCtx.orderTypeCache.get(table);
   }
-  const order = new GraphQLInputObjectType2({
+  const order = new GraphQLInputObjectType3({
     name: `${resolveTypeName(tableName, typeNameMapper)}OrderBy`,
     fields: () => {
       const orderColumns = generateTableOrderCached(table);
@@ -1369,7 +1586,7 @@ var generateListRelationFilterCached = (targetTable, targetTableName, cacheCtx,
   if (cached) {
     return cached;
   }
-  const listFilter = new GraphQLInputObjectType2({
+  const listFilter = new GraphQLInputObjectType3({
     name: `${resolveTypeName(targetTableName, typeNameMapper)}ListRelationFilter`,
     fields: () => {
       const targetFilters = generateTableFilterTypeCached(
@@ -1439,16 +1656,16 @@ var generateTableFilterTypeCached = (table, tableName, cacheCtx, typeNameMapper,
       ...generateRelationFilterFields(tableName, cacheCtx, typeNameMapper, filterColumns, relationMap, tables)
     };
   };
-  const filters = new GraphQLInputObjectType2({
+  const filters = new GraphQLInputObjectType3({
     name: `${resolveTypeName(tableName, typeNameMapper)}Filters`,
     fields: () => ({
       ...buildFields(),
       OR: {
-        type: new GraphQLList2(new GraphQLNonNull2(filters)),
+        type: new GraphQLList3(new GraphQLNonNull3(filters)),
         description: "At least one branch matches; ANDed with any sibling fields"
       },
       AND: {
-        type: new GraphQLList2(new GraphQLNonNull2(filters)),
+        type: new GraphQLList3(new GraphQLNonNull3(filters)),
         description: "Every branch matches"
       },
       NOT: {
@@ -1501,6 +1718,7 @@ var generateSelectFields = (tables, tableName, relationMap, fromTableName, fromR
     const typeName = resolveTypeName(tableName, typeNameMapper);
     const shell = new GraphQLObjectType2({
       name: typeName,
+      description: cacheCtx.docs.describeTable?.(tableName),
       fields: () => ({ ...tableFields, ...container.fields })
     });
     cacheCtx.objectTypeCache.set(tableName, shell);
@@ -1542,36 +1760,47 @@ var generateSelectFields = (tables, tableName, relationMap, fromTableName, fromR
         const capturedTargetContainer = targetContainer;
         relType = new GraphQLObjectType2({
           name: resolveTypeName(targetTableName, typeNameMapper),
+          description: cacheCtx.docs.describeTable?.(targetTableName),
           fields: () => ({ ...targetTableFields, ...capturedTargetContainer.fields })
         });
         cacheCtx.objectTypeCache.set(targetTableName, relType);
       }
       const resolve = resolverFactory?.({ tableName, relationName, relEntry, isOne });
+      const relationDescription = cacheCtx.docs.describeRelation?.(tableName, relationName);
+      const relationDocs = relationDescription !== void 0 ? { description: relationDescription } : {};
       if (isOne) {
         const isRequired = relation.optional === false;
         rawRelationFields.push([
           relationName,
           {
-            type: isRequired ? new GraphQLNonNull2(relType) : relType,
+            type: isRequired ? new GraphQLNonNull3(relType) : relType,
             args: {
               where: { type: relSelectData.filters }
             },
-            resolve
+            resolve,
+            ...relationDocs
           }
         ]);
         continue;
       }
+      const targetDistinctEnum = cacheCtx.features.distinct ? generateDistinctEnum(tables[targetTableName], resolveTypeName(targetTableName, typeNameMapper)) : void 0;
       rawRelationFields.push([
         relationName,
         {
-          type: new GraphQLNonNull2(new GraphQLList2(new GraphQLNonNull2(relType))),
+          type: new GraphQLNonNull3(new GraphQLList3(new GraphQLNonNull3(relType))),
           args: {
             where: { type: relSelectData.filters },
             orderBy: { type: relSelectData.order },
-            offset: { type: GraphQLInt2 },
-            limit: { type: GraphQLInt2 }
+            offset: { type: GraphQLInt3 },
+            limit: { type: GraphQLInt3 },
+            after: {
+              type: GraphQLString2,
+              description: "Keyset pagination: only return related rows strictly after this cursor (a row's `cursor` field from a previous page of this relation, under the same orderBy)."
+            },
+            ...targetDistinctEnum ? { distinct: { type: new GraphQLList3(new GraphQLNonNull3(targetDistinctEnum)) } } : {}
           },
           resolve,
+          ...relationDocs,
           ...cacheCtx.complexity ? { extensions: { complexity: listFieldComplexity(cacheCtx.complexity) } } : {}
         }
       ]);
@@ -1586,7 +1815,7 @@ var generateSelectFields = (tables, tableName, relationMap, fromTableName, fromR
           rawRelationFields.push([
             aggregateFieldName,
             {
-              type: new GraphQLNonNull2(relationAggregate.type),
+              type: new GraphQLNonNull3(relationAggregate.type),
               args: {
                 where: { type: relSelectData.filters }
               },
@@ -1619,7 +1848,7 @@ var generateSelectFields = (tables, tableName, relationMap, fromTableName, fromR
     relationFields: {}
   };
 };
-var generateTableTypes = (tableName, tables, relationMap, withReturning, relationsDepthLimit, cacheCtx, typeNameMapper = void 0, insertPrefix = "create", updatePrefix = "update", resolverFactory, relationAggregateFactory) => {
+var generateTableTypes = (tableName, tables, relationMap, withReturning, relationsDepthLimit, cacheCtx, typeNameMapper = void 0, insertPrefix = "create", updatePrefix = "update", resolverFactory, relationAggregateFactory, nestedWrites) => {
   const { tableFields, relationFields, filters, order } = generateSelectFields(
     tables,
     tableName,
@@ -1638,36 +1867,51 @@ var generateTableTypes = (tableName, tables, relationMap, withReturning, relatio
     relationAggregateFactory
   );
   const table = tables[tableName];
-  const columns = getColumns(table);
+  const columns = getColumns2(table);
   const columnEntries = Object.entries(columns);
+  const relaxedColumns = nestedWrites?.relaxedColumns(tableName);
   const insertFields = Object.fromEntries(
-    columnEntries.map(([columnName, columnDescription]) => [
-      columnName,
-      drizzleColumnToGraphQLType(columnDescription, columnName, tableName, false, true, true)
-    ])
+    columnEntries.map(([columnName, column]) => {
+      const converted = drizzleColumnToGraphQLType(
+        column,
+        columnName,
+        tableName,
+        !!relaxedColumns?.has(columnName),
+        true,
+        true
+      );
+      return [
+        columnName,
+        { ...converted, ...inputFieldDocs(cacheCtx.docs, column, tableName, columnName, converted.type) }
+      ];
+    })
   );
   const updateFields = Object.fromEntries(
-    columnEntries.map(([columnName, columnDescription]) => [
-      columnName,
-      drizzleColumnToGraphQLType(columnDescription, columnName, tableName, true, false, true)
-    ])
+    columnEntries.map(([columnName, column]) => {
+      const converted = drizzleColumnToGraphQLType(column, columnName, tableName, true, false, true);
+      const operations = cacheCtx.features.fieldUpdateOperations ? fieldUpdateInputType(column, columnName, tableName) : void 0;
+      const field = operations ? { ...converted, type: operations } : converted;
+      return [columnName, { ...field, ...inputFieldDocs(cacheCtx.docs, column, tableName, columnName, field.type) }];
+    })
   );
-  const insertInput = new GraphQLInputObjectType2({
-    name: `${capitalize(insertPrefix)}${resolveTypeName(tableName, typeNameMapper)}Input`,
-    fields: insertFields
+  const typeName = resolveTypeName(tableName, typeNameMapper);
+  const insertInput = new GraphQLInputObjectType3({
+    name: `${capitalize(insertPrefix)}${typeName}Input`,
+    fields: nestedWrites ? () => ({ ...insertFields, ...nestedWrites.createFields(tableName, typeName) }) : insertFields
   });
-  const updateInput = new GraphQLInputObjectType2({
-    name: `${capitalize(updatePrefix)}${resolveTypeName(tableName, typeNameMapper)}Input`,
-    fields: updateFields
+  const updateInput = new GraphQLInputObjectType3({
+    name: `${capitalize(updatePrefix)}${typeName}Input`,
+    fields: nestedWrites ? () => ({ ...updateFields, ...nestedWrites.updateFields(tableName, typeName) }) : updateFields
   });
   const selectSingleOutput = cacheCtx.objectTypeCache.get(tableName) ?? new GraphQLObjectType2({
     name: resolveTypeName(tableName, typeNameMapper),
+    description: cacheCtx.docs.describeTable?.(tableName),
     fields: { ...tableFields, ...relationFields }
   });
-  const selectArrOutput = new GraphQLNonNull2(new GraphQLList2(new GraphQLNonNull2(selectSingleOutput)));
+  const selectArrOutput = new GraphQLNonNull3(new GraphQLList3(new GraphQLNonNull3(selectSingleOutput)));
   const arrTableItemOutput = withReturning ? (
     //     ? new GraphQLNonNull(new GraphQLList(new GraphQLNonNull(singleTableItemOutput!)))
-    new GraphQLNonNull2(new GraphQLList2(new GraphQLNonNull2(selectSingleOutput)))
+    new GraphQLNonNull3(new GraphQLList3(new GraphQLNonNull3(selectSingleOutput)))
   ) : void 0;
   const inputs = {
     insertInput,
@@ -1692,7 +1936,7 @@ var generateTableTypes = (tableName, tables, relationMap, withReturning, relatio
 };
 var orderByEntries = (orderArgs) => Object.entries(orderArgs).sort((a, b) => (b[1]?.priority ?? 0) - (a[1]?.priority ?? 0)).filter(([, config]) => config).map(([column, config]) => {
   if (typeof config === "object" && config.direction === void 0) {
-    throw new GraphQLError3(`ORDER BY ${column}: ordering through a relation is not supported in this query`);
+    throw new GraphQLError4(`ORDER BY ${column}: ordering through a relation is not supported in this query`);
   }
   return [column, config.direction, config.nulls ?? void 0];
 });
@@ -1703,16 +1947,16 @@ var orderExpressions = (expr, direction, nulls, dialectColumn) => {
   }
   const isMySql = (dialectColumn.columnType ?? "").startsWith("MySql");
   if (isMySql) {
-    const nullsKey = nulls === "first" ? desc(sql`(${expr} is null)`) : asc(sql`(${expr} is null)`);
+    const nullsKey = nulls === "first" ? desc(sql2`(${expr} is null)`) : asc(sql2`(${expr} is null)`);
     return [nullsKey, directed];
   }
-  return [nulls === "first" ? sql`${directed} nulls first` : sql`${directed} nulls last`];
+  return [nulls === "first" ? sql2`${directed} nulls first` : sql2`${directed} nulls last`];
 };
 var extendRelationOrderChain = (parentTable, relationName, relEntry, ctx, chain) => {
   const targetTable = ctx.tables[relEntry.targetTableName];
   const relation = relEntry.relation ?? relEntry;
   if (!targetTable || !is3(relation, One2) || !isFilterableRelation(relation)) {
-    throw new GraphQLError3(`ORDER BY ${relationName}: Relation cannot be used for ordering`);
+    throw new GraphQLError4(`ORDER BY ${relationName}: Relation cannot be used for ordering`);
   }
   ctx.aliases ??= { n: 0 };
   const aliasedTarget = aliasedTable(targetTable, `dgql_ord_${ctx.aliases.n++}`);
@@ -1729,7 +1973,7 @@ var extendRelationOrderChain = (parentTable, relationName, relEntry, ctx, chain)
   };
 };
 var collectOrderEntries = (table, tableKey, orderArgs, ctx, chain, out) => {
-  const columns = getColumns(table);
+  const columns = getColumns2(table);
   const relations = ctx?.relationMap[tableKey];
   for (const [key, config] of Object.entries(orderArgs)) {
     if (config === null || config === void 0) {
@@ -1738,7 +1982,7 @@ var collectOrderEntries = (table, tableKey, orderArgs, ctx, chain, out) => {
     const column = columns[key];
     if (column) {
       out.push({
-        expression: chain ? sql`(select ${column} from ${sql.join(chain.fromParts, sql`, `)} where ${and(...chain.conditions)})` : column,
+        expression: chain ? sql2`(select ${column} from ${sql2.join(chain.fromParts, sql2`, `)} where ${and(...chain.conditions)})` : column,
         column,
         direction: config.direction,
         nulls: config.nulls ?? void 0,
@@ -1748,7 +1992,7 @@ var collectOrderEntries = (table, tableKey, orderArgs, ctx, chain, out) => {
     }
     const relEntry = relations?.[key];
     if (!relEntry || !ctx) {
-      throw new GraphQLError3(`ORDER BY ${key}: Unknown column or relation`);
+      throw new GraphQLError4(`ORDER BY ${key}: Unknown column or relation`);
     }
     const nextChain = extendRelationOrderChain(chain?.table ?? table, key, relEntry, ctx, chain);
     collectOrderEntries(nextChain.table, relEntry.targetTableName, config, ctx, nextChain, out);
@@ -1771,21 +2015,21 @@ var safeLikeOps = {
 };
 var safeLikeCondition = (column, pattern, insensitive) => {
   if (!insensitive) {
-    return sql`${column} like ${pattern} escape ${LIKE_ESCAPE_CHAR}`;
+    return sql2`${column} like ${pattern} escape ${LIKE_ESCAPE_CHAR}`;
   }
   const isPg = (column.columnType ?? "").startsWith("Pg");
-  return isPg ? sql`${column} ilike ${pattern} escape ${LIKE_ESCAPE_CHAR}` : sql`lower(${column}) like ${pattern.toLowerCase()} escape ${LIKE_ESCAPE_CHAR}`;
+  return isPg ? sql2`${column} ilike ${pattern} escape ${LIKE_ESCAPE_CHAR}` : sql2`lower(${column}) like ${pattern.toLowerCase()} escape ${LIKE_ESCAPE_CHAR}`;
 };
 var isJsonColumn2 = (column) => (column.columnType ?? "").includes("Json");
 var jsonContains = (column, columnName, value) => {
   const serialized = JSON.stringify(value);
   switch (columnDialect(column)) {
     case "pg":
-      return column.columnType === "PgJson" ? sql`${column}::jsonb @> ${serialized}::jsonb` : sql`${column} @> ${serialized}::jsonb`;
+      return column.columnType === "PgJson" ? sql2`${column}::jsonb @> ${serialized}::jsonb` : sql2`${column} @> ${serialized}::jsonb`;
     case "mysql":
-      return sql`json_contains(${column}, ${serialized})`;
+      return sql2`json_contains(${column}, ${serialized})`;
     default:
-      throw new GraphQLError3(`WHERE ${columnName}: Operator 'contains' is not supported for this dialect!`);
+      throw new GraphQLError4(`WHERE ${columnName}: Operator 'contains' is not supported for this dialect!`);
   }
 };
 var extractFiltersColumn = (column, columnName, operators) => {
@@ -1816,7 +2060,7 @@ var extractFiltersColumn = (column, columnName, operators) => {
       variants.push(safeLikeCondition(column, buildPattern(operatorValue), insensitive));
     } else if (operatorName in arrayValueOps) {
       if (!operatorValue.length) {
-        throw new GraphQLError3(`WHERE ${columnName}: Unable to use operator ${operatorName} with an empty array!`);
+        throw new GraphQLError4(`WHERE ${columnName}: Unable to use operator ${operatorName} with an empty array!`);
       }
       const arrayValue = operatorValue.map((val) => remapFromGraphQLCore(val, column, columnName));
       variants.push(arrayValueOps[operatorName](column, arrayValue));
@@ -1824,15 +2068,15 @@ var extractFiltersColumn = (column, columnName, operators) => {
       variants.push(arrayContains(column, [operatorValue]));
     } else if (operatorName in arrayMembershipOps) {
       if (!operatorValue.length) {
-        throw new GraphQLError3(`WHERE ${columnName}: Unable to use operator ${operatorName} with an empty array!`);
+        throw new GraphQLError4(`WHERE ${columnName}: Unable to use operator ${operatorName} with an empty array!`);
       }
       variants.push(arrayMembershipOps[operatorName](column, operatorValue));
     } else if (operatorName === "isEmpty") {
-      variants.push(sql`cardinality(${column}) = 0`);
+      variants.push(sql2`cardinality(${column}) = 0`);
     } else if (operatorName in nullableOps) {
       variants.push(nullableOps[operatorName](column));
     } else {
-      throw new GraphQLError3(`WHERE ${columnName}: Unknown operator: ${operatorName}`);
+      throw new GraphQLError4(`WHERE ${columnName}: Unknown operator: ${operatorName}`);
     }
   }
   if (AND?.length) {
@@ -1868,23 +2112,23 @@ var buildRelationJoinCondition = (parentTable, relation, aliasedTarget, relation
   const sourceColumns = relation.sourceColumns;
   const targetColumns = relation.targetColumns;
   if (!sourceColumns?.length || sourceColumns.length !== targetColumns?.length) {
-    throw new GraphQLError3(`WHERE ${relationName}: Relation cannot be used as a filter`);
+    throw new GraphQLError4(`WHERE ${relationName}: Relation cannot be used as a filter`);
   }
-  const parentColumns = Object.values(getColumns(parentTable));
-  const targetColumnsByName = Object.values(getColumns(aliasedTarget));
+  const parentColumns = Object.values(getColumns2(parentTable));
+  const targetColumnsByName = Object.values(getColumns2(aliasedTarget));
   const conditions = [];
   for (let i = 0; i < sourceColumns.length; i++) {
     const localColumn = parentColumns.find((c) => c.name === sourceColumns[i].name);
     const foreignColumn = targetColumnsByName.find((c) => c.name === targetColumns[i].name);
     if (!localColumn || !foreignColumn) {
-      throw new GraphQLError3(`WHERE ${relationName}: Relation cannot be used as a filter`);
+      throw new GraphQLError4(`WHERE ${relationName}: Relation cannot be used as a filter`);
     }
     conditions.push(eq(localColumn, foreignColumn));
   }
   return conditions.length > 1 ? and(...conditions) : conditions[0];
 };
 var resolveJunctionColumn = (aliasedThrough, junctionRef, relationName) => {
-  const throughColumns = getColumns(aliasedThrough);
+  const throughColumns = getColumns2(aliasedThrough);
   const key = junctionRef?._?.key;
   const byKey = key ? throughColumns[key] : void 0;
   if (byKey) {
@@ -1893,7 +2137,7 @@ var resolveJunctionColumn = (aliasedThrough, junctionRef, relationName) => {
   const columnName = junctionRef?._?.column?.name;
   const byName = columnName ? Object.values(throughColumns).find((c) => c.name === columnName) : void 0;
   if (!byName) {
-    throw new GraphQLError3(`WHERE ${relationName}: Relation cannot be used as a filter`);
+    throw new GraphQLError4(`WHERE ${relationName}: Relation cannot be used as a filter`);
   }
   return byName;
 };
@@ -1902,15 +2146,15 @@ var buildThroughJoinConditions = (parentTable, relation, aliasedThrough, aliased
   const targetColumns = relation.targetColumns;
   const through = relation.through;
   if (!sourceColumns?.length || !targetColumns?.length || through?.source.length !== sourceColumns.length || through.target.length !== targetColumns.length) {
-    throw new GraphQLError3(`WHERE ${relationName}: Relation cannot be used as a filter`);
+    throw new GraphQLError4(`WHERE ${relationName}: Relation cannot be used as a filter`);
   }
-  const parentColumns = Object.values(getColumns(parentTable));
-  const targetTableColumns = Object.values(getColumns(aliasedTarget));
+  const parentColumns = Object.values(getColumns2(parentTable));
+  const targetTableColumns = Object.values(getColumns2(aliasedTarget));
   const correlationConditions = [];
   for (let i = 0; i < sourceColumns.length; i++) {
     const localColumn = parentColumns.find((c) => c.name === sourceColumns[i].name);
     if (!localColumn) {
-      throw new GraphQLError3(`WHERE ${relationName}: Relation cannot be used as a filter`);
+      throw new GraphQLError4(`WHERE ${relationName}: Relation cannot be used as a filter`);
     }
     correlationConditions.push(eq(localColumn, resolveJunctionColumn(aliasedThrough, through.source[i], relationName)));
   }
@@ -1918,7 +2162,7 @@ var buildThroughJoinConditions = (parentTable, relation, aliasedThrough, aliased
   for (let i = 0; i < targetColumns.length; i++) {
     const foreignColumn = targetTableColumns.find((c) => c.name === targetColumns[i].name);
     if (!foreignColumn) {
-      throw new GraphQLError3(`WHERE ${relationName}: Relation cannot be used as a filter`);
+      throw new GraphQLError4(`WHERE ${relationName}: Relation cannot be used as a filter`);
     }
     junctionJoinConditions.push(
       eq(resolveJunctionColumn(aliasedThrough, through.target[i], relationName), foreignColumn)
@@ -1934,7 +2178,7 @@ var buildRelationExists = (parentTable, relationName, relEntry, innerFilters, mo
   const targetTable = ctx.tables[targetTableName];
   const relation = relEntry.relation ?? relEntry;
   if (!targetTable) {
-    throw new GraphQLError3(`WHERE ${relationName}: Relation cannot be used as a filter`);
+    throw new GraphQLError4(`WHERE ${relationName}: Relation cannot be used as a filter`);
   }
   ctx.aliases ??= { n: 0 };
   const aliases = ctx.aliases;
@@ -1951,7 +2195,7 @@ var buildRelationExists = (parentTable, relationName, relEntry, innerFilters, mo
       aliasedTarget,
       relationName
     );
-    fromClause = sql`${getTableAsAliasSQL(aliasedTarget)} inner join ${getTableAsAliasSQL(aliasedThrough)} on ${junctionJoin}`;
+    fromClause = sql2`${getTableAsAliasSQL(aliasedTarget)} inner join ${getTableAsAliasSQL(aliasedThrough)} on ${junctionJoin}`;
     joinCondition = correlation;
   } else {
     fromClause = getTableAsAliasSQL(aliasedTarget);
@@ -1963,10 +2207,10 @@ var buildRelationExists = (parentTable, relationName, relEntry, innerFilters, mo
     if (!inner) {
       return void 0;
     }
-    return sql`not exists (select 1 from ${fromClause} where ${and(joinCondition, relationWhere, not(inner))})`;
+    return sql2`not exists (select 1 from ${fromClause} where ${and(joinCondition, relationWhere, not(inner))})`;
   }
   const condition = and(joinCondition, relationWhere, inner);
-  return mode === "none" ? sql`not exists (select 1 from ${fromClause} where ${condition})` : sql`exists (select 1 from ${fromClause} where ${condition})`;
+  return mode === "none" ? sql2`not exists (select 1 from ${fromClause} where ${condition})` : sql2`exists (select 1 from ${fromClause} where ${condition})`;
 };
 var extractRelationFilter = (parentTable, relationName, relEntry, value, ctx) => {
   const relation = relEntry.relation ?? relEntry;
@@ -1980,7 +2224,7 @@ var extractRelationFilter = (parentTable, relationName, relEntry, value, ctx) =>
       continue;
     }
     if (!relationMatchModes.includes(mode)) {
-      throw new GraphQLError3(`WHERE ${relationName}: Unknown relation filter key: ${mode}`);
+      throw new GraphQLError4(`WHERE ${relationName}: Unknown relation filter key: ${mode}`);
     }
     const extracted = buildRelationExists(parentTable, relationName, relEntry, inner, mode, ctx);
     if (extracted) {
@@ -1992,7 +2236,7 @@ var extractRelationFilter = (parentTable, relationName, relEntry, value, ctx) =>
 var extractFilters = (table, tableName, filters, relationCtx) => {
   const { OR, AND, NOT, ...fieldFilters } = filters;
   const entries = Object.entries(fieldFilters);
-  const columns = getColumns(table);
+  const columns = getColumns2(table);
   const relations = relationCtx?.relationMap[relationCtx.tableKey];
   const variants = [];
   for (const [fieldName, operators] of entries) {
@@ -2001,7 +2245,7 @@ var extractFilters = (table, tableName, filters, relationCtx) => {
     }
     const column = columns[fieldName];
     if (!column && !(relations?.[fieldName] && relationCtx)) {
-      throw new GraphQLError3(`WHERE ${tableName}: Unknown filter key: ${fieldName}`);
+      throw new GraphQLError4(`WHERE ${tableName}: Unknown filter key: ${fieldName}`);
     }
     const extracted = column ? extractFiltersColumn(column, fieldName, operators) : extractRelationFilter(table, fieldName, relations[fieldName], operators, relationCtx);
     if (extracted) {
@@ -2053,15 +2297,27 @@ var extractRelationsParamsInner = (relationMap, tables, tableName, typeName, ori
     if (!field) {
       continue;
     }
+    const selectionCount = Object.values(baseField).reduce(
+      (n, f) => n + (f.name === relName ? 1 : 0),
+      0
+    );
+    if (selectionCount > 1) {
+      continue;
+    }
     const relField = field?.fieldsByTypeName;
     const relFieldSelection = relField?.[relTypeName];
     if (!relFieldSelection) {
       continue;
     }
+    const eagerArgs = field.args;
+    if (!is3(relEntry.relation ?? relEntry, One2) && (eagerArgs?.after != null || !!eagerArgs?.distinct?.length || isCursorFieldSelected(relFieldSelection, tables[targetTableName]))) {
+      continue;
+    }
     const columns = extractSelectedColumnsFromTree(relFieldSelection, tables[targetTableName], {
       tableName: targetTableName,
       relationMap,
-      tables
+      tables,
+      allRelations: filterCtx?.relationMap
     });
     const thisRecord = {};
     thisRecord.columns = columns;
@@ -2109,7 +2365,7 @@ var pruneNonEagerRelations = (relationMap, shouldEagerLoad) => {
   return out;
 };
 var getPrimaryKeyPropNames = (table, compositePkColumnNames) => {
-  const cols = getColumns(table);
+  const cols = getColumns2(table);
   const entries = Object.entries(cols);
   const inlinePks = entries.filter(([, c]) => c.primary).map(([k]) => k);
   if (inlinePks.length) {
@@ -2125,7 +2381,7 @@ var getPrimaryKeyPropNames = (table, compositePkColumnNames) => {
   return [];
 };
 var withPrimaryKeyColumns = (columns, table, pkNames) => {
-  const allCols = getColumns(table);
+  const allCols = getColumns2(table);
   for (const pk of pkNames) {
     if (!(pk in columns) && allCols[pk]) {
       columns[pk] = allCols[pk];
@@ -2138,7 +2394,7 @@ var getPrimaryKeyPropNamesFromConfig = (table, getTableConfig4) => {
   return getPrimaryKeyPropNames(table, compositePkColumnNames);
 };
 var primaryKeyOrderExprs = (table, pkNames) => {
-  const cols = getColumns(table);
+  const cols = getColumns2(table);
   return pkNames.map((n) => cols[n]).filter(Boolean).map((col) => asc(col));
 };
 var CURSOR_FIELD_NAME = "cursor";
@@ -2155,7 +2411,7 @@ var cursorOrderingEntries = (orderBy, pkNames) => {
   return entries;
 };
 var cursorOrderExprs = (table, entries) => {
-  const cols = getColumns(table);
+  const cols = getColumns2(table);
   return entries.flatMap(
     ([column, direction, nulls]) => orderExpressions(cols[column], direction, nulls ?? void 0, cols[column])
   );
@@ -2192,10 +2448,10 @@ var decodeCursor = (after, entries) => {
   try {
     payload = JSON.parse(Buffer.from(after, "base64url").toString("utf8"));
   } catch (_e) {
-    throw new GraphQLError3("Invalid cursor: unable to decode it. Pass a cursor returned by a previous page.");
+    throw new GraphQLError4("Invalid cursor: unable to decode it. Pass a cursor returned by a previous page.");
   }
   if (!payload || typeof payload !== "object" || !Array.isArray(payload.o) || !Array.isArray(payload.v) || payload.o.length !== payload.v.length) {
-    throw new GraphQLError3("Invalid cursor: malformed payload. Pass a cursor returned by a previous page.");
+    throw new GraphQLError4("Invalid cursor: malformed payload. Pass a cursor returned by a previous page.");
   }
   const matchesOrdering = payload.o.length === entries.length && payload.o.every(
     (entry, i) => Array.isArray(entry) && entry[0] === entries[i][0] && entry[1] === entries[i][1] && // The nulls override changes where NULLs sort, so it is part of the ordering identity.
@@ -2203,20 +2459,20 @@ var decodeCursor = (after, entries) => {
     (entry[2] ?? null) === (entries[i][2] ?? null)
   );
   if (!matchesOrdering) {
-    throw new GraphQLError3(
+    throw new GraphQLError4(
       "Invalid cursor: it was issued for a different ordering. Pass the same orderBy the cursor's page used."
     );
   }
   return payload.v.map(decodeCursorValue);
 };
 var buildCursorCondition = (table, entries, values, nullOrdering) => {
-  const cols = getColumns(table);
+  const cols = getColumns2(table);
   const disjuncts = [];
   const equalities = [];
   entries.forEach(([column, direction, nulls], i) => {
     const col = cols[column];
     if (!col) {
-      throw new GraphQLError3(`Invalid cursor: unknown column '${column}'.`);
+      throw new GraphQLError4(`Invalid cursor: unknown column '${column}'.`);
     }
     const value = values[i];
     const nullsSortLast = nulls != null ? nulls === "last" : direction === "asc" === (nullOrdering === "nulls-largest");
@@ -2233,7 +2489,7 @@ var buildCursorCondition = (table, entries, values, nullOrdering) => {
     equalities.push(value === null || value === void 0 ? isNull(col) : eq(col, value));
   });
   if (!disjuncts.length) {
-    return sql`1 = 0`;
+    return sql2`1 = 0`;
   }
   return disjuncts.length > 1 ? or(...disjuncts) : disjuncts[0];
 };
@@ -2241,11 +2497,33 @@ var isCursorFieldSelected = (tree, table) => {
   if (!tree) {
     return false;
   }
-  if (getColumns(table)[CURSOR_FIELD_NAME]) {
+  if (getColumns2(table)[CURSOR_FIELD_NAME]) {
     return false;
   }
   return Object.values(tree).some((field) => field.name === CURSOR_FIELD_NAME);
 };
+var selectsCursorField = (info, table) => {
+  if (getColumns2(table)[CURSOR_FIELD_NAME]) {
+    return false;
+  }
+  const visited = /* @__PURE__ */ new Set();
+  const walk = (selections) => selections.some((selection) => {
+    if (selection.kind === "Field") {
+      return selection.name.value === CURSOR_FIELD_NAME;
+    }
+    if (selection.kind === "InlineFragment") {
+      return walk(selection.selectionSet.selections);
+    }
+    const name = selection.name?.value;
+    if (!name || visited.has(name)) {
+      return false;
+    }
+    visited.add(name);
+    const fragment = info.fragments?.[name];
+    return fragment ? walk(fragment.selectionSet.selections) : false;
+  });
+  return (info.fieldNodes ?? []).some((node) => !!node.selectionSet && walk(node.selectionSet.selections));
+};
 var attachRowCursors = (rows, entries) => {
   for (const row of rows) {
     row[ROW_CURSOR_PROP] = encodeCursor(entries, row);
@@ -2253,7 +2531,7 @@ var attachRowCursors = (rows, entries) => {
 };
 var rowCursorResolver = (source) => source?.[ROW_CURSOR_PROP] ?? null;
 var getUniqueColumnSets = (table, getTableConfig4) => {
-  const cols = getColumns(table);
+  const cols = getColumns2(table);
   const propNameByColumnName = new Map(Object.entries(cols).map(([propName, col]) => [col.name, propName]));
   const toPropNames = (columnNames) => {
     const propNames = [];
@@ -2298,7 +2576,7 @@ var generateColumnEnum = (table, enumName, description, predicate = () => true)
   if (cached) {
     return cached;
   }
-  const columnNames = Object.entries(getColumns(table)).filter(([columnName, column]) => predicate(column, columnName)).map(([columnName]) => columnName);
+  const columnNames = Object.entries(getColumns2(table)).filter(([columnName, column]) => predicate(column, columnName)).map(([columnName]) => columnName);
   if (!columnNames.length) {
     return void 0;
   }
@@ -2340,7 +2618,7 @@ var generateOnConflictInput = (params) => {
       description: "Whether a conflicting row is overwritten or left alone. Defaults to UPDATE."
     },
     update: {
-      type: new GraphQLList2(new GraphQLNonNull2(updateEnum)),
+      type: new GraphQLList3(new GraphQLNonNull3(updateEnum)),
       description: "Columns to overwrite on conflict. Defaults to every column the request supplied, minus the conflict target. Columns the request did not supply cannot be listed here \u2014 there would be no value to write."
     }
   };
@@ -2356,7 +2634,7 @@ var generateOnConflictInput = (params) => {
       return void 0;
     }
     fields["target"] = {
-      type: new GraphQLList2(new GraphQLNonNull2(targetEnum)),
+      type: new GraphQLList3(new GraphQLNonNull3(targetEnum)),
       description: "The unique column set a conflict is detected on. Must match one of the table\u2019s unique constraints exactly. Defaults to the primary key."
     };
     fields["where"] = {
@@ -2364,7 +2642,7 @@ var generateOnConflictInput = (params) => {
       description: "Only overwrite conflicting rows that match this filter. Others are left alone."
     };
   }
-  return new GraphQLInputObjectType2({
+  return new GraphQLInputObjectType3({
     name: `${typeName}OnConflict`,
     description: `Conflict handling for an upsert of ${typeName}`,
     fields
@@ -2372,18 +2650,18 @@ var generateOnConflictInput = (params) => {
 };
 var resolveConflictPlan = (params) => {
   const { table, values, onConflict, pkNames, uniqueSets, excludedRef, withTarget, buildWhere } = params;
-  const columns = getColumns(table);
+  const columns = getColumns2(table);
   let target;
   if (withTarget) {
     const targetNames2 = onConflict?.target?.length ? onConflict.target : [...pkNames];
     if (!targetNames2.length) {
-      throw new GraphQLError3(
+      throw new GraphQLError4(
         "Unable to upsert: no conflict target was given and this table has no primary key. Pass onConflict.target."
       );
     }
     const requested = [...targetNames2].sort().join(",");
     if (!uniqueSets.some((set2) => [...set2].sort().join(",") === requested)) {
-      throw new GraphQLError3(
+      throw new GraphQLError4(
         `Unable to upsert: [${targetNames2.join(", ")}] is not a unique constraint on this table. Valid conflict targets: ${uniqueSets.map((set2) => `[${set2.join(", ")}]`).join(", ")}.`
       );
     }
@@ -2398,7 +2676,7 @@ var resolveConflictPlan = (params) => {
   if (onConflict?.update?.length) {
     const unsupplied = onConflict.update.filter((name) => !supplied.has(name));
     if (unsupplied.length) {
-      throw new GraphQLError3(
+      throw new GraphQLError4(
         `Unable to upsert: onConflict.update lists ${unsupplied.join(", ")}, which the values do not supply.`
       );
     }
@@ -2413,18 +2691,19 @@ var resolveConflictPlan = (params) => {
   const setWhere = onConflict?.where && buildWhere ? buildWhere(onConflict.where) : void 0;
   return { action: "UPDATE", target, set, setWhere };
 };
-var excludedColumnRef = (columnName) => sql`excluded.${sql.identifier(columnName)}`;
-var mysqlValuesColumnRef = (columnName) => sql`values(${sql.identifier(columnName)})`;
+var excludedColumnRef = (columnName) => sql2`excluded.${sql2.identifier(columnName)}`;
+var mysqlValuesColumnRef = (columnName) => sql2`values(${sql2.identifier(columnName)})`;
 var selectDistinctKeys = async (params) => {
-  const { db, table, tableName, distinct, pkNames, where, orderBy, limit, offset } = params;
-  const cols = getColumns(table);
+  const { db, table, tableName, distinct, pkNames, where, orderBy, limit, offset, partitionBy } = params;
+  const cols = getColumns2(table);
   if (!pkNames.length) {
-    throw new GraphQLError3(`Table ${tableName} has no primary key, so 'distinct' cannot be applied to it.`);
+    throw new GraphQLError4(`Table ${tableName} has no primary key, so 'distinct' cannot be applied to it.`);
   }
-  const partitionCols = distinct.map((name) => cols[name]).filter(Boolean);
-  if (!partitionCols.length) {
-    throw new GraphQLError3(`No known columns were given to 'distinct' on ${tableName}.`);
+  const requestedCols = distinct.map((name) => cols[name]).filter(Boolean);
+  if (!requestedCols.length) {
+    throw new GraphQLError4(`No known columns were given to 'distinct' on ${tableName}.`);
   }
+  const partitionCols = [...partitionBy ?? [], ...requestedCols];
   const orderEntries = orderBy ? orderByEntries(orderBy) : [];
   const windowOrder = [
     ...orderEntries.flatMap(
@@ -2432,9 +2711,9 @@ var selectDistinctKeys = async (params) => {
     ),
     ...primaryKeyOrderExprs(table, pkNames)
   ];
-  const rowNumber = sql`row_number() over (partition by ${sql.join(partitionCols, sql`, `)} order by ${sql.join(
+  const rowNumber = sql2`row_number() over (partition by ${sql2.join(partitionCols, sql2`, `)} order by ${sql2.join(
     windowOrder,
-    sql`, `
+    sql2`, `
   )})`.as(DISTINCT_RN);
   const sub = db.select({ ...cols, [DISTINCT_RN]: rowNumber }).from(table).where(where).as("__dgql_distinct");
   const outerOrder = [
@@ -2453,7 +2732,7 @@ var selectDistinctKeys = async (params) => {
   return await query;
 };
 var primaryKeyRestriction = (table, pkNames, keys) => {
-  const cols = getColumns(table);
+  const cols = getColumns2(table);
   if (pkNames.length === 1) {
     const name = pkNames[0];
     return inArray(
@@ -2476,17 +2755,17 @@ var prepareMutationRelationColumns = (params) => {
   return { columns, hasRelations, withParams };
 };
 var toGraphQLError = (e) => {
-  if (e instanceof GraphQLError3) {
+  if (e instanceof GraphQLError4) {
     return e;
   }
-  return e instanceof Error ? new GraphQLError3(e.message, { originalError: e }) : e;
+  return e instanceof Error ? new GraphQLError4(e.message, { originalError: e }) : e;
 };
 var defaultErrorMapper = (error) => {
-  if (error instanceof GraphQLError3 && !error.originalError) {
+  if (error instanceof GraphQLError4 && !error.originalError) {
     return error;
   }
-  return new GraphQLError3("Internal server error", {
-    originalError: error instanceof GraphQLError3 ? error.originalError ?? error : error instanceof Error ? error : null,
+  return new GraphQLError4("Internal server error", {
+    originalError: error instanceof GraphQLError4 ? error.originalError ?? error : error instanceof Error ? error : null,
     extensions: { code: "INTERNAL_SERVER_ERROR" }
   });
 };
@@ -2543,6 +2822,9 @@ var computeResolverFieldNames = (tableName, typeNameMapper, prefixes, suffixes)
   const writeSingleSuffix = suffixes.single === "" ? "Single" : suffixes.single;
   const updateSingleFieldName = `${updateFieldName}${writeSingleSuffix}`;
   const deleteSingleFieldName = `${deleteFieldName}${writeSingleSuffix}`;
+  const pluralNoun = mapped ? capitalize(mapped.plural) : capitalize(tableName);
+  const updateCountFieldName = `${prefixes.update}${pluralNoun}Count`;
+  const deleteCountFieldName = `${prefixes.delete}${pluralNoun}Count`;
   return {
     typeName,
     listFieldName,
@@ -2556,13 +2838,15 @@ var computeResolverFieldNames = (tableName, typeNameMapper, prefixes, suffixes)
     updateFieldName,
     updateManyFieldName,
     updateSingleFieldName,
+    updateCountFieldName,
     deleteFieldName,
-    deleteSingleFieldName
+    deleteSingleFieldName,
+    deleteCountFieldName
   };
 };
 var generateUpdateManyInput = (params) => {
   const { typeName, updatePrefix, updateInput, tableFilters } = params;
-  return new GraphQLInputObjectType2({
+  return new GraphQLInputObjectType3({
     name: `${capitalize(updatePrefix)}${typeName}ManyInput`,
     description: `One entry of a batch update of ${typeName}: the rows \`where\` matches get this entry's \`set\` applied.`,
     fields: {
@@ -2571,7 +2855,7 @@ var generateUpdateManyInput = (params) => {
         description: "Rows this entry updates. An omitted filter updates every row."
       },
       set: {
-        type: new GraphQLNonNull2(updateInput)
+        type: new GraphQLNonNull3(updateInput)
       }
     }
   });
@@ -2579,29 +2863,101 @@ var generateUpdateManyInput = (params) => {
 var extractRequiredFilters = (table, tableName, where, fieldName, relationCtx) => {
   const filters = where ? extractFilters(table, tableName, where, relationCtx) : void 0;
   if (!filters) {
-    throw new GraphQLError3(`${fieldName} requires a 'where' argument with at least one filter!`);
+    throw new GraphQLError4(`${fieldName} requires a 'where' argument with at least one filter!`);
   }
   return filters;
 };
+var rowsAffected = (result, fieldName) => {
+  const asNumber = (value) => typeof value === "number" ? value : typeof value === "bigint" ? Number(value) : void 0;
+  if (result && typeof result === "object") {
+    for (const key of ["rowCount", "affectedRows", "rowsAffected", "changes", "count"]) {
+      const value = asNumber(result[key]);
+      if (value !== void 0) {
+        return value;
+      }
+    }
+    const header = Array.isArray(result) ? result[0] : void 0;
+    const affected = header && typeof header === "object" ? asNumber(header.affectedRows) : void 0;
+    if (affected !== void 0) {
+      return affected;
+    }
+  }
+  throw new GraphQLError4(`${fieldName}: the driver did not report how many rows the write affected.`);
+};
 var assertSingleMatch = async (executor, table, filters, fieldName) => {
-  const matched = await executor.select({ found: sql`1` }).from(table).where(filters).limit(2);
+  const matched = await executor.select({ found: sql2`1` }).from(table).where(filters).limit(2);
   if (matched.length > 1) {
-    throw new GraphQLError3(`${fieldName}: 'where' matched more than one row \u2014 nothing was written!`);
-  }
+    throw new GraphQLError4(`${fieldName}: 'where' matched more than one row \u2014 nothing was written!`);
+  }
+};
+var generateWriteCount = ({
+  db,
+  tableName,
+  table,
+  kind,
+  setArgs,
+  filterArgs,
+  fieldName,
+  requireWhere,
+  filterCtx,
+  txCtx,
+  nested
+}) => {
+  const queryArgs = {
+    ...setArgs ? { set: { type: new GraphQLNonNull3(setArgs) } } : {},
+    where: {
+      type: requireWhere ? new GraphQLNonNull3(filterArgs) : filterArgs
+    }
+  };
+  return {
+    name: fieldName,
+    resolver: async (_source, args, context, info) => {
+      try {
+        return await runMutation(db, context, info, txCtx, async (executor) => {
+          const { where, set } = args;
+          const relationCtx = relationFilterCtx(filterCtx, tableName);
+          const filters = requireWhere ? extractRequiredFilters(table, tableName, where, fieldName, relationCtx) : where ? extractFilters(table, tableName, where, relationCtx) : void 0;
+          let query;
+          if (kind === "delete") {
+            query = executor.delete(table);
+          } else {
+            const entry = nested?.enabled(tableName) ? nested.split(tableName, set) : void 0;
+            if (entry && nested.hasOps(entry.ops)) {
+              throw new GraphQLError4(
+                `${fieldName} does not support nested writes \u2014 use ${fieldName.slice(0, -"Count".length)} instead.`
+              );
+            }
+            const values = remapUpdateInput(entry ? entry.columns : set, table, tableName);
+            if (!Object.keys(values).length) {
+              throw new GraphQLError4("Unable to update with no values specified!");
+            }
+            query = executor.update(table).set(values);
+          }
+          if (filters) {
+            query = query.where(filters);
+          }
+          return rowsAffected(await query, fieldName);
+        });
+      } catch (e) {
+        throw toGraphQLError(e);
+      }
+    },
+    args: queryArgs
+  };
 };
 var selectArrayArgs = (orderArgs, filterArgs, distinctEnum) => ({
-  offset: { type: GraphQLInt2 },
-  limit: { type: GraphQLInt2 },
+  offset: { type: GraphQLInt3 },
+  limit: { type: GraphQLInt3 },
   orderBy: { type: orderArgs },
   where: { type: filterArgs },
   after: {
     type: GraphQLString2,
     description: "Keyset pagination: only return rows strictly after this cursor (a row's `cursor` field from a previous page, under the same orderBy)."
   },
-  ...distinctEnum ? { distinct: { type: new GraphQLList2(new GraphQLNonNull2(distinctEnum)) } } : {}
+  ...distinctEnum ? { distinct: { type: new GraphQLList3(new GraphQLNonNull3(distinctEnum)) } } : {}
 });
 var selectSingleArgs = (orderArgs, filterArgs) => ({
-  offset: { type: GraphQLInt2 },
+  offset: { type: GraphQLInt3 },
   orderBy: { type: orderArgs },
   where: { type: filterArgs }
 });
@@ -2628,17 +2984,17 @@ var runRelationalSelect = async (opts) => {
   let cursorEntries;
   if (!single && (after != null || cursorSelected)) {
     if (after != null && distinct) {
-      throw new GraphQLError3("'after' cannot be combined with 'distinct'.");
+      throw new GraphQLError4("'after' cannot be combined with 'distinct'.");
     }
     if (orderByHasRelationEntry(orderBy)) {
       if (after != null) {
-        throw new GraphQLError3(
+        throw new GraphQLError4(
           "'after' cannot be combined with an orderBy that orders through a relation \u2014 a related row's value cannot be encoded into a cursor."
         );
       }
     } else if (!pkNames?.length) {
       if (after != null) {
-        throw new GraphQLError3(`Table ${tableName} has no primary key, so cursor pagination cannot be used on it.`);
+        throw new GraphQLError4(`Table ${tableName} has no primary key, so cursor pagination cannot be used on it.`);
       }
     } else {
       cursorEntries = cursorOrderingEntries(orderBy, pkNames);
@@ -2667,7 +3023,8 @@ var runRelationalSelect = async (opts) => {
     columns: extractSelectedColumnsFromTree(parsedInfo.fieldsByTypeName[typeName], table, {
       tableName,
       relationMap,
-      tables
+      tables,
+      allRelations: filterCtx?.relationMap
     }),
     offset: distinctKeys ? void 0 : offset,
     // drizzle-orm v1 RQB calls orderBy/where with the aliased table proxy — use it
@@ -2734,20 +3091,20 @@ var eagerLoadMutationRelations = async (db, tableName, rows, pkNames, withParams
     whereRaw = (aliased) => inArray(aliased[pkName], ids);
   } else {
     whereRaw = (aliased) => {
-      const lhs = sql.join(
-        pkNames.map((n) => sql`${aliased[n]}`),
-        sql`, `
+      const lhs = sql2.join(
+        pkNames.map((n) => sql2`${aliased[n]}`),
+        sql2`, `
       );
-      const tuples = sql.join(
+      const tuples = sql2.join(
         keyableRows.map(
-          (row) => sql`(${sql.join(
-            pkNames.map((n) => sql`${row[n]}`),
-            sql`, `
+          (row) => sql2`(${sql2.join(
+            pkNames.map((n) => sql2`${row[n]}`),
+            sql2`, `
           )})`
         ),
-        sql`, `
+        sql2`, `
       );
-      return sql`(${lhs}) in (${tuples})`;
+      return sql2`(${lhs}) in (${tuples})`;
     };
   }
   let enriched;
@@ -2782,9 +3139,10 @@ import { is as is4, One as One3 } from "drizzle-orm";
 import { getTableConfig, MySqlTable } from "drizzle-orm/mysql-core";
 import {
   GraphQLBoolean as GraphQLBoolean3,
-  GraphQLError as GraphQLError5,
-  GraphQLList as GraphQLList4,
-  GraphQLNonNull as GraphQLNonNull4,
+  GraphQLError as GraphQLError6,
+  GraphQLInt as GraphQLInt5,
+  GraphQLList as GraphQLList5,
+  GraphQLNonNull as GraphQLNonNull5,
   GraphQLObjectType as GraphQLObjectType4
 } from "graphql";
 import { parseResolveInfo as parseResolveInfo2 } from "graphql-parse-resolve-info";
@@ -2797,7 +3155,7 @@ import {
   countDistinct,
   eq as eq2,
   extractExtendedColumnType as extractExtendedColumnType3,
-  getColumns as getColumns2,
+  getColumns as getColumns3,
   gt as gt2,
   gte as gte2,
   inArray as inArray2,
@@ -2809,12 +3167,12 @@ import {
   sum
 } from "drizzle-orm";
 import {
-  GraphQLError as GraphQLError4,
-  GraphQLFloat as GraphQLFloat3,
-  GraphQLInputObjectType as GraphQLInputObjectType3,
-  GraphQLInt as GraphQLInt3,
-  GraphQLList as GraphQLList3,
-  GraphQLNonNull as GraphQLNonNull3,
+  GraphQLError as GraphQLError5,
+  GraphQLFloat as GraphQLFloat4,
+  GraphQLInputObjectType as GraphQLInputObjectType4,
+  GraphQLInt as GraphQLInt4,
+  GraphQLList as GraphQLList4,
+  GraphQLNonNull as GraphQLNonNull4,
   GraphQLObjectType as GraphQLObjectType3
 } from "graphql";
 import { parseResolveInfo } from "graphql-parse-resolve-info";
@@ -2833,11 +3191,11 @@ var classifyAggregateColumns = (table, tableName) => {
   const numeric = {};
   const orderable = {};
   const all = {};
-  for (const [columnName, column] of Object.entries(getColumns2(table))) {
+  for (const [columnName, column] of Object.entries(getColumns3(table))) {
     all[columnName] = column;
     const converted = drizzleColumnToGraphQLType(column, columnName, tableName, true, false, false);
     const gqlType = converted.type;
-    if (gqlType instanceof GraphQLList3 || gqlType instanceof GraphQLObjectType3) {
+    if (gqlType instanceof GraphQLList4 || gqlType instanceof GraphQLObjectType3) {
       continue;
     }
     const { type: dataType, constraint } = extractExtendedColumnType3(column);
@@ -2861,14 +3219,14 @@ var generateAggregateTypes = (table, tableName, typeName, cacheCtx) => {
   }
   const { numeric, orderable, all } = classifyAggregateColumns(table, tableName);
   const fields = {
-    count: { type: new GraphQLNonNull3(GraphQLInt3) }
+    count: { type: new GraphQLNonNull4(GraphQLInt4) }
   };
   if (Object.keys(numeric).length) {
     for (const op of ["avg", "sum"]) {
       fields[op] = {
         type: new GraphQLObjectType3({
           name: `${typeName}${capitalize(op)}Aggregate`,
-          fields: Object.fromEntries(Object.keys(numeric).map((columnName) => [columnName, { type: GraphQLFloat3 }]))
+          fields: Object.fromEntries(Object.keys(numeric).map((columnName) => [columnName, { type: GraphQLFloat4 }]))
         })
       };
     }
@@ -2879,9 +3237,9 @@ var generateAggregateTypes = (table, tableName, typeName, cacheCtx) => {
         type: new GraphQLObjectType3({
           name: `${typeName}${capitalize(op)}Aggregate`,
           fields: Object.fromEntries(
-            Object.entries(orderable).map(([columnName, { converted }]) => [
+            Object.entries(orderable).map(([columnName, { column, converted }]) => [
               columnName,
-              { type: converted.type, description: converted.description }
+              { type: converted.type, ...columnDocs(cacheCtx?.docs ?? {}, column, tableName, columnName) }
             ])
           )
         })
@@ -2898,7 +3256,7 @@ var generateAggregateTypes = (table, tableName, typeName, cacheCtx) => {
       type: new GraphQLObjectType3({
         name: `${typeName}${capitalize(op)}Aggregate`,
         fields: Object.fromEntries(
-          columnNames.map((columnName) => [columnName, { type: new GraphQLNonNull3(GraphQLInt3) }])
+          columnNames.map((columnName) => [columnName, { type: new GraphQLNonNull4(GraphQLInt4) }])
         )
       })
     };
@@ -2926,9 +3284,9 @@ var aggregateTarget = (table, tableName, typeName) => {
   return {
     tableName,
     typeName,
-    columns: getColumns2(table),
+    columns: getColumns3(table),
     dateTimeColumns: new Set(
-      Object.entries(orderable).filter(([, { converted }]) => converted.description === "DateTime").map(([columnName]) => columnName)
+      Object.entries(orderable).filter(([, { converted }]) => converted.typeLabel === "DateTime").map(([columnName]) => columnName)
     )
   };
 };
@@ -3077,7 +3435,7 @@ var HAVING_OPS = { eq: eq2, ne: ne2, gt: gt2, gte: gte2, lt: lt2, lte: lte2 };
 var groupableColumns = (table, tableName) => {
   const { orderable } = classifyAggregateColumns(table, tableName);
   const groupable = { ...orderable };
-  for (const [columnName, column] of Object.entries(getColumns2(table))) {
+  for (const [columnName, column] of Object.entries(getColumns3(table))) {
     if (groupable[columnName]) {
       continue;
     }
@@ -3101,10 +3459,10 @@ var generateGroupByEnum = (table, tableName, typeName) => {
     (_column, columnName) => Boolean(groupable[columnName])
   );
 };
-var aggregateNumberFilter = new GraphQLInputObjectType3({
+var aggregateNumberFilter = new GraphQLInputObjectType4({
   name: "AggregateNumberFilter",
   description: "Compares an aggregated value. Several operators in one filter are ANDed together.",
-  fields: Object.fromEntries(Object.keys(HAVING_OPS).map((op) => [op, { type: GraphQLFloat3 }]))
+  fields: Object.fromEntries(Object.keys(HAVING_OPS).map((op) => [op, { type: GraphQLFloat4 }]))
 });
 var generateHavingInput = (table, tableName, typeName) => {
   const { numeric, orderable, all } = classifyAggregateColumns(table, tableName);
@@ -3125,13 +3483,13 @@ var generateHavingInput = (table, tableName, typeName) => {
       continue;
     }
     fields[op] = {
-      type: new GraphQLInputObjectType3({
+      type: new GraphQLInputObjectType4({
         name: `${typeName}${capitalize(op)}Having`,
         fields: Object.fromEntries(columnNames.map((columnName) => [columnName, { type: aggregateNumberFilter }]))
       })
     };
   }
-  return new GraphQLInputObjectType3({
+  return new GraphQLInputObjectType4({
     name: `${typeName}Having`,
     description: `Filters ${typeName} groups by their aggregated values`,
     fields
@@ -3146,9 +3504,9 @@ var generateGroupByType = (table, tableName, typeName, cacheCtx) => {
     name: `${typeName}GroupKeys`,
     description: `The grouped column values of one ${typeName} group. A column the query did not group by is null.`,
     fields: Object.fromEntries(
-      Object.entries(groupable).map(([columnName, { converted }]) => [
+      Object.entries(groupable).map(([columnName, { column, converted }]) => [
         columnName,
-        { type: converted.type, description: converted.description }
+        { type: converted.type, ...columnDocs(cacheCtx?.docs ?? {}, column, tableName, columnName) }
       ])
     )
   });
@@ -3161,7 +3519,7 @@ var generateGroupByType = (table, tableName, typeName, cacheCtx) => {
   );
   return new GraphQLObjectType3({
     name: `${typeName}GroupBy`,
-    fields: { group: { type: new GraphQLNonNull3(keysType) }, ...aggregateFields }
+    fields: { group: { type: new GraphQLNonNull4(keysType) }, ...aggregateFields }
   });
 };
 var havingComparisons = (expression, filter) => Object.entries(filter).filter(([op, value]) => value != null && op in HAVING_OPS).map(([op, value]) => HAVING_OPS[op](expression, value));
@@ -3194,11 +3552,11 @@ var buildHavingCondition = (having, columns) => {
 var generateGroupBy = (db, tableName, table, typeName, fieldName, filterArgs, groupByEnum, havingInput, filterCtx) => {
   const target = aggregateTarget(table, tableName, typeName);
   const groupable = groupableColumns(table, tableName);
-  const columns = getColumns2(table);
+  const columns = getColumns3(table);
   const rootTypeName = `${typeName}GroupBy`;
   const queryArgs = {
     groupBy: {
-      type: new GraphQLNonNull3(new GraphQLList3(new GraphQLNonNull3(groupByEnum))),
+      type: new GraphQLNonNull4(new GraphQLList4(new GraphQLNonNull4(groupByEnum))),
       description: "Columns to group by. One result row per distinct combination of their values."
     },
     where: { type: filterArgs, description: "Filters the rows before they are grouped." },
@@ -3210,12 +3568,12 @@ var generateGroupBy = (db, tableName, table, typeName, fieldName, filterArgs, gr
       try {
         const requestedKeys = [...new Set(args.groupBy ?? [])];
         if (!requestedKeys.length) {
-          throw new GraphQLError4("At least one column to group by is required!");
+          throw new GraphQLError5("At least one column to group by is required!");
         }
         const keyColumns = requestedKeys.map((columnName) => {
           const groupableColumn = groupable[columnName];
           if (!groupableColumn) {
-            throw new GraphQLError4(`Cannot group ${typeName} by ${columnName}!`);
+            throw new GraphQLError5(`Cannot group ${typeName} by ${columnName}!`);
           }
           return [columnName, groupableColumn.column];
         });
@@ -3337,7 +3695,7 @@ var generateSelectSingle = (db, tableName, tables, relationMap, orderArgs, filte
 var generateInsertArray = (db, _tableName, table, baseType, fieldName, txCtx) => {
   const queryArgs = {
     values: {
-      type: new GraphQLNonNull4(new GraphQLList4(new GraphQLNonNull4(baseType)))
+      type: new GraphQLNonNull5(new GraphQLList5(new GraphQLNonNull5(baseType)))
     }
   };
   return {
@@ -3347,7 +3705,7 @@ var generateInsertArray = (db, _tableName, table, baseType, fieldName, txCtx) =>
         return await runMutation(db, context, info, txCtx, async (executor) => {
           const input = remapFromGraphQLArrayInput(args.values, table);
           if (!input.length) {
-            throw new GraphQLError5("No values were provided!");
+            throw new GraphQLError6("No values were provided!");
           }
           await executor.insert(table).values(input);
           return { isSuccess: true };
@@ -3362,7 +3720,7 @@ var generateInsertArray = (db, _tableName, table, baseType, fieldName, txCtx) =>
 var generateInsertSingle = (db, _tableName, table, baseType, fieldName, txCtx) => {
   const queryArgs = {
     values: {
-      type: new GraphQLNonNull4(baseType)
+      type: new GraphQLNonNull5(baseType)
     }
   };
   return {
@@ -3384,7 +3742,7 @@ var generateInsertSingle = (db, _tableName, table, baseType, fieldName, txCtx) =
 var generateUpsert = (db, table, baseType, onConflictType, fieldName, single, txCtx) => {
   const queryArgs = {
     values: {
-      type: single ? new GraphQLNonNull4(baseType) : new GraphQLNonNull4(new GraphQLList4(new GraphQLNonNull4(baseType)))
+      type: single ? new GraphQLNonNull5(baseType) : new GraphQLNonNull5(new GraphQLList5(new GraphQLNonNull5(baseType)))
     },
     onConflict: {
       type: onConflictType,
@@ -3399,7 +3757,7 @@ var generateUpsert = (db, table, baseType, onConflictType, fieldName, single, tx
         return await runMutation(db, context, info, txCtx, async (executor) => {
           const input = single ? [remapFromGraphQLSingleInput(args.values, table)] : remapFromGraphQLArrayInput(args.values, table);
           if (!input.length) {
-            throw new GraphQLError5("No values were provided!");
+            throw new GraphQLError6("No values were provided!");
           }
           const plan = resolveConflictPlan({
             table,
@@ -3427,10 +3785,10 @@ var generateUpsert = (db, table, baseType, onConflictType, fieldName, single, tx
 var generateUpdate = (db, tableName, table, setArgs, filterArgs, fieldName, single, requireWhere, filterCtx, txCtx) => {
   const queryArgs = {
     set: {
-      type: new GraphQLNonNull4(setArgs)
+      type: new GraphQLNonNull5(setArgs)
     },
     where: {
-      type: single || requireWhere ? new GraphQLNonNull4(filterArgs) : filterArgs
+      type: single || requireWhere ? new GraphQLNonNull5(filterArgs) : filterArgs
     }
   };
   return {
@@ -3439,9 +3797,9 @@ var generateUpdate = (db, tableName, table, setArgs, filterArgs, fieldName, sing
       try {
         return await runMutation(db, context, info, txCtx, async (executor) => {
           const { where, set } = args;
-          const input = remapFromGraphQLSingleInput(set, table);
+          const input = remapUpdateInput(set, table, tableName);
           if (!Object.keys(input).length) {
-            throw new GraphQLError5("Unable to update with no values specified!");
+            throw new GraphQLError6("Unable to update with no values specified!");
           }
           const relationCtx = relationFilterCtx(filterCtx, tableName);
           const filters = single || requireWhere ? extractRequiredFilters(table, tableName, where, fieldName, relationCtx) : where ? extractFilters(table, tableName, where, relationCtx) : void 0;
@@ -3465,7 +3823,7 @@ var generateUpdate = (db, tableName, table, setArgs, filterArgs, fieldName, sing
 var generateUpdateMany = (db, tableName, table, updateManyInput, fieldName, filterCtx, txCtx) => {
   const queryArgs = {
     updates: {
-      type: new GraphQLNonNull4(new GraphQLList4(new GraphQLNonNull4(updateManyInput)))
+      type: new GraphQLNonNull5(new GraphQLList5(new GraphQLNonNull5(updateManyInput)))
     }
   };
   return {
@@ -3475,12 +3833,12 @@ var generateUpdateMany = (db, tableName, table, updateManyInput, fieldName, filt
         return await runMutation(db, context, info, txCtx, async (executor) => {
           const { updates } = args;
           if (!updates.length) {
-            throw new GraphQLError5("No updates were provided!");
+            throw new GraphQLError6("No updates were provided!");
           }
           const entries = updates.map(({ where, set }) => {
-            const input = remapFromGraphQLSingleInput(set, table);
+            const input = remapUpdateInput(set, table, tableName);
             if (!Object.keys(input).length) {
-              throw new GraphQLError5("Unable to update with no values specified!");
+              throw new GraphQLError6("Unable to update with no values specified!");
             }
             return {
               set: input,
@@ -3508,7 +3866,7 @@ var generateUpdateMany = (db, tableName, table, updateManyInput, fieldName, filt
 var generateDelete = (db, tableName, table, filterArgs, fieldName, single, requireWhere, filterCtx, txCtx) => {
   const queryArgs = {
     where: {
-      type: single || requireWhere ? new GraphQLNonNull4(filterArgs) : filterArgs
+      type: single || requireWhere ? new GraphQLNonNull5(filterArgs) : filterArgs
     }
   };
   return {
@@ -3548,12 +3906,23 @@ var generateSchemaData = (db, schema, relations, options) => {
       "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);
   const namedRelations = buildNamedRelations(relations ?? {}, tableEntries);
   attachTargetPrimaryKeys(namedRelations, tables, mysqlPrimaryKeyPropNames);
   const eagerRelations = pruneNonEagerRelations(namedRelations, shouldEagerLoad);
   const filterCtx = { tables, relationMap: namedRelations };
-  const resolverFactory = createRelationResolverFactory(db, tables, filterCtx);
+  const resolverFactory = createRelationResolverFactory(
+    db,
+    tables,
+    "nulls-smallest",
+    filterCtx
+  );
   const cacheCtx = {
     genericFilterCache: /* @__PURE__ */ new Map(),
     objectTypeCache: /* @__PURE__ */ new Map(),
@@ -3566,7 +3935,9 @@ var generateSchemaData = (db, schema, relations, options) => {
     filterTypeCache: /* @__PURE__ */ new WeakMap(),
     listRelationFilterCache: /* @__PURE__ */ new Map(),
     aggregateTypeCache: /* @__PURE__ */ new Map(),
-    complexity
+    complexity,
+    docs: options.docs ?? {},
+    features
   };
   const relationAggregateFactory = features.relationAggregates ? createRelationAggregateFactory(db, tables, cacheCtx, typeNameMapper, filterCtx) : void 0;
   const queries = {};
@@ -3594,7 +3965,7 @@ var generateSchemaData = (db, schema, relations, options) => {
     name: "MutationReturn",
     fields: {
       isSuccess: {
-        type: new GraphQLNonNull4(GraphQLBoolean3)
+        type: new GraphQLNonNull5(GraphQLBoolean3)
       }
     }
   });
@@ -3619,8 +3990,10 @@ var generateSchemaData = (db, schema, relations, options) => {
       updateFieldName,
       updateManyFieldName,
       updateSingleFieldName,
+      updateCountFieldName,
       deleteFieldName,
-      deleteSingleFieldName
+      deleteSingleFieldName,
+      deleteCountFieldName
     } = computeResolverFieldNames(tableName, typeNameMapper, prefixes, suffixes);
     const selectArrGenerated = generateSelectArray(
       db,
@@ -3744,6 +4117,29 @@ var generateSchemaData = (db, schema, relations, options) => {
       filterCtx,
       mutationTxCtx
     ) : void 0;
+    const updateCountGenerated = features.update && features.countMutations ? generateWriteCount({
+      db,
+      tableName,
+      table: schema[tableName],
+      kind: "update",
+      setArgs: updateInput,
+      filterArgs: tableFilters,
+      fieldName: updateCountFieldName,
+      requireWhere: features.requireWhere,
+      filterCtx,
+      txCtx: mutationTxCtx
+    }) : void 0;
+    const deleteCountGenerated = features.delete && features.countMutations ? generateWriteCount({
+      db,
+      tableName,
+      table: schema[tableName],
+      kind: "delete",
+      filterArgs: tableFilters,
+      fieldName: deleteCountFieldName,
+      requireWhere: features.requireWhere,
+      filterCtx,
+      txCtx: mutationTxCtx
+    }) : void 0;
     const aggregateType = features.aggregates ? generateAggregateTypes(schema[tableName], tableName, typeName, cacheCtx) : void 0;
     const aggregateGenerated = features.aggregates ? generateAggregate(
       db,
@@ -3781,7 +4177,7 @@ var generateSchemaData = (db, schema, relations, options) => {
     };
     if (aggregateGenerated && aggregateType) {
       queries[aggregateGenerated.name] = {
-        type: new GraphQLNonNull4(aggregateType),
+        type: new GraphQLNonNull5(aggregateType),
         args: aggregateGenerated.args,
         resolve: aggregateGenerated.resolver,
         ...complexity ? { extensions: { complexity: aggregateFieldComplexity(complexity) } } : {}
@@ -3789,7 +4185,7 @@ var generateSchemaData = (db, schema, relations, options) => {
     }
     if (groupByGenerated && groupByType) {
       queries[groupByGenerated.name] = {
-        type: new GraphQLNonNull4(new GraphQLList4(new GraphQLNonNull4(groupByType))),
+        type: new GraphQLNonNull5(new GraphQLList5(new GraphQLNonNull5(groupByType))),
         args: groupByGenerated.args,
         resolve: groupByGenerated.resolver,
         ...complexity ? { extensions: { complexity: aggregateFieldComplexity(complexity) } } : {}
@@ -3814,6 +4210,22 @@ var generateSchemaData = (db, schema, relations, options) => {
         };
       }
     }
+    if (updateCountGenerated) {
+      mutations[updateCountGenerated.name] = {
+        type: new GraphQLNonNull5(GraphQLInt5),
+        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 GraphQLNonNull5(GraphQLInt5),
+        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.
       ...features.insert || onConflictInput ? [insertInput] : [],
@@ -3858,14 +4270,400 @@ var generateSchemaData = (db, schema, relations, options) => {
 };
 
 // src/util/builders/pg.ts
-import { and as and3, getColumns as getColumns3, is as is5, One as One4 } from "drizzle-orm";
+import { and as and4, getColumns as getColumns5, is as is6, One as One5 } from "drizzle-orm";
 import { getTableConfig as getTableConfig2, PgTable } from "drizzle-orm/pg-core";
 import {
-  GraphQLError as GraphQLError6,
-  GraphQLList as GraphQLList5,
-  GraphQLNonNull as GraphQLNonNull5
+  GraphQLError as GraphQLError8,
+  GraphQLInt as GraphQLInt6,
+  GraphQLList as GraphQLList7,
+  GraphQLNonNull as GraphQLNonNull7
 } from "graphql";
 import { parseResolveInfo as parseResolveInfo3 } from "graphql-parse-resolve-info";
+
+// src/util/builders/nested-writes.ts
+import { and as and3, eq as eq3, getColumns as getColumns4, is as is5, One as One4 } from "drizzle-orm";
+import {
+  GraphQLBoolean as GraphQLBoolean4,
+  GraphQLError as GraphQLError7,
+  GraphQLInputObjectType as GraphQLInputObjectType5,
+  GraphQLList as GraphQLList6,
+  GraphQLNonNull as GraphQLNonNull6
+} from "graphql";
+var isOptionalOnInsert = (column) => !column.notNull || !!column.hasDefault || !!column.defaultFn;
+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 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;
+    }
+    const tablePlans = {};
+    for (const [relationName, relEntry] of Object.entries(relations)) {
+      const relation = relEntry.relation;
+      if (relation.through) {
+        continue;
+      }
+      const targetTableName = relEntry.targetTableName;
+      const targetTable = tables[targetTableName];
+      if (!targetTable) {
+        continue;
+      }
+      const joinColumns = extractJoinColumns(relEntry, table, targetTable);
+      if (!joinColumns) {
+        continue;
+      }
+      const { localColPropName, foreignCol, foreignColPropName } = joinColumns;
+      const localCol = getColumns4(table)[localColPropName];
+      if (!localCol) {
+        continue;
+      }
+      const isOne = is5(relation, One4);
+      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 NO_COLUMNS = /* @__PURE__ */ new Set();
+var createNestedWriteTypes = (params) => {
+  const { plans, cacheCtx, typeNameMapper, insertPrefix } = 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 fields = Object.fromEntries(
+      Object.entries(getColumns4(plan.targetTable)).filter(([columnName]) => columnName !== omitted).map(([columnName, column]) => [
+        columnName,
+        drizzleColumnToGraphQLType(column, columnName, plan.targetTableName, false, true, true)
+      ])
+    );
+    const type = new GraphQLInputObjectType5({
+      name: `${capitalize(insertPrefix)}${typeName}${capitalize(plan.relationName)}Input`,
+      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 GraphQLList6(new GraphQLNonNull6(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 payload = payloadType(tableName, typeName, plan);
+    const targetTypeName = resolveTypeName(plan.targetTableName, typeNameMapper);
+    const fields = {};
+    if (plan.isOne) {
+      fields["create"] = { type: payload, description: `Insert a ${targetTypeName} row and attach it` };
+      if (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: GraphQLBoolean4,
+          description: `Detach the currently attached ${targetTypeName} row, leaving it in place`
+        };
+      }
+    } else {
+      fields["create"] = { type: listOf(payload), 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 GraphQLInputObjectType5({
+      name: `${typeName}${capitalize(plan.relationName)}Nested${forUpdate ? "Update" : "Create"}Input`,
+      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 {};
+    }
+    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 {
+    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 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 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 } = params;
+  const conditionOf = (plan, filter, operation) => {
+    const condition = extractFilters(
+      plan.targetTable,
+      plan.targetTableName,
+      filter,
+      relationFilterCtx(filterCtx, plan.targetTableName)
+    );
+    if (!condition) {
+      throw new GraphQLError7(
+        `Drizzle-GraphQL Error: '${operation}' on '${plan.relationName}' needs a filter that selects rows \u2014 it was given one that matches everything.`
+      );
+    }
+    return condition;
+  };
+  const assertSingleOperation = (plan, op) => {
+    const supplied = ["create", "connect", "disconnect"].filter((key) => op[key] !== void 0 && op[key] !== null);
+    if (supplied.length > 1) {
+      throw new GraphQLError7(
+        `Drizzle-GraphQL Error: '${plan.relationName}' takes one of ${supplied.join(", ")} at a time \u2014 it holds a single row.`
+      );
+    }
+  };
+  const detachAll = async (executor, plan, key) => executor.update(plan.targetTable).set({ [plan.foreignColPropName]: null }).where(eq3(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;
+      }
+      const allColumns = getColumns4(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 columns;
+    },
+    applyParentSide: async (executor, tableName, ops) => {
+      const tablePlans = plans[tableName];
+      const patch = {};
+      if (!tablePlans) {
+        return patch;
+      }
+      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 = remapFromGraphQLSingleInput({ ...op["create"] }, plan.targetTable);
+          const inserted = await executor.insert(plan.targetTable).values(values).returning();
+          const created = inserted[0];
+          if (!created) {
+            throw new GraphQLError7(
+              `Drizzle-GraphQL Error: 'create' on '${relationName}' inserted no row, so there is nothing to attach.`
+            );
+          }
+          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"));
+          if (rows.length !== 1) {
+            throw new GraphQLError7(
+              `Drizzle-GraphQL Error: 'connect' on '${relationName}' matched ${rows.length} rows \u2014 it attaches a single row, so its filter must match exactly one.`
+            );
+          }
+          patch[plan.localColPropName] = rows[0][plan.foreignColPropName];
+        } else if (op["disconnect"] === true) {
+          patch[plan.localColPropName] = null;
+        }
+      }
+      return patch;
+    },
+    applyChildSide: async (executor, tableName, ops, parentRows) => {
+      const tablePlans = plans[tableName];
+      if (!tablePlans) {
+        return;
+      }
+      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 new GraphQLError7(
+              `Drizzle-GraphQL Error: cannot write through '${relationName}': the ${tableName} row has no '${plan.localColPropName}' value to attach to.`
+            );
+          }
+          if (op["set"] !== void 0) {
+            await detachAll(executor, plan, key);
+            for (const filter of asArray(op["set"])) {
+              await executor.update(plan.targetTable).set({ [plan.foreignColPropName]: key }).where(conditionOf(plan, filter, "set"));
+            }
+          }
+          if (op["disconnect"] !== void 0) {
+            if (plan.isOne) {
+              if (op["disconnect"] === true) {
+                await detachAll(executor, plan, key);
+              }
+            } else {
+              for (const filter of asArray(op["disconnect"])) {
+                await executor.update(plan.targetTable).set({ [plan.foreignColPropName]: null }).where(and3(eq3(plan.foreignCol, key), conditionOf(plan, filter, "disconnect")));
+              }
+            }
+          }
+          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);
+          }
+          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"));
+            }
+          }
+          if (op["create"] !== void 0) {
+            const rows = asArray(op["create"]).map((row) => ({
+              ...remapFromGraphQLSingleInput({ ...row }, plan.targetTable),
+              [plan.foreignColPropName]: key
+            }));
+            if (rows.length) {
+              await executor.insert(plan.targetTable).values(rows);
+            }
+          }
+        }
+      }
+    }
+  };
+};
+var writeWithNestedOps = async (params) => {
+  const { executor, runtime, tableName, entries, remapValues, write } = params;
+  return executor.transaction(async (tx) => {
+    const rows = [];
+    for (const entry of entries) {
+      const patch = await runtime.applyParentSide(tx, tableName, entry.ops);
+      const written = await write(tx, { ...remapValues(entry.columns), ...patch });
+      await runtime.applyChildSide(tx, tableName, entry.ops, written);
+      rows.push(...written);
+    }
+    return rows;
+  });
+};
+var updateWithNestedOps = async (params) => {
+  const { executor, runtime, tableName, columns, ops, remapValues, write } = params;
+  return executor.transaction(async (tx) => {
+    const patch = await runtime.applyParentSide(tx, tableName, ops);
+    const rows = await write(tx, { ...remapValues(columns), ...patch });
+    await runtime.applyChildSide(tx, tableName, ops, rows);
+    return rows;
+  });
+};
+
+// src/util/builders/pg.ts
 var generateSelectArray2 = (db, tableName, tables, relationMap, orderArgs, filterArgs, fieldName, typeName, typeNameMapper, filterCtx, distinctEnabled = true) => {
   const queryBase = db.query[tableName];
   const table = tables[tableName];
@@ -3910,24 +4708,24 @@ var generateSelectArray2 = (db, tableName, tables, relationMap, orderArgs, filte
         let cursorEntries;
         if (after != null || cursorSelected) {
           if (after != null && distinct?.length) {
-            throw new GraphQLError6("'after' cannot be combined with 'distinct'.");
+            throw new GraphQLError8("'after' cannot be combined with 'distinct'.");
           }
           if (orderByHasRelationEntry(orderBy)) {
             if (after != null) {
-              throw new GraphQLError6(
+              throw new GraphQLError8(
                 "'after' cannot be combined with an orderBy that orders through a relation \u2014 a related row's value cannot be encoded into a cursor."
               );
             }
           } else if (!pkNames.length) {
             if (after != null) {
-              throw new GraphQLError6(
+              throw new GraphQLError8(
                 `Table ${tableName} has no primary key, so cursor pagination cannot be used on it.`
               );
             }
           } else {
             cursorEntries = cursorOrderingEntries(orderBy, pkNames);
             if (cursorSelected) {
-              const allColumns = getColumns3(table);
+              const allColumns = getColumns5(table);
               for (const [column] of cursorEntries) {
                 selectedColumnsSql[column] ??= allColumns[column];
               }
@@ -3936,7 +4734,7 @@ var generateSelectArray2 = (db, tableName, tables, relationMap, orderArgs, filte
         }
         const cursorCondition = after != null && cursorEntries ? buildCursorCondition(table, cursorEntries, decodeCursor(after, cursorEntries), "nulls-largest") : void 0;
         const baseWhereSql = where ? extractFilters(table, tableName, where, relationFilterCtx(filterCtx, tableName)) : void 0;
-        const whereSql = cursorCondition ? and3(baseWhereSql, cursorCondition) : baseWhereSql;
+        const whereSql = cursorCondition ? and4(baseWhereSql, cursorCondition) : baseWhereSql;
         let distinctKeys;
         if (distinct?.length) {
           distinctKeys = await selectDistinctKeys({
@@ -4047,10 +4845,10 @@ var generateSelectSingle2 = (db, tableName, tables, relationMap, orderArgs, filt
   };
 };
 var pgPrimaryKeyPropNames = (table) => getPrimaryKeyPropNamesFromConfig(table, getTableConfig2);
-var generateInsertArray2 = (db, tableName, table, tables, relationMap, baseType, fieldName, typeName, typeNameMapper, conflictDoNothing = false, txCtx) => {
+var generateInsertArray2 = (db, tableName, table, tables, relationMap, baseType, fieldName, typeName, typeNameMapper, conflictDoNothing = false, txCtx, nested) => {
   const queryArgs = {
     values: {
-      type: new GraphQLNonNull5(new GraphQLList5(new GraphQLNonNull5(baseType)))
+      type: new GraphQLNonNull7(new GraphQLList7(new GraphQLNonNull7(baseType)))
     }
   };
   const pkNames = pgPrimaryKeyPropNames(table);
@@ -4059,10 +4857,12 @@ var generateInsertArray2 = (db, tableName, table, tables, relationMap, baseType,
     resolver: async (_source, args, context, info) => {
       try {
         return await runMutation(db, context, info, txCtx, async (executor) => {
-          const input = remapFromGraphQLArrayInput(args.values, table);
-          if (!input.length) {
-            throw new GraphQLError6("No values were provided!");
+          if (!args.values.length) {
+            throw new GraphQLError8("No values were provided!");
           }
+          const entries = nested?.enabled(tableName) ? args.values.map((values) => nested.split(tableName, values)) : void 0;
+          const nestedEntries = entries?.some((entry) => nested.hasOps(entry.ops)) ? entries : void 0;
+          const input = nestedEntries ? [] : remapFromGraphQLArrayInput(entries ? entries.map((entry) => entry.columns) : args.values, table);
           const parsedInfo = parseResolveInfo3(info, {
             deep: true
           });
@@ -4076,11 +4876,22 @@ var generateInsertArray2 = (db, tableName, table, tables, relationMap, baseType,
             pkNames,
             parsedInfo
           });
-          let query = executor.insert(table).values(input).returning(columns);
-          if (conflictDoNothing) {
-            query = query.onConflictDoNothing();
-          }
-          const result = await query;
+          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) => remapFromGraphQLSingleInput(values, table),
+            write: (tx, values) => runInsert(tx, [values])
+          }) : await runInsert(executor, input);
           const enriched = hasRelations ? await eagerLoadMutationRelations(executor, tableName, result, pkNames, withParams) : result;
           return remapToGraphQLArrayOutput(enriched, tableName, table, relationMap);
         });
@@ -4091,10 +4902,10 @@ var generateInsertArray2 = (db, tableName, table, tables, relationMap, baseType,
     args: queryArgs
   };
 };
-var generateInsertSingle2 = (db, tableName, table, tables, relationMap, baseType, fieldName, typeName, typeNameMapper, conflictDoNothing = false, txCtx) => {
+var generateInsertSingle2 = (db, tableName, table, tables, relationMap, baseType, fieldName, typeName, typeNameMapper, conflictDoNothing = false, txCtx, nested) => {
   const queryArgs = {
     values: {
-      type: new GraphQLNonNull5(baseType)
+      type: new GraphQLNonNull7(baseType)
     }
   };
   const pkNames = pgPrimaryKeyPropNames(table);
@@ -4103,7 +4914,9 @@ var generateInsertSingle2 = (db, tableName, table, tables, relationMap, baseType
     resolver: async (_source, args, context, info) => {
       try {
         return await runMutation(db, context, info, txCtx, async (executor) => {
-          const input = remapFromGraphQLSingleInput(args.values, table);
+          const entry = nested?.enabled(tableName) ? nested.split(tableName, args.values) : void 0;
+          const nestedEntry = entry && nested.hasOps(entry.ops) ? entry : void 0;
+          const input = nestedEntry ? {} : remapFromGraphQLSingleInput(entry ? entry.columns : args.values, table);
           const parsedInfo = parseResolveInfo3(info, {
             deep: true
           });
@@ -4117,12 +4930,26 @@ var generateInsertSingle2 = (db, tableName, table, tables, relationMap, baseType
             pkNames,
             parsedInfo
           });
-          let query = executor.insert(table).values(input).returning(columns);
-          if (conflictDoNothing) {
-            query = query.onConflictDoNothing();
-          }
-          const result = await query;
+          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) => remapFromGraphQLSingleInput(values, table),
+            write: runInsert
+          }) : await runInsert(executor, input);
           if (!result[0]) {
+            if (!conflictDoNothing) {
+              throw new GraphQLError8(`${fieldName}: the insert returned no row.`);
+            }
             return void 0;
           }
           const enriched = hasRelations ? await eagerLoadMutationRelations(executor, tableName, result, pkNames, withParams) : result;
@@ -4135,10 +4962,10 @@ var generateInsertSingle2 = (db, tableName, table, tables, relationMap, baseType
     args: queryArgs
   };
 };
-var generateUpsert2 = (db, tableName, table, tables, relationMap, baseType, onConflictType, uniqueSets, fieldName, typeName, single, typeNameMapper, filterCtx, txCtx) => {
+var generateUpsert2 = (db, tableName, table, tables, relationMap, baseType, onConflictType, uniqueSets, fieldName, typeName, single, typeNameMapper, filterCtx, txCtx, nested) => {
   const queryArgs = {
     values: {
-      type: single ? new GraphQLNonNull5(baseType) : new GraphQLNonNull5(new GraphQLList5(new GraphQLNonNull5(baseType)))
+      type: single ? new GraphQLNonNull7(baseType) : new GraphQLNonNull7(new GraphQLList7(new GraphQLNonNull7(baseType)))
     },
     onConflict: {
       type: onConflictType,
@@ -4151,10 +4978,13 @@ var generateUpsert2 = (db, tableName, table, tables, relationMap, baseType, onCo
     resolver: async (_source, args, context, info) => {
       try {
         return await runMutation(db, context, info, txCtx, async (executor) => {
-          const input = single ? [remapFromGraphQLSingleInput(args.values, table)] : remapFromGraphQLArrayInput(args.values, table);
-          if (!input.length) {
-            throw new GraphQLError6("No values were provided!");
+          const supplied = single ? [args.values] : args.values;
+          if (!supplied.length) {
+            throw new GraphQLError8("No values were provided!");
           }
+          const entries = nested?.enabled(tableName) ? supplied.map((values) => nested.split(tableName, values)) : void 0;
+          const nestedEntries = entries?.some((entry) => nested.hasOps(entry.ops)) ? entries : void 0;
+          const input = nestedEntries ? [] : remapFromGraphQLArrayInput(entries ? entries.map((entry) => entry.columns) : supplied, table);
           const parsedInfo = parseResolveInfo3(info, { deep: true });
           const { columns, hasRelations, withParams } = prepareMutationRelationColumns({
             relationMap,
@@ -4166,19 +4996,30 @@ var generateUpsert2 = (db, tableName, table, tables, relationMap, baseType, onCo
             pkNames,
             parsedInfo
           });
-          const plan = resolveConflictPlan({
-            table,
-            values: input,
-            onConflict: args.onConflict,
-            pkNames,
-            uniqueSets,
-            excludedRef: excludedColumnRef,
-            withTarget: true,
-            buildWhere: (where) => extractFilters(table, tableName, where, relationFilterCtx(filterCtx, tableName))
-          });
-          let query = executor.insert(table).values(input).returning(columns);
-          query = plan.action === "NOTHING" ? query.onConflictDoNothing(plan.target ? { target: plan.target } : void 0) : query.onConflictDoUpdate({ target: plan.target, set: plan.set, setWhere: plan.setWhere });
-          const result = await query;
+          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);
+            query = plan.action === "NOTHING" ? query.onConflictDoNothing(plan.target ? { target: plan.target } : void 0) : query.onConflictDoUpdate({ target: plan.target, set: plan.set, setWhere: plan.setWhere });
+            return await query;
+          };
+          const result = nestedEntries ? await writeWithNestedOps({
+            executor,
+            runtime: nested,
+            tableName,
+            entries: nestedEntries,
+            remapValues: (values) => remapFromGraphQLSingleInput(values, table),
+            write: (tx, values) => runUpsert(tx, [values])
+          }) : await runUpsert(executor, input);
           if (single && !result[0]) {
             return void 0;
           }
@@ -4192,13 +5033,13 @@ var generateUpsert2 = (db, tableName, table, tables, relationMap, baseType, onCo
     args: queryArgs
   };
 };
-var generateUpdate2 = (db, tableName, table, tables, relationMap, setArgs, filterArgs, fieldName, typeName, single, requireWhere, typeNameMapper, filterCtx, txCtx) => {
+var generateUpdate2 = (db, tableName, table, tables, relationMap, setArgs, filterArgs, fieldName, typeName, single, requireWhere, typeNameMapper, filterCtx, txCtx, nested) => {
   const queryArgs = {
     set: {
-      type: new GraphQLNonNull5(setArgs)
+      type: new GraphQLNonNull7(setArgs)
     },
     where: {
-      type: single || requireWhere ? new GraphQLNonNull5(filterArgs) : filterArgs
+      type: single || requireWhere ? new GraphQLNonNull7(filterArgs) : filterArgs
     }
   };
   const pkNames = pgPrimaryKeyPropNames(table);
@@ -4221,23 +5062,37 @@ var generateUpdate2 = (db, tableName, table, tables, relationMap, setArgs, filte
             pkNames,
             parsedInfo
           });
-          const input = remapFromGraphQLSingleInput(set, table);
-          if (!Object.keys(input).length) {
-            throw new GraphQLError6("Unable to update with no values specified!");
+          const entry = nested?.enabled(tableName) ? nested.split(tableName, set) : void 0;
+          const nestedOps = entry && nested.hasOps(entry.ops) ? entry.ops : void 0;
+          const input = remapUpdateInput(entry ? entry.columns : set, table, tableName);
+          if (!Object.keys(input).length && !nestedOps) {
+            throw new GraphQLError8("Unable to update with no values specified!");
           }
           const relationCtx = relationFilterCtx(filterCtx, tableName);
           const filters = single || requireWhere ? extractRequiredFilters(table, tableName, where, fieldName, relationCtx) : where ? extractFilters(table, tableName, where, relationCtx) : void 0;
           if (single) {
             await assertSingleMatch(executor, table, filters, fieldName);
           }
-          let query = executor.update(table).set(input);
-          if (filters) {
-            query = query.where(filters);
-          }
-          query = query.returning(columns);
-          const result = await query;
+          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
+          }) : await runUpdate(executor, input);
           if (single && result.length > 1) {
-            throw new GraphQLError6(`${fieldName}: 'where' matched more than one row!`);
+            throw new GraphQLError8(`${fieldName}: 'where' matched more than one row!`);
           }
           if (single && !result[0]) {
             return void 0;
@@ -4252,10 +5107,10 @@ var generateUpdate2 = (db, tableName, table, tables, relationMap, setArgs, filte
     args: queryArgs
   };
 };
-var generateUpdateMany2 = (db, tableName, table, tables, relationMap, updateManyInput, fieldName, typeName, typeNameMapper, filterCtx, txCtx) => {
+var generateUpdateMany2 = (db, tableName, table, tables, relationMap, updateManyInput, fieldName, typeName, typeNameMapper, filterCtx, txCtx, nested) => {
   const queryArgs = {
     updates: {
-      type: new GraphQLNonNull5(new GraphQLList5(new GraphQLNonNull5(updateManyInput)))
+      type: new GraphQLNonNull7(new GraphQLList7(new GraphQLNonNull7(updateManyInput)))
     }
   };
   const pkNames = pgPrimaryKeyPropNames(table);
@@ -4266,7 +5121,7 @@ var generateUpdateMany2 = (db, tableName, table, tables, relationMap, updateMany
         return await runMutation(db, context, info, txCtx, async (executor) => {
           const { updates } = args;
           if (!updates.length) {
-            throw new GraphQLError6("No updates were provided!");
+            throw new GraphQLError8("No updates were provided!");
           }
           const parsedInfo = parseResolveInfo3(info, {
             deep: true
@@ -4282,23 +5137,40 @@ var generateUpdateMany2 = (db, tableName, table, tables, relationMap, updateMany
             parsedInfo
           });
           const entries = updates.map(({ where, set }) => {
-            const input = remapFromGraphQLSingleInput(set, table);
-            if (!Object.keys(input).length) {
-              throw new GraphQLError6("Unable to update with no values specified!");
+            const split = nested?.enabled(tableName) ? nested.split(tableName, set) : void 0;
+            const ops = split && nested.hasOps(split.ops) ? split.ops : void 0;
+            const input = remapUpdateInput(split ? split.columns : set, table, tableName);
+            if (!Object.keys(input).length && !ops) {
+              throw new GraphQLError8("Unable to update with no values specified!");
             }
             return {
               set: input,
+              ops,
               filters: where ? extractFilters(table, tableName, where, relationFilterCtx(filterCtx, tableName)) : void 0
             };
           });
+          const returning = entries.some((entry) => entry.ops) ? nested.withJoinColumns(
+            tableName,
+            mergedOps(entries.map((entry) => ({ ops: entry.ops ?? {} }))),
+            {
+              ...columns
+            },
+            table
+          ) : columns;
           const perEntry = await executor.transaction(async (tx) => {
             const results = [];
             for (const entry of entries) {
-              let query = tx.update(table).set(entry.set);
+              const values = entry.ops ? { ...entry.set, ...await nested.applyParentSide(tx, tableName, entry.ops) } : entry.set;
+              const writes = Object.keys(values).length > 0;
+              let query = writes ? tx.update(table).set(values) : tx.select(returning).from(table);
               if (entry.filters) {
                 query = query.where(entry.filters);
               }
-              results.push(await query.returning(columns));
+              const rows = await (writes ? query.returning(returning) : query);
+              if (entry.ops) {
+                await nested.applyChildSide(tx, tableName, entry.ops, rows);
+              }
+              results.push(rows);
             }
             return results;
           });
@@ -4328,7 +5200,7 @@ var generateUpdateMany2 = (db, tableName, table, tables, relationMap, updateMany
 var generateDelete2 = (db, tableName, table, filterArgs, fieldName, typeName, single, requireWhere, filterCtx, selectionCtx, txCtx) => {
   const queryArgs = {
     where: {
-      type: single || requireWhere ? new GraphQLNonNull5(filterArgs) : filterArgs
+      type: single || requireWhere ? new GraphQLNonNull7(filterArgs) : filterArgs
     }
   };
   return {
@@ -4357,7 +5229,7 @@ var generateDelete2 = (db, tableName, table, filterArgs, fieldName, typeName, si
           query = query.returning(columns);
           const result = await query;
           if (single && result.length > 1) {
-            throw new GraphQLError6(`${fieldName}: 'where' matched more than one row!`);
+            throw new GraphQLError8(`${fieldName}: 'where' matched more than one row!`);
           }
           if (single) {
             return result[0] ? remapToGraphQLSingleOutput(result[0], tableName, table) : void 0;
@@ -4383,7 +5255,7 @@ function generateSchemaData2(db, schema, relations, options) {
     complexity
   } = options;
   const schemaEntries = Object.entries(schema);
-  const tableEntries = schemaEntries.filter(([_key, value]) => is5(value, PgTable));
+  const tableEntries = schemaEntries.filter(([_key, value]) => is6(value, PgTable));
   const tables = Object.fromEntries(tableEntries);
   if (!tableEntries.length) {
     throw new Error(
@@ -4391,11 +5263,17 @@ function generateSchemaData2(db, schema, relations, options) {
     );
   }
   registerScalarOverrides(tables, options);
+  registerEnumConfig(options);
   const namedRelations = buildNamedRelations(relations ?? {}, tableEntries);
   attachTargetPrimaryKeys(namedRelations, tables, pgPrimaryKeyPropNames);
   const eagerRelations = pruneNonEagerRelations(namedRelations, shouldEagerLoad);
   const filterCtx = { tables, relationMap: namedRelations };
-  const resolverFactory = createRelationResolverFactory(db, tables, filterCtx);
+  const resolverFactory = createRelationResolverFactory(
+    db,
+    tables,
+    "nulls-largest",
+    filterCtx
+  );
   const cacheCtx = {
     genericFilterCache: /* @__PURE__ */ new Map(),
     objectTypeCache: /* @__PURE__ */ new Map(),
@@ -4408,8 +5286,19 @@ function generateSchemaData2(db, schema, relations, options) {
     filterTypeCache: /* @__PURE__ */ new WeakMap(),
     listRelationFilterCache: /* @__PURE__ */ new Map(),
     aggregateTypeCache: /* @__PURE__ */ new Map(),
-    complexity
+    complexity,
+    docs: options.docs ?? {},
+    features
   };
+  const nestedPlans = features.nestedWrites ? buildNestedWritePlans(
+    tables,
+    namedRelations,
+    (target) => getUniqueColumnSets(target, getTableConfig2),
+    (target) => pgPrimaryKeyPropNames(target),
+    extractRelationJoinColumns
+  ) : void 0;
+  const nestedTypes = nestedPlans ? createNestedWriteTypes({ plans: nestedPlans, cacheCtx, typeNameMapper, insertPrefix: prefixes.insert }) : void 0;
+  const nestedRuntime = nestedPlans ? createNestedWriteRuntime({ plans: nestedPlans, filterCtx }) : void 0;
   const relationAggregateFactory = features.relationAggregates ? createRelationAggregateFactory(db, tables, cacheCtx, typeNameMapper, filterCtx) : void 0;
   const queries = {};
   const mutations = {};
@@ -4428,7 +5317,8 @@ function generateSchemaData2(db, schema, relations, options) {
         prefixes.insert,
         prefixes.update,
         resolverFactory,
-        relationAggregateFactory
+        relationAggregateFactory,
+        nestedTypes
       )
     ])
   );
@@ -4450,8 +5340,10 @@ function generateSchemaData2(db, schema, relations, options) {
       updateFieldName,
       updateManyFieldName,
       updateSingleFieldName,
+      updateCountFieldName,
       deleteFieldName,
-      deleteSingleFieldName
+      deleteSingleFieldName,
+      deleteCountFieldName
     } = computeResolverFieldNames(tableName, typeNameMapper, prefixes, suffixes);
     const selectArrGenerated = generateSelectArray2(
       db,
@@ -4489,7 +5381,8 @@ function generateSchemaData2(db, schema, relations, options) {
       typeName,
       typeNameMapper,
       conflictDoNothing,
-      mutationTxCtx
+      mutationTxCtx,
+      nestedRuntime
     ) : void 0;
     const insertSingleGenerated = features.insert ? generateInsertSingle2(
       db,
@@ -4502,7 +5395,8 @@ function generateSchemaData2(db, schema, relations, options) {
       typeName,
       typeNameMapper,
       conflictDoNothing,
-      mutationTxCtx
+      mutationTxCtx,
+      nestedRuntime
     ) : void 0;
     const uniqueSets = features.upsert ? getUniqueColumnSets(schema[tableName], getTableConfig2) : [];
     const onConflictInput = features.upsert ? generateOnConflictInput({
@@ -4526,7 +5420,8 @@ function generateSchemaData2(db, schema, relations, options) {
       false,
       typeNameMapper,
       filterCtx,
-      mutationTxCtx
+      mutationTxCtx,
+      nestedRuntime
     ) : void 0;
     const upsertSingleGenerated = onConflictInput ? generateUpsert2(
       db,
@@ -4542,7 +5437,8 @@ function generateSchemaData2(db, schema, relations, options) {
       true,
       typeNameMapper,
       filterCtx,
-      mutationTxCtx
+      mutationTxCtx,
+      nestedRuntime
     ) : void 0;
     const updateGenerated = features.update ? generateUpdate2(
       db,
@@ -4558,7 +5454,8 @@ function generateSchemaData2(db, schema, relations, options) {
       features.requireWhere,
       typeNameMapper,
       filterCtx,
-      mutationTxCtx
+      mutationTxCtx,
+      nestedRuntime
     ) : void 0;
     const updateSingleGenerated = features.update ? generateUpdate2(
       db,
@@ -4574,7 +5471,8 @@ function generateSchemaData2(db, schema, relations, options) {
       features.requireWhere,
       typeNameMapper,
       filterCtx,
-      mutationTxCtx
+      mutationTxCtx,
+      nestedRuntime
     ) : void 0;
     const updateManyInput = features.update && features.updateMany ? generateUpdateManyInput({ typeName, updatePrefix: prefixes.update, updateInput, tableFilters }) : void 0;
     const updateManyGenerated = updateManyInput ? generateUpdateMany2(
@@ -4588,7 +5486,8 @@ function generateSchemaData2(db, schema, relations, options) {
       typeName,
       typeNameMapper,
       filterCtx,
-      mutationTxCtx
+      mutationTxCtx,
+      nestedRuntime
     ) : void 0;
     const deleteGenerated = features.delete ? generateDelete2(
       db,
@@ -4616,6 +5515,30 @@ function generateSchemaData2(db, schema, relations, options) {
       { tableName, relationMap: namedRelations, tables },
       mutationTxCtx
     ) : void 0;
+    const updateCountGenerated = features.update && features.countMutations ? generateWriteCount({
+      db,
+      tableName,
+      table: schema[tableName],
+      kind: "update",
+      setArgs: updateInput,
+      filterArgs: tableFilters,
+      fieldName: updateCountFieldName,
+      requireWhere: features.requireWhere,
+      filterCtx,
+      txCtx: mutationTxCtx,
+      nested: nestedRuntime
+    }) : void 0;
+    const deleteCountGenerated = features.delete && features.countMutations ? generateWriteCount({
+      db,
+      tableName,
+      table: schema[tableName],
+      kind: "delete",
+      filterArgs: tableFilters,
+      fieldName: deleteCountFieldName,
+      requireWhere: features.requireWhere,
+      filterCtx,
+      txCtx: mutationTxCtx
+    }) : void 0;
     const aggregateType = features.aggregates ? generateAggregateTypes(schema[tableName], tableName, typeName, cacheCtx) : void 0;
     const aggregateGenerated = features.aggregates ? generateAggregate(
       db,
@@ -4653,7 +5576,7 @@ function generateSchemaData2(db, schema, relations, options) {
     };
     if (aggregateGenerated && aggregateType) {
       queries[aggregateGenerated.name] = {
-        type: new GraphQLNonNull5(aggregateType),
+        type: new GraphQLNonNull7(aggregateType),
         args: aggregateGenerated.args,
         resolve: aggregateGenerated.resolver,
         ...complexity ? { extensions: { complexity: aggregateFieldComplexity(complexity) } } : {}
@@ -4661,7 +5584,7 @@ function generateSchemaData2(db, schema, relations, options) {
     }
     if (groupByGenerated && groupByType) {
       queries[groupByGenerated.name] = {
-        type: new GraphQLNonNull5(new GraphQLList5(new GraphQLNonNull5(groupByType))),
+        type: new GraphQLNonNull7(new GraphQLList7(new GraphQLNonNull7(groupByType))),
         args: groupByGenerated.args,
         resolve: groupByGenerated.resolver,
         ...complexity ? { extensions: { complexity: aggregateFieldComplexity(complexity) } } : {}
@@ -4676,7 +5599,9 @@ function generateSchemaData2(db, schema, relations, options) {
     }
     if (insertSingleGenerated) {
       mutations[insertSingleGenerated.name] = {
-        type: singleTableItemOutput,
+        // 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 GraphQLNonNull7(singleTableItemOutput),
         args: insertSingleGenerated.args,
         resolve: insertSingleGenerated.resolver
       };
@@ -4704,10 +5629,13 @@ function generateSchemaData2(db, schema, relations, options) {
     }
     if (updateManyGenerated) {
       mutations[updateManyGenerated.name] = {
-        // Nullable items: a no-match entry yields `null` in its slot.
-        type: new GraphQLNonNull5(new GraphQLList5(singleTableItemOutput)),
+        type: new GraphQLNonNull7(new GraphQLList7(singleTableItemOutput)),
         args: updateManyGenerated.args,
-        resolve: updateManyGenerated.resolver
+        resolve: updateManyGenerated.resolver,
+        // The nullable element is deliberate, and the reason this mutation's return type
+        // differs from every sibling's: the result is aligned with the input, one slot per
+        // entry, so an entry that matched nothing has to be able to say so.
+        description: "Each entry's updated rows, in entry order. An entry whose `where` matched no rows contributes `null` in its slot; an entry that matched several contributes each of its rows."
       };
     }
     if (updateSingleGenerated) {
@@ -4731,6 +5659,22 @@ function generateSchemaData2(db, schema, relations, options) {
         resolve: deleteSingleGenerated.resolver
       };
     }
+    if (updateCountGenerated) {
+      mutations[updateCountGenerated.name] = {
+        type: new GraphQLNonNull7(GraphQLInt6),
+        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 GraphQLNonNull7(GraphQLInt6),
+        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.
       ...features.insert || onConflictInput ? [insertInput] : [],
@@ -4762,7 +5706,7 @@ function generateSchemaData2(db, schema, relations, options) {
   for (const [tableName, tableRelations] of Object.entries(namedRelations)) {
     const relResolvers = {};
     for (const [relName, relEntry] of Object.entries(tableRelations)) {
-      const isOne = is5(relEntry.relation ?? relEntry, One4);
+      const isOne = is6(relEntry.relation ?? relEntry, One5);
       const resolver = resolverFactory({ tableName, relationName: relName, relEntry, isOne });
       if (resolver) {
         relResolvers[relName] = resolver;
@@ -4776,12 +5720,13 @@ function generateSchemaData2(db, schema, relations, options) {
 }
 
 // src/util/builders/sqlite.ts
-import { is as is6, One as One5 } from "drizzle-orm";
+import { is as is7, One as One6 } from "drizzle-orm";
 import { getTableConfig as getTableConfig3, SQLiteTable } from "drizzle-orm/sqlite-core";
 import {
-  GraphQLError as GraphQLError7,
-  GraphQLList as GraphQLList6,
-  GraphQLNonNull as GraphQLNonNull6
+  GraphQLError as GraphQLError9,
+  GraphQLInt as GraphQLInt7,
+  GraphQLList as GraphQLList8,
+  GraphQLNonNull as GraphQLNonNull8
 } from "graphql";
 import { parseResolveInfo as parseResolveInfo4 } from "graphql-parse-resolve-info";
 var generateSelectArray3 = (db, tableName, tables, relationMap, orderArgs, filterArgs, fieldName, typeName, typeNameMapper, filterCtx, distinctEnabled = true) => {
@@ -4867,10 +5812,10 @@ var generateSelectSingle3 = (db, tableName, tables, relationMap, orderArgs, filt
   };
 };
 var sqlitePrimaryKeyPropNames = (table) => getPrimaryKeyPropNamesFromConfig(table, getTableConfig3);
-var generateInsertArray3 = (db, tableName, table, tables, relationMap, baseType, fieldName, typeName, typeNameMapper, conflictDoNothing = false, txCtx) => {
+var generateInsertArray3 = (db, tableName, table, tables, relationMap, baseType, fieldName, typeName, typeNameMapper, conflictDoNothing = false, txCtx, nested) => {
   const queryArgs = {
     values: {
-      type: new GraphQLNonNull6(new GraphQLList6(new GraphQLNonNull6(baseType)))
+      type: new GraphQLNonNull8(new GraphQLList8(new GraphQLNonNull8(baseType)))
     }
   };
   const pkNames = sqlitePrimaryKeyPropNames(table);
@@ -4879,10 +5824,12 @@ var generateInsertArray3 = (db, tableName, table, tables, relationMap, baseType,
     resolver: async (_source, args, context, info) => {
       try {
         return await runMutation(db, context, info, txCtx, async (executor) => {
-          const input = remapFromGraphQLArrayInput(args.values, table);
-          if (!input.length) {
-            throw new GraphQLError7("No values were provided!");
+          if (!args.values.length) {
+            throw new GraphQLError9("No values were provided!");
           }
+          const entries = nested?.enabled(tableName) ? args.values.map((values) => nested.split(tableName, values)) : void 0;
+          const nestedEntries = entries?.some((entry) => nested.hasOps(entry.ops)) ? entries : void 0;
+          const input = nestedEntries ? [] : remapFromGraphQLArrayInput(entries ? entries.map((entry) => entry.columns) : args.values, table);
           const parsedInfo = parseResolveInfo4(info, {
             deep: true
           });
@@ -4896,11 +5843,22 @@ var generateInsertArray3 = (db, tableName, table, tables, relationMap, baseType,
             pkNames,
             parsedInfo
           });
-          let query = executor.insert(table).values(input).returning(columns);
-          if (conflictDoNothing) {
-            query = query.onConflictDoNothing();
-          }
-          const result = await query;
+          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) => remapFromGraphQLSingleInput(values, table),
+            write: (tx, values) => runInsert(tx, [values])
+          }) : await runInsert(executor, input);
           const enriched = hasRelations ? await eagerLoadMutationRelations(executor, tableName, result, pkNames, withParams) : result;
           return remapToGraphQLArrayOutput(enriched, tableName, table, relationMap);
         });
@@ -4911,10 +5869,10 @@ var generateInsertArray3 = (db, tableName, table, tables, relationMap, baseType,
     args: queryArgs
   };
 };
-var generateInsertSingle3 = (db, tableName, table, tables, relationMap, baseType, fieldName, typeName, typeNameMapper, conflictDoNothing = false, txCtx) => {
+var generateInsertSingle3 = (db, tableName, table, tables, relationMap, baseType, fieldName, typeName, typeNameMapper, conflictDoNothing = false, txCtx, nested) => {
   const queryArgs = {
     values: {
-      type: new GraphQLNonNull6(baseType)
+      type: new GraphQLNonNull8(baseType)
     }
   };
   const pkNames = sqlitePrimaryKeyPropNames(table);
@@ -4923,7 +5881,9 @@ var generateInsertSingle3 = (db, tableName, table, tables, relationMap, baseType
     resolver: async (_source, args, context, info) => {
       try {
         return await runMutation(db, context, info, txCtx, async (executor) => {
-          const input = remapFromGraphQLSingleInput(args.values, table);
+          const entry = nested?.enabled(tableName) ? nested.split(tableName, args.values) : void 0;
+          const nestedEntry = entry && nested.hasOps(entry.ops) ? entry : void 0;
+          const input = nestedEntry ? {} : remapFromGraphQLSingleInput(entry ? entry.columns : args.values, table);
           const parsedInfo = parseResolveInfo4(info, {
             deep: true
           });
@@ -4937,12 +5897,26 @@ var generateInsertSingle3 = (db, tableName, table, tables, relationMap, baseType
             pkNames,
             parsedInfo
           });
-          let query = executor.insert(table).values(input).returning(columns);
-          if (conflictDoNothing) {
-            query = query.onConflictDoNothing();
-          }
-          const result = await query;
+          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) => remapFromGraphQLSingleInput(values, table),
+            write: runInsert
+          }) : await runInsert(executor, input);
           if (!result[0]) {
+            if (!conflictDoNothing) {
+              throw new GraphQLError9(`${fieldName}: the insert returned no row.`);
+            }
             return void 0;
           }
           const enriched = hasRelations ? await eagerLoadMutationRelations(executor, tableName, result, pkNames, withParams) : result;
@@ -4955,10 +5929,10 @@ var generateInsertSingle3 = (db, tableName, table, tables, relationMap, baseType
     args: queryArgs
   };
 };
-var generateUpsert3 = (db, tableName, table, tables, relationMap, baseType, onConflictType, uniqueSets, fieldName, typeName, single, typeNameMapper, filterCtx, txCtx) => {
+var generateUpsert3 = (db, tableName, table, tables, relationMap, baseType, onConflictType, uniqueSets, fieldName, typeName, single, typeNameMapper, filterCtx, txCtx, nested) => {
   const queryArgs = {
     values: {
-      type: single ? new GraphQLNonNull6(baseType) : new GraphQLNonNull6(new GraphQLList6(new GraphQLNonNull6(baseType)))
+      type: single ? new GraphQLNonNull8(baseType) : new GraphQLNonNull8(new GraphQLList8(new GraphQLNonNull8(baseType)))
     },
     onConflict: {
       type: onConflictType,
@@ -4971,10 +5945,13 @@ var generateUpsert3 = (db, tableName, table, tables, relationMap, baseType, onCo
     resolver: async (_source, args, context, info) => {
       try {
         return await runMutation(db, context, info, txCtx, async (executor) => {
-          const input = single ? [remapFromGraphQLSingleInput(args.values, table)] : remapFromGraphQLArrayInput(args.values, table);
-          if (!input.length) {
-            throw new GraphQLError7("No values were provided!");
+          const supplied = single ? [args.values] : args.values;
+          if (!supplied.length) {
+            throw new GraphQLError9("No values were provided!");
           }
+          const entries = nested?.enabled(tableName) ? supplied.map((values) => nested.split(tableName, values)) : void 0;
+          const nestedEntries = entries?.some((entry) => nested.hasOps(entry.ops)) ? entries : void 0;
+          const input = nestedEntries ? [] : remapFromGraphQLArrayInput(entries ? entries.map((entry) => entry.columns) : supplied, table);
           const parsedInfo = parseResolveInfo4(info, { deep: true });
           const { columns, hasRelations, withParams } = prepareMutationRelationColumns({
             relationMap,
@@ -4986,19 +5963,30 @@ var generateUpsert3 = (db, tableName, table, tables, relationMap, baseType, onCo
             pkNames,
             parsedInfo
           });
-          const plan = resolveConflictPlan({
-            table,
-            values: input,
-            onConflict: args.onConflict,
-            pkNames,
-            uniqueSets,
-            excludedRef: excludedColumnRef,
-            withTarget: true,
-            buildWhere: (where) => extractFilters(table, tableName, where, relationFilterCtx(filterCtx, tableName))
-          });
-          let query = executor.insert(table).values(input).returning(columns);
-          query = plan.action === "NOTHING" ? query.onConflictDoNothing(plan.target ? { target: plan.target } : void 0) : query.onConflictDoUpdate({ target: plan.target, set: plan.set, setWhere: plan.setWhere });
-          const result = await query;
+          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);
+            query = plan.action === "NOTHING" ? query.onConflictDoNothing(plan.target ? { target: plan.target } : void 0) : query.onConflictDoUpdate({ target: plan.target, set: plan.set, setWhere: plan.setWhere });
+            return await query;
+          };
+          const result = nestedEntries ? await writeWithNestedOps({
+            executor,
+            runtime: nested,
+            tableName,
+            entries: nestedEntries,
+            remapValues: (values) => remapFromGraphQLSingleInput(values, table),
+            write: (tx, values) => runUpsert(tx, [values])
+          }) : await runUpsert(executor, input);
           if (single && !result[0]) {
             return void 0;
           }
@@ -5012,13 +6000,13 @@ var generateUpsert3 = (db, tableName, table, tables, relationMap, baseType, onCo
     args: queryArgs
   };
 };
-var generateUpdate3 = (db, tableName, table, tables, relationMap, setArgs, filterArgs, fieldName, typeName, single, requireWhere, typeNameMapper, filterCtx, txCtx) => {
+var generateUpdate3 = (db, tableName, table, tables, relationMap, setArgs, filterArgs, fieldName, typeName, single, requireWhere, typeNameMapper, filterCtx, txCtx, nested) => {
   const queryArgs = {
     set: {
-      type: new GraphQLNonNull6(setArgs)
+      type: new GraphQLNonNull8(setArgs)
     },
     where: {
-      type: single || requireWhere ? new GraphQLNonNull6(filterArgs) : filterArgs
+      type: single || requireWhere ? new GraphQLNonNull8(filterArgs) : filterArgs
     }
   };
   const pkNames = sqlitePrimaryKeyPropNames(table);
@@ -5041,23 +6029,37 @@ var generateUpdate3 = (db, tableName, table, tables, relationMap, setArgs, filte
             pkNames,
             parsedInfo
           });
-          const input = remapFromGraphQLSingleInput(set, table);
-          if (!Object.keys(input).length) {
-            throw new GraphQLError7("Unable to update with no values specified!");
+          const entry = nested?.enabled(tableName) ? nested.split(tableName, set) : void 0;
+          const nestedOps = entry && nested.hasOps(entry.ops) ? entry.ops : void 0;
+          const input = remapUpdateInput(entry ? entry.columns : set, table, tableName);
+          if (!Object.keys(input).length && !nestedOps) {
+            throw new GraphQLError9("Unable to update with no values specified!");
           }
           const relationCtx = relationFilterCtx(filterCtx, tableName);
           const filters = single || requireWhere ? extractRequiredFilters(table, tableName, where, fieldName, relationCtx) : where ? extractFilters(table, tableName, where, relationCtx) : void 0;
           if (single) {
             await assertSingleMatch(executor, table, filters, fieldName);
           }
-          let query = executor.update(table).set(input);
-          if (filters) {
-            query = query.where(filters);
-          }
-          query = query.returning(columns);
-          const result = await query;
+          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
+          }) : await runUpdate(executor, input);
           if (single && result.length > 1) {
-            throw new GraphQLError7(`${fieldName}: 'where' matched more than one row!`);
+            throw new GraphQLError9(`${fieldName}: 'where' matched more than one row!`);
           }
           if (single && !result[0]) {
             return void 0;
@@ -5072,10 +6074,10 @@ var generateUpdate3 = (db, tableName, table, tables, relationMap, setArgs, filte
     args: queryArgs
   };
 };
-var generateUpdateMany3 = (db, tableName, table, tables, relationMap, updateManyInput, fieldName, typeName, typeNameMapper, filterCtx, txCtx) => {
+var generateUpdateMany3 = (db, tableName, table, tables, relationMap, updateManyInput, fieldName, typeName, typeNameMapper, filterCtx, txCtx, nested) => {
   const queryArgs = {
     updates: {
-      type: new GraphQLNonNull6(new GraphQLList6(new GraphQLNonNull6(updateManyInput)))
+      type: new GraphQLNonNull8(new GraphQLList8(new GraphQLNonNull8(updateManyInput)))
     }
   };
   const pkNames = sqlitePrimaryKeyPropNames(table);
@@ -5086,7 +6088,7 @@ var generateUpdateMany3 = (db, tableName, table, tables, relationMap, updateMany
         return await runMutation(db, context, info, txCtx, async (executor) => {
           const { updates } = args;
           if (!updates.length) {
-            throw new GraphQLError7("No updates were provided!");
+            throw new GraphQLError9("No updates were provided!");
           }
           const parsedInfo = parseResolveInfo4(info, {
             deep: true
@@ -5102,23 +6104,55 @@ var generateUpdateMany3 = (db, tableName, table, tables, relationMap, updateMany
             parsedInfo
           });
           const entries = updates.map(({ where, set }) => {
-            const input = remapFromGraphQLSingleInput(set, table);
-            if (!Object.keys(input).length) {
-              throw new GraphQLError7("Unable to update with no values specified!");
+            const split = nested?.enabled(tableName) ? nested.split(tableName, set) : void 0;
+            const ops = split && nested.hasOps(split.ops) ? split.ops : void 0;
+            const input = remapUpdateInput(split ? split.columns : set, table, tableName);
+            if (!Object.keys(input).length && !ops) {
+              throw new GraphQLError9("Unable to update with no values specified!");
             }
             return {
               set: input,
+              ops,
               filters: where ? extractFilters(table, tableName, where, relationFilterCtx(filterCtx, tableName)) : void 0
             };
           });
+          const anyNested = entries.some((entry) => entry.ops);
+          const returning = anyNested ? nested.withJoinColumns(
+            tableName,
+            mergedOps(entries.map((entry) => ({ ops: entry.ops ?? {} }))),
+            { ...columns },
+            table
+          ) : columns;
           const runEntry = (tx, entry) => {
             let query = tx.update(table).set(entry.set);
             if (entry.filters) {
               query = query.where(entry.filters);
             }
-            return query.returning(columns).all();
+            return query.returning(returning).all();
+          };
+          const runNestedEntry = async (tx, entry) => {
+            const values = entry.ops ? { ...entry.set, ...await nested.applyParentSide(tx, tableName, entry.ops) } : entry.set;
+            const writes = Object.keys(values).length > 0;
+            let query = writes ? tx.update(table).set(values) : tx.select(returning).from(table);
+            if (entry.filters) {
+              query = query.where(entry.filters);
+            }
+            const rows = await (writes ? query.returning(returning) : query);
+            if (entry.ops) {
+              await nested.applyChildSide(tx, tableName, entry.ops, rows);
+            }
+            return rows;
           };
           const perEntry = await executor.transaction((tx) => {
+            if (anyNested) {
+              return (async () => {
+                const results2 = [];
+                for (const entry of entries) {
+                  results2.push(await runNestedEntry(tx, entry));
+                }
+                return results2;
+              })();
+            }
             const first = runEntry(tx, entries[0]);
             if (typeof first?.then === "function") {
               return (async () => {
@@ -5161,7 +6195,7 @@ var generateUpdateMany3 = (db, tableName, table, tables, relationMap, updateMany
 var generateDelete3 = (db, tableName, table, filterArgs, fieldName, typeName, single, requireWhere, filterCtx, selectionCtx, txCtx) => {
   const queryArgs = {
     where: {
-      type: single || requireWhere ? new GraphQLNonNull6(filterArgs) : filterArgs
+      type: single || requireWhere ? new GraphQLNonNull8(filterArgs) : filterArgs
     }
   };
   return {
@@ -5190,7 +6224,7 @@ var generateDelete3 = (db, tableName, table, filterArgs, fieldName, typeName, si
           query = query.returning(columns);
           const result = await query;
           if (single && result.length > 1) {
-            throw new GraphQLError7(`${fieldName}: 'where' matched more than one row!`);
+            throw new GraphQLError9(`${fieldName}: 'where' matched more than one row!`);
           }
           if (single) {
             return result[0] ? remapToGraphQLSingleOutput(result[0], tableName, table) : void 0;
@@ -5217,7 +6251,7 @@ var generateSchemaData3 = (db, schema, relations, options) => {
   } = options;
   const rawSchema = schema;
   const schemaEntries = Object.entries(rawSchema);
-  const tableEntries = schemaEntries.filter(([_key, value]) => is6(value, SQLiteTable));
+  const tableEntries = schemaEntries.filter(([_key, value]) => is7(value, SQLiteTable));
   const tables = Object.fromEntries(tableEntries);
   if (!tableEntries.length) {
     throw new Error(
@@ -5225,11 +6259,17 @@ var generateSchemaData3 = (db, schema, relations, options) => {
     );
   }
   registerScalarOverrides(tables, options);
+  registerEnumConfig(options);
   const namedRelations = buildNamedRelations(relations ?? {}, tableEntries);
   attachTargetPrimaryKeys(namedRelations, tables, sqlitePrimaryKeyPropNames);
   const eagerRelations = pruneNonEagerRelations(namedRelations, shouldEagerLoad);
   const filterCtx = { tables, relationMap: namedRelations };
-  const resolverFactory = createRelationResolverFactory(db, tables, filterCtx);
+  const resolverFactory = createRelationResolverFactory(
+    db,
+    tables,
+    "nulls-smallest",
+    filterCtx
+  );
   const cacheCtx = {
     genericFilterCache: /* @__PURE__ */ new Map(),
     objectTypeCache: /* @__PURE__ */ new Map(),
@@ -5242,8 +6282,24 @@ var generateSchemaData3 = (db, schema, relations, options) => {
     filterTypeCache: /* @__PURE__ */ new WeakMap(),
     listRelationFilterCache: /* @__PURE__ */ new Map(),
     aggregateTypeCache: /* @__PURE__ */ new Map(),
-    complexity
+    complexity,
+    docs: options.docs ?? {},
+    features
   };
+  if (features.nestedWrites && db.resultKind === "sync") {
+    throw new Error(
+      "Drizzle-GraphQL Error: features.nestedWrites requires an asynchronous SQLite driver (e.g. libsql). Synchronous drivers cannot run the multi-statement transaction a nested write needs."
+    );
+  }
+  const nestedPlans = features.nestedWrites ? buildNestedWritePlans(
+    tables,
+    namedRelations,
+    (target) => getUniqueColumnSets(target, getTableConfig3),
+    (target) => sqlitePrimaryKeyPropNames(target),
+    extractRelationJoinColumns
+  ) : void 0;
+  const nestedTypes = nestedPlans ? createNestedWriteTypes({ plans: nestedPlans, cacheCtx, typeNameMapper, insertPrefix: prefixes.insert }) : void 0;
+  const nestedRuntime = nestedPlans ? createNestedWriteRuntime({ plans: nestedPlans, filterCtx }) : void 0;
   const relationAggregateFactory = features.relationAggregates ? createRelationAggregateFactory(db, tables, cacheCtx, typeNameMapper, filterCtx) : void 0;
   const queries = {};
   const mutations = {};
@@ -5267,7 +6323,8 @@ var generateSchemaData3 = (db, schema, relations, options) => {
         prefixes.insert,
         prefixes.update,
         resolverFactory,
-        relationAggregateFactory
+        relationAggregateFactory,
+        nestedTypes
       )
     ])
   );
@@ -5289,8 +6346,10 @@ var generateSchemaData3 = (db, schema, relations, options) => {
       updateFieldName,
       updateManyFieldName,
       updateSingleFieldName,
+      updateCountFieldName,
       deleteFieldName,
-      deleteSingleFieldName
+      deleteSingleFieldName,
+      deleteCountFieldName
     } = computeResolverFieldNames(tableName, typeNameMapper, prefixes, suffixes);
     const selectArrGenerated = generateSelectArray3(
       db,
@@ -5328,7 +6387,8 @@ var generateSchemaData3 = (db, schema, relations, options) => {
       typeName,
       typeNameMapper,
       conflictDoNothing,
-      mutationTxCtx
+      mutationTxCtx,
+      nestedRuntime
     ) : void 0;
     const insertSingleGenerated = features.insert ? generateInsertSingle3(
       db,
@@ -5341,7 +6401,8 @@ var generateSchemaData3 = (db, schema, relations, options) => {
       typeName,
       typeNameMapper,
       conflictDoNothing,
-      mutationTxCtx
+      mutationTxCtx,
+      nestedRuntime
     ) : void 0;
     const uniqueSets = features.upsert ? getUniqueColumnSets(schema[tableName], getTableConfig3) : [];
     const onConflictInput = features.upsert ? generateOnConflictInput({
@@ -5365,7 +6426,8 @@ var generateSchemaData3 = (db, schema, relations, options) => {
       false,
       typeNameMapper,
       filterCtx,
-      mutationTxCtx
+      mutationTxCtx,
+      nestedRuntime
     ) : void 0;
     const upsertSingleGenerated = onConflictInput ? generateUpsert3(
       db,
@@ -5381,7 +6443,8 @@ var generateSchemaData3 = (db, schema, relations, options) => {
       true,
       typeNameMapper,
       filterCtx,
-      mutationTxCtx
+      mutationTxCtx,
+      nestedRuntime
     ) : void 0;
     const updateGenerated = features.update ? generateUpdate3(
       db,
@@ -5397,7 +6460,8 @@ var generateSchemaData3 = (db, schema, relations, options) => {
       features.requireWhere,
       typeNameMapper,
       filterCtx,
-      mutationTxCtx
+      mutationTxCtx,
+      nestedRuntime
     ) : void 0;
     const updateSingleGenerated = features.update ? generateUpdate3(
       db,
@@ -5413,7 +6477,8 @@ var generateSchemaData3 = (db, schema, relations, options) => {
       features.requireWhere,
       typeNameMapper,
       filterCtx,
-      mutationTxCtx
+      mutationTxCtx,
+      nestedRuntime
     ) : void 0;
     const updateManyInput = features.update && features.updateMany ? generateUpdateManyInput({ typeName, updatePrefix: prefixes.update, updateInput, tableFilters }) : void 0;
     const updateManyGenerated = updateManyInput ? generateUpdateMany3(
@@ -5427,7 +6492,8 @@ var generateSchemaData3 = (db, schema, relations, options) => {
       typeName,
       typeNameMapper,
       filterCtx,
-      mutationTxCtx
+      mutationTxCtx,
+      nestedRuntime
     ) : void 0;
     const deleteGenerated = features.delete ? generateDelete3(
       db,
@@ -5455,6 +6521,30 @@ var generateSchemaData3 = (db, schema, relations, options) => {
       { tableName, relationMap: namedRelations, tables },
       mutationTxCtx
     ) : void 0;
+    const updateCountGenerated = features.update && features.countMutations ? generateWriteCount({
+      db,
+      tableName,
+      table: schema[tableName],
+      kind: "update",
+      setArgs: updateInput,
+      filterArgs: tableFilters,
+      fieldName: updateCountFieldName,
+      requireWhere: features.requireWhere,
+      filterCtx,
+      txCtx: mutationTxCtx,
+      nested: nestedRuntime
+    }) : void 0;
+    const deleteCountGenerated = features.delete && features.countMutations ? generateWriteCount({
+      db,
+      tableName,
+      table: schema[tableName],
+      kind: "delete",
+      filterArgs: tableFilters,
+      fieldName: deleteCountFieldName,
+      requireWhere: features.requireWhere,
+      filterCtx,
+      txCtx: mutationTxCtx
+    }) : void 0;
     const aggregateType = features.aggregates ? generateAggregateTypes(schema[tableName], tableName, typeName, cacheCtx) : void 0;
     const aggregateGenerated = features.aggregates ? generateAggregate(
       db,
@@ -5492,7 +6582,7 @@ var generateSchemaData3 = (db, schema, relations, options) => {
     };
     if (aggregateGenerated && aggregateType) {
       queries[aggregateGenerated.name] = {
-        type: new GraphQLNonNull6(aggregateType),
+        type: new GraphQLNonNull8(aggregateType),
         args: aggregateGenerated.args,
         resolve: aggregateGenerated.resolver,
         ...complexity ? { extensions: { complexity: aggregateFieldComplexity(complexity) } } : {}
@@ -5500,7 +6590,7 @@ var generateSchemaData3 = (db, schema, relations, options) => {
     }
     if (groupByGenerated && groupByType) {
       queries[groupByGenerated.name] = {
-        type: new GraphQLNonNull6(new GraphQLList6(new GraphQLNonNull6(groupByType))),
+        type: new GraphQLNonNull8(new GraphQLList8(new GraphQLNonNull8(groupByType))),
         args: groupByGenerated.args,
         resolve: groupByGenerated.resolver,
         ...complexity ? { extensions: { complexity: aggregateFieldComplexity(complexity) } } : {}
@@ -5515,7 +6605,9 @@ var generateSchemaData3 = (db, schema, relations, options) => {
     }
     if (insertSingleGenerated) {
       mutations[insertSingleGenerated.name] = {
-        type: singleTableItemOutput,
+        // 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 GraphQLNonNull8(singleTableItemOutput),
         args: insertSingleGenerated.args,
         resolve: insertSingleGenerated.resolver
       };
@@ -5543,10 +6635,13 @@ var generateSchemaData3 = (db, schema, relations, options) => {
     }
     if (updateManyGenerated) {
       mutations[updateManyGenerated.name] = {
-        // Nullable items: a no-match entry yields `null` in its slot.
-        type: new GraphQLNonNull6(new GraphQLList6(singleTableItemOutput)),
+        type: new GraphQLNonNull8(new GraphQLList8(singleTableItemOutput)),
         args: updateManyGenerated.args,
-        resolve: updateManyGenerated.resolver
+        resolve: updateManyGenerated.resolver,
+        // The nullable element is deliberate, and the reason this mutation's return type
+        // differs from every sibling's: the result is aligned with the input, one slot per
+        // entry, so an entry that matched nothing has to be able to say so.
+        description: "Each entry's updated rows, in entry order. An entry whose `where` matched no rows contributes `null` in its slot; an entry that matched several contributes each of its rows."
       };
     }
     if (updateSingleGenerated) {
@@ -5570,6 +6665,22 @@ var generateSchemaData3 = (db, schema, relations, options) => {
         resolve: deleteSingleGenerated.resolver
       };
     }
+    if (updateCountGenerated) {
+      mutations[updateCountGenerated.name] = {
+        type: new GraphQLNonNull8(GraphQLInt7),
+        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 GraphQLNonNull8(GraphQLInt7),
+        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.
       ...features.insert || onConflictInput ? [insertInput] : [],
@@ -5601,7 +6712,7 @@ var generateSchemaData3 = (db, schema, relations, options) => {
   for (const [tableName, tableRelations] of Object.entries(namedRelations)) {
     const relResolvers = {};
     for (const [relName, relEntry] of Object.entries(tableRelations)) {
-      const isOne = is6(relEntry.relation ?? relEntry, One5);
+      const isOne = is7(relEntry.relation ?? relEntry, One6);
       const resolver = resolverFactory({ tableName, relationName: relName, relEntry, isOne });
       if (resolver) {
         relResolvers[relName] = resolver;
@@ -5646,6 +6757,9 @@ var buildSchema = (db, config) => {
     updateMany: config?.features?.updateMany ?? true,
     delete: config?.features?.delete ?? true,
     upsert: config?.features?.upsert ?? false,
+    nestedWrites: config?.features?.nestedWrites ?? false,
+    fieldUpdateOperations: config?.features?.fieldUpdateOperations ?? false,
+    countMutations: config?.features?.countMutations ?? false,
     requireWhere: config?.features?.requireWhere ?? false
   };
   const complexityConfig = config?.complexity ?? true;
@@ -5685,14 +6799,21 @@ var buildSchema = (db, config) => {
     complexity,
     scalars: config?.scalars,
     mapColumnType: config?.mapColumnType,
-    transactions
+    enumNameMapper: config?.enumNameMapper,
+    transactions,
+    docs: {
+      describeColumn: config?.describeColumn,
+      describeTable: config?.describeTable,
+      describeRelation: config?.describeRelation,
+      deprecateColumn: config?.deprecateColumn
+    }
   };
   let generatorOutput;
-  if (is7(db, MySqlDatabase)) {
+  if (is8(db, MySqlDatabase)) {
     generatorOutput = generateSchemaData(db, schema, relations, generatorOptions);
-  } else if (is7(db, PgAsyncDatabase)) {
+  } else if (is8(db, PgAsyncDatabase)) {
     generatorOutput = generateSchemaData2(db, schema, relations, generatorOptions);
-  } else if (is7(db, BaseSQLiteDatabase)) {
+  } else if (is8(db, BaseSQLiteDatabase)) {
     generatorOutput = generateSchemaData3(db, schema, relations, generatorOptions);
   } else {
     throw new Error("Drizzle-GraphQL Error: Unknown database instance type");