@vantreeseba/drizzle-graphql 7.3.0 → 7.5.0

package/dist/index.js

@@ -1,8 +1,8 @@
 // src/index.ts
-import { getColumns as getColumns6, is as is8, Table } from "drizzle-orm";
-import { MySqlDatabase } from "drizzle-orm/mysql-core";
-import { PgAsyncDatabase } from "drizzle-orm/pg-core";
-import { BaseSQLiteDatabase } from "drizzle-orm/sqlite-core";
+import { getColumns as getColumns6, is as is9, Table as Table2 } from "drizzle-orm";
+import { MySqlDatabase as MySqlDatabase2 } from "drizzle-orm/mysql-core";
+import { PgAsyncDatabase as PgAsyncDatabase2 } from "drizzle-orm/pg-core";
+import { BaseSQLiteDatabase as BaseSQLiteDatabase2 } from "drizzle-orm/sqlite-core";
 import {
   GraphQLObjectType as GraphQLObjectType5,
   GraphQLSchema
@@ -103,6 +103,10 @@ var getOrCreateLoader = (context, key, batchFn) => {
 import pluralize from "pluralize";
 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(pluralize.singular(tableName)),
+  plural: uncapitalize(pluralize.plural(tableName))
+});
 
 // src/util/data-mappers/index.ts
 import { getTableColumns as getTableColumns2, is as is2, One } from "drizzle-orm";
@@ -602,6 +606,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
 import { getColumns, sql } from "drizzle-orm";
 import {
@@ -1155,6 +1276,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 });
@@ -1834,7 +1963,8 @@ var generateSelectFields = (tables, tableName, relationMap, fromTableName, fromR
     const shell = new GraphQLObjectType2({
       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);
   }
@@ -1876,7 +2006,10 @@ var generateSelectFields = (tables, tableName, relationMap, fromTableName, fromR
         relType = new GraphQLObjectType2({
           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);
       }
@@ -1893,12 +2026,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,
         {
@@ -1916,11 +2050,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`;
@@ -1939,7 +2072,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) } : {}
+              }
             }
           ]);
         }
@@ -2008,7 +2144,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) }];
     })
@@ -2025,7 +2161,8 @@ var generateTableTypes = (tableName, tables, relationMap, withReturning, relatio
   const selectSingleOutput = cacheCtx.objectTypeCache.get(tableName) ?? new GraphQLObjectType2({
     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 GraphQLNonNull3(new GraphQLList3(new GraphQLNonNull3(selectSingleOutput)));
   const arrTableItemOutput = withReturning ? (
@@ -3433,6 +3570,38 @@ import {
 } from "graphql";
 import { parseResolveInfo as parseResolveInfo2 } from "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
 import {
   and as and2,
@@ -4192,6 +4361,8 @@ var generateSchemaData = (db, schema, relations, options) => {
   const excludedTables = new Set(options.exclude?.tables ?? []);
   const tableEntries = schemaEntries.filter(([key, value]) => is4(value, MySqlTable) && !excludedTables.has(key));
   const tables = Object.fromEntries(tableEntries);
+  const featureOf = resolveTableFeatures(features);
+  const anyTable = (feature) => tableEntries.some(([name]) => featureOf(name)[feature]);
   if (!tableEntries.length) {
     throw new Error(
       "Drizzle-GraphQL Error: No tables detected in Drizzle-ORM's database instance. Did you forget to pass schema to drizzle constructor?"
@@ -4234,9 +4405,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);
@@ -4254,7 +4426,7 @@ var generateSchemaData = (db, schema, relations, options) => {
         prefixes.insert,
         prefixes.update,
         resolverFactory,
-        relationAggregateFactory
+        featureOf(tableName).relationAggregates ? relationAggregateFactory : void 0
       )
     ])
   );
@@ -4268,10 +4440,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 {
@@ -4303,7 +4477,7 @@ var generateSchemaData = (db, schema, relations, options) => {
       typeName,
       typeNameMapper,
       filterCtx,
-      features.distinct,
+      tableFeatures.distinct,
       limits
     );
     const selectSingleGenerated = generateSelectSingle(
@@ -4319,7 +4493,7 @@ var generateSchemaData = (db, schema, relations, options) => {
       filterCtx,
       limits
     );
-    const insertArrGenerated = features.insert ? generateInsertArray(
+    const insertArrGenerated = tableFeatures.insert ? generateInsertArray(
       db,
       tableName,
       schema[tableName],
@@ -4327,7 +4501,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],
@@ -4335,7 +4509,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: [],
@@ -4360,7 +4534,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],
@@ -4368,11 +4542,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],
@@ -4380,11 +4554,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,
@@ -4394,29 +4568,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],
@@ -4424,23 +4598,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],
@@ -4449,7 +4623,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(
@@ -4467,19 +4641,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 GraphQLNonNull5(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) {
@@ -4487,25 +4670,30 @@ var generateSchemaData = (db, schema, relations, options) => {
         type: new GraphQLNonNull5(new GraphQLList5(new GraphQLNonNull5(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 }) }
         };
       }
     }
@@ -4527,9 +4715,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
@@ -5567,6 +5755,8 @@ function generateSchemaData2(db, schema, relations, options) {
   const excludedTables = new Set(options.exclude?.tables ?? []);
   const tableEntries = schemaEntries.filter(([key, value]) => is6(value, 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?"
@@ -5604,7 +5794,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,
@@ -5615,7 +5806,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);
@@ -5633,7 +5824,7 @@ function generateSchemaData2(db, schema, relations, options) {
         prefixes.insert,
         prefixes.update,
         resolverFactory,
-        relationAggregateFactory,
+        featureOf(tableName).relationAggregates ? relationAggregateFactory : void 0,
         nestedTypes
       )
     ])
@@ -5641,6 +5832,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 {
@@ -5672,7 +5865,7 @@ function generateSchemaData2(db, schema, relations, options) {
       typeName,
       typeNameMapper,
       filterCtx,
-      features.distinct,
+      tableFeatures.distinct,
       limits
     );
     const selectSingleGenerated = generateSelectSingle2(
@@ -5688,7 +5881,7 @@ function generateSchemaData2(db, schema, relations, options) {
       filterCtx,
       limits
     );
-    const insertArrGenerated = features.insert ? generateInsertArray2(
+    const insertArrGenerated = tableFeatures.insert ? generateInsertArray2(
       db,
       tableName,
       schema[tableName],
@@ -5703,7 +5896,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],
@@ -5718,8 +5911,8 @@ function generateSchemaData2(db, schema, relations, options) {
       nestedRuntime,
       limits
     ) : void 0;
-    const uniqueSets = features.upsert ? getUniqueColumnSets(schema[tableName], getTableConfig2) : [];
-    const onConflictInput = features.upsert ? generateOnConflictInput({
+    const uniqueSets = tableFeatures.upsert ? getUniqueColumnSets(schema[tableName], getTableConfig2) : [];
+    const onConflictInput = tableFeatures.upsert ? generateOnConflictInput({
       table: schema[tableName],
       typeName,
       uniqueSets,
@@ -5762,7 +5955,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],
@@ -5773,14 +5966,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],
@@ -5791,14 +5984,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,
@@ -5814,7 +6007,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],
@@ -5822,12 +6015,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],
@@ -5835,12 +6028,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],
@@ -5848,24 +6041,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],
@@ -5874,7 +6067,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(
@@ -5892,19 +6085,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 GraphQLNonNull7(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) {
@@ -5912,14 +6114,20 @@ function generateSchemaData2(db, schema, relations, options) {
         type: new GraphQLNonNull7(new GraphQLList7(new GraphQLNonNull7(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) {
@@ -5928,28 +6136,40 @@ function generateSchemaData2(db, schema, relations, options) {
         // `conflictDoNothing` swallowing the insert, so the field is nullable only there.
         type: conflictDoNothing ? singleTableItemOutput : new GraphQLNonNull7(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) {
@@ -5957,6 +6177,9 @@ function generateSchemaData2(db, schema, relations, options) {
         type: new GraphQLNonNull7(new GraphQLList7(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.
@@ -5967,21 +6190,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) {
@@ -6002,9 +6234,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
@@ -6589,6 +6821,8 @@ var generateSchemaData3 = (db, schema, relations, options) => {
   const excludedTables = new Set(options.exclude?.tables ?? []);
   const tableEntries = schemaEntries.filter(([key, value]) => is7(value, 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?"
@@ -6626,7 +6860,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(
@@ -6642,7 +6877,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") {
@@ -6665,7 +6900,7 @@ var generateSchemaData3 = (db, schema, relations, options) => {
         prefixes.insert,
         prefixes.update,
         resolverFactory,
-        relationAggregateFactory,
+        featureOf(tableName).relationAggregates ? relationAggregateFactory : void 0,
         nestedTypes
       )
     ])
@@ -6673,6 +6908,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 {
@@ -6704,7 +6941,7 @@ var generateSchemaData3 = (db, schema, relations, options) => {
       typeName,
       typeNameMapper,
       filterCtx,
-      features.distinct,
+      tableFeatures.distinct,
       limits
     );
     const selectSingleGenerated = generateSelectSingle3(
@@ -6720,7 +6957,7 @@ var generateSchemaData3 = (db, schema, relations, options) => {
       filterCtx,
       limits
     );
-    const insertArrGenerated = features.insert ? generateInsertArray3(
+    const insertArrGenerated = tableFeatures.insert ? generateInsertArray3(
       db,
       tableName,
       schema[tableName],
@@ -6735,7 +6972,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],
@@ -6750,8 +6987,8 @@ var generateSchemaData3 = (db, schema, relations, options) => {
       nestedRuntime,
       limits
     ) : void 0;
-    const uniqueSets = features.upsert ? getUniqueColumnSets(schema[tableName], getTableConfig3) : [];
-    const onConflictInput = features.upsert ? generateOnConflictInput({
+    const uniqueSets = tableFeatures.upsert ? getUniqueColumnSets(schema[tableName], getTableConfig3) : [];
+    const onConflictInput = tableFeatures.upsert ? generateOnConflictInput({
       table: schema[tableName],
       typeName,
       uniqueSets,
@@ -6794,7 +7031,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],
@@ -6805,14 +7042,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],
@@ -6823,14 +7060,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,
@@ -6846,7 +7083,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],
@@ -6854,12 +7091,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],
@@ -6867,12 +7104,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],
@@ -6880,24 +7117,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],
@@ -6906,7 +7143,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(
@@ -6924,19 +7161,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 GraphQLNonNull8(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) {
@@ -6944,14 +7190,20 @@ var generateSchemaData3 = (db, schema, relations, options) => {
         type: new GraphQLNonNull8(new GraphQLList8(new GraphQLNonNull8(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) {
@@ -6960,28 +7212,40 @@ var generateSchemaData3 = (db, schema, relations, options) => {
         // `conflictDoNothing` swallowing the insert, so the field is nullable only there.
         type: conflictDoNothing ? singleTableItemOutput : new GraphQLNonNull8(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) {
@@ -6989,6 +7253,9 @@ var generateSchemaData3 = (db, schema, relations, options) => {
         type: new GraphQLNonNull8(new GraphQLList8(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.
@@ -6999,21 +7266,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) {
@@ -7034,9 +7310,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
@@ -7076,6 +7352,141 @@ var generateSchemaData3 = (db, schema, relations, options) => {
   return { queries, mutations, inputs, types: outputs, fieldResolvers };
 };
 
+// src/util/selection.ts
+import { is as is8, Table } from "drizzle-orm";
+import { getTableConfig as getMySqlTableConfig, MySqlDatabase } from "drizzle-orm/mysql-core";
+import { getTableConfig as getPgTableConfig, PgAsyncDatabase } from "drizzle-orm/pg-core";
+import { BaseSQLiteDatabase, getTableConfig as getSQLiteTableConfig } from "drizzle-orm/sqlite-core";
+import { parseResolveInfo as parseResolveInfo5 } from "graphql-parse-resolve-info";
+var contextCache = /* @__PURE__ */ new WeakMap();
+var tableConfigFor = (db) => {
+  if (is8(db, MySqlDatabase)) {
+    return getMySqlTableConfig;
+  }
+  if (is8(db, PgAsyncDatabase)) {
+    return getPgTableConfig;
+  }
+  if (is8(db, BaseSQLiteDatabase)) {
+    return getSQLiteTableConfig;
+  }
+  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]) => is8(value, 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 parseResolveInfo5(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;
@@ -7097,22 +7508,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]) => is9(value, Table2)).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,
@@ -7149,10 +7549,8 @@ var buildSchema = (db, config) => {
   } : void 0;
   const exclude = config?.exclude;
   if (exclude) {
-    const tableNames = new Set(
-      Object.entries(schema).filter(([, value]) => is8(value, 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(
@@ -7190,6 +7588,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) {
@@ -7216,7 +7657,7 @@ var buildSchema = (db, config) => {
     conflictDoNothing: config?.conflictDoNothing ?? false,
     typeNameMapper,
     shouldEagerLoad,
-    features,
+    features: config?.features ?? {},
     complexity,
     scalars: config?.scalars,
     mapColumnType: config?.mapColumnType,
@@ -7232,11 +7673,11 @@ var buildSchema = (db, config) => {
     }
   };
   let generatorOutput;
-  if (is8(db, MySqlDatabase)) {
+  if (is9(db, MySqlDatabase2)) {
     generatorOutput = generateSchemaData(db, schema, relations, generatorOptions);
-  } else if (is8(db, PgAsyncDatabase)) {
+  } else if (is9(db, PgAsyncDatabase2)) {
     generatorOutput = generateSchemaData2(db, schema, relations, generatorOptions);
-  } else if (is8(db, BaseSQLiteDatabase)) {
+  } else if (is9(db, BaseSQLiteDatabase2)) {
     generatorOutput = generateSchemaData3(db, schema, relations, generatorOptions);
   } else {
     throw new Error("Drizzle-GraphQL Error: Unknown database instance type");
@@ -7275,8 +7716,14 @@ export {
   createRelationResolverFactory,
   defaultErrorMapper,
   drizzleExecutorKey,
+  drizzleExtension,
   extractFilters,
   extractOrderBy,
-  extractRelationJoinColumns
+  extractRelationJoinColumns,
+  identifyRows,
+  isDrizzleFieldExtension,
+  resolveSelection,
+  selectionToWith,
+  singularizeMapper
 };
 //# sourceMappingURL=index.js.map