@vantreeseba/drizzle-graphql 7.4.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
@@ -606,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 {
@@ -1159,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 });
@@ -1838,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);
   }
@@ -1880,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);
       }
@@ -1897,7 +2026,8 @@ var generateSelectFields = (tables, tableName, relationMap, fromTableName, fromR
               where: { type: relSelectData.filters }
             },
             resolve,
-            ...relationDocs
+            ...relationDocs,
+            extensions: { drizzle: relationExtensionFor(relEntry, tableName, relationName, true) }
           }
         ]);
         continue;
@@ -1920,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`;
@@ -1943,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) } : {}
+              }
             }
           ]);
         }
@@ -2029,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 ? (
@@ -4272,6 +4405,7 @@ var generateSchemaData = (db, schema, relations, options) => {
     complexity,
     limits,
     docs: options.docs ?? {},
+    primaryKeyOf: (name) => tables[name] ? mysqlPrimaryKeyPropNames(tables[name]) : [],
     featureOf
   };
   const relationAggregateFactory = anyTable("relationAggregates") ? createRelationAggregateFactory(db, tables, cacheCtx, typeNameMapper, filterCtx) : void 0;
@@ -4311,6 +4445,7 @@ var generateSchemaData = (db, schema, relations, options) => {
   }
   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 {
@@ -4506,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) {
@@ -4526,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 }) }
         };
       }
     }
@@ -5645,6 +5794,7 @@ function generateSchemaData2(db, schema, relations, options) {
     complexity,
     limits,
     docs: options.docs ?? {},
+    primaryKeyOf: (name) => tables[name] ? pgPrimaryKeyPropNames(tables[name]) : [],
     featureOf
   };
   const nestedPlans = features.nestedWrites ? buildNestedWritePlans(
@@ -5683,6 +5833,7 @@ function generateSchemaData2(db, schema, relations, options) {
   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 {
@@ -5934,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) {
@@ -5954,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) {
@@ -5970,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) {
@@ -5999,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.
@@ -6009,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) {
@@ -6670,6 +6860,7 @@ var generateSchemaData3 = (db, schema, relations, options) => {
     complexity,
     limits,
     docs: options.docs ?? {},
+    primaryKeyOf: (name) => tables[name] ? sqlitePrimaryKeyPropNames(tables[name]) : [],
     featureOf
   };
   if (features.nestedWrites && db.resultKind === "sync") {
@@ -6718,6 +6909,7 @@ var generateSchemaData3 = (db, schema, relations, options) => {
   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 {
@@ -6969,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) {
@@ -6989,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) {
@@ -7005,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) {
@@ -7034,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.
@@ -7044,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) {
@@ -7121,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;
@@ -7143,7 +7509,7 @@ var buildSchema = (db, config) => {
     single: config?.suffixes?.single ?? "Single"
   };
   const typeNameMapper = config?.typeNameMapper === "singularize" ? singularizeMapper : config?.typeNameMapper;
-  const tableKeys = Object.entries(schema).filter(([, value]) => is8(value, Table)).map(([key]) => key);
+  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);
@@ -7307,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");
@@ -7350,9 +7716,14 @@ export {
   createRelationResolverFactory,
   defaultErrorMapper,
   drizzleExecutorKey,
+  drizzleExtension,
   extractFilters,
   extractOrderBy,
   extractRelationJoinColumns,
+  identifyRows,
+  isDrizzleFieldExtension,
+  resolveSelection,
+  selectionToWith,
   singularizeMapper
 };
 //# sourceMappingURL=index.js.map