@vantreeseba/drizzle-graphql 5.6.0 → 7.0.0

package/dist/index.cjs

@@ -45,15 +45,15 @@ __export(index_exports, {
   extractRelationJoinColumns: () => extractRelationJoinColumns
 });
 module.exports = __toCommonJS(index_exports);
-var import_drizzle_orm8 = require("drizzle-orm");
+var import_drizzle_orm10 = require("drizzle-orm");
 var import_mysql_core3 = require("drizzle-orm/mysql-core");
 var import_pg_core3 = require("drizzle-orm/pg-core");
 var import_sqlite_core3 = require("drizzle-orm/sqlite-core");
-var import_graphql9 = require("graphql");
+var import_graphql11 = require("graphql");
 
 // src/util/builders/common.ts
-var import_drizzle_orm3 = require("drizzle-orm");
-var import_graphql4 = require("graphql");
+var import_drizzle_orm4 = require("drizzle-orm");
+var import_graphql5 = require("graphql");
 
 // src/util/batch-loader/index.ts
 var DRIZZLE_LOADERS_KEY = /* @__PURE__ */ Symbol("drizzle-graphql-loaders");
@@ -189,15 +189,42 @@ var GraphQLDecimalString = new import_graphql.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 import_graphql2.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,
@@ -206,7 +233,7 @@ var generateEnumCached = (column, columnName, tableName) => {
       ])
     )
   });
-  enumMap.set(column, gqlEnum);
+  enumNamesInUse.set(name, { type: gqlEnum, valuesKey });
   return gqlEnum;
 };
 var geoXyType = new import_graphql2.GraphQLObjectType({
@@ -227,14 +254,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 import_graphql2.GraphQLList(new import_graphql2.GraphQLNonNull(type));
-      description = `Array<${description}>`;
+      typeLabel = `Array<${typeLabel}>`;
     }
-    return { type, description };
+    return { type, typeLabel };
   }
   return columnBaseToGraphQLCore(column, columnName, tableName, isInput);
 };
@@ -242,51 +269,51 @@ var columnBaseToGraphQLCore = (column, columnName, tableName, isInput) => {
   const { type: baseType, constraint } = (0, import_drizzle_orm.extractExtendedColumnType)(column);
   switch (baseType) {
     case "boolean":
-      return { type: import_graphql2.GraphQLBoolean, description: "Boolean" };
+      return { type: import_graphql2.GraphQLBoolean, typeLabel: "Boolean" };
     case "object":
       if (column instanceof import_pg_core.PgTimestamp || column instanceof import_pg_core.PgDate) {
-        return { type: import_graphql_scalars.GraphQLDateTime, description: "DateTime" };
+        return { type: import_graphql_scalars.GraphQLDateTime, typeLabel: "DateTime" };
       }
       return column.columnType === "PgGeometryObject" ? {
         type: isInput ? geoXyInputType : geoXyType,
-        description: "Geometry points XY"
+        typeLabel: "Geometry points XY"
       } : column.columnType === "PgBytea" ? {
         type: new import_graphql2.GraphQLList(new import_graphql2.GraphQLNonNull(import_graphql2.GraphQLInt)),
-        description: "Buffer"
-      } : { type: import_graphql_scalars.GraphQLJSON, description: "JSON" };
+        typeLabel: "Buffer"
+      } : { type: import_graphql_scalars.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 import_pg_core.PgTimestamp || column instanceof import_pg_core.PgTimestampString) {
-        return { type: import_graphql_scalars.GraphQLDateTime, description: "DateTime" };
+        return { type: import_graphql_scalars.GraphQLDateTime, typeLabel: "DateTime" };
       }
       if (column instanceof import_pg_core.PgUUID) {
-        return { type: import_graphql_scalars.GraphQLUUID, description: "UUID" };
+        return { type: import_graphql_scalars.GraphQLUUID, typeLabel: "UUID" };
       }
       if (column instanceof import_pg_core.PgDateString) {
-        return isInput ? { type: import_graphql2.GraphQLString, description: "Date" } : { type: import_graphql_scalars.GraphQLDate, description: "Date" };
+        return isInput ? { type: import_graphql2.GraphQLString, typeLabel: "Date" } : { type: import_graphql_scalars.GraphQLDate, typeLabel: "Date" };
       }
-      return { type: import_graphql2.GraphQLString, description: "String" };
+      return { type: import_graphql2.GraphQLString, typeLabel: "String" };
     case "bigint":
-      return { type: GraphQLBigIntString, description: "BigInt" };
+      return { type: GraphQLBigIntString, typeLabel: "BigInt" };
     case "number": {
-      return (0, import_drizzle_orm.is)(column, import_pg_core.PgInteger) || (0, import_drizzle_orm.is)(column, import_pg_core.PgSerial) || (0, import_drizzle_orm.is)(column, import_mysql_core.MySqlInt) || (0, import_drizzle_orm.is)(column, import_mysql_core.MySqlSerial) || (0, import_drizzle_orm.is)(column, import_sqlite_core.SQLiteInteger) ? { type: import_graphql2.GraphQLInt, description: "Integer" } : { type: import_graphql2.GraphQLFloat, description: "Float" };
+      return (0, import_drizzle_orm.is)(column, import_pg_core.PgInteger) || (0, import_drizzle_orm.is)(column, import_pg_core.PgSerial) || (0, import_drizzle_orm.is)(column, import_mysql_core.MySqlInt) || (0, import_drizzle_orm.is)(column, import_mysql_core.MySqlSerial) || (0, import_drizzle_orm.is)(column, import_sqlite_core.SQLiteInteger) ? { type: import_graphql2.GraphQLInt, typeLabel: "Integer" } : { type: import_graphql2.GraphQLFloat, typeLabel: "Float" };
     }
     case "array": {
       if (column.columnType === "PgVector") {
         return {
           type: new import_graphql2.GraphQLList(new import_graphql2.GraphQLNonNull(import_graphql2.GraphQLFloat)),
-          description: "Array<Float>"
+          typeLabel: "Array<Float>"
         };
       }
       if (column.columnType === "PgGeometry") {
         return {
           type: new import_graphql2.GraphQLList(new import_graphql2.GraphQLNonNull(import_graphql2.GraphQLFloat)),
-          description: "Tuple<[Float, Float]>"
+          typeLabel: "Tuple<[Float, Float]>"
         };
       }
       const innerType = columnToGraphQLCore(
@@ -297,7 +324,7 @@ var columnBaseToGraphQLCore = (column, columnName, tableName, isInput) => {
       );
       return {
         type: new import_graphql2.GraphQLList(new import_graphql2.GraphQLNonNull(innerType.type)),
-        description: `Array<${innerType.description}>`
+        typeLabel: `Array<${innerType.typeLabel}>`
       };
     }
     default:
@@ -353,24 +380,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 } = (0, import_drizzle_orm.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 import_graphql2.GraphQLNonNull(typeDesc.type),
-      description: typeDesc.description
+      typeLabel: typeDesc.typeLabel
     };
   }
   return typeDesc;
@@ -576,6 +593,124 @@ var remapFromGraphQLArrayInput = (queryInput, table) => {
   return queryInput;
 };
 
+// src/util/builders/field-updates.ts
+var import_drizzle_orm3 = require("drizzle-orm");
+var import_graphql4 = require("graphql");
+var NUMERIC_SCALARS = /* @__PURE__ */ new Set([
+  import_graphql4.GraphQLInt,
+  import_graphql4.GraphQLFloat,
+  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 import_graphql4.GraphQLList && !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 import_graphql4.GraphQLInputObjectType({ 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 import_graphql4.GraphQLNonNull ? 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 import_graphql4.GraphQLError(
+    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 = (0, import_drizzle_orm3.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 = import_drizzle_orm3.sql.param(remapFromGraphQLCore(operand, column, columnName), column);
+    expressions[columnName] = operation === "increment" ? import_drizzle_orm3.sql`${column} + ${param}` : operation === "decrement" ? import_drizzle_orm3.sql`${column} - ${param}` : operation === "multiply" ? import_drizzle_orm3.sql`${column} * ${param}` : operation === "divide" ? import_drizzle_orm3.sql`${column} / ${param}` : (
+      // `push`: array concatenation, which is the only dialect-specific operation
+      // here — and arrays are a PostgreSQL column type to begin with.
+      import_drizzle_orm3.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) => {
@@ -638,9 +773,9 @@ var extractRelationJoinColumns = (relEntry, parentTable, targetTable) => {
   }
   const sourceCol = sourceColumns[0];
   const targetCol = targetColumns[0];
-  const parentCols = (0, import_drizzle_orm3.getColumns)(parentTable);
+  const parentCols = (0, import_drizzle_orm4.getColumns)(parentTable);
   const localColPropName = Object.entries(parentCols).find(([, c]) => c === sourceCol)?.[0];
-  const targetCols = (0, import_drizzle_orm3.getColumns)(targetTable);
+  const targetCols = (0, import_drizzle_orm4.getColumns)(targetTable);
   const foreignColPropName = Object.entries(targetCols).find(([, c]) => c === targetCol)?.[0];
   if (!localColPropName || !foreignColPropName) {
     return void 0;
@@ -722,7 +857,7 @@ var collectRootMutationKeys = (selectionSet, fragments, variables, known, keys,
   }
   return true;
 };
-var abortedBatchError = () => new import_graphql4.GraphQLError(
+var abortedBatchError = () => new import_graphql5.GraphQLError(
   "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) => {
@@ -780,7 +915,7 @@ var openSharedTx = (db, context, txCtx, stateKey, expected) => {
       }
       timer = setTimeout(() => {
         state.abort(
-          new import_graphql4.GraphQLError(
+          new import_graphql5.GraphQLError(
             `Drizzle-GraphQL Error: Shared mutation transaction timed out after ${txCtx.timeoutMs}ms waiting for the remaining mutation fields; rolling back.`
           )
         );
@@ -862,27 +997,27 @@ 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 = (0, import_drizzle_orm3.getColumns)(targetTable);
+  const cols = (0, import_drizzle_orm4.getColumns)(targetTable);
   const orderExprs = [
     ...orderByArg ? extractOrderBy(targetTable, orderByArg, orderCtx) : [],
     ...primaryKeyOrderExprs(targetTable, pkNames)
   ];
-  const orderClause = orderExprs.length ? import_drizzle_orm3.sql` order by ${import_drizzle_orm3.sql.join(orderExprs, import_drizzle_orm3.sql`, `)}` : import_drizzle_orm3.sql``;
+  const orderClause = orderExprs.length ? import_drizzle_orm4.sql` order by ${import_drizzle_orm4.sql.join(orderExprs, import_drizzle_orm4.sql`, `)}` : import_drizzle_orm4.sql``;
   const RN = "__drizzle_graphql_rn";
-  const rowNumber = import_drizzle_orm3.sql`row_number() over (partition by ${foreignCol}${orderClause})`.as(RN);
+  const rowNumber = import_drizzle_orm4.sql`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 = [(0, import_drizzle_orm3.gt)(sub[RN], lower)];
+  const windowConds = [(0, import_drizzle_orm4.gt)(sub[RN], lower)];
   if (limit != null) {
-    windowConds.push((0, import_drizzle_orm3.lte)(sub[RN], lower + limit));
+    windowConds.push((0, import_drizzle_orm4.lte)(sub[RN], lower + limit));
   }
-  const rows = await db.select().from(sub).where((0, import_drizzle_orm3.and)(...windowConds)).orderBy(sub[RN]);
+  const rows = await db.select().from(sub).where((0, import_drizzle_orm4.and)(...windowConds)).orderBy(sub[RN]);
   for (const row of rows) {
     delete row[RN];
   }
   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];
@@ -895,7 +1030,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];
     }
@@ -903,21 +1038,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 import_graphql5.GraphQLError("'after' cannot be combined with 'distinct'.");
+      }
+      if (orderByHasRelationEntry(orderByArg)) {
+        if (after != null) {
+          throw new import_graphql5.GraphQLError(
+            "'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 import_graphql5.GraphQLError(
+            `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 = (0, import_drizzle_orm3.and)(
-        (0, import_drizzle_orm3.inArray)(foreignCol, uniqueIds),
-        whereArg ? extractFilters(targetTable, targetTableName, whereArg, relationFilterCtx(filterCtx, targetTableName)) : void 0
+      let whereCondition = (0, import_drizzle_orm4.and)(
+        (0, import_drizzle_orm4.inArray)(foreignCol, uniqueIds),
+        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 = (0, import_drizzle_orm4.and)(whereCondition, primaryKeyRestriction(targetTable, targetPkNames, keys));
+      }
       let rows;
       if (limit != null || offset != null) {
         rows = await batchedPaginatedRelationQuery(
@@ -933,11 +1112,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);
@@ -953,6 +1136,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 import_graphql5.GraphQLNonNull) {
+    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;
@@ -960,18 +1159,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 = (0, import_drizzle_orm3.getColumns)(table);
+  const tableColumns = (0, import_drizzle_orm4.getColumns)(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;
@@ -984,7 +1186,7 @@ var relationAggregateJoinColumns = (tree, table, selectionCtx) => {
   return needed;
 };
 var extractSelectedColumnsFromTree = (tree, table, selectionCtx) => {
-  const tableColumns = (0, import_drizzle_orm3.getColumns)(table);
+  const tableColumns = (0, import_drizzle_orm4.getColumns)(table);
   const treeEntries = Object.entries(tree);
   const selectedColumns = [];
   for (const [_fieldName, fieldData] of treeEntries) {
@@ -993,7 +1195,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) {
@@ -1004,7 +1206,7 @@ var extractSelectedColumnsFromTree = (tree, table, selectionCtx) => {
   return Object.fromEntries(selectedColumns);
 };
 var extractSelectedColumnsFromTreeSQLFormat = (tree, table, selectionCtx) => {
-  const tableColumns = (0, import_drizzle_orm3.getColumns)(table);
+  const tableColumns = (0, import_drizzle_orm4.getColumns)(table);
   const treeEntries = Object.entries(tree);
   const selectedColumns = [];
   for (const [_fieldName, fieldData] of treeEntries) {
@@ -1013,7 +1215,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) {
@@ -1023,7 +1225,7 @@ var extractSelectedColumnsFromTreeSQLFormat = (tree, table, selectionCtx) => {
   }
   return Object.fromEntries(selectedColumns);
 };
-var orderNulls = new import_graphql4.GraphQLEnumType({
+var orderNulls = new import_graphql5.GraphQLEnumType({
   name: "OrderNulls",
   description: "Where NULL values sort relative to non-NULL values",
   values: {
@@ -1037,12 +1239,12 @@ var orderNulls = new import_graphql4.GraphQLEnumType({
     }
   }
 });
-var innerOrder = new import_graphql4.GraphQLInputObjectType({
+var innerOrder = new import_graphql5.GraphQLInputObjectType({
   name: "InnerOrder",
   fields: {
     direction: {
-      type: new import_graphql4.GraphQLNonNull(
-        new import_graphql4.GraphQLEnumType({
+      type: new import_graphql5.GraphQLNonNull(
+        new import_graphql5.GraphQLEnumType({
           name: "OrderDirection",
           description: "Order by direction",
           values: {
@@ -1059,7 +1261,7 @@ var innerOrder = new import_graphql4.GraphQLInputObjectType({
       )
     },
     priority: {
-      type: new import_graphql4.GraphQLNonNull(import_graphql4.GraphQLInt),
+      type: new import_graphql5.GraphQLNonNull(import_graphql5.GraphQLInt),
       description: "Priority of current field"
     },
     nulls: {
@@ -1085,9 +1287,9 @@ var resolveGenericFilterDescriptor = (column, columnGraphQLType) => {
   if (columnGraphQLType.type === import_graphql_scalars.GraphQLJSON) {
     return { name: "JSON", kind: "json" };
   }
-  if (columnGraphQLType.type instanceof import_graphql4.GraphQLList) {
+  if (columnGraphQLType.type instanceof import_graphql5.GraphQLList) {
     let element = columnGraphQLType.type.ofType;
-    if (element instanceof import_graphql4.GraphQLNonNull) {
+    if (element instanceof import_graphql5.GraphQLNonNull) {
       element = element.ofType;
     }
     return { name: `${element.name}Array`, kind: "array" };
@@ -1095,10 +1297,10 @@ var resolveGenericFilterDescriptor = (column, columnGraphQLType) => {
   if (columnGraphQLType.type === import_graphql_scalars.GraphQLUUID) {
     return { name: "Id", kind: "scalar" };
   }
-  if (columnGraphQLType.type === import_graphql4.GraphQLBoolean) {
+  if (columnGraphQLType.type === import_graphql5.GraphQLBoolean) {
     return { name: "Boolean", kind: "scalar" };
   }
-  if (columnGraphQLType.type instanceof import_graphql4.GraphQLEnumType) {
+  if (columnGraphQLType.type instanceof import_graphql5.GraphQLEnumType) {
     return { name: columnGraphQLType.type.name, kind: "scalar" };
   }
   if (columnGraphQLType.type === GraphQLBigIntString) {
@@ -1111,10 +1313,10 @@ var resolveGenericFilterDescriptor = (column, columnGraphQLType) => {
   if (ct === "PgTimestamp" || ct === "PgTimestampString" || ct === "PgDate") {
     return { name: "DateTime", kind: "scalar" };
   }
-  if (columnGraphQLType.type === import_graphql4.GraphQLInt) {
+  if (columnGraphQLType.type === import_graphql5.GraphQLInt) {
     return { name: "Int", kind: "scalar" };
   }
-  if (columnGraphQLType.type === import_graphql4.GraphQLFloat) {
+  if (columnGraphQLType.type === import_graphql5.GraphQLFloat) {
     return { name: "Float", kind: "scalar" };
   }
   return { name: "String", kind: "scalar" };
@@ -1130,35 +1332,37 @@ var jsonFilterFields = (column, colType) => {
         description: "Value structurally contains this JSON (Postgres `@>` / MySQL JSON_CONTAINS)"
       }
     } : {},
-    isNull: { type: import_graphql4.GraphQLBoolean },
-    isNotNull: { type: import_graphql4.GraphQLBoolean }
+    isNull: { type: import_graphql5.GraphQLBoolean },
+    isNotNull: { type: import_graphql5.GraphQLBoolean }
   };
 };
-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 import_graphql4.GraphQLNonNull) {
+  if (element instanceof import_graphql5.GraphQLNonNull) {
     element = element.ofType;
   }
-  const elementList = new import_graphql4.GraphQLList(new import_graphql4.GraphQLNonNull(element));
+  const elementList = new import_graphql5.GraphQLList(new import_graphql5.GraphQLNonNull(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: import_graphql4.GraphQLBoolean, description: "When true, matches arrays with no elements" },
-    inArray: { type: colArr, description: `Array<${colDesc}>` },
-    notInArray: { type: colArr, description: `Array<${colDesc}>` },
-    isNull: { type: import_graphql4.GraphQLBoolean },
-    isNotNull: { type: import_graphql4.GraphQLBoolean }
+    isEmpty: { type: import_graphql5.GraphQLBoolean, description: "When true, matches arrays with no elements" },
+    inArray: { type: colArr, description: IN_ARRAY_DESCRIPTION },
+    notInArray: { type: colArr, description: NOT_IN_ARRAY_DESCRIPTION },
+    isNull: { type: import_graphql5.GraphQLBoolean },
+    isNotNull: { type: import_graphql5.GraphQLBoolean }
   };
 };
 var FILTERS_WITHOUT_STRING_OPS = /* @__PURE__ */ new Set(["Id", "Int", "Float", "BigInt", "Decimal"]);
 var BUILTIN_FILTER_SCALARS = /* @__PURE__ */ new Set([
-  import_graphql4.GraphQLString,
-  import_graphql4.GraphQLInt,
-  import_graphql4.GraphQLFloat,
-  import_graphql4.GraphQLBoolean,
+  import_graphql5.GraphQLString,
+  import_graphql5.GraphQLInt,
+  import_graphql5.GraphQLFloat,
+  import_graphql5.GraphQLBoolean,
   GraphQLBigIntString,
   GraphQLDecimalString,
   import_graphql_scalars.GraphQLUUID,
@@ -1184,63 +1388,62 @@ var generateColumnFilterValues = (column, tableName, columnName, cacheCtx) => {
     return cached;
   }
   const colType = columnGraphQLType.type;
-  const colDesc = columnGraphQLType.description;
-  const colArr = new import_graphql4.GraphQLList(new import_graphql4.GraphQLNonNull(colType));
+  const colArr = new import_graphql5.GraphQLList(new import_graphql5.GraphQLNonNull(colType));
   const customOverrideFilter = inputOverride !== void 0 && !BUILTIN_FILTER_SCALARS.has(inputOverride);
-  const underlying = (0, import_drizzle_orm3.extractExtendedColumnType)(column);
+  const underlying = (0, import_drizzle_orm4.extractExtendedColumnType)(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: import_graphql4.GraphQLString },
-      notLike: { type: import_graphql4.GraphQLString },
-      ilike: { type: import_graphql4.GraphQLString },
-      notIlike: { type: import_graphql4.GraphQLString },
+      like: { type: import_graphql5.GraphQLString },
+      notLike: { type: import_graphql5.GraphQLString },
+      ilike: { type: import_graphql5.GraphQLString },
+      notIlike: { type: import_graphql5.GraphQLString },
       startsWith: {
-        type: import_graphql4.GraphQLString,
+        type: import_graphql5.GraphQLString,
         description: "Matches values starting with the given string. `%`, `_` and `\\` are matched literally."
       },
       endsWith: {
-        type: import_graphql4.GraphQLString,
+        type: import_graphql5.GraphQLString,
         description: "Matches values ending with the given string. `%`, `_` and `\\` are matched literally."
       },
       contains: {
-        type: import_graphql4.GraphQLString,
+        type: import_graphql5.GraphQLString,
         description: "Matches values containing the given string. `%`, `_` and `\\` are matched literally."
       },
       iStartsWith: {
-        type: import_graphql4.GraphQLString,
+        type: import_graphql5.GraphQLString,
         description: "Case-insensitive `startsWith`."
       },
       iEndsWith: {
-        type: import_graphql4.GraphQLString,
+        type: import_graphql5.GraphQLString,
         description: "Case-insensitive `endsWith`."
       },
       iContains: {
-        type: import_graphql4.GraphQLString,
+        type: import_graphql5.GraphQLString,
         description: "Case-insensitive `contains`."
       }
     },
-    inArray: { type: colArr, description: `Array<${colDesc}>` },
-    notInArray: { type: colArr, description: `Array<${colDesc}>` },
-    isNull: { type: import_graphql4.GraphQLBoolean },
-    isNotNull: { type: import_graphql4.GraphQLBoolean }
+    inArray: { type: colArr, description: IN_ARRAY_DESCRIPTION },
+    notInArray: { type: colArr, description: NOT_IN_ARRAY_DESCRIPTION },
+    isNull: { type: import_graphql5.GraphQLBoolean, description: "When true, matches rows where the column is NULL" },
+    isNotNull: { type: import_graphql5.GraphQLBoolean, description: "When true, matches rows where the column is not NULL" }
   };
-  const mainType = new import_graphql4.GraphQLInputObjectType({
+  const mainType = new import_graphql5.GraphQLInputObjectType({
     name: `${genericName}Filter`,
     fields: () => ({
       ...baseFields,
       OR: {
-        type: new import_graphql4.GraphQLList(new import_graphql4.GraphQLNonNull(mainType)),
+        type: new import_graphql5.GraphQLList(new import_graphql5.GraphQLNonNull(mainType)),
         description: "At least one branch matches; ANDed with any sibling operators"
       },
       AND: {
-        type: new import_graphql4.GraphQLList(new import_graphql4.GraphQLNonNull(mainType)),
+        type: new import_graphql5.GraphQLList(new import_graphql5.GraphQLNonNull(mainType)),
         description: "Every branch matches"
       },
       NOT: {
@@ -1259,7 +1462,7 @@ var generateTableOrderCached = (table) => {
   }
   let remapped = {};
   try {
-    const columns = (0, import_drizzle_orm3.getColumns)(table);
+    const columns = (0, import_drizzle_orm4.getColumns)(table);
     const columnEntries = Object.entries(columns);
     remapped = Object.fromEntries(
       columnEntries.map(([columnName, _columnDescription]) => [columnName, { type: innerOrder }])
@@ -1273,13 +1476,17 @@ var generateTableFilterValuesCached = (table, tableName, cacheCtx) => {
   if (cacheCtx.filterFieldCache.has(table)) {
     return cacheCtx.filterFieldCache.get(table);
   }
-  const columns = (0, import_drizzle_orm3.getColumns)(table);
+  const columns = (0, import_drizzle_orm4.getColumns)(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 }) } : {}
       }
     ])
   );
@@ -1290,17 +1497,20 @@ var generateTableSelectTypeFieldsCached = (table, tableName, cacheCtx) => {
   if (cacheCtx.selectFieldCache.has(table)) {
     return cacheCtx.selectFieldCache.get(table);
   }
-  const columns = (0, import_drizzle_orm3.getColumns)(table);
+  const columns = (0, import_drizzle_orm4.getColumns)(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]) {
     remapped[CURSOR_FIELD_NAME] = {
-      type: import_graphql4.GraphQLString,
+      type: import_graphql5.GraphQLString,
       description: "Opaque cursor of this row's position in the query's ordering. Pass it as `after` to resume from here. Only set on rows returned by a list query.",
       resolve: rowCursorResolver
     };
@@ -1321,7 +1531,7 @@ var generateRelationOrderFields = (tableName, cacheCtx, typeNameMapper, columnFi
     }
     const targetTable = tables[relEntry.targetTableName];
     const relation = relEntry.relation ?? relEntry;
-    if (!targetTable || !(0, import_drizzle_orm3.is)(relation, import_drizzle_orm3.One) || !isFilterableRelation(relation)) {
+    if (!targetTable || !(0, import_drizzle_orm4.is)(relation, import_drizzle_orm4.One) || !isFilterableRelation(relation)) {
       continue;
     }
     fields[relationName] = {
@@ -1342,7 +1552,7 @@ var generateTableOrderTypeCached = (table, tableName, typeNameMapper, cacheCtx,
   if (cacheCtx.orderTypeCache.has(table)) {
     return cacheCtx.orderTypeCache.get(table);
   }
-  const order = new import_graphql4.GraphQLInputObjectType({
+  const order = new import_graphql5.GraphQLInputObjectType({
     name: `${resolveTypeName(tableName, typeNameMapper)}OrderBy`,
     fields: () => {
       const orderColumns = generateTableOrderCached(table);
@@ -1360,7 +1570,7 @@ var generateListRelationFilterCached = (targetTable, targetTableName, cacheCtx,
   if (cached) {
     return cached;
   }
-  const listFilter = new import_graphql4.GraphQLInputObjectType({
+  const listFilter = new import_graphql5.GraphQLInputObjectType({
     name: `${resolveTypeName(targetTableName, typeNameMapper)}ListRelationFilter`,
     fields: () => {
       const targetFilters = generateTableFilterTypeCached(
@@ -1396,7 +1606,7 @@ var generateRelationFilterFields = (tableName, cacheCtx, typeNameMapper, columnF
     if (!targetTable) {
       continue;
     }
-    fields[relationName] = (0, import_drizzle_orm3.is)(relation, import_drizzle_orm3.One) ? {
+    fields[relationName] = (0, import_drizzle_orm4.is)(relation, import_drizzle_orm4.One) ? {
       type: generateTableFilterTypeCached(
         targetTable,
         relEntry.targetTableName,
@@ -1430,16 +1640,16 @@ var generateTableFilterTypeCached = (table, tableName, cacheCtx, typeNameMapper,
       ...generateRelationFilterFields(tableName, cacheCtx, typeNameMapper, filterColumns, relationMap, tables)
     };
   };
-  const filters = new import_graphql4.GraphQLInputObjectType({
+  const filters = new import_graphql5.GraphQLInputObjectType({
     name: `${resolveTypeName(tableName, typeNameMapper)}Filters`,
     fields: () => ({
       ...buildFields(),
       OR: {
-        type: new import_graphql4.GraphQLList(new import_graphql4.GraphQLNonNull(filters)),
+        type: new import_graphql5.GraphQLList(new import_graphql5.GraphQLNonNull(filters)),
         description: "At least one branch matches; ANDed with any sibling fields"
       },
       AND: {
-        type: new import_graphql4.GraphQLList(new import_graphql4.GraphQLNonNull(filters)),
+        type: new import_graphql5.GraphQLList(new import_graphql5.GraphQLNonNull(filters)),
         description: "Every branch matches"
       },
       NOT: {
@@ -1490,8 +1700,9 @@ var generateSelectFields = (tables, tableName, relationMap, fromTableName, fromR
   }
   if (isRootCall && !cacheCtx.objectTypeCache.has(tableName)) {
     const typeName = resolveTypeName(tableName, typeNameMapper);
-    const shell = new import_graphql4.GraphQLObjectType({
+    const shell = new import_graphql5.GraphQLObjectType({
       name: typeName,
+      description: cacheCtx.docs.describeTable?.(tableName),
       fields: () => ({ ...tableFields, ...container.fields })
     });
     cacheCtx.objectTypeCache.set(tableName, shell);
@@ -1503,7 +1714,7 @@ var generateSelectFields = (tables, tableName, relationMap, fromTableName, fromR
     for (const [relationName, relEntry] of relationEntries) {
       const { targetTableName } = relEntry;
       const relation = relEntry.relation ?? relEntry;
-      const isOne = (0, import_drizzle_orm3.is)(relation, import_drizzle_orm3.One);
+      const isOne = (0, import_drizzle_orm4.is)(relation, import_drizzle_orm4.One);
       const relSelectData = generateSelectFields(
         tables,
         targetTableName,
@@ -1531,38 +1742,49 @@ var generateSelectFields = (tables, tableName, relationMap, fromTableName, fromR
           cacheCtx.relationFieldContainers.set(targetTableName, targetContainer);
         }
         const capturedTargetContainer = targetContainer;
-        relType = new import_graphql4.GraphQLObjectType({
+        relType = new import_graphql5.GraphQLObjectType({
           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 import_graphql4.GraphQLNonNull(relType) : relType,
+            type: isRequired ? new import_graphql5.GraphQLNonNull(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 import_graphql4.GraphQLNonNull(new import_graphql4.GraphQLList(new import_graphql4.GraphQLNonNull(relType))),
+          type: new import_graphql5.GraphQLNonNull(new import_graphql5.GraphQLList(new import_graphql5.GraphQLNonNull(relType))),
           args: {
             where: { type: relSelectData.filters },
             orderBy: { type: relSelectData.order },
-            offset: { type: import_graphql4.GraphQLInt },
-            limit: { type: import_graphql4.GraphQLInt }
+            offset: { type: import_graphql5.GraphQLInt },
+            limit: { type: import_graphql5.GraphQLInt },
+            after: {
+              type: import_graphql5.GraphQLString,
+              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 import_graphql5.GraphQLList(new import_graphql5.GraphQLNonNull(targetDistinctEnum)) } } : {}
           },
           resolve,
+          ...relationDocs,
           ...cacheCtx.complexity ? { extensions: { complexity: listFieldComplexity(cacheCtx.complexity) } } : {}
         }
       ]);
@@ -1577,7 +1799,7 @@ var generateSelectFields = (tables, tableName, relationMap, fromTableName, fromR
           rawRelationFields.push([
             aggregateFieldName,
             {
-              type: new import_graphql4.GraphQLNonNull(relationAggregate.type),
+              type: new import_graphql5.GraphQLNonNull(relationAggregate.type),
               args: {
                 where: { type: relSelectData.filters }
               },
@@ -1610,7 +1832,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,
@@ -1629,36 +1851,51 @@ var generateTableTypes = (tableName, tables, relationMap, withReturning, relatio
     relationAggregateFactory
   );
   const table = tables[tableName];
-  const columns = (0, import_drizzle_orm3.getColumns)(table);
+  const columns = (0, import_drizzle_orm4.getColumns)(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 import_graphql4.GraphQLInputObjectType({
-    name: `${capitalize(insertPrefix)}${resolveTypeName(tableName, typeNameMapper)}Input`,
-    fields: insertFields
+  const typeName = resolveTypeName(tableName, typeNameMapper);
+  const insertInput = new import_graphql5.GraphQLInputObjectType({
+    name: `${capitalize(insertPrefix)}${typeName}Input`,
+    fields: nestedWrites ? () => ({ ...insertFields, ...nestedWrites.createFields(tableName, typeName) }) : insertFields
   });
-  const updateInput = new import_graphql4.GraphQLInputObjectType({
-    name: `${capitalize(updatePrefix)}${resolveTypeName(tableName, typeNameMapper)}Input`,
-    fields: updateFields
+  const updateInput = new import_graphql5.GraphQLInputObjectType({
+    name: `${capitalize(updatePrefix)}${typeName}Input`,
+    fields: nestedWrites ? () => ({ ...updateFields, ...nestedWrites.updateFields(tableName, typeName) }) : updateFields
   });
-  const selectSingleOutput = cacheCtx.objectTypeCache.get(tableName) ?? new import_graphql4.GraphQLObjectType({
+  const selectSingleOutput = cacheCtx.objectTypeCache.get(tableName) ?? new import_graphql5.GraphQLObjectType({
     name: resolveTypeName(tableName, typeNameMapper),
+    description: cacheCtx.docs.describeTable?.(tableName),
     fields: { ...tableFields, ...relationFields }
   });
-  const selectArrOutput = new import_graphql4.GraphQLNonNull(new import_graphql4.GraphQLList(new import_graphql4.GraphQLNonNull(selectSingleOutput)));
+  const selectArrOutput = new import_graphql5.GraphQLNonNull(new import_graphql5.GraphQLList(new import_graphql5.GraphQLNonNull(selectSingleOutput)));
   const arrTableItemOutput = withReturning ? (
     //     ? new GraphQLNonNull(new GraphQLList(new GraphQLNonNull(singleTableItemOutput!)))
-    new import_graphql4.GraphQLNonNull(new import_graphql4.GraphQLList(new import_graphql4.GraphQLNonNull(selectSingleOutput)))
+    new import_graphql5.GraphQLNonNull(new import_graphql5.GraphQLList(new import_graphql5.GraphQLNonNull(selectSingleOutput)))
   ) : void 0;
   const inputs = {
     insertInput,
@@ -1683,34 +1920,34 @@ 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 import_graphql4.GraphQLError(`ORDER BY ${column}: ordering through a relation is not supported in this query`);
+    throw new import_graphql5.GraphQLError(`ORDER BY ${column}: ordering through a relation is not supported in this query`);
   }
   return [column, config.direction, config.nulls ?? void 0];
 });
 var orderExpressions = (expr, direction, nulls, dialectColumn) => {
-  const directed = direction === "asc" ? (0, import_drizzle_orm3.asc)(expr) : (0, import_drizzle_orm3.desc)(expr);
+  const directed = direction === "asc" ? (0, import_drizzle_orm4.asc)(expr) : (0, import_drizzle_orm4.desc)(expr);
   if (!nulls) {
     return [directed];
   }
   const isMySql = (dialectColumn.columnType ?? "").startsWith("MySql");
   if (isMySql) {
-    const nullsKey = nulls === "first" ? (0, import_drizzle_orm3.desc)(import_drizzle_orm3.sql`(${expr} is null)`) : (0, import_drizzle_orm3.asc)(import_drizzle_orm3.sql`(${expr} is null)`);
+    const nullsKey = nulls === "first" ? (0, import_drizzle_orm4.desc)(import_drizzle_orm4.sql`(${expr} is null)`) : (0, import_drizzle_orm4.asc)(import_drizzle_orm4.sql`(${expr} is null)`);
     return [nullsKey, directed];
   }
-  return [nulls === "first" ? import_drizzle_orm3.sql`${directed} nulls first` : import_drizzle_orm3.sql`${directed} nulls last`];
+  return [nulls === "first" ? import_drizzle_orm4.sql`${directed} nulls first` : import_drizzle_orm4.sql`${directed} nulls last`];
 };
 var extendRelationOrderChain = (parentTable, relationName, relEntry, ctx, chain) => {
   const targetTable = ctx.tables[relEntry.targetTableName];
   const relation = relEntry.relation ?? relEntry;
-  if (!targetTable || !(0, import_drizzle_orm3.is)(relation, import_drizzle_orm3.One) || !isFilterableRelation(relation)) {
-    throw new import_graphql4.GraphQLError(`ORDER BY ${relationName}: Relation cannot be used for ordering`);
+  if (!targetTable || !(0, import_drizzle_orm4.is)(relation, import_drizzle_orm4.One) || !isFilterableRelation(relation)) {
+    throw new import_graphql5.GraphQLError(`ORDER BY ${relationName}: Relation cannot be used for ordering`);
   }
   ctx.aliases ??= { n: 0 };
-  const aliasedTarget = (0, import_drizzle_orm3.aliasedTable)(targetTable, `dgql_ord_${ctx.aliases.n++}`);
+  const aliasedTarget = (0, import_drizzle_orm4.aliasedTable)(targetTable, `dgql_ord_${ctx.aliases.n++}`);
   const joinCondition = buildRelationJoinCondition(parentTable, relation, aliasedTarget, relationName);
-  const relationWhere = relation.where ? (0, import_drizzle_orm3.relationsFilterToSQL)(relation.isReversed ? parentTable : aliasedTarget, relation.where) : void 0;
+  const relationWhere = relation.where ? (0, import_drizzle_orm4.relationsFilterToSQL)(relation.isReversed ? parentTable : aliasedTarget, relation.where) : void 0;
   return {
-    fromParts: [...chain?.fromParts ?? [], (0, import_drizzle_orm3.getTableAsAliasSQL)(aliasedTarget)],
+    fromParts: [...chain?.fromParts ?? [], (0, import_drizzle_orm4.getTableAsAliasSQL)(aliasedTarget)],
     conditions: [
       ...chain?.conditions ?? [],
       ...joinCondition ? [joinCondition] : [],
@@ -1720,7 +1957,7 @@ var extendRelationOrderChain = (parentTable, relationName, relEntry, ctx, chain)
   };
 };
 var collectOrderEntries = (table, tableKey, orderArgs, ctx, chain, out) => {
-  const columns = (0, import_drizzle_orm3.getColumns)(table);
+  const columns = (0, import_drizzle_orm4.getColumns)(table);
   const relations = ctx?.relationMap[tableKey];
   for (const [key, config] of Object.entries(orderArgs)) {
     if (config === null || config === void 0) {
@@ -1729,7 +1966,7 @@ var collectOrderEntries = (table, tableKey, orderArgs, ctx, chain, out) => {
     const column = columns[key];
     if (column) {
       out.push({
-        expression: chain ? import_drizzle_orm3.sql`(select ${column} from ${import_drizzle_orm3.sql.join(chain.fromParts, import_drizzle_orm3.sql`, `)} where ${(0, import_drizzle_orm3.and)(...chain.conditions)})` : column,
+        expression: chain ? import_drizzle_orm4.sql`(select ${column} from ${import_drizzle_orm4.sql.join(chain.fromParts, import_drizzle_orm4.sql`, `)} where ${(0, import_drizzle_orm4.and)(...chain.conditions)})` : column,
         column,
         direction: config.direction,
         nulls: config.nulls ?? void 0,
@@ -1739,7 +1976,7 @@ var collectOrderEntries = (table, tableKey, orderArgs, ctx, chain, out) => {
     }
     const relEntry = relations?.[key];
     if (!relEntry || !ctx) {
-      throw new import_graphql4.GraphQLError(`ORDER BY ${key}: Unknown column or relation`);
+      throw new import_graphql5.GraphQLError(`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);
@@ -1762,34 +1999,34 @@ var safeLikeOps = {
 };
 var safeLikeCondition = (column, pattern, insensitive) => {
   if (!insensitive) {
-    return import_drizzle_orm3.sql`${column} like ${pattern} escape ${LIKE_ESCAPE_CHAR}`;
+    return import_drizzle_orm4.sql`${column} like ${pattern} escape ${LIKE_ESCAPE_CHAR}`;
   }
   const isPg = (column.columnType ?? "").startsWith("Pg");
-  return isPg ? import_drizzle_orm3.sql`${column} ilike ${pattern} escape ${LIKE_ESCAPE_CHAR}` : import_drizzle_orm3.sql`lower(${column}) like ${pattern.toLowerCase()} escape ${LIKE_ESCAPE_CHAR}`;
+  return isPg ? import_drizzle_orm4.sql`${column} ilike ${pattern} escape ${LIKE_ESCAPE_CHAR}` : import_drizzle_orm4.sql`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" ? import_drizzle_orm3.sql`${column}::jsonb @> ${serialized}::jsonb` : import_drizzle_orm3.sql`${column} @> ${serialized}::jsonb`;
+      return column.columnType === "PgJson" ? import_drizzle_orm4.sql`${column}::jsonb @> ${serialized}::jsonb` : import_drizzle_orm4.sql`${column} @> ${serialized}::jsonb`;
     case "mysql":
-      return import_drizzle_orm3.sql`json_contains(${column}, ${serialized})`;
+      return import_drizzle_orm4.sql`json_contains(${column}, ${serialized})`;
     default:
-      throw new import_graphql4.GraphQLError(`WHERE ${columnName}: Operator 'contains' is not supported for this dialect!`);
+      throw new import_graphql5.GraphQLError(`WHERE ${columnName}: Operator 'contains' is not supported for this dialect!`);
   }
 };
 var extractFiltersColumn = (column, columnName, operators) => {
   const { OR, AND, NOT, ...restOperators } = operators;
   const entries = Object.entries(restOperators);
-  const singleValueOps = { eq: import_drizzle_orm3.eq, ne: import_drizzle_orm3.ne, gt: import_drizzle_orm3.gt, gte: import_drizzle_orm3.gte, lt: import_drizzle_orm3.lt, lte: import_drizzle_orm3.lte };
-  const stringValueOps = { like: import_drizzle_orm3.like, notLike: import_drizzle_orm3.notLike, ilike: import_drizzle_orm3.ilike, notIlike: import_drizzle_orm3.notIlike };
-  const arrayValueOps = { inArray: import_drizzle_orm3.inArray, notInArray: import_drizzle_orm3.notInArray };
+  const singleValueOps = { eq: import_drizzle_orm4.eq, ne: import_drizzle_orm4.ne, gt: import_drizzle_orm4.gt, gte: import_drizzle_orm4.gte, lt: import_drizzle_orm4.lt, lte: import_drizzle_orm4.lte };
+  const stringValueOps = { like: import_drizzle_orm4.like, notLike: import_drizzle_orm4.notLike, ilike: import_drizzle_orm4.ilike, notIlike: import_drizzle_orm4.notIlike };
+  const arrayValueOps = { inArray: import_drizzle_orm4.inArray, notInArray: import_drizzle_orm4.notInArray };
   const arrayMembershipOps = {
-    hasSome: import_drizzle_orm3.arrayOverlaps,
-    hasEvery: import_drizzle_orm3.arrayContains
+    hasSome: import_drizzle_orm4.arrayOverlaps,
+    hasEvery: import_drizzle_orm4.arrayContains
   };
-  const nullableOps = { isNull: import_drizzle_orm3.isNull, isNotNull: import_drizzle_orm3.isNotNull };
+  const nullableOps = { isNull: import_drizzle_orm4.isNull, isNotNull: import_drizzle_orm4.isNotNull };
   const variants = [];
   for (const [operatorName, operatorValue] of entries) {
     if (operatorValue === null || operatorValue === false) {
@@ -1807,23 +2044,23 @@ var extractFiltersColumn = (column, columnName, operators) => {
       variants.push(safeLikeCondition(column, buildPattern(operatorValue), insensitive));
     } else if (operatorName in arrayValueOps) {
       if (!operatorValue.length) {
-        throw new import_graphql4.GraphQLError(`WHERE ${columnName}: Unable to use operator ${operatorName} with an empty array!`);
+        throw new import_graphql5.GraphQLError(`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));
     } else if (operatorName === "has") {
-      variants.push((0, import_drizzle_orm3.arrayContains)(column, [operatorValue]));
+      variants.push((0, import_drizzle_orm4.arrayContains)(column, [operatorValue]));
     } else if (operatorName in arrayMembershipOps) {
       if (!operatorValue.length) {
-        throw new import_graphql4.GraphQLError(`WHERE ${columnName}: Unable to use operator ${operatorName} with an empty array!`);
+        throw new import_graphql5.GraphQLError(`WHERE ${columnName}: Unable to use operator ${operatorName} with an empty array!`);
       }
       variants.push(arrayMembershipOps[operatorName](column, operatorValue));
     } else if (operatorName === "isEmpty") {
-      variants.push(import_drizzle_orm3.sql`cardinality(${column}) = 0`);
+      variants.push(import_drizzle_orm4.sql`cardinality(${column}) = 0`);
     } else if (operatorName in nullableOps) {
       variants.push(nullableOps[operatorName](column));
     } else {
-      throw new import_graphql4.GraphQLError(`WHERE ${columnName}: Unknown operator: ${operatorName}`);
+      throw new import_graphql5.GraphQLError(`WHERE ${columnName}: Unknown operator: ${operatorName}`);
     }
   }
   if (AND?.length) {
@@ -1837,7 +2074,7 @@ var extractFiltersColumn = (column, columnName, operators) => {
   if (NOT) {
     const extracted = extractFiltersColumn(column, columnName, NOT);
     if (extracted) {
-      variants.push((0, import_drizzle_orm3.not)(extracted));
+      variants.push((0, import_drizzle_orm4.not)(extracted));
     }
   }
   if (OR?.length) {
@@ -1849,33 +2086,33 @@ var extractFiltersColumn = (column, columnName, operators) => {
       }
     }
     if (orVariants.length) {
-      variants.push(orVariants.length > 1 ? (0, import_drizzle_orm3.or)(...orVariants) : orVariants[0]);
+      variants.push(orVariants.length > 1 ? (0, import_drizzle_orm4.or)(...orVariants) : orVariants[0]);
     }
   }
-  return variants.length ? variants.length > 1 ? (0, import_drizzle_orm3.and)(...variants) : variants[0] : void 0;
+  return variants.length ? variants.length > 1 ? (0, import_drizzle_orm4.and)(...variants) : variants[0] : void 0;
 };
 var relationFilterCtx = (base, tableKey) => base ? { ...base, tableKey } : void 0;
 var buildRelationJoinCondition = (parentTable, relation, aliasedTarget, relationName) => {
   const sourceColumns = relation.sourceColumns;
   const targetColumns = relation.targetColumns;
   if (!sourceColumns?.length || sourceColumns.length !== targetColumns?.length) {
-    throw new import_graphql4.GraphQLError(`WHERE ${relationName}: Relation cannot be used as a filter`);
+    throw new import_graphql5.GraphQLError(`WHERE ${relationName}: Relation cannot be used as a filter`);
   }
-  const parentColumns = Object.values((0, import_drizzle_orm3.getColumns)(parentTable));
-  const targetColumnsByName = Object.values((0, import_drizzle_orm3.getColumns)(aliasedTarget));
+  const parentColumns = Object.values((0, import_drizzle_orm4.getColumns)(parentTable));
+  const targetColumnsByName = Object.values((0, import_drizzle_orm4.getColumns)(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 import_graphql4.GraphQLError(`WHERE ${relationName}: Relation cannot be used as a filter`);
+      throw new import_graphql5.GraphQLError(`WHERE ${relationName}: Relation cannot be used as a filter`);
     }
-    conditions.push((0, import_drizzle_orm3.eq)(localColumn, foreignColumn));
+    conditions.push((0, import_drizzle_orm4.eq)(localColumn, foreignColumn));
   }
-  return conditions.length > 1 ? (0, import_drizzle_orm3.and)(...conditions) : conditions[0];
+  return conditions.length > 1 ? (0, import_drizzle_orm4.and)(...conditions) : conditions[0];
 };
 var resolveJunctionColumn = (aliasedThrough, junctionRef, relationName) => {
-  const throughColumns = (0, import_drizzle_orm3.getColumns)(aliasedThrough);
+  const throughColumns = (0, import_drizzle_orm4.getColumns)(aliasedThrough);
   const key = junctionRef?._?.key;
   const byKey = key ? throughColumns[key] : void 0;
   if (byKey) {
@@ -1884,7 +2121,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 import_graphql4.GraphQLError(`WHERE ${relationName}: Relation cannot be used as a filter`);
+    throw new import_graphql5.GraphQLError(`WHERE ${relationName}: Relation cannot be used as a filter`);
   }
   return byName;
 };
@@ -1893,31 +2130,31 @@ 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 import_graphql4.GraphQLError(`WHERE ${relationName}: Relation cannot be used as a filter`);
+    throw new import_graphql5.GraphQLError(`WHERE ${relationName}: Relation cannot be used as a filter`);
   }
-  const parentColumns = Object.values((0, import_drizzle_orm3.getColumns)(parentTable));
-  const targetTableColumns = Object.values((0, import_drizzle_orm3.getColumns)(aliasedTarget));
+  const parentColumns = Object.values((0, import_drizzle_orm4.getColumns)(parentTable));
+  const targetTableColumns = Object.values((0, import_drizzle_orm4.getColumns)(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 import_graphql4.GraphQLError(`WHERE ${relationName}: Relation cannot be used as a filter`);
+      throw new import_graphql5.GraphQLError(`WHERE ${relationName}: Relation cannot be used as a filter`);
     }
-    correlationConditions.push((0, import_drizzle_orm3.eq)(localColumn, resolveJunctionColumn(aliasedThrough, through.source[i], relationName)));
+    correlationConditions.push((0, import_drizzle_orm4.eq)(localColumn, resolveJunctionColumn(aliasedThrough, through.source[i], relationName)));
   }
   const junctionJoinConditions = [];
   for (let i = 0; i < targetColumns.length; i++) {
     const foreignColumn = targetTableColumns.find((c) => c.name === targetColumns[i].name);
     if (!foreignColumn) {
-      throw new import_graphql4.GraphQLError(`WHERE ${relationName}: Relation cannot be used as a filter`);
+      throw new import_graphql5.GraphQLError(`WHERE ${relationName}: Relation cannot be used as a filter`);
     }
     junctionJoinConditions.push(
-      (0, import_drizzle_orm3.eq)(resolveJunctionColumn(aliasedThrough, through.target[i], relationName), foreignColumn)
+      (0, import_drizzle_orm4.eq)(resolveJunctionColumn(aliasedThrough, through.target[i], relationName), foreignColumn)
     );
   }
   return {
-    correlation: correlationConditions.length > 1 ? (0, import_drizzle_orm3.and)(...correlationConditions) : correlationConditions[0],
-    junctionJoin: junctionJoinConditions.length > 1 ? (0, import_drizzle_orm3.and)(...junctionJoinConditions) : junctionJoinConditions[0]
+    correlation: correlationConditions.length > 1 ? (0, import_drizzle_orm4.and)(...correlationConditions) : correlationConditions[0],
+    junctionJoin: junctionJoinConditions.length > 1 ? (0, import_drizzle_orm4.and)(...junctionJoinConditions) : junctionJoinConditions[0]
   };
 };
 var buildRelationExists = (parentTable, relationName, relEntry, innerFilters, mode, ctx) => {
@@ -1925,16 +2162,16 @@ var buildRelationExists = (parentTable, relationName, relEntry, innerFilters, mo
   const targetTable = ctx.tables[targetTableName];
   const relation = relEntry.relation ?? relEntry;
   if (!targetTable) {
-    throw new import_graphql4.GraphQLError(`WHERE ${relationName}: Relation cannot be used as a filter`);
+    throw new import_graphql5.GraphQLError(`WHERE ${relationName}: Relation cannot be used as a filter`);
   }
   ctx.aliases ??= { n: 0 };
   const aliases = ctx.aliases;
-  const aliasedTarget = (0, import_drizzle_orm3.aliasedTable)(targetTable, `dgql_rel_${aliases.n++}`);
+  const aliasedTarget = (0, import_drizzle_orm4.aliasedTable)(targetTable, `dgql_rel_${aliases.n++}`);
   const throughTable = relation.throughTable;
   let fromClause;
   let joinCondition;
   if (throughTable) {
-    const aliasedThrough = (0, import_drizzle_orm3.aliasedTable)(throughTable, `dgql_rel_${aliases.n++}`);
+    const aliasedThrough = (0, import_drizzle_orm4.aliasedTable)(throughTable, `dgql_rel_${aliases.n++}`);
     const { correlation, junctionJoin } = buildThroughJoinConditions(
       parentTable,
       relation,
@@ -1942,26 +2179,26 @@ var buildRelationExists = (parentTable, relationName, relEntry, innerFilters, mo
       aliasedTarget,
       relationName
     );
-    fromClause = import_drizzle_orm3.sql`${(0, import_drizzle_orm3.getTableAsAliasSQL)(aliasedTarget)} inner join ${(0, import_drizzle_orm3.getTableAsAliasSQL)(aliasedThrough)} on ${junctionJoin}`;
+    fromClause = import_drizzle_orm4.sql`${(0, import_drizzle_orm4.getTableAsAliasSQL)(aliasedTarget)} inner join ${(0, import_drizzle_orm4.getTableAsAliasSQL)(aliasedThrough)} on ${junctionJoin}`;
     joinCondition = correlation;
   } else {
-    fromClause = (0, import_drizzle_orm3.getTableAsAliasSQL)(aliasedTarget);
+    fromClause = (0, import_drizzle_orm4.getTableAsAliasSQL)(aliasedTarget);
     joinCondition = buildRelationJoinCondition(parentTable, relation, aliasedTarget, relationName);
   }
-  const relationWhere = relation.where ? (0, import_drizzle_orm3.relationsFilterToSQL)(relation.isReversed ? parentTable : aliasedTarget, relation.where) : void 0;
+  const relationWhere = relation.where ? (0, import_drizzle_orm4.relationsFilterToSQL)(relation.isReversed ? parentTable : aliasedTarget, relation.where) : void 0;
   const inner = innerFilters ? extractFilters(aliasedTarget, targetTableName, innerFilters, { ...ctx, tableKey: targetTableName, aliases }) : void 0;
   if (mode === "every") {
     if (!inner) {
       return void 0;
     }
-    return import_drizzle_orm3.sql`not exists (select 1 from ${fromClause} where ${(0, import_drizzle_orm3.and)(joinCondition, relationWhere, (0, import_drizzle_orm3.not)(inner))})`;
+    return import_drizzle_orm4.sql`not exists (select 1 from ${fromClause} where ${(0, import_drizzle_orm4.and)(joinCondition, relationWhere, (0, import_drizzle_orm4.not)(inner))})`;
   }
-  const condition = (0, import_drizzle_orm3.and)(joinCondition, relationWhere, inner);
-  return mode === "none" ? import_drizzle_orm3.sql`not exists (select 1 from ${fromClause} where ${condition})` : import_drizzle_orm3.sql`exists (select 1 from ${fromClause} where ${condition})`;
+  const condition = (0, import_drizzle_orm4.and)(joinCondition, relationWhere, inner);
+  return mode === "none" ? import_drizzle_orm4.sql`not exists (select 1 from ${fromClause} where ${condition})` : import_drizzle_orm4.sql`exists (select 1 from ${fromClause} where ${condition})`;
 };
 var extractRelationFilter = (parentTable, relationName, relEntry, value, ctx) => {
   const relation = relEntry.relation ?? relEntry;
-  if ((0, import_drizzle_orm3.is)(relation, import_drizzle_orm3.One)) {
+  if ((0, import_drizzle_orm4.is)(relation, import_drizzle_orm4.One)) {
     return buildRelationExists(parentTable, relationName, relEntry, value, "some", ctx);
   }
   const relationMatchModes = ["some", "none", "every"];
@@ -1971,19 +2208,19 @@ var extractRelationFilter = (parentTable, relationName, relEntry, value, ctx) =>
       continue;
     }
     if (!relationMatchModes.includes(mode)) {
-      throw new import_graphql4.GraphQLError(`WHERE ${relationName}: Unknown relation filter key: ${mode}`);
+      throw new import_graphql5.GraphQLError(`WHERE ${relationName}: Unknown relation filter key: ${mode}`);
     }
     const extracted = buildRelationExists(parentTable, relationName, relEntry, inner, mode, ctx);
     if (extracted) {
       variants.push(extracted);
     }
   }
-  return variants.length ? variants.length > 1 ? (0, import_drizzle_orm3.and)(...variants) : variants[0] : void 0;
+  return variants.length ? variants.length > 1 ? (0, import_drizzle_orm4.and)(...variants) : variants[0] : void 0;
 };
 var extractFilters = (table, tableName, filters, relationCtx) => {
   const { OR, AND, NOT, ...fieldFilters } = filters;
   const entries = Object.entries(fieldFilters);
-  const columns = (0, import_drizzle_orm3.getColumns)(table);
+  const columns = (0, import_drizzle_orm4.getColumns)(table);
   const relations = relationCtx?.relationMap[relationCtx.tableKey];
   const variants = [];
   for (const [fieldName, operators] of entries) {
@@ -1992,7 +2229,7 @@ var extractFilters = (table, tableName, filters, relationCtx) => {
     }
     const column = columns[fieldName];
     if (!column && !(relations?.[fieldName] && relationCtx)) {
-      throw new import_graphql4.GraphQLError(`WHERE ${tableName}: Unknown filter key: ${fieldName}`);
+      throw new import_graphql5.GraphQLError(`WHERE ${tableName}: Unknown filter key: ${fieldName}`);
     }
     const extracted = column ? extractFiltersColumn(column, fieldName, operators) : extractRelationFilter(table, fieldName, relations[fieldName], operators, relationCtx);
     if (extracted) {
@@ -2010,7 +2247,7 @@ var extractFilters = (table, tableName, filters, relationCtx) => {
   if (NOT) {
     const extracted = extractFilters(table, tableName, NOT, relationCtx);
     if (extracted) {
-      variants.push((0, import_drizzle_orm3.not)(extracted));
+      variants.push((0, import_drizzle_orm4.not)(extracted));
     }
   }
   if (OR?.length) {
@@ -2022,10 +2259,10 @@ var extractFilters = (table, tableName, filters, relationCtx) => {
       }
     }
     if (orVariants.length) {
-      variants.push(orVariants.length > 1 ? (0, import_drizzle_orm3.or)(...orVariants) : orVariants[0]);
+      variants.push(orVariants.length > 1 ? (0, import_drizzle_orm4.or)(...orVariants) : orVariants[0]);
     }
   }
-  return variants.length ? variants.length > 1 ? (0, import_drizzle_orm3.and)(...variants) : variants[0] : void 0;
+  return variants.length ? variants.length > 1 ? (0, import_drizzle_orm4.and)(...variants) : variants[0] : void 0;
 };
 var extractRelationsParamsInner = (relationMap, tables, tableName, typeName, originField, typeNameMapper, _isInitial = false, filterCtx) => {
   const relationsForTable = relationMap[tableName];
@@ -2044,15 +2281,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 (!(0, import_drizzle_orm4.is)(relEntry.relation ?? relEntry, import_drizzle_orm4.One) && (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;
@@ -2100,7 +2349,7 @@ var pruneNonEagerRelations = (relationMap, shouldEagerLoad) => {
   return out;
 };
 var getPrimaryKeyPropNames = (table, compositePkColumnNames) => {
-  const cols = (0, import_drizzle_orm3.getColumns)(table);
+  const cols = (0, import_drizzle_orm4.getColumns)(table);
   const entries = Object.entries(cols);
   const inlinePks = entries.filter(([, c]) => c.primary).map(([k]) => k);
   if (inlinePks.length) {
@@ -2116,7 +2365,7 @@ var getPrimaryKeyPropNames = (table, compositePkColumnNames) => {
   return [];
 };
 var withPrimaryKeyColumns = (columns, table, pkNames) => {
-  const allCols = (0, import_drizzle_orm3.getColumns)(table);
+  const allCols = (0, import_drizzle_orm4.getColumns)(table);
   for (const pk of pkNames) {
     if (!(pk in columns) && allCols[pk]) {
       columns[pk] = allCols[pk];
@@ -2129,8 +2378,8 @@ var getPrimaryKeyPropNamesFromConfig = (table, getTableConfig4) => {
   return getPrimaryKeyPropNames(table, compositePkColumnNames);
 };
 var primaryKeyOrderExprs = (table, pkNames) => {
-  const cols = (0, import_drizzle_orm3.getColumns)(table);
-  return pkNames.map((n) => cols[n]).filter(Boolean).map((col) => (0, import_drizzle_orm3.asc)(col));
+  const cols = (0, import_drizzle_orm4.getColumns)(table);
+  return pkNames.map((n) => cols[n]).filter(Boolean).map((col) => (0, import_drizzle_orm4.asc)(col));
 };
 var CURSOR_FIELD_NAME = "cursor";
 var ROW_CURSOR_PROP = "__drizzle_graphql_cursor";
@@ -2146,7 +2395,7 @@ var cursorOrderingEntries = (orderBy, pkNames) => {
   return entries;
 };
 var cursorOrderExprs = (table, entries) => {
-  const cols = (0, import_drizzle_orm3.getColumns)(table);
+  const cols = (0, import_drizzle_orm4.getColumns)(table);
   return entries.flatMap(
     ([column, direction, nulls]) => orderExpressions(cols[column], direction, nulls ?? void 0, cols[column])
   );
@@ -2183,10 +2432,10 @@ var decodeCursor = (after, entries) => {
   try {
     payload = JSON.parse(Buffer.from(after, "base64url").toString("utf8"));
   } catch (_e) {
-    throw new import_graphql4.GraphQLError("Invalid cursor: unable to decode it. Pass a cursor returned by a previous page.");
+    throw new import_graphql5.GraphQLError("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 import_graphql4.GraphQLError("Invalid cursor: malformed payload. Pass a cursor returned by a previous page.");
+    throw new import_graphql5.GraphQLError("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.
@@ -2194,49 +2443,71 @@ var decodeCursor = (after, entries) => {
     (entry[2] ?? null) === (entries[i][2] ?? null)
   );
   if (!matchesOrdering) {
-    throw new import_graphql4.GraphQLError(
+    throw new import_graphql5.GraphQLError(
       "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 = (0, import_drizzle_orm3.getColumns)(table);
+  const cols = (0, import_drizzle_orm4.getColumns)(table);
   const disjuncts = [];
   const equalities = [];
   entries.forEach(([column, direction, nulls], i) => {
     const col = cols[column];
     if (!col) {
-      throw new import_graphql4.GraphQLError(`Invalid cursor: unknown column '${column}'.`);
+      throw new import_graphql5.GraphQLError(`Invalid cursor: unknown column '${column}'.`);
     }
     const value = values[i];
     const nullsSortLast = nulls != null ? nulls === "last" : direction === "asc" === (nullOrdering === "nulls-largest");
     let strictlyAfter;
     if (value === null || value === void 0) {
-      strictlyAfter = nullsSortLast ? void 0 : (0, import_drizzle_orm3.isNotNull)(col);
+      strictlyAfter = nullsSortLast ? void 0 : (0, import_drizzle_orm4.isNotNull)(col);
     } else {
-      const comparison = direction === "asc" ? (0, import_drizzle_orm3.gt)(col, value) : (0, import_drizzle_orm3.lt)(col, value);
-      strictlyAfter = nullsSortLast ? (0, import_drizzle_orm3.or)(comparison, (0, import_drizzle_orm3.isNull)(col)) : comparison;
+      const comparison = direction === "asc" ? (0, import_drizzle_orm4.gt)(col, value) : (0, import_drizzle_orm4.lt)(col, value);
+      strictlyAfter = nullsSortLast ? (0, import_drizzle_orm4.or)(comparison, (0, import_drizzle_orm4.isNull)(col)) : comparison;
     }
     if (strictlyAfter) {
-      disjuncts.push(equalities.length ? (0, import_drizzle_orm3.and)(...equalities, strictlyAfter) : strictlyAfter);
+      disjuncts.push(equalities.length ? (0, import_drizzle_orm4.and)(...equalities, strictlyAfter) : strictlyAfter);
     }
-    equalities.push(value === null || value === void 0 ? (0, import_drizzle_orm3.isNull)(col) : (0, import_drizzle_orm3.eq)(col, value));
+    equalities.push(value === null || value === void 0 ? (0, import_drizzle_orm4.isNull)(col) : (0, import_drizzle_orm4.eq)(col, value));
   });
   if (!disjuncts.length) {
-    return import_drizzle_orm3.sql`1 = 0`;
+    return import_drizzle_orm4.sql`1 = 0`;
   }
-  return disjuncts.length > 1 ? (0, import_drizzle_orm3.or)(...disjuncts) : disjuncts[0];
+  return disjuncts.length > 1 ? (0, import_drizzle_orm4.or)(...disjuncts) : disjuncts[0];
 };
 var isCursorFieldSelected = (tree, table) => {
   if (!tree) {
     return false;
   }
-  if ((0, import_drizzle_orm3.getColumns)(table)[CURSOR_FIELD_NAME]) {
+  if ((0, import_drizzle_orm4.getColumns)(table)[CURSOR_FIELD_NAME]) {
     return false;
   }
   return Object.values(tree).some((field) => field.name === CURSOR_FIELD_NAME);
 };
+var selectsCursorField = (info, table) => {
+  if ((0, import_drizzle_orm4.getColumns)(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);
@@ -2244,7 +2515,7 @@ var attachRowCursors = (rows, entries) => {
 };
 var rowCursorResolver = (source) => source?.[ROW_CURSOR_PROP] ?? null;
 var getUniqueColumnSets = (table, getTableConfig4) => {
-  const cols = (0, import_drizzle_orm3.getColumns)(table);
+  const cols = (0, import_drizzle_orm4.getColumns)(table);
   const propNameByColumnName = new Map(Object.entries(cols).map(([propName, col]) => [col.name, propName]));
   const toPropNames = (columnNames) => {
     const propNames = [];
@@ -2289,11 +2560,11 @@ var generateColumnEnum = (table, enumName, description, predicate = () => true)
   if (cached) {
     return cached;
   }
-  const columnNames = Object.entries((0, import_drizzle_orm3.getColumns)(table)).filter(([columnName, column]) => predicate(column, columnName)).map(([columnName]) => columnName);
+  const columnNames = Object.entries((0, import_drizzle_orm4.getColumns)(table)).filter(([columnName, column]) => predicate(column, columnName)).map(([columnName]) => columnName);
   if (!columnNames.length) {
     return void 0;
   }
-  const enumType = new import_graphql4.GraphQLEnumType({
+  const enumType = new import_graphql5.GraphQLEnumType({
     name: enumName,
     description,
     values: Object.fromEntries(columnNames.map((columnName) => [columnName, { value: columnName }]))
@@ -2306,7 +2577,7 @@ var generateColumnEnum = (table, enumName, description, predicate = () => true)
   return enumType;
 };
 var generateDistinctEnum = (table, typeName) => generateColumnEnum(table, `${typeName}DistinctColumn`, `Columns of ${typeName} that a query can be made distinct on`);
-var conflictActionEnum = new import_graphql4.GraphQLEnumType({
+var conflictActionEnum = new import_graphql5.GraphQLEnumType({
   name: "ConflictAction",
   description: "What an upsert does when a row with the same unique key already exists",
   values: {
@@ -2331,7 +2602,7 @@ var generateOnConflictInput = (params) => {
       description: "Whether a conflicting row is overwritten or left alone. Defaults to UPDATE."
     },
     update: {
-      type: new import_graphql4.GraphQLList(new import_graphql4.GraphQLNonNull(updateEnum)),
+      type: new import_graphql5.GraphQLList(new import_graphql5.GraphQLNonNull(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."
     }
   };
@@ -2347,7 +2618,7 @@ var generateOnConflictInput = (params) => {
       return void 0;
     }
     fields["target"] = {
-      type: new import_graphql4.GraphQLList(new import_graphql4.GraphQLNonNull(targetEnum)),
+      type: new import_graphql5.GraphQLList(new import_graphql5.GraphQLNonNull(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"] = {
@@ -2355,7 +2626,7 @@ var generateOnConflictInput = (params) => {
       description: "Only overwrite conflicting rows that match this filter. Others are left alone."
     };
   }
-  return new import_graphql4.GraphQLInputObjectType({
+  return new import_graphql5.GraphQLInputObjectType({
     name: `${typeName}OnConflict`,
     description: `Conflict handling for an upsert of ${typeName}`,
     fields
@@ -2363,18 +2634,18 @@ var generateOnConflictInput = (params) => {
 };
 var resolveConflictPlan = (params) => {
   const { table, values, onConflict, pkNames, uniqueSets, excludedRef, withTarget, buildWhere } = params;
-  const columns = (0, import_drizzle_orm3.getColumns)(table);
+  const columns = (0, import_drizzle_orm4.getColumns)(table);
   let target;
   if (withTarget) {
     const targetNames2 = onConflict?.target?.length ? onConflict.target : [...pkNames];
     if (!targetNames2.length) {
-      throw new import_graphql4.GraphQLError(
+      throw new import_graphql5.GraphQLError(
         "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 import_graphql4.GraphQLError(
+      throw new import_graphql5.GraphQLError(
         `Unable to upsert: [${targetNames2.join(", ")}] is not a unique constraint on this table. Valid conflict targets: ${uniqueSets.map((set2) => `[${set2.join(", ")}]`).join(", ")}.`
       );
     }
@@ -2389,7 +2660,7 @@ var resolveConflictPlan = (params) => {
   if (onConflict?.update?.length) {
     const unsupplied = onConflict.update.filter((name) => !supplied.has(name));
     if (unsupplied.length) {
-      throw new import_graphql4.GraphQLError(
+      throw new import_graphql5.GraphQLError(
         `Unable to upsert: onConflict.update lists ${unsupplied.join(", ")}, which the values do not supply.`
       );
     }
@@ -2404,18 +2675,19 @@ var resolveConflictPlan = (params) => {
   const setWhere = onConflict?.where && buildWhere ? buildWhere(onConflict.where) : void 0;
   return { action: "UPDATE", target, set, setWhere };
 };
-var excludedColumnRef = (columnName) => import_drizzle_orm3.sql`excluded.${import_drizzle_orm3.sql.identifier(columnName)}`;
-var mysqlValuesColumnRef = (columnName) => import_drizzle_orm3.sql`values(${import_drizzle_orm3.sql.identifier(columnName)})`;
+var excludedColumnRef = (columnName) => import_drizzle_orm4.sql`excluded.${import_drizzle_orm4.sql.identifier(columnName)}`;
+var mysqlValuesColumnRef = (columnName) => import_drizzle_orm4.sql`values(${import_drizzle_orm4.sql.identifier(columnName)})`;
 var selectDistinctKeys = async (params) => {
-  const { db, table, tableName, distinct, pkNames, where, orderBy, limit, offset } = params;
-  const cols = (0, import_drizzle_orm3.getColumns)(table);
+  const { db, table, tableName, distinct, pkNames, where, orderBy, limit, offset, partitionBy } = params;
+  const cols = (0, import_drizzle_orm4.getColumns)(table);
   if (!pkNames.length) {
-    throw new import_graphql4.GraphQLError(`Table ${tableName} has no primary key, so 'distinct' cannot be applied to it.`);
+    throw new import_graphql5.GraphQLError(`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 import_graphql4.GraphQLError(`No known columns were given to 'distinct' on ${tableName}.`);
+  const requestedCols = distinct.map((name) => cols[name]).filter(Boolean);
+  if (!requestedCols.length) {
+    throw new import_graphql5.GraphQLError(`No known columns were given to 'distinct' on ${tableName}.`);
   }
+  const partitionCols = [...partitionBy ?? [], ...requestedCols];
   const orderEntries = orderBy ? orderByEntries(orderBy) : [];
   const windowOrder = [
     ...orderEntries.flatMap(
@@ -2423,18 +2695,18 @@ var selectDistinctKeys = async (params) => {
     ),
     ...primaryKeyOrderExprs(table, pkNames)
   ];
-  const rowNumber = import_drizzle_orm3.sql`row_number() over (partition by ${import_drizzle_orm3.sql.join(partitionCols, import_drizzle_orm3.sql`, `)} order by ${import_drizzle_orm3.sql.join(
+  const rowNumber = import_drizzle_orm4.sql`row_number() over (partition by ${import_drizzle_orm4.sql.join(partitionCols, import_drizzle_orm4.sql`, `)} order by ${import_drizzle_orm4.sql.join(
     windowOrder,
-    import_drizzle_orm3.sql`, `
+    import_drizzle_orm4.sql`, `
   )})`.as(DISTINCT_RN);
   const sub = db.select({ ...cols, [DISTINCT_RN]: rowNumber }).from(table).where(where).as("__dgql_distinct");
   const outerOrder = [
     ...orderEntries.flatMap(
       ([column, direction, nulls]) => orderExpressions(sub[column], direction, nulls, cols[column])
     ),
-    ...pkNames.filter((name) => sub[name]).map((name) => (0, import_drizzle_orm3.asc)(sub[name]))
+    ...pkNames.filter((name) => sub[name]).map((name) => (0, import_drizzle_orm4.asc)(sub[name]))
   ];
-  let query = db.select(Object.fromEntries(pkNames.map((name) => [name, sub[name]]))).from(sub).where((0, import_drizzle_orm3.eq)(sub[DISTINCT_RN], 1)).orderBy(...outerOrder);
+  let query = db.select(Object.fromEntries(pkNames.map((name) => [name, sub[name]]))).from(sub).where((0, import_drizzle_orm4.eq)(sub[DISTINCT_RN], 1)).orderBy(...outerOrder);
   if (offset) {
     query = query.offset(offset);
   }
@@ -2444,15 +2716,15 @@ var selectDistinctKeys = async (params) => {
   return await query;
 };
 var primaryKeyRestriction = (table, pkNames, keys) => {
-  const cols = (0, import_drizzle_orm3.getColumns)(table);
+  const cols = (0, import_drizzle_orm4.getColumns)(table);
   if (pkNames.length === 1) {
     const name = pkNames[0];
-    return (0, import_drizzle_orm3.inArray)(
+    return (0, import_drizzle_orm4.inArray)(
       cols[name],
       keys.map((key) => key[name])
     );
   }
-  return (0, import_drizzle_orm3.or)(...keys.map((key) => (0, import_drizzle_orm3.and)(...pkNames.map((name) => (0, import_drizzle_orm3.eq)(cols[name], key[name])))));
+  return (0, import_drizzle_orm4.or)(...keys.map((key) => (0, import_drizzle_orm4.and)(...pkNames.map((name) => (0, import_drizzle_orm4.eq)(cols[name], key[name])))));
 };
 var prepareMutationRelationColumns = (params) => {
   const { relationMap, tables, tableName, typeName, typeNameMapper, table, pkNames, parsedInfo } = params;
@@ -2467,17 +2739,17 @@ var prepareMutationRelationColumns = (params) => {
   return { columns, hasRelations, withParams };
 };
 var toGraphQLError = (e) => {
-  if (e instanceof import_graphql4.GraphQLError) {
+  if (e instanceof import_graphql5.GraphQLError) {
     return e;
   }
-  return e instanceof Error ? new import_graphql4.GraphQLError(e.message, { originalError: e }) : e;
+  return e instanceof Error ? new import_graphql5.GraphQLError(e.message, { originalError: e }) : e;
 };
 var defaultErrorMapper = (error) => {
-  if (error instanceof import_graphql4.GraphQLError && !error.originalError) {
+  if (error instanceof import_graphql5.GraphQLError && !error.originalError) {
     return error;
   }
-  return new import_graphql4.GraphQLError("Internal server error", {
-    originalError: error instanceof import_graphql4.GraphQLError ? error.originalError ?? error : error instanceof Error ? error : null,
+  return new import_graphql5.GraphQLError("Internal server error", {
+    originalError: error instanceof import_graphql5.GraphQLError ? error.originalError ?? error : error instanceof Error ? error : null,
     extensions: { code: "INTERNAL_SERVER_ERROR" }
   });
 };
@@ -2534,6 +2806,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,
@@ -2547,13 +2822,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 import_graphql4.GraphQLInputObjectType({
+  return new import_graphql5.GraphQLInputObjectType({
     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: {
@@ -2562,7 +2839,7 @@ var generateUpdateManyInput = (params) => {
         description: "Rows this entry updates. An omitted filter updates every row."
       },
       set: {
-        type: new import_graphql4.GraphQLNonNull(updateInput)
+        type: new import_graphql5.GraphQLNonNull(updateInput)
       }
     }
   });
@@ -2570,29 +2847,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 import_graphql4.GraphQLError(`${fieldName} requires a 'where' argument with at least one filter!`);
+    throw new import_graphql5.GraphQLError(`${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 import_graphql5.GraphQLError(`${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: import_drizzle_orm3.sql`1` }).from(table).where(filters).limit(2);
+  const matched = await executor.select({ found: import_drizzle_orm4.sql`1` }).from(table).where(filters).limit(2);
   if (matched.length > 1) {
-    throw new import_graphql4.GraphQLError(`${fieldName}: 'where' matched more than one row \u2014 nothing was written!`);
-  }
+    throw new import_graphql5.GraphQLError(`${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 import_graphql5.GraphQLNonNull(setArgs) } } : {},
+    where: {
+      type: requireWhere ? new import_graphql5.GraphQLNonNull(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 import_graphql5.GraphQLError(
+                `${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 import_graphql5.GraphQLError("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: import_graphql4.GraphQLInt },
-  limit: { type: import_graphql4.GraphQLInt },
+  offset: { type: import_graphql5.GraphQLInt },
+  limit: { type: import_graphql5.GraphQLInt },
   orderBy: { type: orderArgs },
   where: { type: filterArgs },
   after: {
-    type: import_graphql4.GraphQLString,
+    type: import_graphql5.GraphQLString,
     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 import_graphql4.GraphQLList(new import_graphql4.GraphQLNonNull(distinctEnum)) } } : {}
+  ...distinctEnum ? { distinct: { type: new import_graphql5.GraphQLList(new import_graphql5.GraphQLNonNull(distinctEnum)) } } : {}
 });
 var selectSingleArgs = (orderArgs, filterArgs) => ({
-  offset: { type: import_graphql4.GraphQLInt },
+  offset: { type: import_graphql5.GraphQLInt },
   orderBy: { type: orderArgs },
   where: { type: filterArgs }
 });
@@ -2619,17 +2968,17 @@ var runRelationalSelect = async (opts) => {
   let cursorEntries;
   if (!single && (after != null || cursorSelected)) {
     if (after != null && distinct) {
-      throw new import_graphql4.GraphQLError("'after' cannot be combined with 'distinct'.");
+      throw new import_graphql5.GraphQLError("'after' cannot be combined with 'distinct'.");
     }
     if (orderByHasRelationEntry(orderBy)) {
       if (after != null) {
-        throw new import_graphql4.GraphQLError(
+        throw new import_graphql5.GraphQLError(
           "'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 import_graphql4.GraphQLError(`Table ${tableName} has no primary key, so cursor pagination cannot be used on it.`);
+        throw new import_graphql5.GraphQLError(`Table ${tableName} has no primary key, so cursor pagination cannot be used on it.`);
       }
     } else {
       cursorEntries = cursorOrderingEntries(orderBy, pkNames);
@@ -2658,7 +3007,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
@@ -2672,7 +3022,7 @@ var runRelationalSelect = async (opts) => {
       (aliasedTable2) => cursorOrderExprs(aliasedTable2, cursorEntries)
     ) : orderBy ? (aliasedTable2) => extractOrderBy(aliasedTable2, orderBy, relationFilterCtx(filterCtx, tableName)) : needsDefaultOrder && pkNames?.length ? (aliasedTable2) => primaryKeyOrderExprs(aliasedTable2, pkNames) : void 0,
     where: distinctKeys ? { RAW: (aliasedTable2) => primaryKeyRestriction(aliasedTable2, pkNames, distinctKeys) } : where || cursorValues ? {
-      RAW: (aliasedTable2) => (0, import_drizzle_orm3.and)(
+      RAW: (aliasedTable2) => (0, import_drizzle_orm4.and)(
         where ? extractFilters(aliasedTable2, tableName, where, relationFilterCtx(filterCtx, tableName)) : void 0,
         cursorValues ? buildCursorCondition(
           aliasedTable2,
@@ -2722,23 +3072,23 @@ var eagerLoadMutationRelations = async (db, tableName, rows, pkNames, withParams
   if (pkNames.length === 1) {
     const pkName = pkNames[0];
     const ids = keyableRows.map((r) => r[pkName]);
-    whereRaw = (aliased) => (0, import_drizzle_orm3.inArray)(aliased[pkName], ids);
+    whereRaw = (aliased) => (0, import_drizzle_orm4.inArray)(aliased[pkName], ids);
   } else {
     whereRaw = (aliased) => {
-      const lhs = import_drizzle_orm3.sql.join(
-        pkNames.map((n) => import_drizzle_orm3.sql`${aliased[n]}`),
-        import_drizzle_orm3.sql`, `
+      const lhs = import_drizzle_orm4.sql.join(
+        pkNames.map((n) => import_drizzle_orm4.sql`${aliased[n]}`),
+        import_drizzle_orm4.sql`, `
       );
-      const tuples = import_drizzle_orm3.sql.join(
+      const tuples = import_drizzle_orm4.sql.join(
         keyableRows.map(
-          (row) => import_drizzle_orm3.sql`(${import_drizzle_orm3.sql.join(
-            pkNames.map((n) => import_drizzle_orm3.sql`${row[n]}`),
-            import_drizzle_orm3.sql`, `
+          (row) => import_drizzle_orm4.sql`(${import_drizzle_orm4.sql.join(
+            pkNames.map((n) => import_drizzle_orm4.sql`${row[n]}`),
+            import_drizzle_orm4.sql`, `
           )})`
         ),
-        import_drizzle_orm3.sql`, `
+        import_drizzle_orm4.sql`, `
       );
-      return import_drizzle_orm3.sql`(${lhs}) in (${tuples})`;
+      return import_drizzle_orm4.sql`(${lhs}) in (${tuples})`;
     };
   }
   let enriched;
@@ -2769,38 +3119,38 @@ var eagerLoadMutationRelations = async (db, tableName, rows, pkNames, withParams
 };
 
 // src/util/builders/mysql.ts
-var import_drizzle_orm5 = require("drizzle-orm");
+var import_drizzle_orm6 = require("drizzle-orm");
 var import_mysql_core2 = require("drizzle-orm/mysql-core");
-var import_graphql6 = require("graphql");
+var import_graphql7 = require("graphql");
 var import_graphql_parse_resolve_info2 = require("graphql-parse-resolve-info");
 
 // src/util/builders/aggregates.ts
-var import_drizzle_orm4 = require("drizzle-orm");
-var import_graphql5 = require("graphql");
+var import_drizzle_orm5 = require("drizzle-orm");
+var import_graphql6 = require("graphql");
 var import_graphql_parse_resolve_info = require("graphql-parse-resolve-info");
 var AGGREGATE_OPS = ["avg", "sum", "min", "max", "countNonNull", "countDistinct"];
 var COUNT_OPS = /* @__PURE__ */ new Set(["countNonNull", "countDistinct"]);
 var OP_FNS = {
-  avg: import_drizzle_orm4.avg,
-  sum: import_drizzle_orm4.sum,
-  min: import_drizzle_orm4.min,
-  max: import_drizzle_orm4.max,
-  countNonNull: import_drizzle_orm4.count,
-  countDistinct: import_drizzle_orm4.countDistinct
+  avg: import_drizzle_orm5.avg,
+  sum: import_drizzle_orm5.sum,
+  min: import_drizzle_orm5.min,
+  max: import_drizzle_orm5.max,
+  countNonNull: import_drizzle_orm5.count,
+  countDistinct: import_drizzle_orm5.countDistinct
 };
 var SEP = "__";
 var classifyAggregateColumns = (table, tableName) => {
   const numeric = {};
   const orderable = {};
   const all = {};
-  for (const [columnName, column] of Object.entries((0, import_drizzle_orm4.getColumns)(table))) {
+  for (const [columnName, column] of Object.entries((0, import_drizzle_orm5.getColumns)(table))) {
     all[columnName] = column;
     const converted = drizzleColumnToGraphQLType(column, columnName, tableName, true, false, false);
     const gqlType = converted.type;
-    if (gqlType instanceof import_graphql5.GraphQLList || gqlType instanceof import_graphql5.GraphQLObjectType) {
+    if (gqlType instanceof import_graphql6.GraphQLList || gqlType instanceof import_graphql6.GraphQLObjectType) {
       continue;
     }
-    const { type: dataType, constraint } = (0, import_drizzle_orm4.extractExtendedColumnType)(column);
+    const { type: dataType, constraint } = (0, import_drizzle_orm5.extractExtendedColumnType)(column);
     if (dataType === "boolean" || dataType === "array" || dataType === "custom") {
       continue;
     }
@@ -2821,14 +3171,14 @@ var generateAggregateTypes = (table, tableName, typeName, cacheCtx) => {
   }
   const { numeric, orderable, all } = classifyAggregateColumns(table, tableName);
   const fields = {
-    count: { type: new import_graphql5.GraphQLNonNull(import_graphql5.GraphQLInt) }
+    count: { type: new import_graphql6.GraphQLNonNull(import_graphql6.GraphQLInt) }
   };
   if (Object.keys(numeric).length) {
     for (const op of ["avg", "sum"]) {
       fields[op] = {
-        type: new import_graphql5.GraphQLObjectType({
+        type: new import_graphql6.GraphQLObjectType({
           name: `${typeName}${capitalize(op)}Aggregate`,
-          fields: Object.fromEntries(Object.keys(numeric).map((columnName) => [columnName, { type: import_graphql5.GraphQLFloat }]))
+          fields: Object.fromEntries(Object.keys(numeric).map((columnName) => [columnName, { type: import_graphql6.GraphQLFloat }]))
         })
       };
     }
@@ -2836,12 +3186,12 @@ var generateAggregateTypes = (table, tableName, typeName, cacheCtx) => {
   if (Object.keys(orderable).length) {
     for (const op of ["min", "max"]) {
       fields[op] = {
-        type: new import_graphql5.GraphQLObjectType({
+        type: new import_graphql6.GraphQLObjectType({
           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) }
             ])
           )
         })
@@ -2855,15 +3205,15 @@ var generateAggregateTypes = (table, tableName, typeName, cacheCtx) => {
       continue;
     }
     fields[op] = {
-      type: new import_graphql5.GraphQLObjectType({
+      type: new import_graphql6.GraphQLObjectType({
         name: `${typeName}${capitalize(op)}Aggregate`,
         fields: Object.fromEntries(
-          columnNames.map((columnName) => [columnName, { type: new import_graphql5.GraphQLNonNull(import_graphql5.GraphQLInt) }])
+          columnNames.map((columnName) => [columnName, { type: new import_graphql6.GraphQLNonNull(import_graphql6.GraphQLInt) }])
         )
       })
     };
   }
-  const aggregateType = new import_graphql5.GraphQLObjectType({
+  const aggregateType = new import_graphql6.GraphQLObjectType({
     name: `${typeName}Aggregate`,
     fields
   });
@@ -2886,9 +3236,9 @@ var aggregateTarget = (table, tableName, typeName) => {
   return {
     tableName,
     typeName,
-    columns: (0, import_drizzle_orm4.getColumns)(table),
+    columns: (0, import_drizzle_orm5.getColumns)(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)
     )
   };
 };
@@ -2903,7 +3253,7 @@ var parseAggregateRequest = (info, target, rootTypeName = `${target.typeName}Agg
   for (const field of Object.values(selectionTree)) {
     if (field.name === "count") {
       request.count = true;
-      request.selection.count = (0, import_drizzle_orm4.count)();
+      request.selection.count = (0, import_drizzle_orm5.count)();
       continue;
     }
     if (!AGGREGATE_OPS.includes(field.name)) {
@@ -3016,8 +3366,8 @@ var createRelationAggregateFactory = (db, tables, cacheCtx, typeNameMapper, filt
         const loader = getOrCreateLoader(context, loaderKey, async (parentIds) => {
           const executor = resolveExecutor(db, context);
           const uniqueIds = [...new Set(parentIds)];
-          const whereCondition = (0, import_drizzle_orm4.and)(
-            (0, import_drizzle_orm4.inArray)(foreignCol, uniqueIds),
+          const whereCondition = (0, import_drizzle_orm5.and)(
+            (0, import_drizzle_orm5.inArray)(foreignCol, uniqueIds),
             whereArg ? extractFilters(targetTable, targetTableName, whereArg, relationFilterCtx(filterCtx, targetTableName)) : void 0
           );
           const rows = await executor.select({ [GROUP_KEY]: foreignCol, ...request.selection }).from(targetTable).where(whereCondition).groupBy(foreignCol);
@@ -3033,15 +3383,15 @@ var createRelationAggregateFactory = (db, tables, cacheCtx, typeNameMapper, filt
   };
 };
 var GROUP_COL = `group${SEP}`;
-var HAVING_OPS = { eq: import_drizzle_orm4.eq, ne: import_drizzle_orm4.ne, gt: import_drizzle_orm4.gt, gte: import_drizzle_orm4.gte, lt: import_drizzle_orm4.lt, lte: import_drizzle_orm4.lte };
+var HAVING_OPS = { eq: import_drizzle_orm5.eq, ne: import_drizzle_orm5.ne, gt: import_drizzle_orm5.gt, gte: import_drizzle_orm5.gte, lt: import_drizzle_orm5.lt, lte: import_drizzle_orm5.lte };
 var groupableColumns = (table, tableName) => {
   const { orderable } = classifyAggregateColumns(table, tableName);
   const groupable = { ...orderable };
-  for (const [columnName, column] of Object.entries((0, import_drizzle_orm4.getColumns)(table))) {
+  for (const [columnName, column] of Object.entries((0, import_drizzle_orm5.getColumns)(table))) {
     if (groupable[columnName]) {
       continue;
     }
-    const { type: dataType } = (0, import_drizzle_orm4.extractExtendedColumnType)(column);
+    const { type: dataType } = (0, import_drizzle_orm5.extractExtendedColumnType)(column);
     if (dataType !== "boolean") {
       continue;
     }
@@ -3061,10 +3411,10 @@ var generateGroupByEnum = (table, tableName, typeName) => {
     (_column, columnName) => Boolean(groupable[columnName])
   );
 };
-var aggregateNumberFilter = new import_graphql5.GraphQLInputObjectType({
+var aggregateNumberFilter = new import_graphql6.GraphQLInputObjectType({
   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: import_graphql5.GraphQLFloat }]))
+  fields: Object.fromEntries(Object.keys(HAVING_OPS).map((op) => [op, { type: import_graphql6.GraphQLFloat }]))
 });
 var generateHavingInput = (table, tableName, typeName) => {
   const { numeric, orderable, all } = classifyAggregateColumns(table, tableName);
@@ -3085,13 +3435,13 @@ var generateHavingInput = (table, tableName, typeName) => {
       continue;
     }
     fields[op] = {
-      type: new import_graphql5.GraphQLInputObjectType({
+      type: new import_graphql6.GraphQLInputObjectType({
         name: `${typeName}${capitalize(op)}Having`,
         fields: Object.fromEntries(columnNames.map((columnName) => [columnName, { type: aggregateNumberFilter }]))
       })
     };
   }
-  return new import_graphql5.GraphQLInputObjectType({
+  return new import_graphql6.GraphQLInputObjectType({
     name: `${typeName}Having`,
     description: `Filters ${typeName} groups by their aggregated values`,
     fields
@@ -3102,13 +3452,13 @@ var generateGroupByType = (table, tableName, typeName, cacheCtx) => {
   if (!Object.keys(groupable).length) {
     return void 0;
   }
-  const keysType = new import_graphql5.GraphQLObjectType({
+  const keysType = new import_graphql6.GraphQLObjectType({
     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) }
       ])
     )
   });
@@ -3119,9 +3469,9 @@ var generateGroupByType = (table, tableName, typeName, cacheCtx) => {
       { type: field.type, description: field.description ?? void 0 }
     ])
   );
-  return new import_graphql5.GraphQLObjectType({
+  return new import_graphql6.GraphQLObjectType({
     name: `${typeName}GroupBy`,
-    fields: { group: { type: new import_graphql5.GraphQLNonNull(keysType) }, ...aggregateFields }
+    fields: { group: { type: new import_graphql6.GraphQLNonNull(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));
@@ -3135,7 +3485,7 @@ var buildHavingCondition = (having, columns) => {
       continue;
     }
     if (key === "count") {
-      conditions.push(...havingComparisons((0, import_drizzle_orm4.count)(), value));
+      conditions.push(...havingComparisons((0, import_drizzle_orm5.count)(), value));
       continue;
     }
     if (!AGGREGATE_OPS.includes(key)) {
@@ -3149,16 +3499,16 @@ var buildHavingCondition = (having, columns) => {
       conditions.push(...havingComparisons(OP_FNS[key](column), filter));
     }
   }
-  return conditions.length ? (0, import_drizzle_orm4.and)(...conditions) : void 0;
+  return conditions.length ? (0, import_drizzle_orm5.and)(...conditions) : void 0;
 };
 var generateGroupBy = (db, tableName, table, typeName, fieldName, filterArgs, groupByEnum, havingInput, filterCtx) => {
   const target = aggregateTarget(table, tableName, typeName);
   const groupable = groupableColumns(table, tableName);
-  const columns = (0, import_drizzle_orm4.getColumns)(table);
+  const columns = (0, import_drizzle_orm5.getColumns)(table);
   const rootTypeName = `${typeName}GroupBy`;
   const queryArgs = {
     groupBy: {
-      type: new import_graphql5.GraphQLNonNull(new import_graphql5.GraphQLList(new import_graphql5.GraphQLNonNull(groupByEnum))),
+      type: new import_graphql6.GraphQLNonNull(new import_graphql6.GraphQLList(new import_graphql6.GraphQLNonNull(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." },
@@ -3170,12 +3520,12 @@ var generateGroupBy = (db, tableName, table, typeName, fieldName, filterArgs, gr
       try {
         const requestedKeys = [...new Set(args.groupBy ?? [])];
         if (!requestedKeys.length) {
-          throw new import_graphql5.GraphQLError("At least one column to group by is required!");
+          throw new import_graphql6.GraphQLError("At least one column to group by is required!");
         }
         const keyColumns = requestedKeys.map((columnName) => {
           const groupableColumn = groupable[columnName];
           if (!groupableColumn) {
-            throw new import_graphql5.GraphQLError(`Cannot group ${typeName} by ${columnName}!`);
+            throw new import_graphql6.GraphQLError(`Cannot group ${typeName} by ${columnName}!`);
           }
           return [columnName, groupableColumn.column];
         });
@@ -3297,7 +3647,7 @@ var generateSelectSingle = (db, tableName, tables, relationMap, orderArgs, filte
 var generateInsertArray = (db, _tableName, table, baseType, fieldName, txCtx) => {
   const queryArgs = {
     values: {
-      type: new import_graphql6.GraphQLNonNull(new import_graphql6.GraphQLList(new import_graphql6.GraphQLNonNull(baseType)))
+      type: new import_graphql7.GraphQLNonNull(new import_graphql7.GraphQLList(new import_graphql7.GraphQLNonNull(baseType)))
     }
   };
   return {
@@ -3307,7 +3657,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 import_graphql6.GraphQLError("No values were provided!");
+            throw new import_graphql7.GraphQLError("No values were provided!");
           }
           await executor.insert(table).values(input);
           return { isSuccess: true };
@@ -3322,7 +3672,7 @@ var generateInsertArray = (db, _tableName, table, baseType, fieldName, txCtx) =>
 var generateInsertSingle = (db, _tableName, table, baseType, fieldName, txCtx) => {
   const queryArgs = {
     values: {
-      type: new import_graphql6.GraphQLNonNull(baseType)
+      type: new import_graphql7.GraphQLNonNull(baseType)
     }
   };
   return {
@@ -3344,7 +3694,7 @@ var generateInsertSingle = (db, _tableName, table, baseType, fieldName, txCtx) =
 var generateUpsert = (db, table, baseType, onConflictType, fieldName, single, txCtx) => {
   const queryArgs = {
     values: {
-      type: single ? new import_graphql6.GraphQLNonNull(baseType) : new import_graphql6.GraphQLNonNull(new import_graphql6.GraphQLList(new import_graphql6.GraphQLNonNull(baseType)))
+      type: single ? new import_graphql7.GraphQLNonNull(baseType) : new import_graphql7.GraphQLNonNull(new import_graphql7.GraphQLList(new import_graphql7.GraphQLNonNull(baseType)))
     },
     onConflict: {
       type: onConflictType,
@@ -3359,7 +3709,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 import_graphql6.GraphQLError("No values were provided!");
+            throw new import_graphql7.GraphQLError("No values were provided!");
           }
           const plan = resolveConflictPlan({
             table,
@@ -3387,10 +3737,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 import_graphql6.GraphQLNonNull(setArgs)
+      type: new import_graphql7.GraphQLNonNull(setArgs)
     },
     where: {
-      type: single || requireWhere ? new import_graphql6.GraphQLNonNull(filterArgs) : filterArgs
+      type: single || requireWhere ? new import_graphql7.GraphQLNonNull(filterArgs) : filterArgs
     }
   };
   return {
@@ -3399,9 +3749,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 import_graphql6.GraphQLError("Unable to update with no values specified!");
+            throw new import_graphql7.GraphQLError("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;
@@ -3425,7 +3775,7 @@ var generateUpdate = (db, tableName, table, setArgs, filterArgs, fieldName, sing
 var generateUpdateMany = (db, tableName, table, updateManyInput, fieldName, filterCtx, txCtx) => {
   const queryArgs = {
     updates: {
-      type: new import_graphql6.GraphQLNonNull(new import_graphql6.GraphQLList(new import_graphql6.GraphQLNonNull(updateManyInput)))
+      type: new import_graphql7.GraphQLNonNull(new import_graphql7.GraphQLList(new import_graphql7.GraphQLNonNull(updateManyInput)))
     }
   };
   return {
@@ -3435,12 +3785,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 import_graphql6.GraphQLError("No updates were provided!");
+            throw new import_graphql7.GraphQLError("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 import_graphql6.GraphQLError("Unable to update with no values specified!");
+              throw new import_graphql7.GraphQLError("Unable to update with no values specified!");
             }
             return {
               set: input,
@@ -3468,7 +3818,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 import_graphql6.GraphQLNonNull(filterArgs) : filterArgs
+      type: single || requireWhere ? new import_graphql7.GraphQLNonNull(filterArgs) : filterArgs
     }
   };
   return {
@@ -3501,19 +3851,30 @@ var generateSchemaData = (db, schema, relations, options) => {
   const { relationsDepthLimit, prefixes, suffixes, typeNameMapper, shouldEagerLoad, features, complexity } = options;
   const rawSchema = schema;
   const schemaEntries = Object.entries(rawSchema);
-  const tableEntries = schemaEntries.filter(([_key, value]) => (0, import_drizzle_orm5.is)(value, import_mysql_core2.MySqlTable));
+  const tableEntries = schemaEntries.filter(([_key, value]) => (0, import_drizzle_orm6.is)(value, import_mysql_core2.MySqlTable));
   const tables = Object.fromEntries(tableEntries);
   if (!tableEntries.length) {
     throw new Error(
       "Drizzle-GraphQL Error: No tables detected in Drizzle-ORM's database instance. Did you forget to pass schema to drizzle constructor?"
     );
   }
+  if (features.nestedWrites) {
+    throw new Error(
+      "Drizzle-GraphQL Error: features.nestedWrites is not supported on MySQL \u2014 a nested write needs the parent row it just inserted returned to it, and MySQL has no RETURNING clause."
+    );
+  }
   registerScalarOverrides(tables, options);
+  registerEnumConfig(options);
   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(),
@@ -3526,7 +3887,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 = {};
@@ -3550,11 +3913,11 @@ var generateSchemaData = (db, schema, relations, options) => {
       )
     ])
   );
-  const mutationReturnType = new import_graphql6.GraphQLObjectType({
+  const mutationReturnType = new import_graphql7.GraphQLObjectType({
     name: "MutationReturn",
     fields: {
       isSuccess: {
-        type: new import_graphql6.GraphQLNonNull(import_graphql6.GraphQLBoolean)
+        type: new import_graphql7.GraphQLNonNull(import_graphql7.GraphQLBoolean)
       }
     }
   });
@@ -3579,8 +3942,10 @@ var generateSchemaData = (db, schema, relations, options) => {
       updateFieldName,
       updateManyFieldName,
       updateSingleFieldName,
+      updateCountFieldName,
       deleteFieldName,
-      deleteSingleFieldName
+      deleteSingleFieldName,
+      deleteCountFieldName
     } = computeResolverFieldNames(tableName, typeNameMapper, prefixes, suffixes);
     const selectArrGenerated = generateSelectArray(
       db,
@@ -3704,6 +4069,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,
@@ -3741,7 +4129,7 @@ var generateSchemaData = (db, schema, relations, options) => {
     };
     if (aggregateGenerated && aggregateType) {
       queries[aggregateGenerated.name] = {
-        type: new import_graphql6.GraphQLNonNull(aggregateType),
+        type: new import_graphql7.GraphQLNonNull(aggregateType),
         args: aggregateGenerated.args,
         resolve: aggregateGenerated.resolver,
         ...complexity ? { extensions: { complexity: aggregateFieldComplexity(complexity) } } : {}
@@ -3749,7 +4137,7 @@ var generateSchemaData = (db, schema, relations, options) => {
     }
     if (groupByGenerated && groupByType) {
       queries[groupByGenerated.name] = {
-        type: new import_graphql6.GraphQLNonNull(new import_graphql6.GraphQLList(new import_graphql6.GraphQLNonNull(groupByType))),
+        type: new import_graphql7.GraphQLNonNull(new import_graphql7.GraphQLList(new import_graphql7.GraphQLNonNull(groupByType))),
         args: groupByGenerated.args,
         resolve: groupByGenerated.resolver,
         ...complexity ? { extensions: { complexity: aggregateFieldComplexity(complexity) } } : {}
@@ -3774,6 +4162,22 @@ var generateSchemaData = (db, schema, relations, options) => {
         };
       }
     }
+    if (updateCountGenerated) {
+      mutations[updateCountGenerated.name] = {
+        type: new import_graphql7.GraphQLNonNull(import_graphql7.GraphQLInt),
+        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 import_graphql7.GraphQLNonNull(import_graphql7.GraphQLInt),
+        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] : [],
@@ -3804,7 +4208,7 @@ var generateSchemaData = (db, schema, relations, options) => {
   for (const [tableName, tableRelations] of Object.entries(namedRelations)) {
     const relResolvers = {};
     for (const [relName, relEntry] of Object.entries(tableRelations)) {
-      const isOne = (0, import_drizzle_orm5.is)(relEntry.relation ?? relEntry, import_drizzle_orm5.One);
+      const isOne = (0, import_drizzle_orm6.is)(relEntry.relation ?? relEntry, import_drizzle_orm6.One);
       const resolver = resolverFactory({ tableName, relationName: relName, relEntry, isOne });
       if (resolver) {
         relResolvers[relName] = resolver;
@@ -3818,10 +4222,389 @@ var generateSchemaData = (db, schema, relations, options) => {
 };
 
 // src/util/builders/pg.ts
-var import_drizzle_orm6 = require("drizzle-orm");
+var import_drizzle_orm8 = require("drizzle-orm");
 var import_pg_core2 = require("drizzle-orm/pg-core");
-var import_graphql7 = require("graphql");
+var import_graphql9 = require("graphql");
 var import_graphql_parse_resolve_info3 = require("graphql-parse-resolve-info");
+
+// src/util/builders/nested-writes.ts
+var import_drizzle_orm7 = require("drizzle-orm");
+var import_graphql8 = require("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 = (0, import_drizzle_orm7.getColumns)(table)[localColPropName];
+      if (!localCol) {
+        continue;
+      }
+      const isOne = (0, import_drizzle_orm7.is)(relation, import_drizzle_orm7.One);
+      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((0, import_drizzle_orm7.getColumns)(plan.targetTable)).filter(([columnName]) => columnName !== omitted).map(([columnName, column]) => [
+        columnName,
+        drizzleColumnToGraphQLType(column, columnName, plan.targetTableName, false, true, true)
+      ])
+    );
+    const type = new import_graphql8.GraphQLInputObjectType({
+      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 import_graphql8.GraphQLList(new import_graphql8.GraphQLNonNull(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: import_graphql8.GraphQLBoolean,
+          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 import_graphql8.GraphQLInputObjectType({
+      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 import_graphql8.GraphQLError(
+        `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 import_graphql8.GraphQLError(
+        `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((0, import_drizzle_orm7.eq)(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 = (0, import_drizzle_orm7.getColumns)(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 import_graphql8.GraphQLError(
+              `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 import_graphql8.GraphQLError(
+              `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 import_graphql8.GraphQLError(
+              `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((0, import_drizzle_orm7.and)((0, import_drizzle_orm7.eq)(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];
@@ -3866,24 +4649,24 @@ var generateSelectArray2 = (db, tableName, tables, relationMap, orderArgs, filte
         let cursorEntries;
         if (after != null || cursorSelected) {
           if (after != null && distinct?.length) {
-            throw new import_graphql7.GraphQLError("'after' cannot be combined with 'distinct'.");
+            throw new import_graphql9.GraphQLError("'after' cannot be combined with 'distinct'.");
           }
           if (orderByHasRelationEntry(orderBy)) {
             if (after != null) {
-              throw new import_graphql7.GraphQLError(
+              throw new import_graphql9.GraphQLError(
                 "'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 import_graphql7.GraphQLError(
+              throw new import_graphql9.GraphQLError(
                 `Table ${tableName} has no primary key, so cursor pagination cannot be used on it.`
               );
             }
           } else {
             cursorEntries = cursorOrderingEntries(orderBy, pkNames);
             if (cursorSelected) {
-              const allColumns = (0, import_drizzle_orm6.getColumns)(table);
+              const allColumns = (0, import_drizzle_orm8.getColumns)(table);
               for (const [column] of cursorEntries) {
                 selectedColumnsSql[column] ??= allColumns[column];
               }
@@ -3892,7 +4675,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 ? (0, import_drizzle_orm6.and)(baseWhereSql, cursorCondition) : baseWhereSql;
+        const whereSql = cursorCondition ? (0, import_drizzle_orm8.and)(baseWhereSql, cursorCondition) : baseWhereSql;
         let distinctKeys;
         if (distinct?.length) {
           distinctKeys = await selectDistinctKeys({
@@ -4003,10 +4786,10 @@ var generateSelectSingle2 = (db, tableName, tables, relationMap, orderArgs, filt
   };
 };
 var pgPrimaryKeyPropNames = (table) => getPrimaryKeyPropNamesFromConfig(table, import_pg_core2.getTableConfig);
-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 import_graphql7.GraphQLNonNull(new import_graphql7.GraphQLList(new import_graphql7.GraphQLNonNull(baseType)))
+      type: new import_graphql9.GraphQLNonNull(new import_graphql9.GraphQLList(new import_graphql9.GraphQLNonNull(baseType)))
     }
   };
   const pkNames = pgPrimaryKeyPropNames(table);
@@ -4015,10 +4798,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 import_graphql7.GraphQLError("No values were provided!");
+          if (!args.values.length) {
+            throw new import_graphql9.GraphQLError("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 = (0, import_graphql_parse_resolve_info3.parseResolveInfo)(info, {
             deep: true
           });
@@ -4032,11 +4817,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);
         });
@@ -4047,10 +4843,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 import_graphql7.GraphQLNonNull(baseType)
+      type: new import_graphql9.GraphQLNonNull(baseType)
     }
   };
   const pkNames = pgPrimaryKeyPropNames(table);
@@ -4059,7 +4855,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 = (0, import_graphql_parse_resolve_info3.parseResolveInfo)(info, {
             deep: true
           });
@@ -4073,12 +4871,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 import_graphql9.GraphQLError(`${fieldName}: the insert returned no row.`);
+            }
             return void 0;
           }
           const enriched = hasRelations ? await eagerLoadMutationRelations(executor, tableName, result, pkNames, withParams) : result;
@@ -4091,10 +4903,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 import_graphql7.GraphQLNonNull(baseType) : new import_graphql7.GraphQLNonNull(new import_graphql7.GraphQLList(new import_graphql7.GraphQLNonNull(baseType)))
+      type: single ? new import_graphql9.GraphQLNonNull(baseType) : new import_graphql9.GraphQLNonNull(new import_graphql9.GraphQLList(new import_graphql9.GraphQLNonNull(baseType)))
     },
     onConflict: {
       type: onConflictType,
@@ -4107,10 +4919,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 import_graphql7.GraphQLError("No values were provided!");
+          const supplied = single ? [args.values] : args.values;
+          if (!supplied.length) {
+            throw new import_graphql9.GraphQLError("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 = (0, import_graphql_parse_resolve_info3.parseResolveInfo)(info, { deep: true });
           const { columns, hasRelations, withParams } = prepareMutationRelationColumns({
             relationMap,
@@ -4122,19 +4937,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;
           }
@@ -4148,13 +4974,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 import_graphql7.GraphQLNonNull(setArgs)
+      type: new import_graphql9.GraphQLNonNull(setArgs)
     },
     where: {
-      type: single || requireWhere ? new import_graphql7.GraphQLNonNull(filterArgs) : filterArgs
+      type: single || requireWhere ? new import_graphql9.GraphQLNonNull(filterArgs) : filterArgs
     }
   };
   const pkNames = pgPrimaryKeyPropNames(table);
@@ -4177,23 +5003,37 @@ var generateUpdate2 = (db, tableName, table, tables, relationMap, setArgs, filte
             pkNames,
             parsedInfo
           });
-          const input = remapFromGraphQLSingleInput(set, table);
-          if (!Object.keys(input).length) {
-            throw new import_graphql7.GraphQLError("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 import_graphql9.GraphQLError("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 import_graphql7.GraphQLError(`${fieldName}: 'where' matched more than one row!`);
+            throw new import_graphql9.GraphQLError(`${fieldName}: 'where' matched more than one row!`);
           }
           if (single && !result[0]) {
             return void 0;
@@ -4208,10 +5048,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 import_graphql7.GraphQLNonNull(new import_graphql7.GraphQLList(new import_graphql7.GraphQLNonNull(updateManyInput)))
+      type: new import_graphql9.GraphQLNonNull(new import_graphql9.GraphQLList(new import_graphql9.GraphQLNonNull(updateManyInput)))
     }
   };
   const pkNames = pgPrimaryKeyPropNames(table);
@@ -4222,7 +5062,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 import_graphql7.GraphQLError("No updates were provided!");
+            throw new import_graphql9.GraphQLError("No updates were provided!");
           }
           const parsedInfo = (0, import_graphql_parse_resolve_info3.parseResolveInfo)(info, {
             deep: true
@@ -4238,23 +5078,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 import_graphql7.GraphQLError("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 import_graphql9.GraphQLError("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;
           });
@@ -4284,7 +5141,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 import_graphql7.GraphQLNonNull(filterArgs) : filterArgs
+      type: single || requireWhere ? new import_graphql9.GraphQLNonNull(filterArgs) : filterArgs
     }
   };
   return {
@@ -4313,7 +5170,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 import_graphql7.GraphQLError(`${fieldName}: 'where' matched more than one row!`);
+            throw new import_graphql9.GraphQLError(`${fieldName}: 'where' matched more than one row!`);
           }
           if (single) {
             return result[0] ? remapToGraphQLSingleOutput(result[0], tableName, table) : void 0;
@@ -4339,7 +5196,7 @@ function generateSchemaData2(db, schema, relations, options) {
     complexity
   } = options;
   const schemaEntries = Object.entries(schema);
-  const tableEntries = schemaEntries.filter(([_key, value]) => (0, import_drizzle_orm6.is)(value, import_pg_core2.PgTable));
+  const tableEntries = schemaEntries.filter(([_key, value]) => (0, import_drizzle_orm8.is)(value, import_pg_core2.PgTable));
   const tables = Object.fromEntries(tableEntries);
   if (!tableEntries.length) {
     throw new Error(
@@ -4347,11 +5204,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(),
@@ -4364,8 +5227,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, import_pg_core2.getTableConfig),
+    (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 = {};
@@ -4384,7 +5258,8 @@ function generateSchemaData2(db, schema, relations, options) {
         prefixes.insert,
         prefixes.update,
         resolverFactory,
-        relationAggregateFactory
+        relationAggregateFactory,
+        nestedTypes
       )
     ])
   );
@@ -4406,8 +5281,10 @@ function generateSchemaData2(db, schema, relations, options) {
       updateFieldName,
       updateManyFieldName,
       updateSingleFieldName,
+      updateCountFieldName,
       deleteFieldName,
-      deleteSingleFieldName
+      deleteSingleFieldName,
+      deleteCountFieldName
     } = computeResolverFieldNames(tableName, typeNameMapper, prefixes, suffixes);
     const selectArrGenerated = generateSelectArray2(
       db,
@@ -4445,7 +5322,8 @@ function generateSchemaData2(db, schema, relations, options) {
       typeName,
       typeNameMapper,
       conflictDoNothing,
-      mutationTxCtx
+      mutationTxCtx,
+      nestedRuntime
     ) : void 0;
     const insertSingleGenerated = features.insert ? generateInsertSingle2(
       db,
@@ -4458,7 +5336,8 @@ function generateSchemaData2(db, schema, relations, options) {
       typeName,
       typeNameMapper,
       conflictDoNothing,
-      mutationTxCtx
+      mutationTxCtx,
+      nestedRuntime
     ) : void 0;
     const uniqueSets = features.upsert ? getUniqueColumnSets(schema[tableName], import_pg_core2.getTableConfig) : [];
     const onConflictInput = features.upsert ? generateOnConflictInput({
@@ -4482,7 +5361,8 @@ function generateSchemaData2(db, schema, relations, options) {
       false,
       typeNameMapper,
       filterCtx,
-      mutationTxCtx
+      mutationTxCtx,
+      nestedRuntime
     ) : void 0;
     const upsertSingleGenerated = onConflictInput ? generateUpsert2(
       db,
@@ -4498,7 +5378,8 @@ function generateSchemaData2(db, schema, relations, options) {
       true,
       typeNameMapper,
       filterCtx,
-      mutationTxCtx
+      mutationTxCtx,
+      nestedRuntime
     ) : void 0;
     const updateGenerated = features.update ? generateUpdate2(
       db,
@@ -4514,7 +5395,8 @@ function generateSchemaData2(db, schema, relations, options) {
       features.requireWhere,
       typeNameMapper,
       filterCtx,
-      mutationTxCtx
+      mutationTxCtx,
+      nestedRuntime
     ) : void 0;
     const updateSingleGenerated = features.update ? generateUpdate2(
       db,
@@ -4530,7 +5412,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(
@@ -4544,7 +5427,8 @@ function generateSchemaData2(db, schema, relations, options) {
       typeName,
       typeNameMapper,
       filterCtx,
-      mutationTxCtx
+      mutationTxCtx,
+      nestedRuntime
     ) : void 0;
     const deleteGenerated = features.delete ? generateDelete2(
       db,
@@ -4572,6 +5456,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,
@@ -4609,7 +5517,7 @@ function generateSchemaData2(db, schema, relations, options) {
     };
     if (aggregateGenerated && aggregateType) {
       queries[aggregateGenerated.name] = {
-        type: new import_graphql7.GraphQLNonNull(aggregateType),
+        type: new import_graphql9.GraphQLNonNull(aggregateType),
         args: aggregateGenerated.args,
         resolve: aggregateGenerated.resolver,
         ...complexity ? { extensions: { complexity: aggregateFieldComplexity(complexity) } } : {}
@@ -4617,7 +5525,7 @@ function generateSchemaData2(db, schema, relations, options) {
     }
     if (groupByGenerated && groupByType) {
       queries[groupByGenerated.name] = {
-        type: new import_graphql7.GraphQLNonNull(new import_graphql7.GraphQLList(new import_graphql7.GraphQLNonNull(groupByType))),
+        type: new import_graphql9.GraphQLNonNull(new import_graphql9.GraphQLList(new import_graphql9.GraphQLNonNull(groupByType))),
         args: groupByGenerated.args,
         resolve: groupByGenerated.resolver,
         ...complexity ? { extensions: { complexity: aggregateFieldComplexity(complexity) } } : {}
@@ -4632,7 +5540,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 import_graphql9.GraphQLNonNull(singleTableItemOutput),
         args: insertSingleGenerated.args,
         resolve: insertSingleGenerated.resolver
       };
@@ -4660,10 +5570,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 import_graphql7.GraphQLNonNull(new import_graphql7.GraphQLList(singleTableItemOutput)),
+        type: new import_graphql9.GraphQLNonNull(new import_graphql9.GraphQLList(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) {
@@ -4687,6 +5600,22 @@ function generateSchemaData2(db, schema, relations, options) {
         resolve: deleteSingleGenerated.resolver
       };
     }
+    if (updateCountGenerated) {
+      mutations[updateCountGenerated.name] = {
+        type: new import_graphql9.GraphQLNonNull(import_graphql9.GraphQLInt),
+        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 import_graphql9.GraphQLNonNull(import_graphql9.GraphQLInt),
+        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] : [],
@@ -4718,7 +5647,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 = (0, import_drizzle_orm6.is)(relEntry.relation ?? relEntry, import_drizzle_orm6.One);
+      const isOne = (0, import_drizzle_orm8.is)(relEntry.relation ?? relEntry, import_drizzle_orm8.One);
       const resolver = resolverFactory({ tableName, relationName: relName, relEntry, isOne });
       if (resolver) {
         relResolvers[relName] = resolver;
@@ -4732,9 +5661,9 @@ function generateSchemaData2(db, schema, relations, options) {
 }
 
 // src/util/builders/sqlite.ts
-var import_drizzle_orm7 = require("drizzle-orm");
+var import_drizzle_orm9 = require("drizzle-orm");
 var import_sqlite_core2 = require("drizzle-orm/sqlite-core");
-var import_graphql8 = require("graphql");
+var import_graphql10 = require("graphql");
 var import_graphql_parse_resolve_info4 = require("graphql-parse-resolve-info");
 var generateSelectArray3 = (db, tableName, tables, relationMap, orderArgs, filterArgs, fieldName, typeName, typeNameMapper, filterCtx, distinctEnabled = true) => {
   const queryBase = db.query[tableName];
@@ -4819,10 +5748,10 @@ var generateSelectSingle3 = (db, tableName, tables, relationMap, orderArgs, filt
   };
 };
 var sqlitePrimaryKeyPropNames = (table) => getPrimaryKeyPropNamesFromConfig(table, import_sqlite_core2.getTableConfig);
-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 import_graphql8.GraphQLNonNull(new import_graphql8.GraphQLList(new import_graphql8.GraphQLNonNull(baseType)))
+      type: new import_graphql10.GraphQLNonNull(new import_graphql10.GraphQLList(new import_graphql10.GraphQLNonNull(baseType)))
     }
   };
   const pkNames = sqlitePrimaryKeyPropNames(table);
@@ -4831,10 +5760,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 import_graphql8.GraphQLError("No values were provided!");
+          if (!args.values.length) {
+            throw new import_graphql10.GraphQLError("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 = (0, import_graphql_parse_resolve_info4.parseResolveInfo)(info, {
             deep: true
           });
@@ -4848,11 +5779,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);
         });
@@ -4863,10 +5805,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 import_graphql8.GraphQLNonNull(baseType)
+      type: new import_graphql10.GraphQLNonNull(baseType)
     }
   };
   const pkNames = sqlitePrimaryKeyPropNames(table);
@@ -4875,7 +5817,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 = (0, import_graphql_parse_resolve_info4.parseResolveInfo)(info, {
             deep: true
           });
@@ -4889,12 +5833,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 import_graphql10.GraphQLError(`${fieldName}: the insert returned no row.`);
+            }
             return void 0;
           }
           const enriched = hasRelations ? await eagerLoadMutationRelations(executor, tableName, result, pkNames, withParams) : result;
@@ -4907,10 +5865,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 import_graphql8.GraphQLNonNull(baseType) : new import_graphql8.GraphQLNonNull(new import_graphql8.GraphQLList(new import_graphql8.GraphQLNonNull(baseType)))
+      type: single ? new import_graphql10.GraphQLNonNull(baseType) : new import_graphql10.GraphQLNonNull(new import_graphql10.GraphQLList(new import_graphql10.GraphQLNonNull(baseType)))
     },
     onConflict: {
       type: onConflictType,
@@ -4923,10 +5881,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 import_graphql8.GraphQLError("No values were provided!");
+          const supplied = single ? [args.values] : args.values;
+          if (!supplied.length) {
+            throw new import_graphql10.GraphQLError("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 = (0, import_graphql_parse_resolve_info4.parseResolveInfo)(info, { deep: true });
           const { columns, hasRelations, withParams } = prepareMutationRelationColumns({
             relationMap,
@@ -4938,19 +5899,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;
           }
@@ -4964,13 +5936,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 import_graphql8.GraphQLNonNull(setArgs)
+      type: new import_graphql10.GraphQLNonNull(setArgs)
     },
     where: {
-      type: single || requireWhere ? new import_graphql8.GraphQLNonNull(filterArgs) : filterArgs
+      type: single || requireWhere ? new import_graphql10.GraphQLNonNull(filterArgs) : filterArgs
     }
   };
   const pkNames = sqlitePrimaryKeyPropNames(table);
@@ -4993,23 +5965,37 @@ var generateUpdate3 = (db, tableName, table, tables, relationMap, setArgs, filte
             pkNames,
             parsedInfo
           });
-          const input = remapFromGraphQLSingleInput(set, table);
-          if (!Object.keys(input).length) {
-            throw new import_graphql8.GraphQLError("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 import_graphql10.GraphQLError("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 import_graphql8.GraphQLError(`${fieldName}: 'where' matched more than one row!`);
+            throw new import_graphql10.GraphQLError(`${fieldName}: 'where' matched more than one row!`);
           }
           if (single && !result[0]) {
             return void 0;
@@ -5024,10 +6010,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 import_graphql8.GraphQLNonNull(new import_graphql8.GraphQLList(new import_graphql8.GraphQLNonNull(updateManyInput)))
+      type: new import_graphql10.GraphQLNonNull(new import_graphql10.GraphQLList(new import_graphql10.GraphQLNonNull(updateManyInput)))
     }
   };
   const pkNames = sqlitePrimaryKeyPropNames(table);
@@ -5038,7 +6024,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 import_graphql8.GraphQLError("No updates were provided!");
+            throw new import_graphql10.GraphQLError("No updates were provided!");
           }
           const parsedInfo = (0, import_graphql_parse_resolve_info4.parseResolveInfo)(info, {
             deep: true
@@ -5054,23 +6040,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 import_graphql8.GraphQLError("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 import_graphql10.GraphQLError("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 () => {
@@ -5113,7 +6131,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 import_graphql8.GraphQLNonNull(filterArgs) : filterArgs
+      type: single || requireWhere ? new import_graphql10.GraphQLNonNull(filterArgs) : filterArgs
     }
   };
   return {
@@ -5142,7 +6160,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 import_graphql8.GraphQLError(`${fieldName}: 'where' matched more than one row!`);
+            throw new import_graphql10.GraphQLError(`${fieldName}: 'where' matched more than one row!`);
           }
           if (single) {
             return result[0] ? remapToGraphQLSingleOutput(result[0], tableName, table) : void 0;
@@ -5169,7 +6187,7 @@ var generateSchemaData3 = (db, schema, relations, options) => {
   } = options;
   const rawSchema = schema;
   const schemaEntries = Object.entries(rawSchema);
-  const tableEntries = schemaEntries.filter(([_key, value]) => (0, import_drizzle_orm7.is)(value, import_sqlite_core2.SQLiteTable));
+  const tableEntries = schemaEntries.filter(([_key, value]) => (0, import_drizzle_orm9.is)(value, import_sqlite_core2.SQLiteTable));
   const tables = Object.fromEntries(tableEntries);
   if (!tableEntries.length) {
     throw new Error(
@@ -5177,11 +6195,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(),
@@ -5194,8 +6218,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, import_sqlite_core2.getTableConfig),
+    (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 = {};
@@ -5219,7 +6259,8 @@ var generateSchemaData3 = (db, schema, relations, options) => {
         prefixes.insert,
         prefixes.update,
         resolverFactory,
-        relationAggregateFactory
+        relationAggregateFactory,
+        nestedTypes
       )
     ])
   );
@@ -5241,8 +6282,10 @@ var generateSchemaData3 = (db, schema, relations, options) => {
       updateFieldName,
       updateManyFieldName,
       updateSingleFieldName,
+      updateCountFieldName,
       deleteFieldName,
-      deleteSingleFieldName
+      deleteSingleFieldName,
+      deleteCountFieldName
     } = computeResolverFieldNames(tableName, typeNameMapper, prefixes, suffixes);
     const selectArrGenerated = generateSelectArray3(
       db,
@@ -5280,7 +6323,8 @@ var generateSchemaData3 = (db, schema, relations, options) => {
       typeName,
       typeNameMapper,
       conflictDoNothing,
-      mutationTxCtx
+      mutationTxCtx,
+      nestedRuntime
     ) : void 0;
     const insertSingleGenerated = features.insert ? generateInsertSingle3(
       db,
@@ -5293,7 +6337,8 @@ var generateSchemaData3 = (db, schema, relations, options) => {
       typeName,
       typeNameMapper,
       conflictDoNothing,
-      mutationTxCtx
+      mutationTxCtx,
+      nestedRuntime
     ) : void 0;
     const uniqueSets = features.upsert ? getUniqueColumnSets(schema[tableName], import_sqlite_core2.getTableConfig) : [];
     const onConflictInput = features.upsert ? generateOnConflictInput({
@@ -5317,7 +6362,8 @@ var generateSchemaData3 = (db, schema, relations, options) => {
       false,
       typeNameMapper,
       filterCtx,
-      mutationTxCtx
+      mutationTxCtx,
+      nestedRuntime
     ) : void 0;
     const upsertSingleGenerated = onConflictInput ? generateUpsert3(
       db,
@@ -5333,7 +6379,8 @@ var generateSchemaData3 = (db, schema, relations, options) => {
       true,
       typeNameMapper,
       filterCtx,
-      mutationTxCtx
+      mutationTxCtx,
+      nestedRuntime
     ) : void 0;
     const updateGenerated = features.update ? generateUpdate3(
       db,
@@ -5349,7 +6396,8 @@ var generateSchemaData3 = (db, schema, relations, options) => {
       features.requireWhere,
       typeNameMapper,
       filterCtx,
-      mutationTxCtx
+      mutationTxCtx,
+      nestedRuntime
     ) : void 0;
     const updateSingleGenerated = features.update ? generateUpdate3(
       db,
@@ -5365,7 +6413,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(
@@ -5379,7 +6428,8 @@ var generateSchemaData3 = (db, schema, relations, options) => {
       typeName,
       typeNameMapper,
       filterCtx,
-      mutationTxCtx
+      mutationTxCtx,
+      nestedRuntime
     ) : void 0;
     const deleteGenerated = features.delete ? generateDelete3(
       db,
@@ -5407,6 +6457,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,
@@ -5444,7 +6518,7 @@ var generateSchemaData3 = (db, schema, relations, options) => {
     };
     if (aggregateGenerated && aggregateType) {
       queries[aggregateGenerated.name] = {
-        type: new import_graphql8.GraphQLNonNull(aggregateType),
+        type: new import_graphql10.GraphQLNonNull(aggregateType),
         args: aggregateGenerated.args,
         resolve: aggregateGenerated.resolver,
         ...complexity ? { extensions: { complexity: aggregateFieldComplexity(complexity) } } : {}
@@ -5452,7 +6526,7 @@ var generateSchemaData3 = (db, schema, relations, options) => {
     }
     if (groupByGenerated && groupByType) {
       queries[groupByGenerated.name] = {
-        type: new import_graphql8.GraphQLNonNull(new import_graphql8.GraphQLList(new import_graphql8.GraphQLNonNull(groupByType))),
+        type: new import_graphql10.GraphQLNonNull(new import_graphql10.GraphQLList(new import_graphql10.GraphQLNonNull(groupByType))),
         args: groupByGenerated.args,
         resolve: groupByGenerated.resolver,
         ...complexity ? { extensions: { complexity: aggregateFieldComplexity(complexity) } } : {}
@@ -5467,7 +6541,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 import_graphql10.GraphQLNonNull(singleTableItemOutput),
         args: insertSingleGenerated.args,
         resolve: insertSingleGenerated.resolver
       };
@@ -5495,10 +6571,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 import_graphql8.GraphQLNonNull(new import_graphql8.GraphQLList(singleTableItemOutput)),
+        type: new import_graphql10.GraphQLNonNull(new import_graphql10.GraphQLList(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) {
@@ -5522,6 +6601,22 @@ var generateSchemaData3 = (db, schema, relations, options) => {
         resolve: deleteSingleGenerated.resolver
       };
     }
+    if (updateCountGenerated) {
+      mutations[updateCountGenerated.name] = {
+        type: new import_graphql10.GraphQLNonNull(import_graphql10.GraphQLInt),
+        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 import_graphql10.GraphQLNonNull(import_graphql10.GraphQLInt),
+        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] : [],
@@ -5553,7 +6648,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 = (0, import_drizzle_orm7.is)(relEntry.relation ?? relEntry, import_drizzle_orm7.One);
+      const isOne = (0, import_drizzle_orm9.is)(relEntry.relation ?? relEntry, import_drizzle_orm9.One);
       const resolver = resolverFactory({ tableName, relationName: relName, relEntry, isOne });
       if (resolver) {
         relResolvers[relName] = resolver;
@@ -5598,6 +6693,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;
@@ -5637,14 +6735,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 ((0, import_drizzle_orm8.is)(db, import_mysql_core3.MySqlDatabase)) {
+  if ((0, import_drizzle_orm10.is)(db, import_mysql_core3.MySqlDatabase)) {
     generatorOutput = generateSchemaData(db, schema, relations, generatorOptions);
-  } else if ((0, import_drizzle_orm8.is)(db, import_pg_core3.PgAsyncDatabase)) {
+  } else if ((0, import_drizzle_orm10.is)(db, import_pg_core3.PgAsyncDatabase)) {
     generatorOutput = generateSchemaData2(db, schema, relations, generatorOptions);
-  } else if ((0, import_drizzle_orm8.is)(db, import_sqlite_core3.BaseSQLiteDatabase)) {
+  } else if ((0, import_drizzle_orm10.is)(db, import_sqlite_core3.BaseSQLiteDatabase)) {
     generatorOutput = generateSchemaData3(db, schema, relations, generatorOptions);
   } else {
     throw new Error("Drizzle-GraphQL Error: Unknown database instance type");
@@ -5657,19 +6762,19 @@ var buildSchema = (db, config) => {
   const { queries, mutations, inputs, types } = generatorOutput;
   const graphQLSchemaConfig = {
     types: [...Object.values(inputs), ...Object.values(types)],
-    query: new import_graphql9.GraphQLObjectType({
+    query: new import_graphql11.GraphQLObjectType({
       name: "Query",
       fields: queries
     })
   };
   if (config?.mutations !== false && Object.keys(mutations).length) {
-    const mutation = new import_graphql9.GraphQLObjectType({
+    const mutation = new import_graphql11.GraphQLObjectType({
       name: "Mutation",
       fields: mutations
     });
     graphQLSchemaConfig.mutation = mutation;
   }
-  const outputSchema = new import_graphql9.GraphQLSchema(graphQLSchemaConfig);
+  const outputSchema = new import_graphql11.GraphQLSchema(graphQLSchemaConfig);
   return { schema: outputSchema, entities: generatorOutput };
 };
 // Annotate the CommonJS export names for ESM import in node: