@vantreeseba/drizzle-graphql 7.3.0 → 7.5.0

package/dist/index.cjs

@@ -40,15 +40,21 @@ __export(index_exports, {
   createRelationResolverFactory: () => createRelationResolverFactory,
   defaultErrorMapper: () => defaultErrorMapper,
   drizzleExecutorKey: () => drizzleExecutorKey,
+  drizzleExtension: () => drizzleExtension,
   extractFilters: () => extractFilters,
   extractOrderBy: () => extractOrderBy,
-  extractRelationJoinColumns: () => extractRelationJoinColumns
+  extractRelationJoinColumns: () => extractRelationJoinColumns,
+  identifyRows: () => identifyRows,
+  isDrizzleFieldExtension: () => isDrizzleFieldExtension,
+  resolveSelection: () => resolveSelection,
+  selectionToWith: () => selectionToWith,
+  singularizeMapper: () => singularizeMapper
 });
 module.exports = __toCommonJS(index_exports);
-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_drizzle_orm11 = require("drizzle-orm");
+var import_mysql_core4 = require("drizzle-orm/mysql-core");
+var import_pg_core4 = require("drizzle-orm/pg-core");
+var import_sqlite_core4 = require("drizzle-orm/sqlite-core");
 var import_graphql11 = require("graphql");
 
 // src/util/builders/common.ts
@@ -105,6 +111,10 @@ var getOrCreateLoader = (context, key, batchFn) => {
 var import_pluralize = __toESM(require("pluralize"), 1);
 var uncapitalize = (input) => input?.length ? `${input[0].toLocaleLowerCase()}${input.length > 1 ? input.slice(1, input.length) : ""}` : input;
 var capitalize = (input) => input?.length ? `${input[0].toLocaleUpperCase()}${input.length > 1 ? input.slice(1, input.length) : ""}` : input;
+var singularizeMapper = (tableName) => ({
+  singular: uncapitalize(import_pluralize.default.singular(tableName)),
+  plural: uncapitalize(import_pluralize.default.plural(tableName))
+});
 
 // src/util/data-mappers/index.ts
 var import_drizzle_orm2 = require("drizzle-orm");
@@ -593,6 +603,123 @@ var remapFromGraphQLArrayInput = (queryInput, table) => {
   return queryInput;
 };
 
+// src/util/extensions.ts
+var drizzleExtension = (target) => {
+  const value = target?.extensions?.drizzle;
+  return value && typeof value === "object" ? value : void 0;
+};
+var isDrizzleFieldExtension = (value) => !!value && value.kind !== "type";
+var tableFieldExtensions = (table, primaryKey) => (meta) => ({
+  table,
+  primaryKey,
+  ...meta
+});
+var tableTypeExtension = (table, primaryKey) => ({
+  table,
+  kind: "type",
+  primaryKey
+});
+var relationFieldExtension = (params) => ({
+  table: params.targetTable,
+  kind: params.aggregate ? "aggregate" : "relation",
+  operation: params.aggregate ? "relationAggregate" : "relation",
+  // An aggregate over a to-many relation still resolves to a single aggregate object.
+  single: params.aggregate ? true : params.single,
+  targetArg: "where",
+  primaryKey: params.primaryKey,
+  relation: params.relation,
+  parentTable: params.parentTable
+});
+var keyFromValues = (entry, primaryKey) => {
+  if (!entry || typeof entry !== "object") {
+    return void 0;
+  }
+  const row = {};
+  for (const column of primaryKey) {
+    const value = entry[column];
+    if (value === void 0 || value === null) {
+      return void 0;
+    }
+    row[column] = value;
+  }
+  return row;
+};
+var keysFromWhere = (where, primaryKey) => {
+  const none = { rows: [], complete: false };
+  if (!where || typeof where !== "object" || Array.isArray(where)) {
+    return none;
+  }
+  const filters = where;
+  if (filters.OR || filters.AND || filters.NOT) {
+    return none;
+  }
+  if (primaryKey.length > 1) {
+    const row = {};
+    for (const column2 of primaryKey) {
+      const operators2 = filters[column2];
+      if (!operators2 || typeof operators2 !== "object" || operators2.eq === void 0) {
+        return none;
+      }
+      row[column2] = operators2.eq;
+    }
+    return { rows: [row], complete: Object.keys(filters).length === primaryKey.length };
+  }
+  const column = primaryKey[0];
+  if (!column) {
+    return none;
+  }
+  const operators = filters[column];
+  if (!operators || typeof operators !== "object") {
+    return none;
+  }
+  const exact = Object.keys(filters).length === 1 && Object.keys(operators).length === 1;
+  if (operators.eq !== void 0) {
+    return { rows: [{ [column]: operators.eq }], complete: exact };
+  }
+  if (Array.isArray(operators.inArray)) {
+    return { rows: operators.inArray.map((value) => ({ [column]: value })), complete: exact };
+  }
+  return none;
+};
+var identifyRows = (field, args) => {
+  const meta = drizzleExtension(field);
+  if (!isDrizzleFieldExtension(meta)) {
+    return void 0;
+  }
+  const { table, primaryKey, targetArg } = meta;
+  const empty = { table, primaryKey, rows: [], complete: false };
+  if (!primaryKey.length || !targetArg) {
+    return empty;
+  }
+  const target = args?.[targetArg];
+  if (targetArg === "values") {
+    const entries = Array.isArray(target) ? target : target === void 0 ? [] : [target];
+    const rows = entries.map((entry) => keyFromValues(entry, primaryKey));
+    return {
+      table,
+      primaryKey,
+      rows: rows.filter((row) => !!row),
+      // A row whose key the database generates is not identifiable before the write.
+      complete: entries.length > 0 && rows.every(Boolean)
+    };
+  }
+  if (targetArg === "updates") {
+    if (!Array.isArray(target)) {
+      return empty;
+    }
+    const perEntry = target.map(
+      (entry) => keysFromWhere(entry?.where, primaryKey)
+    );
+    return {
+      table,
+      primaryKey,
+      rows: perEntry.flatMap((entry) => entry.rows),
+      complete: target.length > 0 && perEntry.every((entry) => entry.complete)
+    };
+  }
+  return { table, primaryKey, ...keysFromWhere(target, primaryKey) };
+};
+
 // src/util/builders/field-updates.ts
 var import_drizzle_orm3 = require("drizzle-orm");
 var import_graphql4 = require("graphql");
@@ -1139,6 +1266,14 @@ var createRelationResolverFactory = (db, tables, nullOrdering, filterCtx, limits
     return loader.load(localValue);
   };
 };
+var relationExtensionFor = (relEntry, parentTable, relationName, isOne, aggregate) => relationFieldExtension({
+  targetTable: relEntry.targetTableName,
+  parentTable,
+  relation: relationName,
+  single: isOne,
+  primaryKey: relEntry.targetPkNames ?? [],
+  aggregate
+});
 var columnDocs = (docs, column, tableName, columnName) => {
   const description = docs.describeColumn?.(column, { tableName, columnName });
   const deprecationReason = docs.deprecateColumn?.(column, { tableName, columnName });
@@ -1818,7 +1953,8 @@ var generateSelectFields = (tables, tableName, relationMap, fromTableName, fromR
     const shell = new import_graphql5.GraphQLObjectType({
       name: typeName,
       description: cacheCtx.docs.describeTable?.(tableName),
-      fields: () => ({ ...tableFields, ...container.fields })
+      fields: () => ({ ...tableFields, ...container.fields }),
+      extensions: { drizzle: tableTypeExtension(tableName, cacheCtx.primaryKeyOf?.(tableName) ?? []) }
     });
     cacheCtx.objectTypeCache.set(tableName, shell);
   }
@@ -1860,7 +1996,10 @@ var generateSelectFields = (tables, tableName, relationMap, fromTableName, fromR
         relType = new import_graphql5.GraphQLObjectType({
           name: resolveTypeName(targetTableName, typeNameMapper),
           description: cacheCtx.docs.describeTable?.(targetTableName),
-          fields: () => ({ ...targetTableFields, ...capturedTargetContainer.fields })
+          fields: () => ({ ...targetTableFields, ...capturedTargetContainer.fields }),
+          extensions: {
+            drizzle: tableTypeExtension(targetTableName, cacheCtx.primaryKeyOf?.(targetTableName) ?? [])
+          }
         });
         cacheCtx.objectTypeCache.set(targetTableName, relType);
       }
@@ -1877,12 +2016,13 @@ var generateSelectFields = (tables, tableName, relationMap, fromTableName, fromR
               where: { type: relSelectData.filters }
             },
             resolve,
-            ...relationDocs
+            ...relationDocs,
+            extensions: { drizzle: relationExtensionFor(relEntry, tableName, relationName, true) }
           }
         ]);
         continue;
       }
-      const targetDistinctEnum = cacheCtx.features.distinct ? generateDistinctEnum(tables[targetTableName], resolveTypeName(targetTableName, typeNameMapper)) : void 0;
+      const targetDistinctEnum = cacheCtx.featureOf(targetTableName).distinct ? generateDistinctEnum(tables[targetTableName], resolveTypeName(targetTableName, typeNameMapper)) : void 0;
       rawRelationFields.push([
         relationName,
         {
@@ -1900,11 +2040,10 @@ var generateSelectFields = (tables, tableName, relationMap, fromTableName, fromR
           },
           resolve,
           ...relationDocs,
-          ...cacheCtx.complexity ? {
-            extensions: {
-              complexity: listFieldComplexity(cacheCtx.complexity, cacheCtx.limits?.(targetTableName))
-            }
-          } : {}
+          extensions: {
+            drizzle: relationExtensionFor(relEntry, tableName, relationName, false),
+            ...cacheCtx.complexity ? { complexity: listFieldComplexity(cacheCtx.complexity, cacheCtx.limits?.(targetTableName)) } : {}
+          }
         }
       ]);
       const aggregateFieldName = `${relationName}Aggregate`;
@@ -1923,7 +2062,10 @@ var generateSelectFields = (tables, tableName, relationMap, fromTableName, fromR
                 where: { type: relSelectData.filters }
               },
               resolve: relationAggregate.resolve,
-              ...cacheCtx.complexity ? { extensions: { complexity: aggregateFieldComplexity(cacheCtx.complexity) } } : {}
+              extensions: {
+                drizzle: relationExtensionFor(relEntry, tableName, relationName, isOne, true),
+                ...cacheCtx.complexity ? { complexity: aggregateFieldComplexity(cacheCtx.complexity) } : {}
+              }
             }
           ]);
         }
@@ -1992,7 +2134,7 @@ var generateTableTypes = (tableName, tables, relationMap, withReturning, relatio
   const updateFields = Object.fromEntries(
     columnEntries.map(([columnName, column]) => {
       const converted = drizzleColumnToGraphQLType(column, columnName, tableName, true, false, true);
-      const operations = cacheCtx.features.fieldUpdateOperations ? fieldUpdateInputType(column, columnName, tableName) : void 0;
+      const operations = cacheCtx.featureOf(tableName).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) }];
     })
@@ -2009,7 +2151,8 @@ var generateTableTypes = (tableName, tables, relationMap, withReturning, relatio
   const selectSingleOutput = cacheCtx.objectTypeCache.get(tableName) ?? new import_graphql5.GraphQLObjectType({
     name: resolveTypeName(tableName, typeNameMapper),
     description: cacheCtx.docs.describeTable?.(tableName),
-    fields: { ...tableFields, ...relationFields }
+    fields: { ...tableFields, ...relationFields },
+    extensions: { drizzle: tableTypeExtension(tableName, cacheCtx.primaryKeyOf?.(tableName) ?? []) }
   });
   const selectArrOutput = new import_graphql5.GraphQLNonNull(new import_graphql5.GraphQLList(new import_graphql5.GraphQLNonNull(selectSingleOutput)));
   const arrTableItemOutput = withReturning ? (
@@ -3410,6 +3553,38 @@ var import_mysql_core2 = require("drizzle-orm/mysql-core");
 var import_graphql7 = require("graphql");
 var import_graphql_parse_resolve_info2 = require("graphql-parse-resolve-info");
 
+// src/util/features.ts
+var featureDefaults = {
+  aggregates: true,
+  groupBy: true,
+  relationAggregates: true,
+  distinct: true,
+  insert: true,
+  update: true,
+  updateMany: true,
+  delete: true,
+  upsert: false,
+  fieldUpdateOperations: false,
+  countMutations: false,
+  requireWhere: false
+};
+var resolveTableFeatures = (features) => {
+  const cache = /* @__PURE__ */ new Map();
+  const names = Object.keys(featureDefaults);
+  return (tableName) => {
+    let resolved = cache.get(tableName);
+    if (!resolved) {
+      resolved = {};
+      for (const name of names) {
+        const configured = features?.[name];
+        resolved[name] = configured === void 0 ? featureDefaults[name] : typeof configured === "function" ? !!configured(tableName) : !!configured;
+      }
+      cache.set(tableName, resolved);
+    }
+    return resolved;
+  };
+};
+
 // src/util/builders/aggregates.ts
 var import_drizzle_orm5 = require("drizzle-orm");
 var import_graphql6 = require("graphql");
@@ -4144,6 +4319,8 @@ var generateSchemaData = (db, schema, relations, options) => {
   const excludedTables = new Set(options.exclude?.tables ?? []);
   const tableEntries = schemaEntries.filter(([key, value]) => (0, import_drizzle_orm6.is)(value, import_mysql_core2.MySqlTable) && !excludedTables.has(key));
   const tables = Object.fromEntries(tableEntries);
+  const featureOf = resolveTableFeatures(features);
+  const anyTable = (feature) => tableEntries.some(([name]) => featureOf(name)[feature]);
   if (!tableEntries.length) {
     throw new Error(
       "Drizzle-GraphQL Error: No tables detected in Drizzle-ORM's database instance. Did you forget to pass schema to drizzle constructor?"
@@ -4186,9 +4363,10 @@ var generateSchemaData = (db, schema, relations, options) => {
     complexity,
     limits,
     docs: options.docs ?? {},
-    features
+    primaryKeyOf: (name) => tables[name] ? mysqlPrimaryKeyPropNames(tables[name]) : [],
+    featureOf
   };
-  const relationAggregateFactory = features.relationAggregates ? createRelationAggregateFactory(db, tables, cacheCtx, typeNameMapper, filterCtx) : void 0;
+  const relationAggregateFactory = anyTable("relationAggregates") ? createRelationAggregateFactory(db, tables, cacheCtx, typeNameMapper, filterCtx) : void 0;
   const queries = {};
   const mutations = {};
   const mutationTxCtx = createMutationTxCtx(options.transactions);
@@ -4206,7 +4384,7 @@ var generateSchemaData = (db, schema, relations, options) => {
         prefixes.insert,
         prefixes.update,
         resolverFactory,
-        relationAggregateFactory
+        featureOf(tableName).relationAggregates ? relationAggregateFactory : void 0
       )
     ])
   );
@@ -4220,10 +4398,12 @@ var generateSchemaData = (db, schema, relations, options) => {
   });
   const inputs = {};
   const outputs = {};
-  if (features.insert || features.upsert || features.update || features.delete) {
+  if (["insert", "upsert", "update", "delete"].some((feature) => anyTable(feature))) {
     outputs.MutationReturn = mutationReturnType;
   }
   for (const [tableName, tableTypes] of Object.entries(gqlSchemaTypes)) {
+    const tableFeatures = featureOf(tableName);
+    const drizzleMeta = tableFieldExtensions(tableName, mysqlPrimaryKeyPropNames(schema[tableName]));
     const { insertInput, updateInput, tableFilters, tableOrder } = tableTypes.inputs;
     const { selectSingleOutput, selectArrOutput } = tableTypes.outputs;
     const {
@@ -4255,7 +4435,7 @@ var generateSchemaData = (db, schema, relations, options) => {
       typeName,
       typeNameMapper,
       filterCtx,
-      features.distinct,
+      tableFeatures.distinct,
       limits
     );
     const selectSingleGenerated = generateSelectSingle(
@@ -4271,7 +4451,7 @@ var generateSchemaData = (db, schema, relations, options) => {
       filterCtx,
       limits
     );
-    const insertArrGenerated = features.insert ? generateInsertArray(
+    const insertArrGenerated = tableFeatures.insert ? generateInsertArray(
       db,
       tableName,
       schema[tableName],
@@ -4279,7 +4459,7 @@ var generateSchemaData = (db, schema, relations, options) => {
       createArrayFieldName,
       mutationTxCtx
     ) : void 0;
-    const insertSingleGenerated = features.insert ? generateInsertSingle(
+    const insertSingleGenerated = tableFeatures.insert ? generateInsertSingle(
       db,
       tableName,
       schema[tableName],
@@ -4287,7 +4467,7 @@ var generateSchemaData = (db, schema, relations, options) => {
       createSingleFieldName,
       mutationTxCtx
     ) : void 0;
-    const onConflictInput = features.upsert ? generateOnConflictInput({
+    const onConflictInput = tableFeatures.upsert ? generateOnConflictInput({
       table: schema[tableName],
       typeName,
       uniqueSets: [],
@@ -4312,7 +4492,7 @@ var generateSchemaData = (db, schema, relations, options) => {
       true,
       mutationTxCtx
     ) : void 0;
-    const updateGenerated = features.update ? generateUpdate(
+    const updateGenerated = tableFeatures.update ? generateUpdate(
       db,
       tableName,
       schema[tableName],
@@ -4320,11 +4500,11 @@ var generateSchemaData = (db, schema, relations, options) => {
       tableFilters,
       updateFieldName,
       false,
-      features.requireWhere,
+      tableFeatures.requireWhere,
       filterCtx,
       mutationTxCtx
     ) : void 0;
-    const updateSingleGenerated = features.update ? generateUpdate(
+    const updateSingleGenerated = tableFeatures.update ? generateUpdate(
       db,
       tableName,
       schema[tableName],
@@ -4332,11 +4512,11 @@ var generateSchemaData = (db, schema, relations, options) => {
       tableFilters,
       updateSingleFieldName,
       true,
-      features.requireWhere,
+      tableFeatures.requireWhere,
       filterCtx,
       mutationTxCtx
     ) : void 0;
-    const updateManyInput = features.update && features.updateMany ? generateUpdateManyInput({ typeName, updatePrefix: prefixes.update, updateInput, tableFilters }) : void 0;
+    const updateManyInput = tableFeatures.update && tableFeatures.updateMany ? generateUpdateManyInput({ typeName, updatePrefix: prefixes.update, updateInput, tableFilters }) : void 0;
     const updateManyGenerated = updateManyInput ? generateUpdateMany(
       db,
       tableName,
@@ -4346,29 +4526,29 @@ var generateSchemaData = (db, schema, relations, options) => {
       filterCtx,
       mutationTxCtx
     ) : void 0;
-    const deleteGenerated = features.delete ? generateDelete(
+    const deleteGenerated = tableFeatures.delete ? generateDelete(
       db,
       tableName,
       schema[tableName],
       tableFilters,
       deleteFieldName,
       false,
-      features.requireWhere,
+      tableFeatures.requireWhere,
       filterCtx,
       mutationTxCtx
     ) : void 0;
-    const deleteSingleGenerated = features.delete ? generateDelete(
+    const deleteSingleGenerated = tableFeatures.delete ? generateDelete(
       db,
       tableName,
       schema[tableName],
       tableFilters,
       deleteSingleFieldName,
       true,
-      features.requireWhere,
+      tableFeatures.requireWhere,
       filterCtx,
       mutationTxCtx
     ) : void 0;
-    const updateCountGenerated = features.update && features.countMutations ? generateWriteCount({
+    const updateCountGenerated = tableFeatures.update && tableFeatures.countMutations ? generateWriteCount({
       db,
       tableName,
       table: schema[tableName],
@@ -4376,23 +4556,23 @@ var generateSchemaData = (db, schema, relations, options) => {
       setArgs: updateInput,
       filterArgs: tableFilters,
       fieldName: updateCountFieldName,
-      requireWhere: features.requireWhere,
+      requireWhere: tableFeatures.requireWhere,
       filterCtx,
       txCtx: mutationTxCtx
     }) : void 0;
-    const deleteCountGenerated = features.delete && features.countMutations ? generateWriteCount({
+    const deleteCountGenerated = tableFeatures.delete && tableFeatures.countMutations ? generateWriteCount({
       db,
       tableName,
       table: schema[tableName],
       kind: "delete",
       filterArgs: tableFilters,
       fieldName: deleteCountFieldName,
-      requireWhere: features.requireWhere,
+      requireWhere: tableFeatures.requireWhere,
       filterCtx,
       txCtx: mutationTxCtx
     }) : void 0;
-    const aggregateType = features.aggregates ? generateAggregateTypes(schema[tableName], tableName, typeName, cacheCtx) : void 0;
-    const aggregateGenerated = features.aggregates ? generateAggregate(
+    const aggregateType = tableFeatures.aggregates ? generateAggregateTypes(schema[tableName], tableName, typeName, cacheCtx) : void 0;
+    const aggregateGenerated = tableFeatures.aggregates ? generateAggregate(
       db,
       tableName,
       schema[tableName],
@@ -4401,7 +4581,7 @@ var generateSchemaData = (db, schema, relations, options) => {
       tableFilters,
       filterCtx
     ) : void 0;
-    const groupByType = features.aggregates && features.groupBy ? generateGroupByType(schema[tableName], tableName, typeName, cacheCtx) : void 0;
+    const groupByType = tableFeatures.aggregates && tableFeatures.groupBy ? generateGroupByType(schema[tableName], tableName, typeName, cacheCtx) : void 0;
     const groupByEnum = groupByType ? generateGroupByEnum(schema[tableName], tableName, typeName) : void 0;
     const havingInput = groupByEnum ? generateHavingInput(schema[tableName], tableName, typeName) : void 0;
     const groupByGenerated = groupByType && groupByEnum && havingInput ? generateGroupBy(
@@ -4419,19 +4599,28 @@ var generateSchemaData = (db, schema, relations, options) => {
       type: selectArrOutput,
       args: selectArrGenerated.args,
       resolve: selectArrGenerated.resolver,
-      ...complexity ? { extensions: { complexity: listFieldComplexity(complexity, limits?.(tableName)) } } : {}
+      extensions: {
+        drizzle: drizzleMeta({ kind: "query", operation: "select", single: false, targetArg: "where" }),
+        ...complexity ? { complexity: listFieldComplexity(complexity, limits?.(tableName)) } : {}
+      }
     };
     queries[selectSingleGenerated.name] = {
       type: selectSingleOutput,
       args: selectSingleGenerated.args,
-      resolve: selectSingleGenerated.resolver
+      resolve: selectSingleGenerated.resolver,
+      extensions: {
+        drizzle: drizzleMeta({ kind: "query", operation: "select", single: true, targetArg: "where" })
+      }
     };
     if (aggregateGenerated && aggregateType) {
       queries[aggregateGenerated.name] = {
         type: new import_graphql7.GraphQLNonNull(aggregateType),
         args: aggregateGenerated.args,
         resolve: aggregateGenerated.resolver,
-        ...complexity ? { extensions: { complexity: aggregateFieldComplexity(complexity) } } : {}
+        extensions: {
+          drizzle: drizzleMeta({ kind: "aggregate", operation: "aggregate", single: true, targetArg: "where" }),
+          ...complexity ? { complexity: aggregateFieldComplexity(complexity) } : {}
+        }
       };
     }
     if (groupByGenerated && groupByType) {
@@ -4439,25 +4628,30 @@ var generateSchemaData = (db, schema, relations, options) => {
         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) } } : {}
+        extensions: {
+          drizzle: drizzleMeta({ kind: "aggregate", operation: "groupBy", single: false, targetArg: "where" }),
+          ...complexity ? { complexity: aggregateFieldComplexity(complexity) } : {}
+        }
       };
     }
-    for (const generated of [
-      insertArrGenerated,
-      insertSingleGenerated,
-      upsertArrGenerated,
-      upsertSingleGenerated,
-      updateGenerated,
-      updateManyGenerated,
-      updateSingleGenerated,
-      deleteGenerated,
-      deleteSingleGenerated
-    ]) {
+    const generatedMutations = [
+      [insertArrGenerated, { operation: "insert", single: false, targetArg: "values" }],
+      [insertSingleGenerated, { operation: "insert", single: true, targetArg: "values" }],
+      [upsertArrGenerated, { operation: "upsert", single: false, targetArg: "values" }],
+      [upsertSingleGenerated, { operation: "upsert", single: true, targetArg: "values" }],
+      [updateGenerated, { operation: "update", single: false, targetArg: "where" }],
+      [updateManyGenerated, { operation: "updateMany", single: false, targetArg: "updates" }],
+      [updateSingleGenerated, { operation: "update", single: true, targetArg: "where" }],
+      [deleteGenerated, { operation: "delete", single: false, targetArg: "where" }],
+      [deleteSingleGenerated, { operation: "delete", single: true, targetArg: "where" }]
+    ];
+    for (const [generated, meta] of generatedMutations) {
       if (generated) {
         mutations[generated.name] = {
           type: mutationReturnType,
           args: generated.args,
-          resolve: generated.resolver
+          resolve: generated.resolver,
+          extensions: { drizzle: drizzleMeta({ kind: "mutation", ...meta }) }
         };
       }
     }
@@ -4479,9 +4673,9 @@ var generateSchemaData = (db, schema, relations, options) => {
     }
     const activeInputs = [
       // The insert input types the upsert mutations too, so either feature keeps it.
-      ...features.insert || onConflictInput ? [insertInput] : [],
+      ...tableFeatures.insert || onConflictInput ? [insertInput] : [],
       ...onConflictInput ? [onConflictInput] : [],
-      ...features.update ? [updateInput] : [],
+      ...tableFeatures.update ? [updateInput] : [],
       ...updateManyInput ? [updateManyInput] : [],
       tableFilters,
       tableOrder
@@ -5508,6 +5702,8 @@ function generateSchemaData2(db, schema, relations, options) {
   const excludedTables = new Set(options.exclude?.tables ?? []);
   const tableEntries = schemaEntries.filter(([key, value]) => (0, import_drizzle_orm8.is)(value, import_pg_core2.PgTable) && !excludedTables.has(key));
   const tables = Object.fromEntries(tableEntries);
+  const featureOf = resolveTableFeatures(features);
+  const anyTable = (feature) => tableEntries.some(([name]) => featureOf(name)[feature]);
   if (!tableEntries.length) {
     throw new Error(
       "Drizzle-GraphQL Error: No tables detected in Drizzle-ORM's database instance. Did you forget to pass schema to drizzle constructor?"
@@ -5545,7 +5741,8 @@ function generateSchemaData2(db, schema, relations, options) {
     complexity,
     limits,
     docs: options.docs ?? {},
-    features
+    primaryKeyOf: (name) => tables[name] ? pgPrimaryKeyPropNames(tables[name]) : [],
+    featureOf
   };
   const nestedPlans = features.nestedWrites ? buildNestedWritePlans(
     tables,
@@ -5556,7 +5753,7 @@ function generateSchemaData2(db, schema, relations, options) {
   ) : void 0;
   const nestedTypes = nestedPlans ? createNestedWriteTypes({ plans: nestedPlans, cacheCtx, typeNameMapper, insertPrefix: prefixes.insert }) : void 0;
   const nestedRuntime = nestedPlans ? createNestedWriteRuntime({ plans: nestedPlans, filterCtx }) : void 0;
-  const relationAggregateFactory = features.relationAggregates ? createRelationAggregateFactory(db, tables, cacheCtx, typeNameMapper, filterCtx) : void 0;
+  const relationAggregateFactory = anyTable("relationAggregates") ? createRelationAggregateFactory(db, tables, cacheCtx, typeNameMapper, filterCtx) : void 0;
   const queries = {};
   const mutations = {};
   const mutationTxCtx = createMutationTxCtx(options.transactions);
@@ -5574,7 +5771,7 @@ function generateSchemaData2(db, schema, relations, options) {
         prefixes.insert,
         prefixes.update,
         resolverFactory,
-        relationAggregateFactory,
+        featureOf(tableName).relationAggregates ? relationAggregateFactory : void 0,
         nestedTypes
       )
     ])
@@ -5582,6 +5779,8 @@ function generateSchemaData2(db, schema, relations, options) {
   const inputs = {};
   const outputs = {};
   for (const [tableName, tableTypes] of Object.entries(gqlSchemaTypes)) {
+    const tableFeatures = featureOf(tableName);
+    const drizzleMeta = tableFieldExtensions(tableName, pgPrimaryKeyPropNames(schema[tableName]));
     const { insertInput, updateInput, tableFilters, tableOrder } = tableTypes.inputs;
     const { selectSingleOutput, selectArrOutput, singleTableItemOutput, arrTableItemOutput } = tableTypes.outputs;
     const {
@@ -5613,7 +5812,7 @@ function generateSchemaData2(db, schema, relations, options) {
       typeName,
       typeNameMapper,
       filterCtx,
-      features.distinct,
+      tableFeatures.distinct,
       limits
     );
     const selectSingleGenerated = generateSelectSingle2(
@@ -5629,7 +5828,7 @@ function generateSchemaData2(db, schema, relations, options) {
       filterCtx,
       limits
     );
-    const insertArrGenerated = features.insert ? generateInsertArray2(
+    const insertArrGenerated = tableFeatures.insert ? generateInsertArray2(
       db,
       tableName,
       schema[tableName],
@@ -5644,7 +5843,7 @@ function generateSchemaData2(db, schema, relations, options) {
       nestedRuntime,
       limits
     ) : void 0;
-    const insertSingleGenerated = features.insert ? generateInsertSingle2(
+    const insertSingleGenerated = tableFeatures.insert ? generateInsertSingle2(
       db,
       tableName,
       schema[tableName],
@@ -5659,8 +5858,8 @@ function generateSchemaData2(db, schema, relations, options) {
       nestedRuntime,
       limits
     ) : void 0;
-    const uniqueSets = features.upsert ? getUniqueColumnSets(schema[tableName], import_pg_core2.getTableConfig) : [];
-    const onConflictInput = features.upsert ? generateOnConflictInput({
+    const uniqueSets = tableFeatures.upsert ? getUniqueColumnSets(schema[tableName], import_pg_core2.getTableConfig) : [];
+    const onConflictInput = tableFeatures.upsert ? generateOnConflictInput({
       table: schema[tableName],
       typeName,
       uniqueSets,
@@ -5703,7 +5902,7 @@ function generateSchemaData2(db, schema, relations, options) {
       nestedRuntime,
       limits
     ) : void 0;
-    const updateGenerated = features.update ? generateUpdate2(
+    const updateGenerated = tableFeatures.update ? generateUpdate2(
       db,
       tableName,
       schema[tableName],
@@ -5714,14 +5913,14 @@ function generateSchemaData2(db, schema, relations, options) {
       updateFieldName,
       typeName,
       false,
-      features.requireWhere,
+      tableFeatures.requireWhere,
       typeNameMapper,
       filterCtx,
       mutationTxCtx,
       nestedRuntime,
       limits
     ) : void 0;
-    const updateSingleGenerated = features.update ? generateUpdate2(
+    const updateSingleGenerated = tableFeatures.update ? generateUpdate2(
       db,
       tableName,
       schema[tableName],
@@ -5732,14 +5931,14 @@ function generateSchemaData2(db, schema, relations, options) {
       updateSingleFieldName,
       typeName,
       true,
-      features.requireWhere,
+      tableFeatures.requireWhere,
       typeNameMapper,
       filterCtx,
       mutationTxCtx,
       nestedRuntime,
       limits
     ) : void 0;
-    const updateManyInput = features.update && features.updateMany ? generateUpdateManyInput({ typeName, updatePrefix: prefixes.update, updateInput, tableFilters }) : void 0;
+    const updateManyInput = tableFeatures.update && tableFeatures.updateMany ? generateUpdateManyInput({ typeName, updatePrefix: prefixes.update, updateInput, tableFilters }) : void 0;
     const updateManyGenerated = updateManyInput ? generateUpdateMany2(
       db,
       tableName,
@@ -5755,7 +5954,7 @@ function generateSchemaData2(db, schema, relations, options) {
       nestedRuntime,
       limits
     ) : void 0;
-    const deleteGenerated = features.delete ? generateDelete2(
+    const deleteGenerated = tableFeatures.delete ? generateDelete2(
       db,
       tableName,
       schema[tableName],
@@ -5763,12 +5962,12 @@ function generateSchemaData2(db, schema, relations, options) {
       deleteFieldName,
       typeName,
       false,
-      features.requireWhere,
+      tableFeatures.requireWhere,
       filterCtx,
       { tableName, relationMap: namedRelations, tables },
       mutationTxCtx
     ) : void 0;
-    const deleteSingleGenerated = features.delete ? generateDelete2(
+    const deleteSingleGenerated = tableFeatures.delete ? generateDelete2(
       db,
       tableName,
       schema[tableName],
@@ -5776,12 +5975,12 @@ function generateSchemaData2(db, schema, relations, options) {
       deleteSingleFieldName,
       typeName,
       true,
-      features.requireWhere,
+      tableFeatures.requireWhere,
       filterCtx,
       { tableName, relationMap: namedRelations, tables },
       mutationTxCtx
     ) : void 0;
-    const updateCountGenerated = features.update && features.countMutations ? generateWriteCount({
+    const updateCountGenerated = tableFeatures.update && tableFeatures.countMutations ? generateWriteCount({
       db,
       tableName,
       table: schema[tableName],
@@ -5789,24 +5988,24 @@ function generateSchemaData2(db, schema, relations, options) {
       setArgs: updateInput,
       filterArgs: tableFilters,
       fieldName: updateCountFieldName,
-      requireWhere: features.requireWhere,
+      requireWhere: tableFeatures.requireWhere,
       filterCtx,
       txCtx: mutationTxCtx,
       nested: nestedRuntime
     }) : void 0;
-    const deleteCountGenerated = features.delete && features.countMutations ? generateWriteCount({
+    const deleteCountGenerated = tableFeatures.delete && tableFeatures.countMutations ? generateWriteCount({
       db,
       tableName,
       table: schema[tableName],
       kind: "delete",
       filterArgs: tableFilters,
       fieldName: deleteCountFieldName,
-      requireWhere: features.requireWhere,
+      requireWhere: tableFeatures.requireWhere,
       filterCtx,
       txCtx: mutationTxCtx
     }) : void 0;
-    const aggregateType = features.aggregates ? generateAggregateTypes(schema[tableName], tableName, typeName, cacheCtx) : void 0;
-    const aggregateGenerated = features.aggregates ? generateAggregate(
+    const aggregateType = tableFeatures.aggregates ? generateAggregateTypes(schema[tableName], tableName, typeName, cacheCtx) : void 0;
+    const aggregateGenerated = tableFeatures.aggregates ? generateAggregate(
       db,
       tableName,
       schema[tableName],
@@ -5815,7 +6014,7 @@ function generateSchemaData2(db, schema, relations, options) {
       tableFilters,
       filterCtx
     ) : void 0;
-    const groupByType = features.aggregates && features.groupBy ? generateGroupByType(schema[tableName], tableName, typeName, cacheCtx) : void 0;
+    const groupByType = tableFeatures.aggregates && tableFeatures.groupBy ? generateGroupByType(schema[tableName], tableName, typeName, cacheCtx) : void 0;
     const groupByEnum = groupByType ? generateGroupByEnum(schema[tableName], tableName, typeName) : void 0;
     const havingInput = groupByEnum ? generateHavingInput(schema[tableName], tableName, typeName) : void 0;
     const groupByGenerated = groupByType && groupByEnum && havingInput ? generateGroupBy(
@@ -5833,19 +6032,28 @@ function generateSchemaData2(db, schema, relations, options) {
       type: selectArrOutput,
       args: selectArrGenerated.args,
       resolve: selectArrGenerated.resolver,
-      ...complexity ? { extensions: { complexity: listFieldComplexity(complexity, limits?.(tableName)) } } : {}
+      extensions: {
+        drizzle: drizzleMeta({ kind: "query", operation: "select", single: false, targetArg: "where" }),
+        ...complexity ? { complexity: listFieldComplexity(complexity, limits?.(tableName)) } : {}
+      }
     };
     queries[selectSingleGenerated.name] = {
       type: selectSingleOutput,
       args: selectSingleGenerated.args,
-      resolve: selectSingleGenerated.resolver
+      resolve: selectSingleGenerated.resolver,
+      extensions: {
+        drizzle: drizzleMeta({ kind: "query", operation: "select", single: true, targetArg: "where" })
+      }
     };
     if (aggregateGenerated && aggregateType) {
       queries[aggregateGenerated.name] = {
         type: new import_graphql9.GraphQLNonNull(aggregateType),
         args: aggregateGenerated.args,
         resolve: aggregateGenerated.resolver,
-        ...complexity ? { extensions: { complexity: aggregateFieldComplexity(complexity) } } : {}
+        extensions: {
+          drizzle: drizzleMeta({ kind: "aggregate", operation: "aggregate", single: true, targetArg: "where" }),
+          ...complexity ? { complexity: aggregateFieldComplexity(complexity) } : {}
+        }
       };
     }
     if (groupByGenerated && groupByType) {
@@ -5853,14 +6061,20 @@ function generateSchemaData2(db, schema, relations, options) {
         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) } } : {}
+        extensions: {
+          drizzle: drizzleMeta({ kind: "aggregate", operation: "groupBy", single: false, targetArg: "where" }),
+          ...complexity ? { complexity: aggregateFieldComplexity(complexity) } : {}
+        }
       };
     }
     if (insertArrGenerated) {
       mutations[insertArrGenerated.name] = {
         type: arrTableItemOutput,
         args: insertArrGenerated.args,
-        resolve: insertArrGenerated.resolver
+        resolve: insertArrGenerated.resolver,
+        extensions: {
+          drizzle: drizzleMeta({ kind: "mutation", operation: "insert", single: false, targetArg: "values" })
+        }
       };
     }
     if (insertSingleGenerated) {
@@ -5869,28 +6083,40 @@ function generateSchemaData2(db, schema, relations, options) {
         // `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
+        resolve: insertSingleGenerated.resolver,
+        extensions: {
+          drizzle: drizzleMeta({ kind: "mutation", operation: "insert", single: true, targetArg: "values" })
+        }
       };
     }
     if (upsertArrGenerated) {
       mutations[upsertArrGenerated.name] = {
         type: arrTableItemOutput,
         args: upsertArrGenerated.args,
-        resolve: upsertArrGenerated.resolver
+        resolve: upsertArrGenerated.resolver,
+        extensions: {
+          drizzle: drizzleMeta({ kind: "mutation", operation: "upsert", single: false, targetArg: "values" })
+        }
       };
     }
     if (upsertSingleGenerated) {
       mutations[upsertSingleGenerated.name] = {
         type: singleTableItemOutput,
         args: upsertSingleGenerated.args,
-        resolve: upsertSingleGenerated.resolver
+        resolve: upsertSingleGenerated.resolver,
+        extensions: {
+          drizzle: drizzleMeta({ kind: "mutation", operation: "upsert", single: true, targetArg: "values" })
+        }
       };
     }
     if (updateGenerated) {
       mutations[updateGenerated.name] = {
         type: arrTableItemOutput,
         args: updateGenerated.args,
-        resolve: updateGenerated.resolver
+        resolve: updateGenerated.resolver,
+        extensions: {
+          drizzle: drizzleMeta({ kind: "mutation", operation: "update", single: false, targetArg: "where" })
+        }
       };
     }
     if (updateManyGenerated) {
@@ -5898,6 +6124,9 @@ function generateSchemaData2(db, schema, relations, options) {
         type: new import_graphql9.GraphQLNonNull(new import_graphql9.GraphQLList(singleTableItemOutput)),
         args: updateManyGenerated.args,
         resolve: updateManyGenerated.resolver,
+        extensions: {
+          drizzle: drizzleMeta({ kind: "mutation", operation: "updateMany", single: false, targetArg: "updates" })
+        },
         // 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.
@@ -5908,21 +6137,30 @@ function generateSchemaData2(db, schema, relations, options) {
       mutations[updateSingleGenerated.name] = {
         type: singleTableItemOutput,
         args: updateSingleGenerated.args,
-        resolve: updateSingleGenerated.resolver
+        resolve: updateSingleGenerated.resolver,
+        extensions: {
+          drizzle: drizzleMeta({ kind: "mutation", operation: "update", single: true, targetArg: "where" })
+        }
       };
     }
     if (deleteGenerated) {
       mutations[deleteGenerated.name] = {
         type: arrTableItemOutput,
         args: deleteGenerated.args,
-        resolve: deleteGenerated.resolver
+        resolve: deleteGenerated.resolver,
+        extensions: {
+          drizzle: drizzleMeta({ kind: "mutation", operation: "delete", single: false, targetArg: "where" })
+        }
       };
     }
     if (deleteSingleGenerated) {
       mutations[deleteSingleGenerated.name] = {
         type: singleTableItemOutput,
         args: deleteSingleGenerated.args,
-        resolve: deleteSingleGenerated.resolver
+        resolve: deleteSingleGenerated.resolver,
+        extensions: {
+          drizzle: drizzleMeta({ kind: "mutation", operation: "delete", single: true, targetArg: "where" })
+        }
       };
     }
     if (updateCountGenerated) {
@@ -5943,9 +6181,9 @@ function generateSchemaData2(db, schema, relations, options) {
     }
     const activeInputs = [
       // The insert input types the upsert mutations too, so either feature keeps it.
-      ...features.insert || onConflictInput ? [insertInput] : [],
+      ...tableFeatures.insert || onConflictInput ? [insertInput] : [],
       ...onConflictInput ? [onConflictInput] : [],
-      ...features.update ? [updateInput] : [],
+      ...tableFeatures.update ? [updateInput] : [],
       ...updateManyInput ? [updateManyInput] : [],
       tableFilters,
       tableOrder
@@ -6525,6 +6763,8 @@ var generateSchemaData3 = (db, schema, relations, options) => {
   const excludedTables = new Set(options.exclude?.tables ?? []);
   const tableEntries = schemaEntries.filter(([key, value]) => (0, import_drizzle_orm9.is)(value, import_sqlite_core2.SQLiteTable) && !excludedTables.has(key));
   const tables = Object.fromEntries(tableEntries);
+  const featureOf = resolveTableFeatures(features);
+  const anyTable = (feature) => tableEntries.some(([name]) => featureOf(name)[feature]);
   if (!tableEntries.length) {
     throw new Error(
       "Drizzle-GraphQL Error: No tables detected in Drizzle-ORM's database instance. Did you forget to pass schema to drizzle constructor?"
@@ -6562,7 +6802,8 @@ var generateSchemaData3 = (db, schema, relations, options) => {
     complexity,
     limits,
     docs: options.docs ?? {},
-    features
+    primaryKeyOf: (name) => tables[name] ? sqlitePrimaryKeyPropNames(tables[name]) : [],
+    featureOf
   };
   if (features.nestedWrites && db.resultKind === "sync") {
     throw new Error(
@@ -6578,7 +6819,7 @@ var generateSchemaData3 = (db, schema, relations, options) => {
   ) : void 0;
   const nestedTypes = nestedPlans ? createNestedWriteTypes({ plans: nestedPlans, cacheCtx, typeNameMapper, insertPrefix: prefixes.insert }) : void 0;
   const nestedRuntime = nestedPlans ? createNestedWriteRuntime({ plans: nestedPlans, filterCtx }) : void 0;
-  const relationAggregateFactory = features.relationAggregates ? createRelationAggregateFactory(db, tables, cacheCtx, typeNameMapper, filterCtx) : void 0;
+  const relationAggregateFactory = anyTable("relationAggregates") ? createRelationAggregateFactory(db, tables, cacheCtx, typeNameMapper, filterCtx) : void 0;
   const queries = {};
   const mutations = {};
   if (options.transactions && db.resultKind === "sync") {
@@ -6601,7 +6842,7 @@ var generateSchemaData3 = (db, schema, relations, options) => {
         prefixes.insert,
         prefixes.update,
         resolverFactory,
-        relationAggregateFactory,
+        featureOf(tableName).relationAggregates ? relationAggregateFactory : void 0,
         nestedTypes
       )
     ])
@@ -6609,6 +6850,8 @@ var generateSchemaData3 = (db, schema, relations, options) => {
   const inputs = {};
   const outputs = {};
   for (const [tableName, tableTypes] of Object.entries(gqlSchemaTypes)) {
+    const tableFeatures = featureOf(tableName);
+    const drizzleMeta = tableFieldExtensions(tableName, sqlitePrimaryKeyPropNames(schema[tableName]));
     const { insertInput, updateInput, tableFilters, tableOrder } = tableTypes.inputs;
     const { selectSingleOutput, selectArrOutput, singleTableItemOutput, arrTableItemOutput } = tableTypes.outputs;
     const {
@@ -6640,7 +6883,7 @@ var generateSchemaData3 = (db, schema, relations, options) => {
       typeName,
       typeNameMapper,
       filterCtx,
-      features.distinct,
+      tableFeatures.distinct,
       limits
     );
     const selectSingleGenerated = generateSelectSingle3(
@@ -6656,7 +6899,7 @@ var generateSchemaData3 = (db, schema, relations, options) => {
       filterCtx,
       limits
     );
-    const insertArrGenerated = features.insert ? generateInsertArray3(
+    const insertArrGenerated = tableFeatures.insert ? generateInsertArray3(
       db,
       tableName,
       schema[tableName],
@@ -6671,7 +6914,7 @@ var generateSchemaData3 = (db, schema, relations, options) => {
       nestedRuntime,
       limits
     ) : void 0;
-    const insertSingleGenerated = features.insert ? generateInsertSingle3(
+    const insertSingleGenerated = tableFeatures.insert ? generateInsertSingle3(
       db,
       tableName,
       schema[tableName],
@@ -6686,8 +6929,8 @@ var generateSchemaData3 = (db, schema, relations, options) => {
       nestedRuntime,
       limits
     ) : void 0;
-    const uniqueSets = features.upsert ? getUniqueColumnSets(schema[tableName], import_sqlite_core2.getTableConfig) : [];
-    const onConflictInput = features.upsert ? generateOnConflictInput({
+    const uniqueSets = tableFeatures.upsert ? getUniqueColumnSets(schema[tableName], import_sqlite_core2.getTableConfig) : [];
+    const onConflictInput = tableFeatures.upsert ? generateOnConflictInput({
       table: schema[tableName],
       typeName,
       uniqueSets,
@@ -6730,7 +6973,7 @@ var generateSchemaData3 = (db, schema, relations, options) => {
       nestedRuntime,
       limits
     ) : void 0;
-    const updateGenerated = features.update ? generateUpdate3(
+    const updateGenerated = tableFeatures.update ? generateUpdate3(
       db,
       tableName,
       schema[tableName],
@@ -6741,14 +6984,14 @@ var generateSchemaData3 = (db, schema, relations, options) => {
       updateFieldName,
       typeName,
       false,
-      features.requireWhere,
+      tableFeatures.requireWhere,
       typeNameMapper,
       filterCtx,
       mutationTxCtx,
       nestedRuntime,
       limits
     ) : void 0;
-    const updateSingleGenerated = features.update ? generateUpdate3(
+    const updateSingleGenerated = tableFeatures.update ? generateUpdate3(
       db,
       tableName,
       schema[tableName],
@@ -6759,14 +7002,14 @@ var generateSchemaData3 = (db, schema, relations, options) => {
       updateSingleFieldName,
       typeName,
       true,
-      features.requireWhere,
+      tableFeatures.requireWhere,
       typeNameMapper,
       filterCtx,
       mutationTxCtx,
       nestedRuntime,
       limits
     ) : void 0;
-    const updateManyInput = features.update && features.updateMany ? generateUpdateManyInput({ typeName, updatePrefix: prefixes.update, updateInput, tableFilters }) : void 0;
+    const updateManyInput = tableFeatures.update && tableFeatures.updateMany ? generateUpdateManyInput({ typeName, updatePrefix: prefixes.update, updateInput, tableFilters }) : void 0;
     const updateManyGenerated = updateManyInput ? generateUpdateMany3(
       db,
       tableName,
@@ -6782,7 +7025,7 @@ var generateSchemaData3 = (db, schema, relations, options) => {
       nestedRuntime,
       limits
     ) : void 0;
-    const deleteGenerated = features.delete ? generateDelete3(
+    const deleteGenerated = tableFeatures.delete ? generateDelete3(
       db,
       tableName,
       schema[tableName],
@@ -6790,12 +7033,12 @@ var generateSchemaData3 = (db, schema, relations, options) => {
       deleteFieldName,
       typeName,
       false,
-      features.requireWhere,
+      tableFeatures.requireWhere,
       filterCtx,
       { tableName, relationMap: namedRelations, tables },
       mutationTxCtx
     ) : void 0;
-    const deleteSingleGenerated = features.delete ? generateDelete3(
+    const deleteSingleGenerated = tableFeatures.delete ? generateDelete3(
       db,
       tableName,
       schema[tableName],
@@ -6803,12 +7046,12 @@ var generateSchemaData3 = (db, schema, relations, options) => {
       deleteSingleFieldName,
       typeName,
       true,
-      features.requireWhere,
+      tableFeatures.requireWhere,
       filterCtx,
       { tableName, relationMap: namedRelations, tables },
       mutationTxCtx
     ) : void 0;
-    const updateCountGenerated = features.update && features.countMutations ? generateWriteCount({
+    const updateCountGenerated = tableFeatures.update && tableFeatures.countMutations ? generateWriteCount({
       db,
       tableName,
       table: schema[tableName],
@@ -6816,24 +7059,24 @@ var generateSchemaData3 = (db, schema, relations, options) => {
       setArgs: updateInput,
       filterArgs: tableFilters,
       fieldName: updateCountFieldName,
-      requireWhere: features.requireWhere,
+      requireWhere: tableFeatures.requireWhere,
       filterCtx,
       txCtx: mutationTxCtx,
       nested: nestedRuntime
     }) : void 0;
-    const deleteCountGenerated = features.delete && features.countMutations ? generateWriteCount({
+    const deleteCountGenerated = tableFeatures.delete && tableFeatures.countMutations ? generateWriteCount({
       db,
       tableName,
       table: schema[tableName],
       kind: "delete",
       filterArgs: tableFilters,
       fieldName: deleteCountFieldName,
-      requireWhere: features.requireWhere,
+      requireWhere: tableFeatures.requireWhere,
       filterCtx,
       txCtx: mutationTxCtx
     }) : void 0;
-    const aggregateType = features.aggregates ? generateAggregateTypes(schema[tableName], tableName, typeName, cacheCtx) : void 0;
-    const aggregateGenerated = features.aggregates ? generateAggregate(
+    const aggregateType = tableFeatures.aggregates ? generateAggregateTypes(schema[tableName], tableName, typeName, cacheCtx) : void 0;
+    const aggregateGenerated = tableFeatures.aggregates ? generateAggregate(
       db,
       tableName,
       schema[tableName],
@@ -6842,7 +7085,7 @@ var generateSchemaData3 = (db, schema, relations, options) => {
       tableFilters,
       filterCtx
     ) : void 0;
-    const groupByType = features.aggregates && features.groupBy ? generateGroupByType(schema[tableName], tableName, typeName, cacheCtx) : void 0;
+    const groupByType = tableFeatures.aggregates && tableFeatures.groupBy ? generateGroupByType(schema[tableName], tableName, typeName, cacheCtx) : void 0;
     const groupByEnum = groupByType ? generateGroupByEnum(schema[tableName], tableName, typeName) : void 0;
     const havingInput = groupByEnum ? generateHavingInput(schema[tableName], tableName, typeName) : void 0;
     const groupByGenerated = groupByType && groupByEnum && havingInput ? generateGroupBy(
@@ -6860,19 +7103,28 @@ var generateSchemaData3 = (db, schema, relations, options) => {
       type: selectArrOutput,
       args: selectArrGenerated.args,
       resolve: selectArrGenerated.resolver,
-      ...complexity ? { extensions: { complexity: listFieldComplexity(complexity, limits?.(tableName)) } } : {}
+      extensions: {
+        drizzle: drizzleMeta({ kind: "query", operation: "select", single: false, targetArg: "where" }),
+        ...complexity ? { complexity: listFieldComplexity(complexity, limits?.(tableName)) } : {}
+      }
     };
     queries[selectSingleGenerated.name] = {
       type: selectSingleOutput,
       args: selectSingleGenerated.args,
-      resolve: selectSingleGenerated.resolver
+      resolve: selectSingleGenerated.resolver,
+      extensions: {
+        drizzle: drizzleMeta({ kind: "query", operation: "select", single: true, targetArg: "where" })
+      }
     };
     if (aggregateGenerated && aggregateType) {
       queries[aggregateGenerated.name] = {
         type: new import_graphql10.GraphQLNonNull(aggregateType),
         args: aggregateGenerated.args,
         resolve: aggregateGenerated.resolver,
-        ...complexity ? { extensions: { complexity: aggregateFieldComplexity(complexity) } } : {}
+        extensions: {
+          drizzle: drizzleMeta({ kind: "aggregate", operation: "aggregate", single: true, targetArg: "where" }),
+          ...complexity ? { complexity: aggregateFieldComplexity(complexity) } : {}
+        }
       };
     }
     if (groupByGenerated && groupByType) {
@@ -6880,14 +7132,20 @@ var generateSchemaData3 = (db, schema, relations, options) => {
         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) } } : {}
+        extensions: {
+          drizzle: drizzleMeta({ kind: "aggregate", operation: "groupBy", single: false, targetArg: "where" }),
+          ...complexity ? { complexity: aggregateFieldComplexity(complexity) } : {}
+        }
       };
     }
     if (insertArrGenerated) {
       mutations[insertArrGenerated.name] = {
         type: arrTableItemOutput,
         args: insertArrGenerated.args,
-        resolve: insertArrGenerated.resolver
+        resolve: insertArrGenerated.resolver,
+        extensions: {
+          drizzle: drizzleMeta({ kind: "mutation", operation: "insert", single: false, targetArg: "values" })
+        }
       };
     }
     if (insertSingleGenerated) {
@@ -6896,28 +7154,40 @@ var generateSchemaData3 = (db, schema, relations, options) => {
         // `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
+        resolve: insertSingleGenerated.resolver,
+        extensions: {
+          drizzle: drizzleMeta({ kind: "mutation", operation: "insert", single: true, targetArg: "values" })
+        }
       };
     }
     if (upsertArrGenerated) {
       mutations[upsertArrGenerated.name] = {
         type: arrTableItemOutput,
         args: upsertArrGenerated.args,
-        resolve: upsertArrGenerated.resolver
+        resolve: upsertArrGenerated.resolver,
+        extensions: {
+          drizzle: drizzleMeta({ kind: "mutation", operation: "upsert", single: false, targetArg: "values" })
+        }
       };
     }
     if (upsertSingleGenerated) {
       mutations[upsertSingleGenerated.name] = {
         type: singleTableItemOutput,
         args: upsertSingleGenerated.args,
-        resolve: upsertSingleGenerated.resolver
+        resolve: upsertSingleGenerated.resolver,
+        extensions: {
+          drizzle: drizzleMeta({ kind: "mutation", operation: "upsert", single: true, targetArg: "values" })
+        }
       };
     }
     if (updateGenerated) {
       mutations[updateGenerated.name] = {
         type: arrTableItemOutput,
         args: updateGenerated.args,
-        resolve: updateGenerated.resolver
+        resolve: updateGenerated.resolver,
+        extensions: {
+          drizzle: drizzleMeta({ kind: "mutation", operation: "update", single: false, targetArg: "where" })
+        }
       };
     }
     if (updateManyGenerated) {
@@ -6925,6 +7195,9 @@ var generateSchemaData3 = (db, schema, relations, options) => {
         type: new import_graphql10.GraphQLNonNull(new import_graphql10.GraphQLList(singleTableItemOutput)),
         args: updateManyGenerated.args,
         resolve: updateManyGenerated.resolver,
+        extensions: {
+          drizzle: drizzleMeta({ kind: "mutation", operation: "updateMany", single: false, targetArg: "updates" })
+        },
         // 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.
@@ -6935,21 +7208,30 @@ var generateSchemaData3 = (db, schema, relations, options) => {
       mutations[updateSingleGenerated.name] = {
         type: singleTableItemOutput,
         args: updateSingleGenerated.args,
-        resolve: updateSingleGenerated.resolver
+        resolve: updateSingleGenerated.resolver,
+        extensions: {
+          drizzle: drizzleMeta({ kind: "mutation", operation: "update", single: true, targetArg: "where" })
+        }
       };
     }
     if (deleteGenerated) {
       mutations[deleteGenerated.name] = {
         type: arrTableItemOutput,
         args: deleteGenerated.args,
-        resolve: deleteGenerated.resolver
+        resolve: deleteGenerated.resolver,
+        extensions: {
+          drizzle: drizzleMeta({ kind: "mutation", operation: "delete", single: false, targetArg: "where" })
+        }
       };
     }
     if (deleteSingleGenerated) {
       mutations[deleteSingleGenerated.name] = {
         type: singleTableItemOutput,
         args: deleteSingleGenerated.args,
-        resolve: deleteSingleGenerated.resolver
+        resolve: deleteSingleGenerated.resolver,
+        extensions: {
+          drizzle: drizzleMeta({ kind: "mutation", operation: "delete", single: true, targetArg: "where" })
+        }
       };
     }
     if (updateCountGenerated) {
@@ -6970,9 +7252,9 @@ var generateSchemaData3 = (db, schema, relations, options) => {
     }
     const activeInputs = [
       // The insert input types the upsert mutations too, so either feature keeps it.
-      ...features.insert || onConflictInput ? [insertInput] : [],
+      ...tableFeatures.insert || onConflictInput ? [insertInput] : [],
       ...onConflictInput ? [onConflictInput] : [],
-      ...features.update ? [updateInput] : [],
+      ...tableFeatures.update ? [updateInput] : [],
       ...updateManyInput ? [updateManyInput] : [],
       tableFilters,
       tableOrder
@@ -7012,6 +7294,141 @@ var generateSchemaData3 = (db, schema, relations, options) => {
   return { queries, mutations, inputs, types: outputs, fieldResolvers };
 };
 
+// src/util/selection.ts
+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_graphql_parse_resolve_info5 = require("graphql-parse-resolve-info");
+var contextCache = /* @__PURE__ */ new WeakMap();
+var tableConfigFor = (db) => {
+  if ((0, import_drizzle_orm10.is)(db, import_mysql_core3.MySqlDatabase)) {
+    return import_mysql_core3.getTableConfig;
+  }
+  if ((0, import_drizzle_orm10.is)(db, import_pg_core3.PgAsyncDatabase)) {
+    return import_pg_core3.getTableConfig;
+  }
+  if ((0, import_drizzle_orm10.is)(db, import_sqlite_core3.BaseSQLiteDatabase)) {
+    return import_sqlite_core3.getTableConfig;
+  }
+  throw new Error("Drizzle-GraphQL Error: unsupported database instance \u2014 expected a PostgreSQL, MySQL or SQLite one.");
+};
+var contextFor = (db) => {
+  const cached = contextCache.get(db);
+  if (cached) {
+    return cached;
+  }
+  const relations = db._.relations ?? {};
+  const schema = db._.fullSchema ?? Object.fromEntries(
+    Object.entries(relations).filter(([, config]) => config?.table != null).map(([key, config]) => [key, config.table])
+  );
+  const tableEntries = Object.entries(schema).filter(([, value]) => (0, import_drizzle_orm10.is)(value, import_drizzle_orm10.Table));
+  if (!tableEntries.length) {
+    throw new Error(
+      "Drizzle-GraphQL Error: Schema not found in drizzle instance. Pass relations (from buildRelations/defineRelations) to the drizzle constructor so drizzle-graphql can read your tables."
+    );
+  }
+  const tables = Object.fromEntries(tableEntries);
+  const getTableConfig4 = tableConfigFor(db);
+  const primaryKeyCache = /* @__PURE__ */ new Map();
+  const primaryKeyOf = (tableName) => {
+    let pk = primaryKeyCache.get(tableName);
+    if (!pk) {
+      const table = tables[tableName];
+      pk = table ? getPrimaryKeyPropNamesFromConfig(table, getTableConfig4) : [];
+      primaryKeyCache.set(tableName, pk);
+    }
+    return pk;
+  };
+  const relationMap = buildNamedRelations(relations, tableEntries);
+  attachTargetPrimaryKeys(relationMap, tables, (table) => [...primaryKeyOf(tableNameOf(tables, table))]);
+  const context = {
+    tables,
+    relationMap,
+    filterCtx: { tables, relationMap },
+    primaryKeyOf
+  };
+  contextCache.set(db, context);
+  return context;
+};
+var tableNameOf = (tables, table) => Object.keys(tables).find((name) => tables[name] === table) ?? "";
+var parseInfo = (info) => {
+  if ("fieldsByTypeName" in info) {
+    return info;
+  }
+  return (0, import_graphql_parse_resolve_info5.parseResolveInfo)(info, { deep: true });
+};
+var selectionToWith = (info, options) => {
+  const { db, table, typeNameMapper } = options;
+  const { tables, relationMap, filterCtx } = contextFor(db);
+  if (!tables[table]) {
+    throw new Error(`Drizzle-GraphQL Error: '${table}' is not a table in the Drizzle schema.`);
+  }
+  if (!relationMap[table]) {
+    return void 0;
+  }
+  const parsed = parseInfo(info);
+  const params = extractRelationsParams(
+    relationMap,
+    tables,
+    table,
+    parsed,
+    resolveTypeName(table, typeNameMapper),
+    typeNameMapper,
+    filterCtx
+  );
+  return params && Object.keys(params).length ? params : void 0;
+};
+var resolveSelection = async (info, options) => {
+  const {
+    db,
+    table: tableName,
+    typeNameMapper,
+    executor,
+    single = false,
+    where,
+    orderBy,
+    limit,
+    offset,
+    after
+  } = options;
+  const { tables, relationMap, filterCtx, primaryKeyOf } = contextFor(db);
+  const table = tables[tableName];
+  if (!table) {
+    throw new Error(`Drizzle-GraphQL Error: '${tableName}' is not a table in the Drizzle schema.`);
+  }
+  const parsedInfo = parseInfo(info);
+  if (!parsedInfo) {
+    throw new Error("Drizzle-GraphQL Error: resolveSelection could not read a selection set from the resolve info.");
+  }
+  const source = executor ?? db;
+  const queryBase = source.query?.[tableName];
+  if (!queryBase) {
+    throw new Error(
+      `Drizzle-GraphQL Error: the executor passed to resolveSelection has no relational query builder for '${tableName}'.`
+    );
+  }
+  return runRelationalSelect({
+    queryBase,
+    tables,
+    tableName,
+    table,
+    relationMap,
+    typeName: resolveTypeName(tableName, typeNameMapper),
+    typeNameMapper,
+    parsedInfo,
+    single,
+    where,
+    orderBy,
+    limit,
+    offset,
+    after,
+    filterCtx,
+    pkNames: primaryKeyOf(tableName),
+    db: source
+  });
+};
+
 // src/index.ts
 var buildSchema = (db, config) => {
   const relations = db._.relations;
@@ -7033,22 +7450,11 @@ var buildSchema = (db, config) => {
     list: config?.suffixes?.list ?? "",
     single: config?.suffixes?.single ?? "Single"
   };
-  const typeNameMapper = config?.typeNameMapper;
-  const features = {
-    aggregates: config?.features?.aggregates ?? true,
-    groupBy: config?.features?.groupBy ?? true,
-    relationAggregates: config?.features?.relationAggregates ?? true,
-    distinct: config?.features?.distinct ?? true,
-    insert: config?.features?.insert ?? true,
-    update: config?.features?.update ?? true,
-    updateMany: config?.features?.updateMany ?? true,
-    delete: config?.features?.delete ?? true,
-    upsert: config?.features?.upsert ?? false,
-    nestedWrites: config?.features?.nestedWrites ?? false,
-    fieldUpdateOperations: config?.features?.fieldUpdateOperations ?? false,
-    countMutations: config?.features?.countMutations ?? false,
-    requireWhere: config?.features?.requireWhere ?? false
-  };
+  const typeNameMapper = config?.typeNameMapper === "singularize" ? singularizeMapper : config?.typeNameMapper;
+  const tableKeys = Object.entries(schema).filter(([, value]) => (0, import_drizzle_orm11.is)(value, import_drizzle_orm11.Table)).map(([key]) => key);
+  const excludedTableNames = new Set(config?.exclude?.tables ?? []);
+  const featureTables = tableKeys.filter((key) => !excludedTableNames.has(key));
+  const forTable = resolveTableFeatures(config?.features);
   const complexityConfig = config?.complexity ?? true;
   const complexity = complexityConfig === false ? void 0 : {
     defaultListSize: (complexityConfig === true ? void 0 : complexityConfig.defaultListSize) ?? 10,
@@ -7085,10 +7491,8 @@ var buildSchema = (db, config) => {
   } : void 0;
   const exclude = config?.exclude;
   if (exclude) {
-    const tableNames = new Set(
-      Object.entries(schema).filter(([, value]) => (0, import_drizzle_orm10.is)(value, import_drizzle_orm10.Table)).map(([key]) => key)
-    );
-    const excludedTables = new Set(exclude.tables ?? []);
+    const tableNames = new Set(tableKeys);
+    const excludedTables = excludedTableNames;
     for (const tableName of excludedTables) {
       if (!tableNames.has(tableName)) {
         throw new Error(
@@ -7110,7 +7514,7 @@ var buildSchema = (db, config) => {
       if (excludedTables.has(tableName)) {
         continue;
       }
-      const columns = (0, import_drizzle_orm10.getColumns)(schema[tableName]);
+      const columns = (0, import_drizzle_orm11.getColumns)(schema[tableName]);
       for (const columnName of columnNames) {
         const column = columns[columnName];
         if (!column) {
@@ -7126,6 +7530,49 @@ var buildSchema = (db, config) => {
       }
     }
   }
+  const featureConflicts = /* @__PURE__ */ new Map();
+  const noteConflict = (message, tableName) => {
+    const tables = featureConflicts.get(message);
+    if (tables) {
+      tables.push(tableName);
+    } else {
+      featureConflicts.set(message, [tableName]);
+    }
+  };
+  for (const tableName of featureTables) {
+    const tableFeatures = forTable(tableName);
+    if (tableFeatures.upsert) {
+      const missing = [!tableFeatures.insert ? "insert" : void 0, !tableFeatures.update ? "update" : void 0].filter(Boolean).join(" and ");
+      if (missing) {
+        noteConflict(
+          `upsert is on while ${missing} is off, so the upsert mutations are a second write path past the operation you turned off`,
+          tableName
+        );
+      }
+    }
+    if (config?.features?.nestedWrites && (!tableFeatures.insert || !tableFeatures.update)) {
+      noteConflict(
+        "nestedWrites is on while this table's own insert or update is off, so a nested `create` or `connect` under another table's mutation can still write it",
+        tableName
+      );
+    }
+    if (config?.features?.updateMany !== void 0 && tableFeatures.updateMany && !tableFeatures.update) {
+      noteConflict("updateMany is on while update is off, so no batch update is generated", tableName);
+    }
+    if (config?.features?.groupBy !== void 0 && tableFeatures.groupBy && !tableFeatures.aggregates) {
+      noteConflict("groupBy is on while aggregates is off, so no grouped query is generated", tableName);
+    }
+    if (tableFeatures.countMutations && !tableFeatures.update && !tableFeatures.delete) {
+      noteConflict(
+        "countMutations is on while update and delete are both off, so no count mutation is generated",
+        tableName
+      );
+    }
+  }
+  for (const [message, tables] of featureConflicts) {
+    const listed = tables.length > 5 ? `${tables.slice(0, 5).join(", ")} and ${tables.length - 5} more` : tables.join(", ");
+    console.warn(`Drizzle-GraphQL Warning: config.features \u2014 ${message} (${listed}).`);
+  }
   const eagerOpt = config?.eagerLoadRelations;
   const shouldEagerLoad = eagerOpt === void 0 || eagerOpt === true ? () => true : eagerOpt === false ? () => false : eagerOpt;
   if (!typeNameMapper && suffixes.list === suffixes.single) {
@@ -7152,7 +7599,7 @@ var buildSchema = (db, config) => {
     conflictDoNothing: config?.conflictDoNothing ?? false,
     typeNameMapper,
     shouldEagerLoad,
-    features,
+    features: config?.features ?? {},
     complexity,
     scalars: config?.scalars,
     mapColumnType: config?.mapColumnType,
@@ -7168,11 +7615,11 @@ var buildSchema = (db, config) => {
     }
   };
   let generatorOutput;
-  if ((0, import_drizzle_orm10.is)(db, import_mysql_core3.MySqlDatabase)) {
+  if ((0, import_drizzle_orm11.is)(db, import_mysql_core4.MySqlDatabase)) {
     generatorOutput = generateSchemaData(db, schema, relations, generatorOptions);
-  } else if ((0, import_drizzle_orm10.is)(db, import_pg_core3.PgAsyncDatabase)) {
+  } else if ((0, import_drizzle_orm11.is)(db, import_pg_core4.PgAsyncDatabase)) {
     generatorOutput = generateSchemaData2(db, schema, relations, generatorOptions);
-  } else if ((0, import_drizzle_orm10.is)(db, import_sqlite_core3.BaseSQLiteDatabase)) {
+  } else if ((0, import_drizzle_orm11.is)(db, import_sqlite_core4.BaseSQLiteDatabase)) {
     generatorOutput = generateSchemaData3(db, schema, relations, generatorOptions);
   } else {
     throw new Error("Drizzle-GraphQL Error: Unknown database instance type");
@@ -7212,8 +7659,14 @@ var buildSchema = (db, config) => {
   createRelationResolverFactory,
   defaultErrorMapper,
   drizzleExecutorKey,
+  drizzleExtension,
   extractFilters,
   extractOrderBy,
-  extractRelationJoinColumns
+  extractRelationJoinColumns,
+  identifyRows,
+  isDrizzleFieldExtension,
+  resolveSelection,
+  selectionToWith,
+  singularizeMapper
 });
 //# sourceMappingURL=index.cjs.map