@vantreeseba/drizzle-graphql 6.0.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_orm9 = 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_graphql10 = 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");
@@ -593,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) => {
@@ -655,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;
@@ -739,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) => {
@@ -797,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.`
           )
         );
@@ -879,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];
@@ -912,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];
     }
@@ -920,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(
@@ -950,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);
@@ -980,7 +1146,7 @@ var columnDocs = (docs, column, tableName, columnName) => {
 };
 var inputFieldDocs = (docs, column, tableName, columnName, fieldType) => {
   const resolved = columnDocs(docs, column, tableName, columnName);
-  if (resolved.deprecationReason !== void 0 && fieldType instanceof import_graphql4.GraphQLNonNull) {
+  if (resolved.deprecationReason !== void 0 && fieldType instanceof import_graphql5.GraphQLNonNull) {
     const { deprecationReason: _dropped, ...rest } = resolved;
     return rest;
   }
@@ -1001,7 +1167,7 @@ var relationJoinColumns = (tree, table, selectionCtx) => {
   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]) {
@@ -1020,7 +1186,7 @@ var relationJoinColumns = (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) {
@@ -1040,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) {
@@ -1059,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: {
@@ -1073,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: {
@@ -1095,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: {
@@ -1121,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" };
@@ -1131,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) {
@@ -1147,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" };
@@ -1166,37 +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 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: "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" },
+    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_graphql4.GraphQLBoolean },
-    isNotNull: { type: import_graphql4.GraphQLBoolean }
+    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,
@@ -1222,9 +1388,9 @@ var generateColumnFilterValues = (column, tableName, columnName, cacheCtx) => {
     return cached;
   }
   const colType = columnGraphQLType.type;
-  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) : {
     eq: { type: colType, description: "Equal to" },
@@ -1234,50 +1400,50 @@ var generateColumnFilterValues = (column, tableName, columnName, cacheCtx) => {
     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: IN_ARRAY_DESCRIPTION },
     notInArray: { type: colArr, description: NOT_IN_ARRAY_DESCRIPTION },
-    isNull: { type: import_graphql4.GraphQLBoolean, description: "When true, matches rows where the column is NULL" },
-    isNotNull: { type: import_graphql4.GraphQLBoolean, description: "When true, matches rows where the column is not NULL" }
+    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: {
@@ -1296,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 }])
@@ -1310,7 +1476,7 @@ 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, column]) => [
@@ -1331,7 +1497,7 @@ 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, column]) => [
@@ -1344,7 +1510,7 @@ var generateTableSelectTypeFieldsCached = (table, tableName, cacheCtx) => {
   );
   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
     };
@@ -1365,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] = {
@@ -1386,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);
@@ -1404,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(
@@ -1440,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,
@@ -1474,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: {
@@ -1534,7 +1700,7 @@ 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 })
@@ -1548,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,
@@ -1576,7 +1742,7 @@ 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 })
@@ -1591,7 +1757,7 @@ var generateSelectFields = (tables, tableName, relationMap, fromTableName, fromR
         rawRelationFields.push([
           relationName,
           {
-            type: isRequired ? new import_graphql4.GraphQLNonNull(relType) : relType,
+            type: isRequired ? new import_graphql5.GraphQLNonNull(relType) : relType,
             args: {
               where: { type: relSelectData.filters }
             },
@@ -1601,15 +1767,21 @@ var generateSelectFields = (tables, tableName, relationMap, fromTableName, fromR
         ]);
         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,
@@ -1627,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 }
               },
@@ -1679,7 +1851,7 @@ 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(
@@ -1701,30 +1873,29 @@ var generateTableTypes = (tableName, tables, relationMap, withReturning, relatio
   const updateFields = Object.fromEntries(
     columnEntries.map(([columnName, column]) => {
       const converted = drizzleColumnToGraphQLType(column, columnName, tableName, true, false, true);
-      return [
-        columnName,
-        { ...converted, ...inputFieldDocs(cacheCtx.docs, column, tableName, columnName, converted.type) }
-      ];
+      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 typeName = resolveTypeName(tableName, typeNameMapper);
-  const insertInput = new import_graphql4.GraphQLInputObjectType({
+  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({
+  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,
@@ -1749,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] : [],
@@ -1786,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) {
@@ -1795,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,
@@ -1805,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);
@@ -1828,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) {
@@ -1873,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) {
@@ -1903,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) {
@@ -1915,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) {
@@ -1950,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;
 };
@@ -1959,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) => {
@@ -1991,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,
@@ -2008,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"];
@@ -2037,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) {
@@ -2058,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) {
@@ -2076,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) {
@@ -2088,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];
@@ -2122,6 +2293,10 @@ var extractRelationsParamsInner = (relationMap, tables, tableName, typeName, ori
     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,
@@ -2174,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) {
@@ -2190,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];
@@ -2203,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";
@@ -2220,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])
   );
@@ -2257,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.
@@ -2268,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);
@@ -2318,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 = [];
@@ -2363,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 }]))
@@ -2380,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: {
@@ -2405,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."
     }
   };
@@ -2421,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"] = {
@@ -2429,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
@@ -2437,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(", ")}.`
       );
     }
@@ -2463,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.`
       );
     }
@@ -2478,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(
@@ -2497,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);
   }
@@ -2518,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;
@@ -2541,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" }
   });
 };
@@ -2608,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,
@@ -2621,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: {
@@ -2636,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)
       }
     }
   });
@@ -2644,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 }
 });
@@ -2693,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);
@@ -2747,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,
@@ -2797,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;
@@ -2844,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;
     }
@@ -2896,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 }]))
         })
       };
     }
@@ -2911,7 +3186,7 @@ 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, { column, converted }]) => [
@@ -2930,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
   });
@@ -2961,7 +3236,7 @@ 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.typeLabel === "DateTime").map(([columnName]) => columnName)
     )
@@ -2978,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)) {
@@ -3091,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);
@@ -3108,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;
     }
@@ -3136,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);
@@ -3160,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
@@ -3177,7 +3452,7 @@ 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(
@@ -3194,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));
@@ -3210,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)) {
@@ -3224,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." },
@@ -3245,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];
         });
@@ -3372,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 {
@@ -3382,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 };
@@ -3397,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 {
@@ -3419,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,
@@ -3434,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,
@@ -3462,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 {
@@ -3474,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;
@@ -3500,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 {
@@ -3510,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,
@@ -3543,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 {
@@ -3576,7 +3851,7 @@ 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(
@@ -3594,7 +3869,12 @@ var generateSchemaData = (db, schema, relations, options) => {
   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(),
@@ -3608,7 +3888,8 @@ var generateSchemaData = (db, schema, relations, options) => {
     listRelationFilterCache: /* @__PURE__ */ new Map(),
     aggregateTypeCache: /* @__PURE__ */ new Map(),
     complexity,
-    docs: options.docs ?? {}
+    docs: options.docs ?? {},
+    features
   };
   const relationAggregateFactory = features.relationAggregates ? createRelationAggregateFactory(db, tables, cacheCtx, typeNameMapper, filterCtx) : void 0;
   const queries = {};
@@ -3632,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)
       }
     }
   });
@@ -3661,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,
@@ -3786,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,
@@ -3823,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) } } : {}
@@ -3831,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) } } : {}
@@ -3856,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] : [],
@@ -3886,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;
@@ -3900,14 +4222,14 @@ var generateSchemaData = (db, schema, relations, options) => {
 };
 
 // src/util/builders/pg.ts
-var import_drizzle_orm7 = require("drizzle-orm");
+var import_drizzle_orm8 = require("drizzle-orm");
 var import_pg_core2 = require("drizzle-orm/pg-core");
-var import_graphql8 = 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_orm6 = require("drizzle-orm");
-var import_graphql7 = require("graphql");
+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();
@@ -3951,11 +4273,11 @@ var buildNestedWritePlans = (tables, relationMap, resolveUniqueSets, resolvePrim
         continue;
       }
       const { localColPropName, foreignCol, foreignColPropName } = joinColumns;
-      const localCol = (0, import_drizzle_orm6.getColumns)(table)[localColPropName];
+      const localCol = (0, import_drizzle_orm7.getColumns)(table)[localColPropName];
       if (!localCol) {
         continue;
       }
-      const isOne = (0, import_drizzle_orm6.is)(relation, import_drizzle_orm6.One);
+      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);
@@ -4007,12 +4329,12 @@ var createNestedWriteTypes = (params) => {
     }
     const omitted = plan.fkSide === "child" ? plan.foreignColPropName : void 0;
     const fields = Object.fromEntries(
-      Object.entries((0, import_drizzle_orm6.getColumns)(plan.targetTable)).filter(([columnName]) => columnName !== omitted).map(([columnName, column]) => [
+      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_graphql7.GraphQLInputObjectType({
+    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
@@ -4021,7 +4343,7 @@ var createNestedWriteTypes = (params) => {
     return type;
   };
   const targetFilters = (plan) => cacheCtx.filterTypeCache.get(plan.targetTable);
-  const listOf = (type) => new import_graphql7.GraphQLList(new import_graphql7.GraphQLNonNull(type));
+  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);
@@ -4042,7 +4364,7 @@ var createNestedWriteTypes = (params) => {
       }
       if (forUpdate && plan.canDetach) {
         fields["disconnect"] = {
-          type: import_graphql7.GraphQLBoolean,
+          type: import_graphql8.GraphQLBoolean,
           description: `Detach the currently attached ${targetTypeName} row, leaving it in place`
         };
       }
@@ -4065,7 +4387,7 @@ var createNestedWriteTypes = (params) => {
         }
       }
     }
-    const type = new import_graphql7.GraphQLInputObjectType({
+    const type = new import_graphql8.GraphQLInputObjectType({
       name: `${typeName}${capitalize(plan.relationName)}Nested${forUpdate ? "Update" : "Create"}Input`,
       description: `Writes through ${typeName}.${plan.relationName}`,
       fields
@@ -4115,7 +4437,7 @@ var createNestedWriteRuntime = (params) => {
       relationFilterCtx(filterCtx, plan.targetTableName)
     );
     if (!condition) {
-      throw new import_graphql7.GraphQLError(
+      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.`
       );
     }
@@ -4124,12 +4446,12 @@ var createNestedWriteRuntime = (params) => {
   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_graphql7.GraphQLError(
+      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_orm6.eq)(plan.foreignCol, key));
+  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) => {
@@ -4154,7 +4476,7 @@ var createNestedWriteRuntime = (params) => {
       if (!tablePlans) {
         return columns;
       }
-      const allColumns = (0, import_drizzle_orm6.getColumns)(table);
+      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]) {
@@ -4180,7 +4502,7 @@ var createNestedWriteRuntime = (params) => {
           const inserted = await executor.insert(plan.targetTable).values(values).returning();
           const created = inserted[0];
           if (!created) {
-            throw new import_graphql7.GraphQLError(
+            throw new import_graphql8.GraphQLError(
               `Drizzle-GraphQL Error: 'create' on '${relationName}' inserted no row, so there is nothing to attach.`
             );
           }
@@ -4188,7 +4510,7 @@ var createNestedWriteRuntime = (params) => {
         } 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_graphql7.GraphQLError(
+            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.`
             );
           }
@@ -4215,7 +4537,7 @@ var createNestedWriteRuntime = (params) => {
         for (const parentRow of parentRows) {
           const key = parentRow?.[plan.localColPropName];
           if (key === void 0 || key === null) {
-            throw new import_graphql7.GraphQLError(
+            throw new import_graphql8.GraphQLError(
               `Drizzle-GraphQL Error: cannot write through '${relationName}': the ${tableName} row has no '${plan.localColPropName}' value to attach to.`
             );
           }
@@ -4232,7 +4554,7 @@ var createNestedWriteRuntime = (params) => {
               }
             } else {
               for (const filter of asArray(op["disconnect"])) {
-                await executor.update(plan.targetTable).set({ [plan.foreignColPropName]: null }).where((0, import_drizzle_orm6.and)((0, import_drizzle_orm6.eq)(plan.foreignCol, key), conditionOf(plan, filter, "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")));
               }
             }
           }
@@ -4327,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_graphql8.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_graphql8.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_graphql8.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_orm7.getColumns)(table);
+              const allColumns = (0, import_drizzle_orm8.getColumns)(table);
               for (const [column] of cursorEntries) {
                 selectedColumnsSql[column] ??= allColumns[column];
               }
@@ -4353,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_orm7.and)(baseWhereSql, cursorCondition) : baseWhereSql;
+        const whereSql = cursorCondition ? (0, import_drizzle_orm8.and)(baseWhereSql, cursorCondition) : baseWhereSql;
         let distinctKeys;
         if (distinct?.length) {
           distinctKeys = await selectDistinctKeys({
@@ -4467,7 +4789,7 @@ var pgPrimaryKeyPropNames = (table) => getPrimaryKeyPropNamesFromConfig(table, i
 var generateInsertArray2 = (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_graphql9.GraphQLNonNull(new import_graphql9.GraphQLList(new import_graphql9.GraphQLNonNull(baseType)))
     }
   };
   const pkNames = pgPrimaryKeyPropNames(table);
@@ -4477,7 +4799,7 @@ var generateInsertArray2 = (db, tableName, table, tables, relationMap, baseType,
       try {
         return await runMutation(db, context, info, txCtx, async (executor) => {
           if (!args.values.length) {
-            throw new import_graphql8.GraphQLError("No values were provided!");
+            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;
@@ -4524,7 +4846,7 @@ var generateInsertArray2 = (db, tableName, table, tables, relationMap, baseType,
 var generateInsertSingle2 = (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_graphql9.GraphQLNonNull(baseType)
     }
   };
   const pkNames = pgPrimaryKeyPropNames(table);
@@ -4566,6 +4888,9 @@ var generateInsertSingle2 = (db, tableName, table, tables, relationMap, baseType
             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;
@@ -4581,7 +4906,7 @@ var generateInsertSingle2 = (db, tableName, table, tables, relationMap, baseType
 var generateUpsert2 = (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_graphql9.GraphQLNonNull(baseType) : new import_graphql9.GraphQLNonNull(new import_graphql9.GraphQLList(new import_graphql9.GraphQLNonNull(baseType)))
     },
     onConflict: {
       type: onConflictType,
@@ -4596,7 +4921,7 @@ var generateUpsert2 = (db, tableName, table, tables, relationMap, baseType, onCo
         return await runMutation(db, context, info, txCtx, async (executor) => {
           const supplied = single ? [args.values] : args.values;
           if (!supplied.length) {
-            throw new import_graphql8.GraphQLError("No values were provided!");
+            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;
@@ -4652,10 +4977,10 @@ var generateUpsert2 = (db, tableName, table, tables, relationMap, baseType, onCo
 var generateUpdate2 = (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_graphql9.GraphQLNonNull(setArgs)
     },
     where: {
-      type: single || requireWhere ? new import_graphql8.GraphQLNonNull(filterArgs) : filterArgs
+      type: single || requireWhere ? new import_graphql9.GraphQLNonNull(filterArgs) : filterArgs
     }
   };
   const pkNames = pgPrimaryKeyPropNames(table);
@@ -4680,9 +5005,9 @@ var generateUpdate2 = (db, tableName, table, tables, relationMap, setArgs, filte
           });
           const entry = nested?.enabled(tableName) ? nested.split(tableName, set) : void 0;
           const nestedOps = entry && nested.hasOps(entry.ops) ? entry.ops : void 0;
-          const input = remapFromGraphQLSingleInput(entry ? entry.columns : set, table);
+          const input = remapUpdateInput(entry ? entry.columns : set, table, tableName);
           if (!Object.keys(input).length && !nestedOps) {
-            throw new import_graphql8.GraphQLError("Unable to update with no values specified!");
+            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;
@@ -4708,7 +5033,7 @@ var generateUpdate2 = (db, tableName, table, tables, relationMap, setArgs, filte
             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_graphql9.GraphQLError(`${fieldName}: 'where' matched more than one row!`);
           }
           if (single && !result[0]) {
             return void 0;
@@ -4726,7 +5051,7 @@ var generateUpdate2 = (db, tableName, table, tables, relationMap, setArgs, filte
 var generateUpdateMany2 = (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_graphql9.GraphQLNonNull(new import_graphql9.GraphQLList(new import_graphql9.GraphQLNonNull(updateManyInput)))
     }
   };
   const pkNames = pgPrimaryKeyPropNames(table);
@@ -4737,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_graphql8.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
@@ -4755,9 +5080,9 @@ var generateUpdateMany2 = (db, tableName, table, tables, relationMap, updateMany
           const entries = updates.map(({ where, set }) => {
             const split = nested?.enabled(tableName) ? nested.split(tableName, set) : void 0;
             const ops = split && nested.hasOps(split.ops) ? split.ops : void 0;
-            const input = remapFromGraphQLSingleInput(split ? split.columns : set, table);
+            const input = remapUpdateInput(split ? split.columns : set, table, tableName);
             if (!Object.keys(input).length && !ops) {
-              throw new import_graphql8.GraphQLError("Unable to update with no values specified!");
+              throw new import_graphql9.GraphQLError("Unable to update with no values specified!");
             }
             return {
               set: input,
@@ -4816,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_graphql8.GraphQLNonNull(filterArgs) : filterArgs
+      type: single || requireWhere ? new import_graphql9.GraphQLNonNull(filterArgs) : filterArgs
     }
   };
   return {
@@ -4845,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_graphql8.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;
@@ -4871,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_orm7.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(
@@ -4884,7 +5209,12 @@ function generateSchemaData2(db, schema, relations, options) {
   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(),
@@ -4898,7 +5228,8 @@ function generateSchemaData2(db, schema, relations, options) {
     listRelationFilterCache: /* @__PURE__ */ new Map(),
     aggregateTypeCache: /* @__PURE__ */ new Map(),
     complexity,
-    docs: options.docs ?? {}
+    docs: options.docs ?? {},
+    features
   };
   const nestedPlans = features.nestedWrites ? buildNestedWritePlans(
     tables,
@@ -4950,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,
@@ -5123,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,
@@ -5160,7 +5517,7 @@ function generateSchemaData2(db, schema, relations, options) {
     };
     if (aggregateGenerated && aggregateType) {
       queries[aggregateGenerated.name] = {
-        type: new import_graphql8.GraphQLNonNull(aggregateType),
+        type: new import_graphql9.GraphQLNonNull(aggregateType),
         args: aggregateGenerated.args,
         resolve: aggregateGenerated.resolver,
         ...complexity ? { extensions: { complexity: aggregateFieldComplexity(complexity) } } : {}
@@ -5168,7 +5525,7 @@ function generateSchemaData2(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_graphql9.GraphQLNonNull(new import_graphql9.GraphQLList(new import_graphql9.GraphQLNonNull(groupByType))),
         args: groupByGenerated.args,
         resolve: groupByGenerated.resolver,
         ...complexity ? { extensions: { complexity: aggregateFieldComplexity(complexity) } } : {}
@@ -5183,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
       };
@@ -5211,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_graphql8.GraphQLNonNull(new import_graphql8.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) {
@@ -5238,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] : [],
@@ -5269,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_orm7.is)(relEntry.relation ?? relEntry, import_drizzle_orm7.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;
@@ -5283,9 +5661,9 @@ function generateSchemaData2(db, schema, relations, options) {
 }
 
 // src/util/builders/sqlite.ts
-var import_drizzle_orm8 = require("drizzle-orm");
+var import_drizzle_orm9 = require("drizzle-orm");
 var import_sqlite_core2 = require("drizzle-orm/sqlite-core");
-var import_graphql9 = 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];
@@ -5373,7 +5751,7 @@ var sqlitePrimaryKeyPropNames = (table) => getPrimaryKeyPropNamesFromConfig(tabl
 var generateInsertArray3 = (db, tableName, table, tables, relationMap, baseType, fieldName, typeName, typeNameMapper, conflictDoNothing = false, txCtx, nested) => {
   const queryArgs = {
     values: {
-      type: new import_graphql9.GraphQLNonNull(new import_graphql9.GraphQLList(new import_graphql9.GraphQLNonNull(baseType)))
+      type: new import_graphql10.GraphQLNonNull(new import_graphql10.GraphQLList(new import_graphql10.GraphQLNonNull(baseType)))
     }
   };
   const pkNames = sqlitePrimaryKeyPropNames(table);
@@ -5383,7 +5761,7 @@ var generateInsertArray3 = (db, tableName, table, tables, relationMap, baseType,
       try {
         return await runMutation(db, context, info, txCtx, async (executor) => {
           if (!args.values.length) {
-            throw new import_graphql9.GraphQLError("No values were provided!");
+            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;
@@ -5430,7 +5808,7 @@ var generateInsertArray3 = (db, tableName, table, tables, relationMap, baseType,
 var generateInsertSingle3 = (db, tableName, table, tables, relationMap, baseType, fieldName, typeName, typeNameMapper, conflictDoNothing = false, txCtx, nested) => {
   const queryArgs = {
     values: {
-      type: new import_graphql9.GraphQLNonNull(baseType)
+      type: new import_graphql10.GraphQLNonNull(baseType)
     }
   };
   const pkNames = sqlitePrimaryKeyPropNames(table);
@@ -5472,6 +5850,9 @@ var generateInsertSingle3 = (db, tableName, table, tables, relationMap, baseType
             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;
@@ -5487,7 +5868,7 @@ var generateInsertSingle3 = (db, tableName, table, tables, relationMap, baseType
 var generateUpsert3 = (db, tableName, table, tables, relationMap, baseType, onConflictType, uniqueSets, fieldName, typeName, single, typeNameMapper, filterCtx, txCtx, nested) => {
   const queryArgs = {
     values: {
-      type: single ? new import_graphql9.GraphQLNonNull(baseType) : new import_graphql9.GraphQLNonNull(new import_graphql9.GraphQLList(new import_graphql9.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,
@@ -5502,7 +5883,7 @@ var generateUpsert3 = (db, tableName, table, tables, relationMap, baseType, onCo
         return await runMutation(db, context, info, txCtx, async (executor) => {
           const supplied = single ? [args.values] : args.values;
           if (!supplied.length) {
-            throw new import_graphql9.GraphQLError("No values were provided!");
+            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;
@@ -5558,10 +5939,10 @@ var generateUpsert3 = (db, tableName, table, tables, relationMap, baseType, onCo
 var generateUpdate3 = (db, tableName, table, tables, relationMap, setArgs, filterArgs, fieldName, typeName, single, requireWhere, typeNameMapper, filterCtx, txCtx, nested) => {
   const queryArgs = {
     set: {
-      type: new import_graphql9.GraphQLNonNull(setArgs)
+      type: new import_graphql10.GraphQLNonNull(setArgs)
     },
     where: {
-      type: single || requireWhere ? new import_graphql9.GraphQLNonNull(filterArgs) : filterArgs
+      type: single || requireWhere ? new import_graphql10.GraphQLNonNull(filterArgs) : filterArgs
     }
   };
   const pkNames = sqlitePrimaryKeyPropNames(table);
@@ -5586,9 +5967,9 @@ var generateUpdate3 = (db, tableName, table, tables, relationMap, setArgs, filte
           });
           const entry = nested?.enabled(tableName) ? nested.split(tableName, set) : void 0;
           const nestedOps = entry && nested.hasOps(entry.ops) ? entry.ops : void 0;
-          const input = remapFromGraphQLSingleInput(entry ? entry.columns : set, table);
+          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!");
+            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;
@@ -5614,7 +5995,7 @@ var generateUpdate3 = (db, tableName, table, tables, relationMap, setArgs, filte
             write: runUpdate
           }) : await runUpdate(executor, input);
           if (single && result.length > 1) {
-            throw new import_graphql9.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;
@@ -5632,7 +6013,7 @@ var generateUpdate3 = (db, tableName, table, tables, relationMap, setArgs, filte
 var generateUpdateMany3 = (db, tableName, table, tables, relationMap, updateManyInput, fieldName, typeName, typeNameMapper, filterCtx, txCtx, nested) => {
   const queryArgs = {
     updates: {
-      type: new import_graphql9.GraphQLNonNull(new import_graphql9.GraphQLList(new import_graphql9.GraphQLNonNull(updateManyInput)))
+      type: new import_graphql10.GraphQLNonNull(new import_graphql10.GraphQLList(new import_graphql10.GraphQLNonNull(updateManyInput)))
     }
   };
   const pkNames = sqlitePrimaryKeyPropNames(table);
@@ -5643,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_graphql9.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
@@ -5661,9 +6042,9 @@ var generateUpdateMany3 = (db, tableName, table, tables, relationMap, updateMany
           const entries = updates.map(({ where, set }) => {
             const split = nested?.enabled(tableName) ? nested.split(tableName, set) : void 0;
             const ops = split && nested.hasOps(split.ops) ? split.ops : void 0;
-            const input = remapFromGraphQLSingleInput(split ? split.columns : set, table);
+            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!");
+              throw new import_graphql10.GraphQLError("Unable to update with no values specified!");
             }
             return {
               set: input,
@@ -5750,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_graphql9.GraphQLNonNull(filterArgs) : filterArgs
+      type: single || requireWhere ? new import_graphql10.GraphQLNonNull(filterArgs) : filterArgs
     }
   };
   return {
@@ -5779,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_graphql9.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;
@@ -5806,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_orm8.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(
@@ -5819,7 +6200,12 @@ var generateSchemaData3 = (db, schema, relations, options) => {
   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(),
@@ -5833,7 +6219,8 @@ var generateSchemaData3 = (db, schema, relations, options) => {
     listRelationFilterCache: /* @__PURE__ */ new Map(),
     aggregateTypeCache: /* @__PURE__ */ new Map(),
     complexity,
-    docs: options.docs ?? {}
+    docs: options.docs ?? {},
+    features
   };
   if (features.nestedWrites && db.resultKind === "sync") {
     throw new Error(
@@ -5895,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,
@@ -6068,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,
@@ -6105,7 +6518,7 @@ var generateSchemaData3 = (db, schema, relations, options) => {
     };
     if (aggregateGenerated && aggregateType) {
       queries[aggregateGenerated.name] = {
-        type: new import_graphql9.GraphQLNonNull(aggregateType),
+        type: new import_graphql10.GraphQLNonNull(aggregateType),
         args: aggregateGenerated.args,
         resolve: aggregateGenerated.resolver,
         ...complexity ? { extensions: { complexity: aggregateFieldComplexity(complexity) } } : {}
@@ -6113,7 +6526,7 @@ var generateSchemaData3 = (db, schema, relations, options) => {
     }
     if (groupByGenerated && groupByType) {
       queries[groupByGenerated.name] = {
-        type: new import_graphql9.GraphQLNonNull(new import_graphql9.GraphQLList(new import_graphql9.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) } } : {}
@@ -6128,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
       };
@@ -6156,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_graphql9.GraphQLNonNull(new import_graphql9.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) {
@@ -6183,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] : [],
@@ -6214,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_orm8.is)(relEntry.relation ?? relEntry, import_drizzle_orm8.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;
@@ -6260,6 +6694,8 @@ var buildSchema = (db, config) => {
     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;
@@ -6309,11 +6745,11 @@ var buildSchema = (db, config) => {
     }
   };
   let generatorOutput;
-  if ((0, import_drizzle_orm9.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_orm9.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_orm9.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");
@@ -6326,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_graphql10.GraphQLObjectType({
+    query: new import_graphql11.GraphQLObjectType({
       name: "Query",
       fields: queries
     })
   };
   if (config?.mutations !== false && Object.keys(mutations).length) {
-    const mutation = new import_graphql10.GraphQLObjectType({
+    const mutation = new import_graphql11.GraphQLObjectType({
       name: "Mutation",
       fields: mutations
     });
     graphQLSchemaConfig.mutation = mutation;
   }
-  const outputSchema = new import_graphql10.GraphQLSchema(graphQLSchemaConfig);
+  const outputSchema = new import_graphql11.GraphQLSchema(graphQLSchemaConfig);
   return { schema: outputSchema, entities: generatorOutput };
 };
 // Annotate the CommonJS export names for ESM import in node: