@vantreeseba/drizzle-graphql 2.0.0 → 3.0.0

package/dist/index.js

@@ -4,29 +4,19 @@ import { MySqlDatabase } from "drizzle-orm/mysql-core";
 import { PgAsyncDatabase } from "drizzle-orm/pg-core";
 import { BaseSQLiteDatabase } from "drizzle-orm/sqlite-core";
 import {
-  GraphQLObjectType as GraphQLObjectType4,
+  GraphQLObjectType as GraphQLObjectType5,
   GraphQLSchema
 } from "graphql";
 
-// src/util/builders/mysql.ts
-import { is as is4, One as One3 } from "drizzle-orm";
-import { getTableConfig, MySqlTable } from "drizzle-orm/mysql-core";
-import {
-  GraphQLBoolean as GraphQLBoolean3,
-  GraphQLError as GraphQLError3,
-  GraphQLList as GraphQLList3,
-  GraphQLNonNull as GraphQLNonNull3,
-  GraphQLObjectType as GraphQLObjectType3
-} from "graphql";
-import { parseResolveInfo } from "graphql-parse-resolve-info";
-
 // src/util/builders/common.ts
 import {
+  aliasedTable,
   and,
   asc,
   desc,
   eq,
   getColumns,
+  getTableAsAliasSQL,
   gt,
   gte,
   ilike,
@@ -38,17 +28,19 @@ import {
   lt,
   lte,
   ne,
+  not,
   notIlike,
   notInArray,
   notLike,
   One as One2,
   or,
+  relationsFilterToSQL,
   sql
 } from "drizzle-orm";
 import {
   GraphQLBoolean as GraphQLBoolean2,
   GraphQLEnumType as GraphQLEnumType2,
-  GraphQLError as GraphQLError2,
+  GraphQLError as GraphQLError3,
   GraphQLInputObjectType as GraphQLInputObjectType2,
   GraphQLInt as GraphQLInt2,
   GraphQLList as GraphQLList2,
@@ -111,6 +103,7 @@ var capitalize = (input) => input?.length ? `${input[0].toLocaleUpperCase()}${in
 // src/util/data-mappers/index.ts
 import { getTableColumns, is, One } from "drizzle-orm";
 import { GraphQLError } from "graphql";
+var isJsonColumn = (column) => (column.dataType ?? "").includes("json") && column.columnType !== "PgGeometryObject";
 var remapToGraphQLCore = (key, value, tableName, column, relationMap) => {
   if (Array.isArray(value)) {
     const relations = relationMap?.[tableName];
@@ -140,6 +133,9 @@ var remapToGraphQLCore = (key, value, tableName, column, relationMap) => {
   if (!column) {
     return value;
   }
+  if (isJsonColumn(column)) {
+    return value;
+  }
   if (value instanceof Date) {
     return value.toISOString();
   }
@@ -217,17 +213,7 @@ var remapFromGraphQLCore = (value, column, columnName) => {
     }
   }
   if (dataType.includes("json") && column.columnType !== "PgGeometryObject") {
-    if (typeof value !== "string") {
-      return value;
-    }
-    try {
-      return JSON.parse(value);
-    } catch (e) {
-      throw new GraphQLError(
-        `Invalid JSON in field '${columnName}':
-${e instanceof Error ? e.message : "Unknown error"}`
-      );
-    }
+    return value;
   }
   switch (dataType) {
     case "date": {
@@ -310,7 +296,7 @@ var remapFromGraphQLArrayInput = (queryInput, table) => {
 // src/util/type-converter/index.ts
 import { extractExtendedColumnType, is as is2 } from "drizzle-orm";
 import { MySqlInt, MySqlSerial } from "drizzle-orm/mysql-core";
-import { PgDate, PgDateString, PgInteger, PgSerial, PgTimestamp, PgTimestampString } from "drizzle-orm/pg-core";
+import { PgDate, PgDateString, PgInteger, PgSerial, PgTimestamp, PgTimestampString, PgUUID } from "drizzle-orm/pg-core";
 import { SQLiteInteger } from "drizzle-orm/sqlite-core";
 import {
   GraphQLBoolean,
@@ -323,7 +309,47 @@ import {
   GraphQLObjectType,
   GraphQLString
 } from "graphql";
-import { GraphQLDate, GraphQLDateTime } from "graphql-scalars";
+
+// src/util/scalars/index.ts
+import { GraphQLError as GraphQLError2, GraphQLScalarType, Kind } from "graphql";
+import { GraphQLDate, GraphQLDateTime, GraphQLJSON, GraphQLUUID } from "graphql-scalars";
+var asDecimalString = (value) => {
+  if (typeof value === "bigint") {
+    return value.toString();
+  }
+  if (typeof value === "number") {
+    if (!Number.isInteger(value)) {
+      throw new GraphQLError2(`BigInt cannot represent non-integer value: ${value}`);
+    }
+    if (!Number.isSafeInteger(value)) {
+      throw new GraphQLError2(
+        `BigInt cannot represent the number ${value} without precision loss \u2014 pass it as a string instead`
+      );
+    }
+    return String(value);
+  }
+  if (typeof value === "string") {
+    if (!/^-?\d+$/.test(value)) {
+      throw new GraphQLError2(`BigInt cannot represent non-integer value: "${value}"`);
+    }
+    return value;
+  }
+  throw new GraphQLError2(`BigInt cannot represent value: ${JSON.stringify(value)}`);
+};
+var GraphQLBigIntString = new GraphQLScalarType({
+  name: "BigInt",
+  description: "A 64-bit integer, transported as a decimal string so that values beyond JavaScript's safe integer range survive the round-trip intact.",
+  serialize: asDecimalString,
+  parseValue: asDecimalString,
+  parseLiteral: (ast) => {
+    if (ast.kind !== Kind.STRING && ast.kind !== Kind.INT) {
+      throw new GraphQLError2(`BigInt cannot represent a ${ast.kind}`, { nodes: ast });
+    }
+    return asDecimalString(ast.value);
+  }
+});
+
+// src/util/type-converter/index.ts
 var allowedNameChars = /^[a-zA-Z0-9_]+$/;
 var enumMap = /* @__PURE__ */ new WeakMap();
 var generateEnumCached = (column, columnName, tableName) => {
@@ -374,7 +400,7 @@ var columnToGraphQLCore = (column, columnName, tableName, isInput) => {
       } : column.columnType === "PgBytea" ? {
         type: new GraphQLList(new GraphQLNonNull(GraphQLInt)),
         description: "Buffer"
-      } : { type: GraphQLString, description: "JSON" };
+      } : { type: GraphQLJSON, description: "JSON" };
     case "string":
       if (column.enumValues?.length) {
         return { type: generateEnumCached(column, columnName, tableName) };
@@ -382,12 +408,15 @@ var columnToGraphQLCore = (column, columnName, tableName, isInput) => {
       if (column instanceof PgTimestamp || column instanceof PgTimestampString) {
         return { type: GraphQLDateTime, description: "DateTime" };
       }
+      if (column instanceof PgUUID) {
+        return { type: GraphQLUUID, description: "UUID" };
+      }
       if (column instanceof PgDateString) {
         return isInput ? { type: GraphQLString, description: "Date" } : { type: GraphQLDate, description: "Date" };
       }
       return { type: GraphQLString, description: "String" };
     case "bigint":
-      return { type: GraphQLString, description: "BigInt" };
+      return { type: GraphQLBigIntString, description: "BigInt" };
     case "number": {
       const dims = column.dimensions;
       if (dims !== void 0 && dims > 0) {
@@ -518,6 +547,23 @@ var extractRelationJoinColumns = (relEntry, parentTable, targetTable) => {
   }
   return { localColPropName, foreignCol: targetCol, foreignColPropName };
 };
+var drizzleExecutorKey = /* @__PURE__ */ Symbol.for("drizzle-graphql:executor");
+var resolveExecutor = (db, context) => {
+  if (context && typeof context === "object") {
+    const executor = context[drizzleExecutorKey];
+    if (executor) {
+      return executor;
+    }
+  }
+  return db;
+};
+var resolveQueryExecutor = (db, context, tableName, buildTimeQueryBase) => {
+  const executor = resolveExecutor(db, context);
+  return {
+    executor,
+    queryBase: buildTimeQueryBase ? executor?.query?.[tableName] ?? buildTimeQueryBase : buildTimeQueryBase
+  };
+};
 var batchedPaginatedRelationQuery = async (db, targetTable, foreignCol, whereCondition, orderByArg, limit, offset, pkNames) => {
   const cols = getColumns(targetTable);
   const orderExprs = [
@@ -539,7 +585,7 @@ var batchedPaginatedRelationQuery = async (db, targetTable, foreignCol, whereCon
   }
   return rows;
 };
-var createRelationResolverFactory = (db, tables) => ({ tableName, relationName, relEntry, isOne }) => {
+var createRelationResolverFactory = (db, tables, filterCtx) => ({ tableName, relationName, relEntry, isOne }) => {
   const parentTable = tables[tableName];
   const targetTableName = relEntry.targetTableName;
   const targetTable = tables[targetTableName];
@@ -569,15 +615,16 @@ var createRelationResolverFactory = (db, tables) => ({ tableName, relationName,
     });
     const loaderKey = `${tableName}::${relationName}::${argsKey}`;
     const loader = getOrCreateLoader(context, loaderKey, async (parentIds) => {
+      const executor = resolveExecutor(db, context);
       const uniqueIds = [...new Set(parentIds)];
       const whereCondition = and(
         inArray(foreignCol, uniqueIds),
-        whereArg ? extractFilters(targetTable, targetTableName, whereArg) : void 0
+        whereArg ? extractFilters(targetTable, targetTableName, whereArg, relationFilterCtx(filterCtx, targetTableName)) : void 0
       );
       let rows;
       if (limit != null || offset != null) {
         rows = await batchedPaginatedRelationQuery(
-          db,
+          executor,
           targetTable,
           foreignCol,
           whereCondition,
@@ -587,7 +634,7 @@ var createRelationResolverFactory = (db, tables) => ({ tableName, relationName,
           targetPkNames
         );
       } else {
-        let q = db.select().from(targetTable).where(whereCondition);
+        let q = executor.select().from(targetTable).where(whereCondition);
         if (orderByArg) {
           q = q.orderBy(...extractOrderBy(targetTable, orderByArg));
         }
@@ -608,7 +655,31 @@ var createRelationResolverFactory = (db, tables) => ({ tableName, relationName,
     return loader.load(localValue);
   };
 };
-var extractSelectedColumnsFromTree = (tree, table) => {
+var AGGREGATE_FIELD_SUFFIX = "Aggregate";
+var relationAggregateJoinColumns = (tree, table, selectionCtx) => {
+  const relations = selectionCtx?.relationMap[selectionCtx.tableName];
+  if (!relations || !selectionCtx) {
+    return [];
+  }
+  const tableColumns = getColumns(table);
+  const needed = [];
+  for (const fieldData of Object.values(tree)) {
+    if (tableColumns[fieldData.name] || !fieldData.name.endsWith(AGGREGATE_FIELD_SUFFIX)) {
+      continue;
+    }
+    const relEntry = relations[fieldData.name.slice(0, -AGGREGATE_FIELD_SUFFIX.length)];
+    const targetTable = relEntry ? selectionCtx.tables[relEntry.targetTableName] : void 0;
+    if (!relEntry || !targetTable) {
+      continue;
+    }
+    const joinCols = extractRelationJoinColumns(relEntry, table, targetTable);
+    if (joinCols) {
+      needed.push(joinCols.localColPropName);
+    }
+  }
+  return needed;
+};
+var extractSelectedColumnsFromTree = (tree, table, selectionCtx) => {
   const tableColumns = getColumns(table);
   const treeEntries = Object.entries(tree);
   const selectedColumns = [];
@@ -618,6 +689,9 @@ var extractSelectedColumnsFromTree = (tree, table) => {
     }
     selectedColumns.push([fieldData.name, true]);
   }
+  for (const columnName of relationAggregateJoinColumns(tree, table, selectionCtx)) {
+    selectedColumns.push([columnName, true]);
+  }
   if (!selectedColumns.length) {
     const columnKeys = Object.entries(tableColumns);
     const columnName = columnKeys.find((e) => rqbCrashTypes.find((haram) => e[1].columnType !== haram))?.[0] ?? columnKeys[0][0];
@@ -625,7 +699,7 @@ var extractSelectedColumnsFromTree = (tree, table) => {
   }
   return Object.fromEntries(selectedColumns);
 };
-var extractSelectedColumnsFromTreeSQLFormat = (tree, table) => {
+var extractSelectedColumnsFromTreeSQLFormat = (tree, table, selectionCtx) => {
   const tableColumns = getColumns(table);
   const treeEntries = Object.entries(tree);
   const selectedColumns = [];
@@ -635,6 +709,9 @@ var extractSelectedColumnsFromTreeSQLFormat = (tree, table) => {
     }
     selectedColumns.push([fieldData.name, tableColumns[fieldData.name]]);
   }
+  for (const columnName of relationAggregateJoinColumns(tree, table, selectionCtx)) {
+    selectedColumns.push([columnName, tableColumns[columnName]]);
+  }
   if (!selectedColumns.length) {
     const columnKeys = Object.entries(tableColumns);
     const columnName = columnKeys.find((e) => rqbCrashTypes.find((haram) => e[1].columnType !== haram))?.[0] ?? columnKeys[0][0];
@@ -797,34 +874,102 @@ var generateTableOrderTypeCached = (table, tableName, typeNameMapper, cacheCtx)
   cacheCtx.orderTypeCache.set(table, order);
   return order;
 };
-var generateTableFilterTypeCached = (table, tableName, cacheCtx, typeNameMapper) => {
+var isFilterableRelation = (relation) => !relation.through;
+var generateListRelationFilterCached = (targetTable, targetTableName, cacheCtx, typeNameMapper, relationMap, tables) => {
+  const cached = cacheCtx.listRelationFilterCache.get(targetTableName);
+  if (cached) {
+    return cached;
+  }
+  const listFilter = new GraphQLInputObjectType2({
+    name: `${resolveTypeName(targetTableName, typeNameMapper)}ListRelationFilter`,
+    fields: () => {
+      const targetFilters = generateTableFilterTypeCached(
+        targetTable,
+        targetTableName,
+        cacheCtx,
+        typeNameMapper,
+        relationMap,
+        tables
+      );
+      return {
+        some: { type: targetFilters, description: "At least one related row matches" },
+        none: { type: targetFilters, description: "No related row matches" },
+        every: { type: targetFilters, description: "Every related row matches" }
+      };
+    }
+  });
+  cacheCtx.listRelationFilterCache.set(targetTableName, listFilter);
+  return listFilter;
+};
+var generateRelationFilterFields = (tableName, cacheCtx, typeNameMapper, columnFields, relationMap, tables) => {
+  const relations = relationMap?.[tableName];
+  if (!relations || !tables) {
+    return {};
+  }
+  const fields = {};
+  for (const [relationName, relEntry] of Object.entries(relations)) {
+    if (relationName in columnFields) {
+      continue;
+    }
+    const targetTable = tables[relEntry.targetTableName];
+    const relation = relEntry.relation ?? relEntry;
+    if (!targetTable || !isFilterableRelation(relation)) {
+      continue;
+    }
+    fields[relationName] = is3(relation, One2) ? {
+      type: generateTableFilterTypeCached(
+        targetTable,
+        relEntry.targetTableName,
+        cacheCtx,
+        typeNameMapper,
+        relationMap,
+        tables
+      ),
+      description: `Matches rows whose ${relationName} matches these filters`
+    } : {
+      type: generateListRelationFilterCached(
+        targetTable,
+        relEntry.targetTableName,
+        cacheCtx,
+        typeNameMapper,
+        relationMap,
+        tables
+      )
+    };
+  }
+  return fields;
+};
+var generateTableFilterTypeCached = (table, tableName, cacheCtx, typeNameMapper, relationMap, tables) => {
   if (cacheCtx.filterTypeCache.has(table)) {
     return cacheCtx.filterTypeCache.get(table);
   }
-  const filterColumns = generateTableFilterValuesCached(table, tableName, cacheCtx);
+  const buildFields = () => {
+    const filterColumns = generateTableFilterValuesCached(table, tableName, cacheCtx);
+    return {
+      ...filterColumns,
+      ...generateRelationFilterFields(tableName, cacheCtx, typeNameMapper, filterColumns, relationMap, tables)
+    };
+  };
+  const orFilters = new GraphQLInputObjectType2({
+    name: `${resolveTypeName(tableName, typeNameMapper)}FiltersOr`,
+    fields: buildFields
+  });
   const filters = new GraphQLInputObjectType2({
     name: `${resolveTypeName(tableName, typeNameMapper)}Filters`,
-    fields: {
-      ...filterColumns,
+    fields: () => ({
+      ...buildFields(),
       OR: {
-        type: new GraphQLList2(
-          new GraphQLNonNull2(
-            new GraphQLInputObjectType2({
-              name: `${resolveTypeName(tableName, typeNameMapper)}FiltersOr`,
-              fields: filterColumns
-            })
-          )
-        )
+        type: new GraphQLList2(new GraphQLNonNull2(orFilters))
       }
-    }
+    })
   });
   cacheCtx.filterTypeCache.set(table, filters);
   return filters;
 };
-var generateSelectFields = (tables, tableName, relationMap, fromTableName, fromRelationName, withOrder, relationsDepthLimit, cacheCtx, typeNameMapper, usedTables = /* @__PURE__ */ new Set(), resolverFactory, currentDepth = 0) => {
+var generateSelectFields = (tables, tableName, relationMap, fromTableName, fromRelationName, withOrder, relationsDepthLimit, cacheCtx, typeNameMapper, usedTables = /* @__PURE__ */ new Set(), resolverFactory, currentDepth = 0, relationAggregateFactory) => {
   const table = tables[tableName];
   const order = withOrder ? generateTableOrderTypeCached(table, tableName, typeNameMapper, cacheCtx) : void 0;
-  const filters = generateTableFilterTypeCached(table, tableName, cacheCtx, typeNameMapper);
+  const filters = generateTableFilterTypeCached(table, tableName, cacheCtx, typeNameMapper, relationMap, tables);
   const tableFields = generateTableSelectTypeFieldsCached(table, tableName);
   const relationsForTable = relationMap[tableName];
   const relationEntries = relationsForTable ? Object.entries(relationsForTable) : [];
@@ -888,7 +1033,8 @@ var generateSelectFields = (tables, tableName, relationMap, fromTableName, fromR
         typeNameMapper,
         nextUsedTables,
         resolverFactory,
-        currentDepth + 1
+        currentDepth + 1,
+        relationAggregateFactory
       );
       let relType = cacheCtx.objectTypeCache.get(targetTableName);
       if (!relType) {
@@ -933,6 +1079,26 @@ var generateSelectFields = (tables, tableName, relationMap, fromTableName, fromR
           resolve
         }
       ]);
+      const aggregateFieldName = `${relationName}Aggregate`;
+      if (!tableFields[aggregateFieldName] && !relationsForTable?.[aggregateFieldName]) {
+        const relationAggregate = relationAggregateFactory?.({
+          tableName,
+          relationName,
+          relEntry
+        });
+        if (relationAggregate) {
+          rawRelationFields.push([
+            aggregateFieldName,
+            {
+              type: new GraphQLNonNull2(relationAggregate.type),
+              args: {
+                where: { type: relSelectData.filters }
+              },
+              resolve: relationAggregate.resolve
+            }
+          ]);
+        }
+      }
     }
     const builtRelationFields = Object.fromEntries(rawRelationFields);
     if (isRootCall) {
@@ -956,7 +1122,7 @@ var generateSelectFields = (tables, tableName, relationMap, fromTableName, fromR
     relationFields: {}
   };
 };
-var generateTableTypes = (tableName, tables, relationMap, withReturning, relationsDepthLimit, cacheCtx, typeNameMapper = void 0, insertPrefix = "create", updatePrefix = "update", resolverFactory) => {
+var generateTableTypes = (tableName, tables, relationMap, withReturning, relationsDepthLimit, cacheCtx, typeNameMapper = void 0, insertPrefix = "create", updatePrefix = "update", resolverFactory, relationAggregateFactory) => {
   const { tableFields, relationFields, filters, order } = generateSelectFields(
     tables,
     tableName,
@@ -971,7 +1137,8 @@ var generateTableTypes = (tableName, tables, relationMap, withReturning, relatio
     typeNameMapper,
     /* @__PURE__ */ new Set(),
     resolverFactory,
-    0
+    0,
+    relationAggregateFactory
   );
   const table = tables[tableName];
   const columns = getColumns(table);
@@ -1026,19 +1193,10 @@ var generateTableTypes = (tableName, tables, relationMap, withReturning, relatio
     outputs
   };
 };
-var extractOrderBy = (table, orderArgs) => {
-  const res = [];
-  for (const [column, config] of Object.entries(orderArgs).sort(
-    (a, b) => (b[1]?.priority ?? 0) - (a[1]?.priority ?? 0)
-  )) {
-    if (!config) {
-      continue;
-    }
-    const { direction } = config;
-    res.push(direction === "asc" ? asc(getColumns(table)[column]) : desc(getColumns(table)[column]));
-  }
-  return res;
-};
+var orderByEntries = (orderArgs) => Object.entries(orderArgs).sort((a, b) => (b[1]?.priority ?? 0) - (a[1]?.priority ?? 0)).filter(([, config]) => config).map(([column, config]) => [column, config.direction]);
+var extractOrderBy = (table, orderArgs) => orderByEntries(orderArgs).map(
+  ([column, direction]) => direction === "asc" ? asc(getColumns(table)[column]) : desc(getColumns(table)[column])
+);
 var extractFiltersColumn = (column, columnName, operators) => {
   if (!operators.OR?.length) {
     delete operators.OR;
@@ -1046,7 +1204,7 @@ var extractFiltersColumn = (column, columnName, operators) => {
   const entries = Object.entries(operators);
   if (operators.OR) {
     if (entries.length > 1) {
-      throw new GraphQLError2(`WHERE ${columnName}: Cannot specify both fields and 'OR' in column operators!`);
+      throw new GraphQLError3(`WHERE ${columnName}: Cannot specify both fields and 'OR' in column operators!`);
     }
     const variants2 = [];
     for (const variant of operators.OR) {
@@ -1073,7 +1231,7 @@ var extractFiltersColumn = (column, columnName, operators) => {
       variants.push(stringValueOps[operatorName](column, operatorValue));
     } else if (operatorName in arrayValueOps) {
       if (!operatorValue.length) {
-        throw new GraphQLError2(`WHERE ${columnName}: Unable to use operator ${operatorName} with an empty array!`);
+        throw new GraphQLError3(`WHERE ${columnName}: Unable to use operator ${operatorName} with an empty array!`);
       }
       const arrayValue = operatorValue.map((val) => remapFromGraphQLCore(val, column, columnName));
       variants.push(arrayValueOps[operatorName](column, arrayValue));
@@ -1083,7 +1241,67 @@ var extractFiltersColumn = (column, columnName, operators) => {
   }
   return variants.length ? variants.length > 1 ? and(...variants) : variants[0] : void 0;
 };
-var extractFilters = (table, tableName, filters) => {
+var relationFilterCtx = (base, tableKey) => base ? { ...base, tableKey } : void 0;
+var buildRelationJoinCondition = (parentTable, relation, aliasedTarget, relationName) => {
+  const sourceColumns = relation.sourceColumns;
+  const targetColumns = relation.targetColumns;
+  if (!sourceColumns?.length || sourceColumns.length !== targetColumns?.length) {
+    throw new GraphQLError3(`WHERE ${relationName}: Relation cannot be used as a filter`);
+  }
+  const parentColumns = Object.values(getColumns(parentTable));
+  const targetColumnsByName = Object.values(getColumns(aliasedTarget));
+  const conditions = [];
+  for (let i = 0; i < sourceColumns.length; i++) {
+    const localColumn = parentColumns.find((c) => c.name === sourceColumns[i].name);
+    const foreignColumn = targetColumnsByName.find((c) => c.name === targetColumns[i].name);
+    if (!localColumn || !foreignColumn) {
+      throw new GraphQLError3(`WHERE ${relationName}: Relation cannot be used as a filter`);
+    }
+    conditions.push(eq(localColumn, foreignColumn));
+  }
+  return conditions.length > 1 ? and(...conditions) : conditions[0];
+};
+var buildRelationExists = (parentTable, relationName, relEntry, innerFilters, mode, ctx) => {
+  const { targetTableName } = relEntry;
+  const targetTable = ctx.tables[targetTableName];
+  const relation = relEntry.relation ?? relEntry;
+  if (!targetTable || !isFilterableRelation(relation)) {
+    throw new GraphQLError3(`WHERE ${relationName}: Relation cannot be used as a filter`);
+  }
+  ctx.aliases ??= { n: 0 };
+  const aliases = ctx.aliases;
+  const aliasedTarget = aliasedTable(targetTable, `dgql_rel_${aliases.n++}`);
+  const joinCondition = buildRelationJoinCondition(parentTable, relation, aliasedTarget, relationName);
+  const relationWhere = relation.where ? relationsFilterToSQL(relation.isReversed ? parentTable : aliasedTarget, relation.where) : void 0;
+  const inner = innerFilters ? extractFilters(aliasedTarget, targetTableName, innerFilters, { ...ctx, tableKey: targetTableName, aliases }) : void 0;
+  if (mode === "every") {
+    if (!inner) {
+      return void 0;
+    }
+    return sql`not exists (select 1 from ${getTableAsAliasSQL(aliasedTarget)} where ${and(joinCondition, relationWhere, not(inner))})`;
+  }
+  const condition = and(joinCondition, relationWhere, inner);
+  return mode === "none" ? sql`not exists (select 1 from ${getTableAsAliasSQL(aliasedTarget)} where ${condition})` : sql`exists (select 1 from ${getTableAsAliasSQL(aliasedTarget)} where ${condition})`;
+};
+var extractRelationFilter = (parentTable, relationName, relEntry, value, ctx) => {
+  const relation = relEntry.relation ?? relEntry;
+  if (is3(relation, One2)) {
+    return buildRelationExists(parentTable, relationName, relEntry, value, "some", ctx);
+  }
+  const variants = [];
+  for (const mode of ["some", "none", "every"]) {
+    const inner = value[mode];
+    if (inner === void 0 || inner === null) {
+      continue;
+    }
+    const extracted = buildRelationExists(parentTable, relationName, relEntry, inner, mode, ctx);
+    if (extracted) {
+      variants.push(extracted);
+    }
+  }
+  return variants.length ? variants.length > 1 ? and(...variants) : variants[0] : void 0;
+};
+var extractFilters = (table, tableName, filters, relationCtx) => {
   if (!filters.OR?.length) {
     delete filters.OR;
   }
@@ -1093,28 +1311,33 @@ var extractFilters = (table, tableName, filters) => {
   }
   if (filters.OR) {
     if (entries.length > 1) {
-      throw new GraphQLError2(`WHERE ${tableName}: Cannot specify both fields and 'OR' in table filters!`);
+      throw new GraphQLError3(`WHERE ${tableName}: Cannot specify both fields and 'OR' in table filters!`);
     }
     const variants2 = [];
     for (const variant of filters.OR) {
-      const extracted = extractFilters(table, tableName, variant);
+      const extracted = extractFilters(table, tableName, variant, relationCtx);
       if (extracted) {
         variants2.push(extracted);
       }
     }
     return variants2.length ? variants2.length > 1 ? or(...variants2) : variants2[0] : void 0;
   }
+  const columns = getColumns(table);
+  const relations = relationCtx?.relationMap[relationCtx.tableKey];
   const variants = [];
-  for (const [columnName, operators] of entries) {
-    if (operators === null) {
+  for (const [fieldName, operators] of entries) {
+    if (operators === null || operators === void 0) {
       continue;
     }
-    const column = getColumns(table)[columnName];
-    variants.push(extractFiltersColumn(column, columnName, operators));
+    const column = columns[fieldName];
+    const extracted = column ? extractFiltersColumn(column, fieldName, operators) : relations?.[fieldName] && relationCtx ? extractRelationFilter(table, fieldName, relations[fieldName], operators, relationCtx) : void 0;
+    if (extracted) {
+      variants.push(extracted);
+    }
   }
   return variants.length ? variants.length > 1 ? and(...variants) : variants[0] : void 0;
 };
-var extractRelationsParamsInner = (relationMap, tables, tableName, typeName, originField, typeNameMapper, _isInitial = false) => {
+var extractRelationsParamsInner = (relationMap, tables, tableName, typeName, originField, typeNameMapper, _isInitial = false, filterCtx) => {
   const relationsForTable = relationMap[tableName];
   if (!relationsForTable) {
     return void 0;
@@ -1136,7 +1359,11 @@ var extractRelationsParamsInner = (relationMap, tables, tableName, typeName, ori
     if (!relFieldSelection) {
       continue;
     }
-    const columns = extractSelectedColumnsFromTree(relFieldSelection, tables[targetTableName]);
+    const columns = extractSelectedColumnsFromTree(relFieldSelection, tables[targetTableName], {
+      tableName: targetTableName,
+      relationMap,
+      tables
+    });
     const thisRecord = {};
     thisRecord.columns = columns;
     const relationField = Object.values(baseField).find((e) => e.name === relName);
@@ -1144,23 +1371,34 @@ var extractRelationsParamsInner = (relationMap, tables, tableName, typeName, ori
     const offset = relationArgs?.offset ?? void 0;
     const limit = relationArgs?.limit ?? void 0;
     const relWhere = relationArgs?.where;
-    thisRecord.where = relWhere ? { RAW: (aliasedTable) => extractFilters(aliasedTable, relName, relWhere) } : void 0;
+    thisRecord.where = relWhere ? {
+      RAW: (aliasedTable2) => extractFilters(aliasedTable2, relName, relWhere, relationFilterCtx(filterCtx, targetTableName))
+    } : void 0;
     const hasPagination = offset != null || limit != null;
     const pkNames = targetPkNames ?? [];
-    thisRecord.orderBy = relationArgs?.orderBy ? (aliasedTable) => extractOrderBy(aliasedTable, relationArgs.orderBy) : hasPagination && pkNames.length ? (aliasedTable) => primaryKeyOrderExprs(aliasedTable, pkNames) : void 0;
+    thisRecord.orderBy = relationArgs?.orderBy ? (aliasedTable2) => extractOrderBy(aliasedTable2, relationArgs.orderBy) : hasPagination && pkNames.length ? (aliasedTable2) => primaryKeyOrderExprs(aliasedTable2, pkNames) : void 0;
     thisRecord.offset = offset;
     thisRecord.limit = limit;
-    const relWith = relationField ? extractRelationsParamsInner(relationMap, tables, targetTableName, relTypeName, relationField, typeNameMapper) : void 0;
+    const relWith = relationField ? extractRelationsParamsInner(
+      relationMap,
+      tables,
+      targetTableName,
+      relTypeName,
+      relationField,
+      typeNameMapper,
+      false,
+      filterCtx
+    ) : void 0;
     thisRecord.with = relWith;
     args[relName] = thisRecord;
   }
   return args;
 };
-var extractRelationsParams = (relationMap, tables, tableName, info, typeName, typeNameMapper) => {
+var extractRelationsParams = (relationMap, tables, tableName, info, typeName, typeNameMapper, filterCtx) => {
   if (!info) {
     return void 0;
   }
-  return extractRelationsParamsInner(relationMap, tables, tableName, typeName, info, typeNameMapper, true);
+  return extractRelationsParamsInner(relationMap, tables, tableName, typeName, info, typeNameMapper, true, filterCtx);
 };
 var pruneNonEagerRelations = (relationMap, shouldEagerLoad) => {
   const out = {};
@@ -1204,39 +1442,307 @@ var primaryKeyOrderExprs = (table, pkNames) => {
   const cols = getColumns(table);
   return pkNames.map((n) => cols[n]).filter(Boolean).map((col) => asc(col));
 };
+var getUniqueColumnSets = (table, getTableConfig4) => {
+  const cols = getColumns(table);
+  const propNameByColumnName = new Map(Object.entries(cols).map(([propName, col]) => [col.name, propName]));
+  const toPropNames = (columnNames) => {
+    const propNames = [];
+    for (const columnName of columnNames) {
+      const propName = columnName === void 0 ? void 0 : propNameByColumnName.get(columnName);
+      if (!propName) {
+        return void 0;
+      }
+      propNames.push(propName);
+    }
+    return propNames.length ? propNames : void 0;
+  };
+  const config = getTableConfig4(table);
+  const candidates = [
+    // Inline `.primaryKey()` columns, then table-level `primaryKey({ columns })`.
+    Object.entries(cols).filter(([, col]) => col.primary).map(([propName]) => propName),
+    ...config.primaryKeys.map((pk) => toPropNames(pk.columns.map((c) => c.name))),
+    ...(config.uniqueConstraints ?? []).map((uc) => toPropNames(uc.columns.map((c) => c.name))),
+    ...(config.indexes ?? []).filter((index) => index.config.unique).map((index) => toPropNames(index.config.columns.map((c) => c?.name))),
+    ...Object.entries(cols).filter(([, col]) => col.isUnique).map(([propName]) => [propName])
+  ];
+  const seen = /* @__PURE__ */ new Set();
+  const sets = [];
+  for (const set of candidates) {
+    if (!set?.length) {
+      continue;
+    }
+    const key = [...set].sort().join(",");
+    if (seen.has(key)) {
+      continue;
+    }
+    seen.add(key);
+    sets.push(set);
+  }
+  return sets;
+};
+var DISTINCT_RN = "__drizzle_graphql_distinct_rn";
+var columnEnumCache = /* @__PURE__ */ new WeakMap();
+var generateColumnEnum = (table, enumName, description, predicate = () => true) => {
+  let tableCache = columnEnumCache.get(table);
+  const cached = tableCache?.get(enumName);
+  if (cached) {
+    return cached;
+  }
+  const columnNames = Object.entries(getColumns(table)).filter(([columnName, column]) => predicate(column, columnName)).map(([columnName]) => columnName);
+  if (!columnNames.length) {
+    return void 0;
+  }
+  const enumType = new GraphQLEnumType2({
+    name: enumName,
+    description,
+    values: Object.fromEntries(columnNames.map((columnName) => [columnName, { value: columnName }]))
+  });
+  if (!tableCache) {
+    tableCache = /* @__PURE__ */ new Map();
+    columnEnumCache.set(table, tableCache);
+  }
+  tableCache.set(enumName, enumType);
+  return enumType;
+};
+var generateDistinctEnum = (table, typeName) => generateColumnEnum(table, `${typeName}DistinctColumn`, `Columns of ${typeName} that a query can be made distinct on`);
+var conflictActionEnum = new GraphQLEnumType2({
+  name: "ConflictAction",
+  description: "What an upsert does when a row with the same unique key already exists",
+  values: {
+    UPDATE: { value: "UPDATE", description: "Overwrite the conflicting row with the supplied values" },
+    NOTHING: { value: "NOTHING", description: "Keep the existing row and insert nothing" }
+  }
+});
+var generateOnConflictInput = (params) => {
+  const { table, typeName, uniqueSets, tableFilters, withTarget } = params;
+  const updateEnum = generateColumnEnum(
+    table,
+    `${typeName}UpdateColumn`,
+    `Columns of ${typeName} that an upsert can overwrite`
+  );
+  if (!updateEnum) {
+    return void 0;
+  }
+  const fields = {
+    action: {
+      type: conflictActionEnum,
+      defaultValue: "UPDATE",
+      description: "Whether a conflicting row is overwritten or left alone. Defaults to UPDATE."
+    },
+    update: {
+      type: new GraphQLList2(new GraphQLNonNull2(updateEnum)),
+      description: "Columns to overwrite on conflict. Defaults to every column the request supplied, minus the conflict target. Columns the request did not supply cannot be listed here \u2014 there would be no value to write."
+    }
+  };
+  if (withTarget) {
+    const uniqueColumns = new Set(uniqueSets.flat());
+    const targetEnum = generateColumnEnum(
+      table,
+      `${typeName}ConflictTarget`,
+      `Columns of ${typeName} that carry a unique constraint, and so can be conflicted on`,
+      (_column, columnName) => uniqueColumns.has(columnName)
+    );
+    if (!targetEnum) {
+      return void 0;
+    }
+    fields["target"] = {
+      type: new GraphQLList2(new GraphQLNonNull2(targetEnum)),
+      description: "The unique column set a conflict is detected on. Must match one of the table\u2019s unique constraints exactly. Defaults to the primary key."
+    };
+    fields["where"] = {
+      type: tableFilters,
+      description: "Only overwrite conflicting rows that match this filter. Others are left alone."
+    };
+  }
+  return new GraphQLInputObjectType2({
+    name: `${typeName}OnConflict`,
+    description: `Conflict handling for an upsert of ${typeName}`,
+    fields
+  });
+};
+var resolveConflictPlan = (params) => {
+  const { table, values, onConflict, pkNames, uniqueSets, excludedRef, withTarget, buildWhere } = params;
+  const columns = getColumns(table);
+  let target;
+  if (withTarget) {
+    const targetNames2 = onConflict?.target?.length ? onConflict.target : [...pkNames];
+    if (!targetNames2.length) {
+      throw new GraphQLError3(
+        "Unable to upsert: no conflict target was given and this table has no primary key. Pass onConflict.target."
+      );
+    }
+    const requested = [...targetNames2].sort().join(",");
+    if (!uniqueSets.some((set2) => [...set2].sort().join(",") === requested)) {
+      throw new GraphQLError3(
+        `Unable to upsert: [${targetNames2.join(", ")}] is not a unique constraint on this table. Valid conflict targets: ${uniqueSets.map((set2) => `[${set2.join(", ")}]`).join(", ")}.`
+      );
+    }
+    target = targetNames2.map((name) => columns[name]);
+  }
+  if ((onConflict?.action ?? "UPDATE") === "NOTHING") {
+    return { action: "NOTHING", target, set: {}, setWhere: void 0 };
+  }
+  const supplied = new Set(values.flatMap((row) => Object.keys(row)));
+  const targetNames = new Set(withTarget ? onConflict?.target?.length ? onConflict.target : pkNames : []);
+  let updateNames;
+  if (onConflict?.update?.length) {
+    const unsupplied = onConflict.update.filter((name) => !supplied.has(name));
+    if (unsupplied.length) {
+      throw new GraphQLError3(
+        `Unable to upsert: onConflict.update lists ${unsupplied.join(", ")}, which the values do not supply.`
+      );
+    }
+    updateNames = onConflict.update;
+  } else {
+    updateNames = [...supplied].filter((name) => !targetNames.has(name));
+  }
+  if (!updateNames.length) {
+    return { action: "NOTHING", target, set: {}, setWhere: void 0 };
+  }
+  const set = Object.fromEntries(updateNames.map((name) => [name, excludedRef(columns[name].name)]));
+  const setWhere = onConflict?.where && buildWhere ? buildWhere(onConflict.where) : void 0;
+  return { action: "UPDATE", target, set, setWhere };
+};
+var excludedColumnRef = (columnName) => sql`excluded.${sql.identifier(columnName)}`;
+var mysqlValuesColumnRef = (columnName) => sql`values(${sql.identifier(columnName)})`;
+var selectDistinctKeys = async (params) => {
+  const { db, table, tableName, distinct, pkNames, where, orderBy, limit, offset } = params;
+  const cols = getColumns(table);
+  if (!pkNames.length) {
+    throw new GraphQLError3(`Table ${tableName} has no primary key, so 'distinct' cannot be applied to it.`);
+  }
+  const partitionCols = distinct.map((name) => cols[name]).filter(Boolean);
+  if (!partitionCols.length) {
+    throw new GraphQLError3(`No known columns were given to 'distinct' on ${tableName}.`);
+  }
+  const orderEntries = orderBy ? orderByEntries(orderBy) : [];
+  const windowOrder = [
+    ...orderEntries.map(([column, direction]) => direction === "asc" ? asc(cols[column]) : desc(cols[column])),
+    ...primaryKeyOrderExprs(table, pkNames)
+  ];
+  const rowNumber = sql`row_number() over (partition by ${sql.join(partitionCols, sql`, `)} order by ${sql.join(
+    windowOrder,
+    sql`, `
+  )})`.as(DISTINCT_RN);
+  const sub = db.select({ ...cols, [DISTINCT_RN]: rowNumber }).from(table).where(where).as("__dgql_distinct");
+  const outerOrder = [
+    ...orderEntries.map(([column, direction]) => direction === "asc" ? asc(sub[column]) : desc(sub[column])),
+    ...pkNames.filter((name) => sub[name]).map((name) => asc(sub[name]))
+  ];
+  let query = db.select(Object.fromEntries(pkNames.map((name) => [name, sub[name]]))).from(sub).where(eq(sub[DISTINCT_RN], 1)).orderBy(...outerOrder);
+  if (offset) {
+    query = query.offset(offset);
+  }
+  if (limit != null) {
+    query = query.limit(limit);
+  }
+  return await query;
+};
+var primaryKeyRestriction = (table, pkNames, keys) => {
+  const cols = getColumns(table);
+  if (pkNames.length === 1) {
+    const name = pkNames[0];
+    return inArray(
+      cols[name],
+      keys.map((key) => key[name])
+    );
+  }
+  return or(...keys.map((key) => and(...pkNames.map((name) => eq(cols[name], key[name])))));
+};
 var prepareMutationRelationColumns = (params) => {
   const { relationMap, tables, tableName, typeName, typeNameMapper, table, pkNames, parsedInfo } = params;
   const withParams = relationMap[tableName] ? extractRelationsParams(relationMap, tables, tableName, parsedInfo, typeName, typeNameMapper) : void 0;
   const hasRelations = !!(withParams && Object.keys(withParams).length);
-  const baseColumns = extractSelectedColumnsFromTreeSQLFormat(parsedInfo.fieldsByTypeName[typeName], table);
+  const baseColumns = extractSelectedColumnsFromTreeSQLFormat(parsedInfo.fieldsByTypeName[typeName], table, {
+    tableName,
+    relationMap,
+    tables
+  });
   const columns = hasRelations ? withPrimaryKeyColumns(baseColumns, table, pkNames) : baseColumns;
   return { columns, hasRelations, withParams };
 };
-var toGraphQLError = (e) => e instanceof Error ? new GraphQLError2(e.message) : e;
+var toGraphQLError = (e) => {
+  if (e instanceof GraphQLError3) {
+    return e;
+  }
+  return e instanceof Error ? new GraphQLError3(e.message, { originalError: e }) : e;
+};
+var defaultErrorMapper = (error) => {
+  if (error instanceof GraphQLError3 && !error.originalError) {
+    return error;
+  }
+  return new GraphQLError3("Internal server error", {
+    originalError: error instanceof GraphQLError3 ? error.originalError ?? error : error instanceof Error ? error : null,
+    extensions: { code: "INTERNAL_SERVER_ERROR" }
+  });
+};
+var applyErrorMapper = (entities, mapError) => {
+  const wrap = (resolve) => (...args) => {
+    try {
+      const result = resolve(...args);
+      if (result && typeof result.then === "function") {
+        return result.then(void 0, (e) => {
+          throw mapError(e);
+        });
+      }
+      return result;
+    } catch (e) {
+      throw mapError(e);
+    }
+  };
+  for (const field of [...Object.values(entities.queries), ...Object.values(entities.mutations)]) {
+    if (field?.resolve) {
+      field.resolve = wrap(field.resolve);
+    }
+  }
+  for (const type of Object.values(entities.types)) {
+    if (typeof type?.getFields !== "function") {
+      continue;
+    }
+    for (const field of Object.values(type.getFields())) {
+      if (field?.resolve) {
+        field.resolve = wrap(field.resolve);
+      }
+    }
+  }
+  for (const tableResolvers of Object.values(entities.fieldResolvers ?? {})) {
+    for (const [relationName, resolve] of Object.entries(tableResolvers)) {
+      tableResolvers[relationName] = wrap(resolve);
+    }
+  }
+};
 var computeResolverFieldNames = (tableName, typeNameMapper, prefixes, suffixes) => {
   const mapped = typeNameMapper?.(tableName);
   const typeName = mapped ? capitalize(mapped.singular) : capitalize(tableName);
   const listFieldName = (mapped?.plural ?? uncapitalize(tableName)) + suffixes.list;
   const singleFieldName = mapped?.singular ?? uncapitalize(tableName) + suffixes.single;
+  const aggregateFieldName = `${mapped?.plural ?? uncapitalize(tableName)}Aggregate`;
   const createArrayFieldName = `${prefixes.insert}${mapped ? capitalize(mapped.plural) : capitalize(tableName)}`;
   const createSingleFieldName = mapped ? `${prefixes.insert}${capitalize(mapped.singular)}` : `${prefixes.insert}${capitalize(tableName)}${suffixes.single}`;
+  const upsertPrefix = prefixes.upsert ?? "upsert";
+  const upsertArrayFieldName = `${upsertPrefix}${mapped ? capitalize(mapped.plural) : capitalize(tableName)}`;
+  const upsertSingleFieldName = mapped ? `${upsertPrefix}${capitalize(mapped.singular)}` : `${upsertPrefix}${capitalize(tableName)}${suffixes.single}`;
   const updateFieldName = `${prefixes.update}${mapped ? capitalize(mapped.singular) : capitalize(tableName)}`;
   const deleteFieldName = `${prefixes.delete}${mapped ? capitalize(mapped.singular) : capitalize(tableName)}`;
   return {
     typeName,
     listFieldName,
     singleFieldName,
+    aggregateFieldName,
     createArrayFieldName,
     createSingleFieldName,
+    upsertArrayFieldName,
+    upsertSingleFieldName,
     updateFieldName,
     deleteFieldName
   };
 };
-var selectArrayArgs = (orderArgs, filterArgs) => ({
+var selectArrayArgs = (orderArgs, filterArgs, distinctEnum) => ({
   offset: { type: GraphQLInt2 },
   limit: { type: GraphQLInt2 },
   orderBy: { type: orderArgs },
-  where: { type: filterArgs }
+  where: { type: filterArgs },
+  ...distinctEnum ? { distinct: { type: new GraphQLList2(new GraphQLNonNull2(distinctEnum)) } } : {}
 });
 var selectSingleArgs = (orderArgs, filterArgs) => ({
   offset: { type: GraphQLInt2 },
@@ -1256,22 +1762,52 @@ var runRelationalSelect = async (opts) => {
     offset,
     orderBy,
     where,
-    single
+    single,
+    filterCtx,
+    pkNames
   } = opts;
+  const distinct = opts.distinct?.length ? opts.distinct : void 0;
+  const needsDefaultOrder = single || offset != null || opts.limit != null;
+  let distinctKeys;
+  if (distinct) {
+    distinctKeys = await selectDistinctKeys({
+      db: opts.db,
+      table,
+      tableName,
+      distinct,
+      pkNames: pkNames ?? [],
+      where: where ? extractFilters(table, tableName, where, relationFilterCtx(filterCtx, tableName)) : void 0,
+      orderBy,
+      limit: single ? 1 : opts.limit,
+      offset
+    });
+    if (!distinctKeys.length) {
+      return single ? void 0 : [];
+    }
+  }
   const params = {
-    columns: extractSelectedColumnsFromTree(parsedInfo.fieldsByTypeName[typeName], table),
-    offset,
+    columns: extractSelectedColumnsFromTree(parsedInfo.fieldsByTypeName[typeName], table, {
+      tableName,
+      relationMap,
+      tables
+    }),
+    offset: distinctKeys ? void 0 : offset,
     // drizzle-orm v1 RQB calls orderBy/where with the aliased table proxy — use it
     // directly so column refs match the CTE alias.
-    orderBy: orderBy ? (aliasedTable) => extractOrderBy(aliasedTable, orderBy) : void 0,
-    where: where ? { RAW: (aliasedTable) => extractFilters(aliasedTable, tableName, where) } : void 0,
-    with: relationMap[tableName] ? extractRelationsParams(relationMap, tables, tableName, parsedInfo, typeName, typeNameMapper) : void 0
+    orderBy: distinctKeys ? (aliasedTable2) => [
+      ...orderBy ? extractOrderBy(aliasedTable2, orderBy) : [],
+      ...primaryKeyOrderExprs(aliasedTable2, pkNames)
+    ] : orderBy ? (aliasedTable2) => extractOrderBy(aliasedTable2, orderBy) : needsDefaultOrder && pkNames?.length ? (aliasedTable2) => primaryKeyOrderExprs(aliasedTable2, pkNames) : void 0,
+    where: distinctKeys ? { RAW: (aliasedTable2) => primaryKeyRestriction(aliasedTable2, pkNames, distinctKeys) } : where ? {
+      RAW: (aliasedTable2) => extractFilters(aliasedTable2, tableName, where, relationFilterCtx(filterCtx, tableName))
+    } : void 0,
+    with: relationMap[tableName] ? extractRelationsParams(relationMap, tables, tableName, parsedInfo, typeName, typeNameMapper, filterCtx) : void 0
   };
   if (single) {
     const result2 = await queryBase.findFirst(params);
     return result2 ? remapToGraphQLSingleOutput(result2, tableName, table, relationMap) : void 0;
   }
-  params.limit = opts.limit;
+  params.limit = distinctKeys ? void 0 : opts.limit;
   const result = await queryBase.findMany(params);
   return remapToGraphQLArrayOutput(result, tableName, table, relationMap);
 };
@@ -1344,32 +1880,233 @@ var eagerLoadMutationRelations = async (db, tableName, rows, pkNames, withParams
 };
 
 // src/util/builders/mysql.ts
-var generateSelectArray = (db, tableName, tables, relationMap, orderArgs, filterArgs, fieldName, typeName, typeNameMapper) => {
-  const queryBase = db.query[tableName];
-  if (!queryBase) {
-    throw new Error(
-      `Drizzle-GraphQL Error: Table ${tableName} not found in drizzle instance. Did you forget to pass schema to drizzle constructor?`
-    );
+import { is as is4, One as One3 } from "drizzle-orm";
+import { getTableConfig, MySqlTable } from "drizzle-orm/mysql-core";
+import {
+  GraphQLBoolean as GraphQLBoolean3,
+  GraphQLError as GraphQLError4,
+  GraphQLList as GraphQLList4,
+  GraphQLNonNull as GraphQLNonNull4,
+  GraphQLObjectType as GraphQLObjectType4
+} from "graphql";
+import { parseResolveInfo as parseResolveInfo2 } from "graphql-parse-resolve-info";
+
+// src/util/builders/aggregates.ts
+import {
+  and as and2,
+  avg,
+  count,
+  countDistinct,
+  extractExtendedColumnType as extractExtendedColumnType2,
+  getColumns as getColumns2,
+  inArray as inArray2,
+  max,
+  min,
+  sum
+} from "drizzle-orm";
+import {
+  GraphQLFloat as GraphQLFloat2,
+  GraphQLInt as GraphQLInt3,
+  GraphQLList as GraphQLList3,
+  GraphQLNonNull as GraphQLNonNull3,
+  GraphQLObjectType as GraphQLObjectType3
+} from "graphql";
+import { parseResolveInfo } from "graphql-parse-resolve-info";
+var AGGREGATE_OPS = ["avg", "sum", "min", "max", "countNonNull", "countDistinct"];
+var COUNT_OPS = /* @__PURE__ */ new Set(["countNonNull", "countDistinct"]);
+var OP_FNS = {
+  avg,
+  sum,
+  min,
+  max,
+  countNonNull: count,
+  countDistinct
+};
+var SEP = "__";
+var classifyAggregateColumns = (table, tableName) => {
+  const numeric = {};
+  const orderable = {};
+  const all = {};
+  for (const [columnName, column] of Object.entries(getColumns2(table))) {
+    all[columnName] = column;
+    const converted = drizzleColumnToGraphQLType(column, columnName, tableName, true, false, false);
+    const gqlType = converted.type;
+    if (gqlType instanceof GraphQLList3 || gqlType instanceof GraphQLObjectType3) {
+      continue;
+    }
+    const { type: dataType, constraint } = extractExtendedColumnType2(column);
+    if (dataType === "boolean" || dataType === "array" || dataType === "custom") {
+      continue;
+    }
+    if (dataType === "object" && constraint !== "date") {
+      continue;
+    }
+    orderable[columnName] = { column, converted };
+    if (dataType === "number") {
+      numeric[columnName] = column;
+    }
   }
-  const queryArgs = selectArrayArgs(orderArgs, filterArgs);
-  const table = tables[tableName];
-  return {
-    name: fieldName,
-    resolver: async (_source, args, _context, info) => {
-      try {
-        const parsedInfo = parseResolveInfo(info, { deep: true });
-        return await runRelationalSelect({
-          queryBase,
-          tables,
-          tableName,
-          table,
-          relationMap,
-          typeName,
-          typeNameMapper,
-          parsedInfo,
-          ...args,
-          single: false
-        });
+  return { numeric, orderable, all };
+};
+var generateAggregateTypes = (table, tableName, typeName, cacheCtx) => {
+  const cached = cacheCtx?.aggregateTypeCache.get(tableName);
+  if (cached) {
+    return cached;
+  }
+  const { numeric, orderable, all } = classifyAggregateColumns(table, tableName);
+  const fields = {
+    count: { type: new GraphQLNonNull3(GraphQLInt3) }
+  };
+  if (Object.keys(numeric).length) {
+    for (const op of ["avg", "sum"]) {
+      fields[op] = {
+        type: new GraphQLObjectType3({
+          name: `${typeName}${capitalize(op)}Aggregate`,
+          fields: Object.fromEntries(Object.keys(numeric).map((columnName) => [columnName, { type: GraphQLFloat2 }]))
+        })
+      };
+    }
+  }
+  if (Object.keys(orderable).length) {
+    for (const op of ["min", "max"]) {
+      fields[op] = {
+        type: new GraphQLObjectType3({
+          name: `${typeName}${capitalize(op)}Aggregate`,
+          fields: Object.fromEntries(
+            Object.entries(orderable).map(([columnName, { converted }]) => [
+              columnName,
+              { type: converted.type, description: converted.description }
+            ])
+          )
+        })
+      };
+    }
+  }
+  const countSets = { countNonNull: all, countDistinct: orderable };
+  for (const [op, columns] of Object.entries(countSets)) {
+    const columnNames = Object.keys(columns);
+    if (!columnNames.length) {
+      continue;
+    }
+    fields[op] = {
+      type: new GraphQLObjectType3({
+        name: `${typeName}${capitalize(op)}Aggregate`,
+        fields: Object.fromEntries(
+          columnNames.map((columnName) => [columnName, { type: new GraphQLNonNull3(GraphQLInt3) }])
+        )
+      })
+    };
+  }
+  const aggregateType = new GraphQLObjectType3({
+    name: `${typeName}Aggregate`,
+    fields
+  });
+  cacheCtx?.aggregateTypeCache.set(tableName, aggregateType);
+  return aggregateType;
+};
+var parseDriverDateTime = (raw) => {
+  let v = raw.includes(" ") ? raw.replace(" ", "T") : raw;
+  if (!v.includes("T")) {
+    v = `${v}T00:00:00`;
+  }
+  if (!/(?:[Zz]|[+-]\d{2}(?::?\d{2})?)$/.test(v)) {
+    v = `${v}Z`;
+  }
+  const parsed = new Date(v);
+  return Number.isNaN(parsed.getTime()) ? new Date(raw) : parsed;
+};
+var aggregateTarget = (table, tableName, typeName) => {
+  const { orderable } = classifyAggregateColumns(table, tableName);
+  return {
+    tableName,
+    typeName,
+    columns: getColumns2(table),
+    dateTimeColumns: new Set(
+      Object.entries(orderable).filter(([, { converted }]) => converted.description === "DateTime").map(([columnName]) => columnName)
+    )
+  };
+};
+var parseAggregateRequest = (info, target) => {
+  const parsedInfo = parseResolveInfo(info, { deep: true });
+  const selectionTree = parsedInfo.fieldsByTypeName[`${target.typeName}Aggregate`] ?? {};
+  const request = {
+    count: false,
+    ops: { avg: [], sum: [], min: [], max: [], countNonNull: [], countDistinct: [] },
+    selection: {}
+  };
+  for (const field of Object.values(selectionTree)) {
+    if (field.name === "count") {
+      request.count = true;
+      request.selection.count = count();
+      continue;
+    }
+    if (!AGGREGATE_OPS.includes(field.name)) {
+      continue;
+    }
+    const op = field.name;
+    const subTree = field.fieldsByTypeName[`${target.typeName}${capitalize(op)}Aggregate`];
+    if (!subTree) {
+      continue;
+    }
+    for (const subField of Object.values(subTree)) {
+      const columnName = subField.name;
+      const column = target.columns[columnName];
+      if (!column || request.ops[op].includes(columnName)) {
+        continue;
+      }
+      request.ops[op].push(columnName);
+      request.selection[`${op}${SEP}${columnName}`] = OP_FNS[op](column);
+    }
+  }
+  return request;
+};
+var assembleAggregateRow = (row, request, target) => {
+  const result = {};
+  if (request.count) {
+    result.count = row.count == null ? 0 : Number(row.count);
+  }
+  for (const op of AGGREGATE_OPS) {
+    if (!request.ops[op].length) {
+      continue;
+    }
+    const opResult = {};
+    for (const columnName of request.ops[op]) {
+      const value = row[`${op}${SEP}${columnName}`];
+      if (COUNT_OPS.has(op)) {
+        opResult[columnName] = value == null ? 0 : Number(value);
+      } else if (value == null) {
+        opResult[columnName] = null;
+      } else if (op === "avg" || op === "sum") {
+        opResult[columnName] = Number(value);
+      } else {
+        const column = target.columns[columnName];
+        const decoded = typeof value === "string" && target.dateTimeColumns.has(columnName) ? parseDriverDateTime(value) : value;
+        opResult[columnName] = remapToGraphQLCore(columnName, decoded, target.tableName, column);
+      }
+    }
+    result[op] = opResult;
+  }
+  return result;
+};
+var generateAggregate = (db, tableName, table, typeName, fieldName, filterArgs, filterCtx) => {
+  const target = aggregateTarget(table, tableName, typeName);
+  const queryArgs = {
+    where: { type: filterArgs }
+  };
+  return {
+    name: fieldName,
+    resolver: async (_source, args, context, info) => {
+      try {
+        const request = parseAggregateRequest(info, target);
+        if (!Object.keys(request.selection).length) {
+          return {};
+        }
+        let query = resolveExecutor(db, context).select(request.selection).from(table);
+        if (args.where) {
+          query = query.where(extractFilters(table, tableName, args.where, relationFilterCtx(filterCtx, tableName)));
+        }
+        const rows = await query;
+        return assembleAggregateRow(rows[0] ?? {}, request, target);
       } catch (e) {
         throw toGraphQLError(e);
       }
@@ -1377,7 +2114,103 @@ var generateSelectArray = (db, tableName, tables, relationMap, orderArgs, filter
     args: queryArgs
   };
 };
-var generateSelectSingle = (db, tableName, tables, relationMap, orderArgs, filterArgs, fieldName, typeName, typeNameMapper) => {
+var GROUP_KEY = "__dgql_group_key";
+var createRelationAggregateFactory = (db, tables, cacheCtx, typeNameMapper, filterCtx) => {
+  return ({ tableName, relationName, relEntry }) => {
+    const parentTable = tables[tableName];
+    const targetTableName = relEntry.targetTableName;
+    const targetTable = tables[targetTableName];
+    if (!parentTable || !targetTable) {
+      return void 0;
+    }
+    const joinCols = extractRelationJoinColumns(relEntry, parentTable, targetTable);
+    if (!joinCols) {
+      return void 0;
+    }
+    const { localColPropName, foreignCol } = joinCols;
+    const targetTypeName = resolveTypeName(targetTableName, typeNameMapper);
+    const type = generateAggregateTypes(targetTable, targetTableName, targetTypeName, cacheCtx);
+    const target = aggregateTarget(targetTable, targetTableName, targetTypeName);
+    const resolve = async (parent, args, context, info) => {
+      try {
+        const request = parseAggregateRequest(info, target);
+        if (!Object.keys(request.selection).length) {
+          return {};
+        }
+        const localValue = parent[localColPropName];
+        if (localValue == null) {
+          return assembleAggregateRow({}, request, target);
+        }
+        const whereArg = args?.where;
+        const argsKey = JSON.stringify({
+          where: whereArg ?? null,
+          selection: Object.keys(request.selection).sort()
+        });
+        const loaderKey = `${tableName}::${relationName}::aggregate::${argsKey}`;
+        const loader = getOrCreateLoader(context, loaderKey, async (parentIds) => {
+          const executor = resolveExecutor(db, context);
+          const uniqueIds = [...new Set(parentIds)];
+          const whereCondition = and2(
+            inArray2(foreignCol, uniqueIds),
+            whereArg ? extractFilters(targetTable, targetTableName, whereArg, relationFilterCtx(filterCtx, targetTableName)) : void 0
+          );
+          const rows = await executor.select({ [GROUP_KEY]: foreignCol, ...request.selection }).from(targetTable).where(whereCondition).groupBy(foreignCol);
+          const byKey = new Map(rows.map((row) => [row[GROUP_KEY], row]));
+          return parentIds.map((id) => byKey.get(id) ?? {});
+        });
+        return assembleAggregateRow(await loader.load(localValue), request, target);
+      } catch (e) {
+        throw toGraphQLError(e);
+      }
+    };
+    return { type, resolve };
+  };
+};
+
+// src/util/builders/mysql.ts
+var generateSelectArray = (db, tableName, tables, relationMap, orderArgs, filterArgs, fieldName, typeName, typeNameMapper, filterCtx, distinctEnabled = true) => {
+  const queryBase = db.query[tableName];
+  if (!queryBase) {
+    throw new Error(
+      `Drizzle-GraphQL Error: Table ${tableName} not found in drizzle instance. Did you forget to pass schema to drizzle constructor?`
+    );
+  }
+  const table = tables[tableName];
+  const pkNames = mysqlPrimaryKeyPropNames(table);
+  const queryArgs = selectArrayArgs(
+    orderArgs,
+    filterArgs,
+    distinctEnabled ? generateDistinctEnum(table, typeName) : void 0
+  );
+  return {
+    name: fieldName,
+    resolver: async (_source, args, context, info) => {
+      try {
+        const parsedInfo = parseResolveInfo2(info, { deep: true });
+        const { executor, queryBase: requestQueryBase } = resolveQueryExecutor(db, context, tableName, queryBase);
+        return await runRelationalSelect({
+          queryBase: requestQueryBase,
+          tables,
+          tableName,
+          table,
+          relationMap,
+          typeName,
+          typeNameMapper,
+          parsedInfo,
+          ...args,
+          single: false,
+          filterCtx,
+          pkNames,
+          db: executor
+        });
+      } catch (e) {
+        throw toGraphQLError(e);
+      }
+    },
+    args: queryArgs
+  };
+};
+var generateSelectSingle = (db, tableName, tables, relationMap, orderArgs, filterArgs, fieldName, typeName, typeNameMapper, filterCtx) => {
   const queryBase = db.query[tableName];
   if (!queryBase) {
     throw new Error(
@@ -1386,13 +2219,15 @@ var generateSelectSingle = (db, tableName, tables, relationMap, orderArgs, filte
   }
   const queryArgs = selectSingleArgs(orderArgs, filterArgs);
   const table = tables[tableName];
+  const pkNames = mysqlPrimaryKeyPropNames(table);
   return {
     name: fieldName,
-    resolver: async (_source, args, _context, info) => {
+    resolver: async (_source, args, context, info) => {
       try {
-        const parsedInfo = parseResolveInfo(info, { deep: true });
+        const parsedInfo = parseResolveInfo2(info, { deep: true });
+        const { executor, queryBase: requestQueryBase } = resolveQueryExecutor(db, context, tableName, queryBase);
         return await runRelationalSelect({
-          queryBase,
+          queryBase: requestQueryBase,
           tables,
           tableName,
           table,
@@ -1401,7 +2236,10 @@ var generateSelectSingle = (db, tableName, tables, relationMap, orderArgs, filte
           typeNameMapper,
           parsedInfo,
           ...args,
-          single: true
+          single: true,
+          filterCtx,
+          pkNames,
+          db: executor
         });
       } catch (e) {
         throw toGraphQLError(e);
@@ -1413,18 +2251,18 @@ var generateSelectSingle = (db, tableName, tables, relationMap, orderArgs, filte
 var generateInsertArray = (db, _tableName, table, baseType, fieldName) => {
   const queryArgs = {
     values: {
-      type: new GraphQLNonNull3(new GraphQLList3(new GraphQLNonNull3(baseType)))
+      type: new GraphQLNonNull4(new GraphQLList4(new GraphQLNonNull4(baseType)))
     }
   };
   return {
     name: fieldName,
-    resolver: async (_source, args, _context, _info) => {
+    resolver: async (_source, args, context, _info) => {
       try {
         const input = remapFromGraphQLArrayInput(args.values, table);
         if (!input.length) {
-          throw new GraphQLError3("No values were provided!");
+          throw new GraphQLError4("No values were provided!");
         }
-        await db.insert(table).values(input);
+        await resolveExecutor(db, context).insert(table).values(input);
         return { isSuccess: true };
       } catch (e) {
         throw toGraphQLError(e);
@@ -1436,15 +2274,15 @@ var generateInsertArray = (db, _tableName, table, baseType, fieldName) => {
 var generateInsertSingle = (db, _tableName, table, baseType, fieldName) => {
   const queryArgs = {
     values: {
-      type: new GraphQLNonNull3(baseType)
+      type: new GraphQLNonNull4(baseType)
     }
   };
   return {
     name: fieldName,
-    resolver: async (_source, args, _context, _info) => {
+    resolver: async (_source, args, context, _info) => {
       try {
         const input = remapFromGraphQLSingleInput(args.values, table);
-        await db.insert(table).values(input);
+        await resolveExecutor(db, context).insert(table).values(input);
         return { isSuccess: true };
       } catch (e) {
         throw toGraphQLError(e);
@@ -1453,10 +2291,52 @@ var generateInsertSingle = (db, _tableName, table, baseType, fieldName) => {
     args: queryArgs
   };
 };
-var generateUpdate = (db, tableName, table, setArgs, filterArgs, fieldName) => {
+var generateUpsert = (db, table, baseType, onConflictType, fieldName, single) => {
+  const queryArgs = {
+    values: {
+      type: single ? new GraphQLNonNull4(baseType) : new GraphQLNonNull4(new GraphQLList4(new GraphQLNonNull4(baseType)))
+    },
+    onConflict: {
+      type: onConflictType,
+      description: "How a conflicting row is resolved. Defaults to overwriting it."
+    }
+  };
+  const pkNames = mysqlPrimaryKeyPropNames(table);
+  return {
+    name: fieldName,
+    resolver: async (_source, args, context, _info) => {
+      try {
+        const input = single ? [remapFromGraphQLSingleInput(args.values, table)] : remapFromGraphQLArrayInput(args.values, table);
+        if (!input.length) {
+          throw new GraphQLError4("No values were provided!");
+        }
+        const plan = resolveConflictPlan({
+          table,
+          values: input,
+          onConflict: args.onConflict,
+          pkNames,
+          uniqueSets: [],
+          excludedRef: mysqlValuesColumnRef,
+          withTarget: false
+        });
+        const executor = resolveExecutor(db, context);
+        if (plan.action === "NOTHING") {
+          await executor.insert(table).ignore().values(input);
+        } else {
+          await executor.insert(table).values(input).onDuplicateKeyUpdate({ set: plan.set });
+        }
+        return { isSuccess: true };
+      } catch (e) {
+        throw toGraphQLError(e);
+      }
+    },
+    args: queryArgs
+  };
+};
+var generateUpdate = (db, tableName, table, setArgs, filterArgs, fieldName, filterCtx) => {
   const queryArgs = {
     set: {
-      type: new GraphQLNonNull3(setArgs)
+      type: new GraphQLNonNull4(setArgs)
     },
     where: {
       type: filterArgs
@@ -1464,16 +2344,17 @@ var generateUpdate = (db, tableName, table, setArgs, filterArgs, fieldName) => {
   };
   return {
     name: fieldName,
-    resolver: async (_source, args, _context, _info) => {
+    resolver: async (_source, args, context, _info) => {
       try {
         const { where, set } = args;
         const input = remapFromGraphQLSingleInput(set, table);
         if (!Object.keys(input).length) {
-          throw new GraphQLError3("Unable to update with no values specified!");
+          throw new GraphQLError4("Unable to update with no values specified!");
         }
-        let query = db.update(table).set(input);
+        const executor = resolveExecutor(db, context);
+        let query = executor.update(table).set(input);
         if (where) {
-          const filters = extractFilters(table, tableName, where);
+          const filters = extractFilters(table, tableName, where, relationFilterCtx(filterCtx, tableName));
           query = query.where(filters);
         }
         await query;
@@ -1485,7 +2366,7 @@ var generateUpdate = (db, tableName, table, setArgs, filterArgs, fieldName) => {
     args: queryArgs
   };
 };
-var generateDelete = (db, tableName, table, filterArgs, fieldName) => {
+var generateDelete = (db, tableName, table, filterArgs, fieldName, filterCtx) => {
   const queryArgs = {
     where: {
       type: filterArgs
@@ -1493,12 +2374,13 @@ var generateDelete = (db, tableName, table, filterArgs, fieldName) => {
   };
   return {
     name: fieldName,
-    resolver: async (_source, args, _context, _info) => {
+    resolver: async (_source, args, context, _info) => {
       try {
         const { where } = args;
-        let query = db.delete(table);
+        const executor = resolveExecutor(db, context);
+        let query = executor.delete(table);
         if (where) {
-          const filters = extractFilters(table, tableName, where);
+          const filters = extractFilters(table, tableName, where, relationFilterCtx(filterCtx, tableName));
           query = query.where(filters);
         }
         await query;
@@ -1511,7 +2393,8 @@ var generateDelete = (db, tableName, table, filterArgs, fieldName) => {
   };
 };
 var mysqlPrimaryKeyPropNames = (table) => getPrimaryKeyPropNamesFromConfig(table, getTableConfig);
-var generateSchemaData = (db, schema, relations, relationsDepthLimit, prefixes, suffixes, typeNameMapper, shouldEagerLoad = () => true) => {
+var generateSchemaData = (db, schema, relations, options) => {
+  const { relationsDepthLimit, prefixes, suffixes, typeNameMapper, shouldEagerLoad, features } = options;
   const rawSchema = schema;
   const schemaEntries = Object.entries(rawSchema);
   const tableEntries = schemaEntries.filter(([_key, value]) => is4(value, MySqlTable));
@@ -1524,7 +2407,8 @@ var generateSchemaData = (db, schema, relations, relationsDepthLimit, prefixes,
   const namedRelations = buildNamedRelations(relations ?? {}, tableEntries);
   attachTargetPrimaryKeys(namedRelations, tables, mysqlPrimaryKeyPropNames);
   const eagerRelations = pruneNonEagerRelations(namedRelations, shouldEagerLoad);
-  const resolverFactory = createRelationResolverFactory(db, tables);
+  const filterCtx = { tables, relationMap: namedRelations };
+  const resolverFactory = createRelationResolverFactory(db, tables, filterCtx);
   const cacheCtx = {
     genericFilterCache: /* @__PURE__ */ new Map(),
     objectTypeCache: /* @__PURE__ */ new Map(),
@@ -1532,8 +2416,11 @@ var generateSchemaData = (db, schema, relations, relationsDepthLimit, prefixes,
     fullyBuiltTables: /* @__PURE__ */ new Set(),
     relationTypeCache: /* @__PURE__ */ new Map(),
     orderTypeCache: /* @__PURE__ */ new WeakMap(),
-    filterTypeCache: /* @__PURE__ */ new WeakMap()
+    filterTypeCache: /* @__PURE__ */ new WeakMap(),
+    listRelationFilterCache: /* @__PURE__ */ new Map(),
+    aggregateTypeCache: /* @__PURE__ */ new Map()
   };
+  const relationAggregateFactory = features.relationAggregates ? createRelationAggregateFactory(db, tables, cacheCtx, typeNameMapper, filterCtx) : void 0;
   const queries = {};
   const mutations = {};
   const gqlSchemaTypes = Object.fromEntries(
@@ -1549,22 +2436,24 @@ var generateSchemaData = (db, schema, relations, relationsDepthLimit, prefixes,
         typeNameMapper,
         prefixes.insert,
         prefixes.update,
-        resolverFactory
+        resolverFactory,
+        relationAggregateFactory
       )
     ])
   );
-  const mutationReturnType = new GraphQLObjectType3({
+  const mutationReturnType = new GraphQLObjectType4({
     name: "MutationReturn",
     fields: {
       isSuccess: {
-        type: new GraphQLNonNull3(GraphQLBoolean3)
+        type: new GraphQLNonNull4(GraphQLBoolean3)
       }
     }
   });
   const inputs = {};
-  const outputs = {
-    MutationReturn: mutationReturnType
-  };
+  const outputs = {};
+  if (features.insert || features.upsert || features.update || features.delete) {
+    outputs.MutationReturn = mutationReturnType;
+  }
   for (const [tableName, tableTypes] of Object.entries(gqlSchemaTypes)) {
     const { insertInput, updateInput, tableFilters, tableOrder } = tableTypes.inputs;
     const { selectSingleOutput, selectArrOutput } = tableTypes.outputs;
@@ -1572,8 +2461,11 @@ var generateSchemaData = (db, schema, relations, relationsDepthLimit, prefixes,
       typeName,
       listFieldName,
       singleFieldName,
+      aggregateFieldName,
       createArrayFieldName,
       createSingleFieldName,
+      upsertArrayFieldName,
+      upsertSingleFieldName,
       updateFieldName,
       deleteFieldName
     } = computeResolverFieldNames(tableName, typeNameMapper, prefixes, suffixes);
@@ -1586,7 +2478,9 @@ var generateSchemaData = (db, schema, relations, relationsDepthLimit, prefixes,
       tableFilters,
       listFieldName,
       typeName,
-      typeNameMapper
+      typeNameMapper,
+      filterCtx,
+      features.distinct
     );
     const selectSingleGenerated = generateSelectSingle(
       db,
@@ -1597,37 +2491,40 @@ var generateSchemaData = (db, schema, relations, relationsDepthLimit, prefixes,
       tableFilters,
       singleFieldName,
       typeName,
-      typeNameMapper
-    );
-    const insertArrGenerated = generateInsertArray(
-      db,
-      tableName,
-      schema[tableName],
-      insertInput,
-      createArrayFieldName
-    );
-    const insertSingleGenerated = generateInsertSingle(
-      db,
-      tableName,
-      schema[tableName],
-      insertInput,
-      createSingleFieldName
+      typeNameMapper,
+      filterCtx
     );
-    const updateGenerated = generateUpdate(
+    const insertArrGenerated = features.insert ? generateInsertArray(db, tableName, schema[tableName], insertInput, createArrayFieldName) : void 0;
+    const insertSingleGenerated = features.insert ? generateInsertSingle(db, tableName, schema[tableName], insertInput, createSingleFieldName) : void 0;
+    const onConflictInput = features.upsert ? generateOnConflictInput({
+      table: schema[tableName],
+      typeName,
+      uniqueSets: [],
+      tableFilters,
+      withTarget: false
+    }) : void 0;
+    const upsertArrGenerated = onConflictInput ? generateUpsert(db, schema[tableName], insertInput, onConflictInput, upsertArrayFieldName, false) : void 0;
+    const upsertSingleGenerated = onConflictInput ? generateUpsert(db, schema[tableName], insertInput, onConflictInput, upsertSingleFieldName, true) : void 0;
+    const updateGenerated = features.update ? generateUpdate(
       db,
       tableName,
       schema[tableName],
       updateInput,
       tableFilters,
-      updateFieldName
-    );
-    const deleteGenerated = generateDelete(
+      updateFieldName,
+      filterCtx
+    ) : void 0;
+    const deleteGenerated = features.delete ? generateDelete(db, tableName, schema[tableName], tableFilters, deleteFieldName, filterCtx) : void 0;
+    const aggregateType = features.aggregates ? generateAggregateTypes(schema[tableName], tableName, typeName, cacheCtx) : void 0;
+    const aggregateGenerated = features.aggregates ? generateAggregate(
       db,
       tableName,
       schema[tableName],
+      typeName,
+      aggregateFieldName,
       tableFilters,
-      deleteFieldName
-    );
+      filterCtx
+    ) : void 0;
     queries[selectArrGenerated.name] = {
       type: selectArrOutput,
       args: selectArrGenerated.args,
@@ -1638,30 +2535,44 @@ var generateSchemaData = (db, schema, relations, relationsDepthLimit, prefixes,
       args: selectSingleGenerated.args,
       resolve: selectSingleGenerated.resolver
     };
-    mutations[insertArrGenerated.name] = {
-      type: mutationReturnType,
-      args: insertArrGenerated.args,
-      resolve: insertArrGenerated.resolver
-    };
-    mutations[insertSingleGenerated.name] = {
-      type: mutationReturnType,
-      args: insertSingleGenerated.args,
-      resolve: insertSingleGenerated.resolver
-    };
-    mutations[updateGenerated.name] = {
-      type: mutationReturnType,
-      args: updateGenerated.args,
-      resolve: updateGenerated.resolver
-    };
-    mutations[deleteGenerated.name] = {
-      type: mutationReturnType,
-      args: deleteGenerated.args,
-      resolve: deleteGenerated.resolver
-    };
-    [insertInput, updateInput, tableFilters, tableOrder].forEach((e) => {
+    if (aggregateGenerated && aggregateType) {
+      queries[aggregateGenerated.name] = {
+        type: new GraphQLNonNull4(aggregateType),
+        args: aggregateGenerated.args,
+        resolve: aggregateGenerated.resolver
+      };
+    }
+    for (const generated of [
+      insertArrGenerated,
+      insertSingleGenerated,
+      upsertArrGenerated,
+      upsertSingleGenerated,
+      updateGenerated,
+      deleteGenerated
+    ]) {
+      if (generated) {
+        mutations[generated.name] = {
+          type: mutationReturnType,
+          args: generated.args,
+          resolve: generated.resolver
+        };
+      }
+    }
+    const activeInputs = [
+      // The insert input types the upsert mutations too, so either feature keeps it.
+      ...features.insert || onConflictInput ? [insertInput] : [],
+      ...onConflictInput ? [onConflictInput] : [],
+      ...features.update ? [updateInput] : [],
+      tableFilters,
+      tableOrder
+    ];
+    activeInputs.forEach((e) => {
       inputs[e.name] = e;
     });
     outputs[selectSingleOutput.name] = selectSingleOutput;
+    if (aggregateType) {
+      outputs[aggregateType.name] = aggregateType;
+    }
   }
   const fieldResolvers = {};
   for (const [tableName, tableRelations] of Object.entries(namedRelations)) {
@@ -1684,23 +2595,29 @@ var generateSchemaData = (db, schema, relations, relationsDepthLimit, prefixes,
 import { is as is5, One as One4 } from "drizzle-orm";
 import { getTableConfig as getTableConfig2, PgTable } from "drizzle-orm/pg-core";
 import {
-  GraphQLError as GraphQLError4,
-  GraphQLList as GraphQLList4,
-  GraphQLNonNull as GraphQLNonNull4
+  GraphQLError as GraphQLError5,
+  GraphQLList as GraphQLList5,
+  GraphQLNonNull as GraphQLNonNull5
 } from "graphql";
-import { parseResolveInfo as parseResolveInfo2 } from "graphql-parse-resolve-info";
-var generateSelectArray2 = (db, tableName, tables, relationMap, orderArgs, filterArgs, fieldName, typeName, typeNameMapper) => {
+import { parseResolveInfo as parseResolveInfo3 } from "graphql-parse-resolve-info";
+var generateSelectArray2 = (db, tableName, tables, relationMap, orderArgs, filterArgs, fieldName, typeName, typeNameMapper, filterCtx, distinctEnabled = true) => {
   const queryBase = db.query[tableName];
-  const queryArgs = selectArrayArgs(orderArgs, filterArgs);
   const table = tables[tableName];
+  const pkNames = pgPrimaryKeyPropNames(table);
+  const queryArgs = selectArrayArgs(
+    orderArgs,
+    filterArgs,
+    distinctEnabled ? generateDistinctEnum(table, typeName) : void 0
+  );
   return {
     name: fieldName,
-    resolver: async (_source, args, _context, info) => {
+    resolver: async (_source, args, context, info) => {
       try {
-        const parsedInfo = parseResolveInfo2(info, { deep: true });
-        if (queryBase) {
+        const parsedInfo = parseResolveInfo3(info, { deep: true });
+        const { executor, queryBase: requestQueryBase } = resolveQueryExecutor(db, context, tableName, queryBase);
+        if (requestQueryBase) {
           return await runRelationalSelect({
-            queryBase,
+            queryBase: requestQueryBase,
             tables,
             tableName,
             table,
@@ -1709,26 +2626,57 @@ var generateSelectArray2 = (db, tableName, tables, relationMap, orderArgs, filte
             typeNameMapper,
             parsedInfo,
             ...args,
-            single: false
+            single: false,
+            filterCtx,
+            pkNames,
+            db: executor
           });
         }
-        const { offset, limit, orderBy, where } = args;
+        const { offset, limit, orderBy, where, distinct } = args;
         const selectedColumnsSql = extractSelectedColumnsFromTreeSQLFormat(
           parsedInfo.fieldsByTypeName[typeName],
-          table
+          table,
+          { tableName, relationMap, tables }
         );
-        let q = db.select(selectedColumnsSql).from(table);
-        if (where) {
-          q = q.where(extractFilters(table, tableName, where));
+        const whereSql = where ? extractFilters(table, tableName, where, relationFilterCtx(filterCtx, tableName)) : void 0;
+        let distinctKeys;
+        if (distinct?.length) {
+          distinctKeys = await selectDistinctKeys({
+            db: executor,
+            table,
+            tableName,
+            distinct,
+            pkNames,
+            where: whereSql,
+            orderBy,
+            limit,
+            offset
+          });
+          if (!distinctKeys.length) {
+            return [];
+          }
         }
-        if (orderBy) {
-          q = q.orderBy(...extractOrderBy(table, orderBy));
+        let q = executor.select(selectedColumnsSql).from(table);
+        if (distinctKeys) {
+          q = q.where(primaryKeyRestriction(table, pkNames, distinctKeys));
+        } else if (whereSql) {
+          q = q.where(whereSql);
         }
-        if (offset) {
-          q = q.offset(offset);
+        if (orderBy) {
+          q = q.orderBy(
+            ...extractOrderBy(table, orderBy),
+            ...distinctKeys ? primaryKeyOrderExprs(table, pkNames) : []
+          );
+        } else if ((distinctKeys || offset != null || limit != null) && pkNames.length) {
+          q = q.orderBy(...primaryKeyOrderExprs(table, pkNames));
         }
-        if (limit) {
-          q = q.limit(limit);
+        if (!distinctKeys) {
+          if (offset) {
+            q = q.offset(offset);
+          }
+          if (limit) {
+            q = q.limit(limit);
+          }
         }
         return remapToGraphQLArrayOutput(await q, tableName, table, relationMap);
       } catch (e) {
@@ -1738,18 +2686,20 @@ var generateSelectArray2 = (db, tableName, tables, relationMap, orderArgs, filte
     args: queryArgs
   };
 };
-var generateSelectSingle2 = (db, tableName, tables, relationMap, orderArgs, filterArgs, fieldName, typeName, typeNameMapper) => {
+var generateSelectSingle2 = (db, tableName, tables, relationMap, orderArgs, filterArgs, fieldName, typeName, typeNameMapper, filterCtx) => {
   const queryBase = db.query[tableName];
   const queryArgs = selectSingleArgs(orderArgs, filterArgs);
   const table = tables[tableName];
+  const pkNames = pgPrimaryKeyPropNames(table);
   return {
     name: fieldName,
-    resolver: async (_source, args, _context, info) => {
+    resolver: async (_source, args, context, info) => {
       try {
-        const parsedInfo = parseResolveInfo2(info, { deep: true });
-        if (queryBase) {
+        const parsedInfo = parseResolveInfo3(info, { deep: true });
+        const { executor, queryBase: requestQueryBase } = resolveQueryExecutor(db, context, tableName, queryBase);
+        if (requestQueryBase) {
           return await runRelationalSelect({
-            queryBase,
+            queryBase: requestQueryBase,
             tables,
             tableName,
             table,
@@ -1758,20 +2708,26 @@ var generateSelectSingle2 = (db, tableName, tables, relationMap, orderArgs, filt
             typeNameMapper,
             parsedInfo,
             ...args,
-            single: true
+            single: true,
+            filterCtx,
+            pkNames,
+            db: executor
           });
         }
         const { offset, orderBy, where } = args;
         const selectedColumnsSql = extractSelectedColumnsFromTreeSQLFormat(
           parsedInfo.fieldsByTypeName[typeName],
-          table
+          table,
+          { tableName, relationMap, tables }
         );
-        let q = db.select(selectedColumnsSql).from(table);
+        let q = executor.select(selectedColumnsSql).from(table);
         if (where) {
-          q = q.where(extractFilters(table, tableName, where));
+          q = q.where(extractFilters(table, tableName, where, relationFilterCtx(filterCtx, tableName)));
         }
         if (orderBy) {
           q = q.orderBy(...extractOrderBy(table, orderBy));
+        } else if (pkNames.length) {
+          q = q.orderBy(...primaryKeyOrderExprs(table, pkNames));
         }
         if (offset) {
           q = q.offset(offset);
@@ -1790,19 +2746,19 @@ var pgPrimaryKeyPropNames = (table) => getPrimaryKeyPropNamesFromConfig(table, g
 var generateInsertArray2 = (db, tableName, table, tables, relationMap, baseType, fieldName, typeName, typeNameMapper, conflictDoNothing = false) => {
   const queryArgs = {
     values: {
-      type: new GraphQLNonNull4(new GraphQLList4(new GraphQLNonNull4(baseType)))
+      type: new GraphQLNonNull5(new GraphQLList5(new GraphQLNonNull5(baseType)))
     }
   };
   const pkNames = pgPrimaryKeyPropNames(table);
   return {
     name: fieldName,
-    resolver: async (_source, args, _context, info) => {
+    resolver: async (_source, args, context, info) => {
       try {
         const input = remapFromGraphQLArrayInput(args.values, table);
         if (!input.length) {
-          throw new GraphQLError4("No values were provided!");
+          throw new GraphQLError5("No values were provided!");
         }
-        const parsedInfo = parseResolveInfo2(info, {
+        const parsedInfo = parseResolveInfo3(info, {
           deep: true
         });
         const { columns, hasRelations, withParams } = prepareMutationRelationColumns({
@@ -1815,12 +2771,13 @@ var generateInsertArray2 = (db, tableName, table, tables, relationMap, baseType,
           pkNames,
           parsedInfo
         });
-        let query = db.insert(table).values(input).returning(columns);
+        const executor = resolveExecutor(db, context);
+        let query = executor.insert(table).values(input).returning(columns);
         if (conflictDoNothing) {
           query = query.onConflictDoNothing();
         }
         const result = await query;
-        const enriched = hasRelations ? await eagerLoadMutationRelations(db, tableName, result, pkNames, withParams) : result;
+        const enriched = hasRelations ? await eagerLoadMutationRelations(executor, tableName, result, pkNames, withParams) : result;
         return remapToGraphQLArrayOutput(enriched, tableName, table, relationMap);
       } catch (e) {
         throw toGraphQLError(e);
@@ -1832,16 +2789,16 @@ var generateInsertArray2 = (db, tableName, table, tables, relationMap, baseType,
 var generateInsertSingle2 = (db, tableName, table, tables, relationMap, baseType, fieldName, typeName, typeNameMapper, conflictDoNothing = false) => {
   const queryArgs = {
     values: {
-      type: new GraphQLNonNull4(baseType)
+      type: new GraphQLNonNull5(baseType)
     }
   };
   const pkNames = pgPrimaryKeyPropNames(table);
   return {
     name: fieldName,
-    resolver: async (_source, args, _context, info) => {
+    resolver: async (_source, args, context, info) => {
       try {
         const input = remapFromGraphQLSingleInput(args.values, table);
-        const parsedInfo = parseResolveInfo2(info, {
+        const parsedInfo = parseResolveInfo3(info, {
           deep: true
         });
         const { columns, hasRelations, withParams } = prepareMutationRelationColumns({
@@ -1854,7 +2811,8 @@ var generateInsertSingle2 = (db, tableName, table, tables, relationMap, baseType
           pkNames,
           parsedInfo
         });
-        let query = db.insert(table).values(input).returning(columns);
+        const executor = resolveExecutor(db, context);
+        let query = executor.insert(table).values(input).returning(columns);
         if (conflictDoNothing) {
           query = query.onConflictDoNothing();
         }
@@ -1862,7 +2820,7 @@ var generateInsertSingle2 = (db, tableName, table, tables, relationMap, baseType
         if (!result[0]) {
           return void 0;
         }
-        const enriched = hasRelations ? await eagerLoadMutationRelations(db, tableName, result, pkNames, withParams) : result;
+        const enriched = hasRelations ? await eagerLoadMutationRelations(executor, tableName, result, pkNames, withParams) : result;
         return remapToGraphQLSingleOutput(enriched[0], tableName, table, relationMap);
       } catch (e) {
         throw toGraphQLError(e);
@@ -1871,10 +2829,66 @@ var generateInsertSingle2 = (db, tableName, table, tables, relationMap, baseType
     args: queryArgs
   };
 };
-var generateUpdate2 = (db, tableName, table, tables, relationMap, setArgs, filterArgs, fieldName, typeName, typeNameMapper) => {
+var generateUpsert2 = (db, tableName, table, tables, relationMap, baseType, onConflictType, uniqueSets, fieldName, typeName, single, typeNameMapper, filterCtx) => {
+  const queryArgs = {
+    values: {
+      type: single ? new GraphQLNonNull5(baseType) : new GraphQLNonNull5(new GraphQLList5(new GraphQLNonNull5(baseType)))
+    },
+    onConflict: {
+      type: onConflictType,
+      description: "How a conflicting row is resolved. Defaults to overwriting it on the primary key."
+    }
+  };
+  const pkNames = pgPrimaryKeyPropNames(table);
+  return {
+    name: fieldName,
+    resolver: async (_source, args, context, info) => {
+      try {
+        const input = single ? [remapFromGraphQLSingleInput(args.values, table)] : remapFromGraphQLArrayInput(args.values, table);
+        if (!input.length) {
+          throw new GraphQLError5("No values were provided!");
+        }
+        const parsedInfo = parseResolveInfo3(info, { deep: true });
+        const { columns, hasRelations, withParams } = prepareMutationRelationColumns({
+          relationMap,
+          tables,
+          tableName,
+          typeName,
+          typeNameMapper,
+          table,
+          pkNames,
+          parsedInfo
+        });
+        const plan = resolveConflictPlan({
+          table,
+          values: input,
+          onConflict: args.onConflict,
+          pkNames,
+          uniqueSets,
+          excludedRef: excludedColumnRef,
+          withTarget: true,
+          buildWhere: (where) => extractFilters(table, tableName, where, relationFilterCtx(filterCtx, tableName))
+        });
+        const executor = resolveExecutor(db, context);
+        let query = executor.insert(table).values(input).returning(columns);
+        query = plan.action === "NOTHING" ? query.onConflictDoNothing(plan.target ? { target: plan.target } : void 0) : query.onConflictDoUpdate({ target: plan.target, set: plan.set, setWhere: plan.setWhere });
+        const result = await query;
+        if (single && !result[0]) {
+          return void 0;
+        }
+        const enriched = hasRelations ? await eagerLoadMutationRelations(executor, tableName, result, pkNames, withParams) : result;
+        return single ? remapToGraphQLSingleOutput(enriched[0], tableName, table, relationMap) : remapToGraphQLArrayOutput(enriched, tableName, table, relationMap);
+      } catch (e) {
+        throw toGraphQLError(e);
+      }
+    },
+    args: queryArgs
+  };
+};
+var generateUpdate2 = (db, tableName, table, tables, relationMap, setArgs, filterArgs, fieldName, typeName, typeNameMapper, filterCtx) => {
   const queryArgs = {
     set: {
-      type: new GraphQLNonNull4(setArgs)
+      type: new GraphQLNonNull5(setArgs)
     },
     where: {
       type: filterArgs
@@ -1883,10 +2897,10 @@ var generateUpdate2 = (db, tableName, table, tables, relationMap, setArgs, filte
   const pkNames = pgPrimaryKeyPropNames(table);
   return {
     name: fieldName,
-    resolver: async (_source, args, _context, info) => {
+    resolver: async (_source, args, context, info) => {
       try {
         const { where, set } = args;
-        const parsedInfo = parseResolveInfo2(info, {
+        const parsedInfo = parseResolveInfo3(info, {
           deep: true
         });
         const { columns, hasRelations, withParams } = prepareMutationRelationColumns({
@@ -1901,16 +2915,17 @@ var generateUpdate2 = (db, tableName, table, tables, relationMap, setArgs, filte
         });
         const input = remapFromGraphQLSingleInput(set, table);
         if (!Object.keys(input).length) {
-          throw new GraphQLError4("Unable to update with no values specified!");
+          throw new GraphQLError5("Unable to update with no values specified!");
         }
-        let query = db.update(table).set(input);
+        const executor = resolveExecutor(db, context);
+        let query = executor.update(table).set(input);
         if (where) {
-          const filters = extractFilters(table, tableName, where);
+          const filters = extractFilters(table, tableName, where, relationFilterCtx(filterCtx, tableName));
           query = query.where(filters);
         }
         query = query.returning(columns);
         const result = await query;
-        const enriched = hasRelations ? await eagerLoadMutationRelations(db, tableName, result, pkNames, withParams) : result;
+        const enriched = hasRelations ? await eagerLoadMutationRelations(executor, tableName, result, pkNames, withParams) : result;
         return remapToGraphQLArrayOutput(enriched, tableName, table, relationMap);
       } catch (e) {
         throw toGraphQLError(e);
@@ -1919,7 +2934,7 @@ var generateUpdate2 = (db, tableName, table, tables, relationMap, setArgs, filte
     args: queryArgs
   };
 };
-var generateDelete2 = (db, tableName, table, filterArgs, fieldName, typeName) => {
+var generateDelete2 = (db, tableName, table, filterArgs, fieldName, typeName, filterCtx, selectionCtx) => {
   const queryArgs = {
     where: {
       type: filterArgs
@@ -1927,19 +2942,21 @@ var generateDelete2 = (db, tableName, table, filterArgs, fieldName, typeName) =>
   };
   return {
     name: fieldName,
-    resolver: async (_source, args, _context, info) => {
+    resolver: async (_source, args, context, info) => {
       try {
         const { where } = args;
-        const parsedInfo = parseResolveInfo2(info, {
+        const parsedInfo = parseResolveInfo3(info, {
           deep: true
         });
         const columns = extractSelectedColumnsFromTreeSQLFormat(
           parsedInfo.fieldsByTypeName[typeName],
-          table
+          table,
+          selectionCtx
         );
-        let query = db.delete(table);
+        const executor = resolveExecutor(db, context);
+        let query = executor.delete(table);
         if (where) {
-          const filters = extractFilters(table, tableName, where);
+          const filters = extractFilters(table, tableName, where, relationFilterCtx(filterCtx, tableName));
           query = query.where(filters);
         }
         query = query.returning(columns);
@@ -1952,7 +2969,8 @@ var generateDelete2 = (db, tableName, table, filterArgs, fieldName, typeName) =>
     args: queryArgs
   };
 };
-function generateSchemaData2(db, schema, relations, relationsDepthLimit, prefixes, suffixes, conflictDoNothing = false, typeNameMapper, shouldEagerLoad = () => true) {
+function generateSchemaData2(db, schema, relations, options) {
+  const { relationsDepthLimit, prefixes, suffixes, conflictDoNothing, typeNameMapper, shouldEagerLoad, features } = options;
   const schemaEntries = Object.entries(schema);
   const tableEntries = schemaEntries.filter(([_key, value]) => is5(value, PgTable));
   const tables = Object.fromEntries(tableEntries);
@@ -1964,7 +2982,8 @@ function generateSchemaData2(db, schema, relations, relationsDepthLimit, prefixe
   const namedRelations = buildNamedRelations(relations ?? {}, tableEntries);
   attachTargetPrimaryKeys(namedRelations, tables, pgPrimaryKeyPropNames);
   const eagerRelations = pruneNonEagerRelations(namedRelations, shouldEagerLoad);
-  const resolverFactory = createRelationResolverFactory(db, tables);
+  const filterCtx = { tables, relationMap: namedRelations };
+  const resolverFactory = createRelationResolverFactory(db, tables, filterCtx);
   const cacheCtx = {
     genericFilterCache: /* @__PURE__ */ new Map(),
     objectTypeCache: /* @__PURE__ */ new Map(),
@@ -1972,8 +2991,11 @@ function generateSchemaData2(db, schema, relations, relationsDepthLimit, prefixe
     fullyBuiltTables: /* @__PURE__ */ new Set(),
     relationTypeCache: /* @__PURE__ */ new Map(),
     orderTypeCache: /* @__PURE__ */ new WeakMap(),
-    filterTypeCache: /* @__PURE__ */ new WeakMap()
+    filterTypeCache: /* @__PURE__ */ new WeakMap(),
+    listRelationFilterCache: /* @__PURE__ */ new Map(),
+    aggregateTypeCache: /* @__PURE__ */ new Map()
   };
+  const relationAggregateFactory = features.relationAggregates ? createRelationAggregateFactory(db, tables, cacheCtx, typeNameMapper, filterCtx) : void 0;
   const queries = {};
   const mutations = {};
   const gqlSchemaTypes = Object.fromEntries(
@@ -1989,7 +3011,8 @@ function generateSchemaData2(db, schema, relations, relationsDepthLimit, prefixe
         typeNameMapper,
         prefixes.insert,
         prefixes.update,
-        resolverFactory
+        resolverFactory,
+        relationAggregateFactory
       )
     ])
   );
@@ -2002,8 +3025,11 @@ function generateSchemaData2(db, schema, relations, relationsDepthLimit, prefixe
       typeName,
       listFieldName,
       singleFieldName,
+      aggregateFieldName,
       createArrayFieldName,
       createSingleFieldName,
+      upsertArrayFieldName,
+      upsertSingleFieldName,
       updateFieldName,
       deleteFieldName
     } = computeResolverFieldNames(tableName, typeNameMapper, prefixes, suffixes);
@@ -2016,7 +3042,9 @@ function generateSchemaData2(db, schema, relations, relationsDepthLimit, prefixe
       tableFilters,
       listFieldName,
       typeName,
-      typeNameMapper
+      typeNameMapper,
+      filterCtx,
+      features.distinct
     );
     const selectSingleGenerated = generateSelectSingle2(
       db,
@@ -2027,9 +3055,10 @@ function generateSchemaData2(db, schema, relations, relationsDepthLimit, prefixe
       tableFilters,
       singleFieldName,
       typeName,
-      typeNameMapper
+      typeNameMapper,
+      filterCtx
     );
-    const insertArrGenerated = generateInsertArray2(
+    const insertArrGenerated = features.insert ? generateInsertArray2(
       db,
       tableName,
       schema[tableName],
@@ -2040,8 +3069,8 @@ function generateSchemaData2(db, schema, relations, relationsDepthLimit, prefixe
       typeName,
       typeNameMapper,
       conflictDoNothing
-    );
-    const insertSingleGenerated = generateInsertSingle2(
+    ) : void 0;
+    const insertSingleGenerated = features.insert ? generateInsertSingle2(
       db,
       tableName,
       schema[tableName],
@@ -2052,8 +3081,46 @@ function generateSchemaData2(db, schema, relations, relationsDepthLimit, prefixe
       typeName,
       typeNameMapper,
       conflictDoNothing
-    );
-    const updateGenerated = generateUpdate2(
+    ) : void 0;
+    const uniqueSets = features.upsert ? getUniqueColumnSets(schema[tableName], getTableConfig2) : [];
+    const onConflictInput = features.upsert ? generateOnConflictInput({
+      table: schema[tableName],
+      typeName,
+      uniqueSets,
+      tableFilters,
+      withTarget: true
+    }) : void 0;
+    const upsertArrGenerated = onConflictInput ? generateUpsert2(
+      db,
+      tableName,
+      schema[tableName],
+      tables,
+      eagerRelations,
+      insertInput,
+      onConflictInput,
+      uniqueSets,
+      upsertArrayFieldName,
+      typeName,
+      false,
+      typeNameMapper,
+      filterCtx
+    ) : void 0;
+    const upsertSingleGenerated = onConflictInput ? generateUpsert2(
+      db,
+      tableName,
+      schema[tableName],
+      tables,
+      eagerRelations,
+      insertInput,
+      onConflictInput,
+      uniqueSets,
+      upsertSingleFieldName,
+      typeName,
+      true,
+      typeNameMapper,
+      filterCtx
+    ) : void 0;
+    const updateGenerated = features.update ? generateUpdate2(
       db,
       tableName,
       schema[tableName],
@@ -2063,16 +3130,29 @@ function generateSchemaData2(db, schema, relations, relationsDepthLimit, prefixe
       tableFilters,
       updateFieldName,
       typeName,
-      typeNameMapper
-    );
-    const deleteGenerated = generateDelete2(
+      typeNameMapper,
+      filterCtx
+    ) : void 0;
+    const deleteGenerated = features.delete ? generateDelete2(
       db,
       tableName,
       schema[tableName],
       tableFilters,
       deleteFieldName,
-      typeName
-    );
+      typeName,
+      filterCtx,
+      { tableName, relationMap: namedRelations, tables }
+    ) : void 0;
+    const aggregateType = features.aggregates ? generateAggregateTypes(schema[tableName], tableName, typeName, cacheCtx) : void 0;
+    const aggregateGenerated = features.aggregates ? generateAggregate(
+      db,
+      tableName,
+      schema[tableName],
+      typeName,
+      aggregateFieldName,
+      tableFilters,
+      filterCtx
+    ) : void 0;
     queries[selectArrGenerated.name] = {
       type: selectArrOutput,
       args: selectArrGenerated.args,
@@ -2083,31 +3163,71 @@ function generateSchemaData2(db, schema, relations, relationsDepthLimit, prefixe
       args: selectSingleGenerated.args,
       resolve: selectSingleGenerated.resolver
     };
-    mutations[insertArrGenerated.name] = {
-      type: arrTableItemOutput,
-      args: insertArrGenerated.args,
-      resolve: insertArrGenerated.resolver
-    };
-    mutations[insertSingleGenerated.name] = {
-      type: singleTableItemOutput,
-      args: insertSingleGenerated.args,
-      resolve: insertSingleGenerated.resolver
-    };
-    mutations[updateGenerated.name] = {
-      type: arrTableItemOutput,
-      args: updateGenerated.args,
-      resolve: updateGenerated.resolver
-    };
-    mutations[deleteGenerated.name] = {
-      type: arrTableItemOutput,
-      args: deleteGenerated.args,
-      resolve: deleteGenerated.resolver
-    };
-    [insertInput, updateInput, tableFilters, tableOrder].forEach((e) => {
+    if (aggregateGenerated && aggregateType) {
+      queries[aggregateGenerated.name] = {
+        type: new GraphQLNonNull5(aggregateType),
+        args: aggregateGenerated.args,
+        resolve: aggregateGenerated.resolver
+      };
+    }
+    if (insertArrGenerated) {
+      mutations[insertArrGenerated.name] = {
+        type: arrTableItemOutput,
+        args: insertArrGenerated.args,
+        resolve: insertArrGenerated.resolver
+      };
+    }
+    if (insertSingleGenerated) {
+      mutations[insertSingleGenerated.name] = {
+        type: singleTableItemOutput,
+        args: insertSingleGenerated.args,
+        resolve: insertSingleGenerated.resolver
+      };
+    }
+    if (upsertArrGenerated) {
+      mutations[upsertArrGenerated.name] = {
+        type: arrTableItemOutput,
+        args: upsertArrGenerated.args,
+        resolve: upsertArrGenerated.resolver
+      };
+    }
+    if (upsertSingleGenerated) {
+      mutations[upsertSingleGenerated.name] = {
+        type: singleTableItemOutput,
+        args: upsertSingleGenerated.args,
+        resolve: upsertSingleGenerated.resolver
+      };
+    }
+    if (updateGenerated) {
+      mutations[updateGenerated.name] = {
+        type: arrTableItemOutput,
+        args: updateGenerated.args,
+        resolve: updateGenerated.resolver
+      };
+    }
+    if (deleteGenerated) {
+      mutations[deleteGenerated.name] = {
+        type: arrTableItemOutput,
+        args: deleteGenerated.args,
+        resolve: deleteGenerated.resolver
+      };
+    }
+    const activeInputs = [
+      // The insert input types the upsert mutations too, so either feature keeps it.
+      ...features.insert || onConflictInput ? [insertInput] : [],
+      ...onConflictInput ? [onConflictInput] : [],
+      ...features.update ? [updateInput] : [],
+      tableFilters,
+      tableOrder
+    ];
+    activeInputs.forEach((e) => {
       inputs[e.name] = e;
     });
     outputs[selectSingleOutput.name] = selectSingleOutput;
     outputs[singleTableItemOutput.name] = singleTableItemOutput;
+    if (aggregateType) {
+      outputs[aggregateType.name] = aggregateType;
+    }
   }
   const fieldResolvers = {};
   for (const [tableName, tableRelations] of Object.entries(namedRelations)) {
@@ -2130,27 +3250,33 @@ function generateSchemaData2(db, schema, relations, relationsDepthLimit, prefixe
 import { is as is6, One as One5 } from "drizzle-orm";
 import { getTableConfig as getTableConfig3, SQLiteTable } from "drizzle-orm/sqlite-core";
 import {
-  GraphQLError as GraphQLError5,
-  GraphQLList as GraphQLList5,
-  GraphQLNonNull as GraphQLNonNull5
+  GraphQLError as GraphQLError6,
+  GraphQLList as GraphQLList6,
+  GraphQLNonNull as GraphQLNonNull6
 } from "graphql";
-import { parseResolveInfo as parseResolveInfo3 } from "graphql-parse-resolve-info";
-var generateSelectArray3 = (db, tableName, tables, relationMap, orderArgs, filterArgs, fieldName, typeName, typeNameMapper) => {
+import { parseResolveInfo as parseResolveInfo4 } from "graphql-parse-resolve-info";
+var generateSelectArray3 = (db, tableName, tables, relationMap, orderArgs, filterArgs, fieldName, typeName, typeNameMapper, filterCtx, distinctEnabled = true) => {
   const queryBase = db.query[tableName];
   if (!queryBase) {
     throw new Error(
       `Drizzle-GraphQL Error: Table ${tableName} not found in drizzle instance. Did you forget to pass schema to drizzle constructor?`
     );
   }
-  const queryArgs = selectArrayArgs(orderArgs, filterArgs);
   const table = tables[tableName];
+  const pkNames = sqlitePrimaryKeyPropNames(table);
+  const queryArgs = selectArrayArgs(
+    orderArgs,
+    filterArgs,
+    distinctEnabled ? generateDistinctEnum(table, typeName) : void 0
+  );
   return {
     name: fieldName,
-    resolver: async (_source, args, _context, info) => {
+    resolver: async (_source, args, context, info) => {
       try {
-        const parsedInfo = parseResolveInfo3(info, { deep: true });
+        const parsedInfo = parseResolveInfo4(info, { deep: true });
+        const { executor, queryBase: requestQueryBase } = resolveQueryExecutor(db, context, tableName, queryBase);
         return await runRelationalSelect({
-          queryBase,
+          queryBase: requestQueryBase,
           tables,
           tableName,
           table,
@@ -2159,7 +3285,10 @@ var generateSelectArray3 = (db, tableName, tables, relationMap, orderArgs, filte
           typeNameMapper,
           parsedInfo,
           ...args,
-          single: false
+          single: false,
+          filterCtx,
+          pkNames,
+          db: executor
         });
       } catch (e) {
         throw toGraphQLError(e);
@@ -2168,7 +3297,7 @@ var generateSelectArray3 = (db, tableName, tables, relationMap, orderArgs, filte
     args: queryArgs
   };
 };
-var generateSelectSingle3 = (db, tableName, tables, relationMap, orderArgs, filterArgs, fieldName, typeName, typeNameMapper) => {
+var generateSelectSingle3 = (db, tableName, tables, relationMap, orderArgs, filterArgs, fieldName, typeName, typeNameMapper, filterCtx) => {
   const queryBase = db.query[tableName];
   if (!queryBase) {
     throw new Error(
@@ -2177,13 +3306,15 @@ var generateSelectSingle3 = (db, tableName, tables, relationMap, orderArgs, filt
   }
   const queryArgs = selectSingleArgs(orderArgs, filterArgs);
   const table = tables[tableName];
+  const pkNames = sqlitePrimaryKeyPropNames(table);
   return {
     name: fieldName,
-    resolver: async (_source, args, _context, info) => {
+    resolver: async (_source, args, context, info) => {
       try {
-        const parsedInfo = parseResolveInfo3(info, { deep: true });
+        const parsedInfo = parseResolveInfo4(info, { deep: true });
+        const { executor, queryBase: requestQueryBase } = resolveQueryExecutor(db, context, tableName, queryBase);
         return await runRelationalSelect({
-          queryBase,
+          queryBase: requestQueryBase,
           tables,
           tableName,
           table,
@@ -2192,7 +3323,10 @@ var generateSelectSingle3 = (db, tableName, tables, relationMap, orderArgs, filt
           typeNameMapper,
           parsedInfo,
           ...args,
-          single: true
+          single: true,
+          filterCtx,
+          pkNames,
+          db: executor
         });
       } catch (e) {
         throw toGraphQLError(e);
@@ -2202,22 +3336,22 @@ var generateSelectSingle3 = (db, tableName, tables, relationMap, orderArgs, filt
   };
 };
 var sqlitePrimaryKeyPropNames = (table) => getPrimaryKeyPropNamesFromConfig(table, getTableConfig3);
-var generateInsertArray3 = (db, tableName, table, tables, relationMap, baseType, fieldName, typeName, typeNameMapper) => {
+var generateInsertArray3 = (db, tableName, table, tables, relationMap, baseType, fieldName, typeName, typeNameMapper, conflictDoNothing = false) => {
   const queryArgs = {
     values: {
-      type: new GraphQLNonNull5(new GraphQLList5(new GraphQLNonNull5(baseType)))
+      type: new GraphQLNonNull6(new GraphQLList6(new GraphQLNonNull6(baseType)))
     }
   };
   const pkNames = sqlitePrimaryKeyPropNames(table);
   return {
     name: fieldName,
-    resolver: async (_source, args, _context, info) => {
+    resolver: async (_source, args, context, info) => {
       try {
         const input = remapFromGraphQLArrayInput(args.values, table);
         if (!input.length) {
-          throw new GraphQLError5("No values were provided!");
+          throw new GraphQLError6("No values were provided!");
         }
-        const parsedInfo = parseResolveInfo3(info, {
+        const parsedInfo = parseResolveInfo4(info, {
           deep: true
         });
         const { columns, hasRelations, withParams } = prepareMutationRelationColumns({
@@ -2230,8 +3364,13 @@ var generateInsertArray3 = (db, tableName, table, tables, relationMap, baseType,
           pkNames,
           parsedInfo
         });
-        const result = await db.insert(table).values(input).returning(columns).onConflictDoNothing();
-        const enriched = hasRelations ? await eagerLoadMutationRelations(db, tableName, result, pkNames, withParams) : result;
+        const executor = resolveExecutor(db, context);
+        let query = executor.insert(table).values(input).returning(columns);
+        if (conflictDoNothing) {
+          query = query.onConflictDoNothing();
+        }
+        const result = await query;
+        const enriched = hasRelations ? await eagerLoadMutationRelations(executor, tableName, result, pkNames, withParams) : result;
         return remapToGraphQLArrayOutput(enriched, tableName, table, relationMap);
       } catch (e) {
         throw toGraphQLError(e);
@@ -2240,19 +3379,19 @@ var generateInsertArray3 = (db, tableName, table, tables, relationMap, baseType,
     args: queryArgs
   };
 };
-var generateInsertSingle3 = (db, tableName, table, tables, relationMap, baseType, fieldName, typeName, typeNameMapper) => {
+var generateInsertSingle3 = (db, tableName, table, tables, relationMap, baseType, fieldName, typeName, typeNameMapper, conflictDoNothing = false) => {
   const queryArgs = {
     values: {
-      type: new GraphQLNonNull5(baseType)
+      type: new GraphQLNonNull6(baseType)
     }
   };
   const pkNames = sqlitePrimaryKeyPropNames(table);
   return {
     name: fieldName,
-    resolver: async (_source, args, _context, info) => {
+    resolver: async (_source, args, context, info) => {
       try {
         const input = remapFromGraphQLSingleInput(args.values, table);
-        const parsedInfo = parseResolveInfo3(info, {
+        const parsedInfo = parseResolveInfo4(info, {
           deep: true
         });
         const { columns, hasRelations, withParams } = prepareMutationRelationColumns({
@@ -2265,11 +3404,16 @@ var generateInsertSingle3 = (db, tableName, table, tables, relationMap, baseType
           pkNames,
           parsedInfo
         });
-        const result = await db.insert(table).values(input).returning(columns).onConflictDoNothing();
+        const executor = resolveExecutor(db, context);
+        let query = executor.insert(table).values(input).returning(columns);
+        if (conflictDoNothing) {
+          query = query.onConflictDoNothing();
+        }
+        const result = await query;
         if (!result[0]) {
           return void 0;
         }
-        const enriched = hasRelations ? await eagerLoadMutationRelations(db, tableName, result, pkNames, withParams) : result;
+        const enriched = hasRelations ? await eagerLoadMutationRelations(executor, tableName, result, pkNames, withParams) : result;
         return remapToGraphQLSingleOutput(enriched[0], tableName, table, relationMap);
       } catch (e) {
         throw toGraphQLError(e);
@@ -2278,10 +3422,66 @@ var generateInsertSingle3 = (db, tableName, table, tables, relationMap, baseType
     args: queryArgs
   };
 };
-var generateUpdate3 = (db, tableName, table, tables, relationMap, setArgs, filterArgs, fieldName, typeName, typeNameMapper) => {
+var generateUpsert3 = (db, tableName, table, tables, relationMap, baseType, onConflictType, uniqueSets, fieldName, typeName, single, typeNameMapper, filterCtx) => {
+  const queryArgs = {
+    values: {
+      type: single ? new GraphQLNonNull6(baseType) : new GraphQLNonNull6(new GraphQLList6(new GraphQLNonNull6(baseType)))
+    },
+    onConflict: {
+      type: onConflictType,
+      description: "How a conflicting row is resolved. Defaults to overwriting it on the primary key."
+    }
+  };
+  const pkNames = sqlitePrimaryKeyPropNames(table);
+  return {
+    name: fieldName,
+    resolver: async (_source, args, context, info) => {
+      try {
+        const input = single ? [remapFromGraphQLSingleInput(args.values, table)] : remapFromGraphQLArrayInput(args.values, table);
+        if (!input.length) {
+          throw new GraphQLError6("No values were provided!");
+        }
+        const parsedInfo = parseResolveInfo4(info, { deep: true });
+        const { columns, hasRelations, withParams } = prepareMutationRelationColumns({
+          relationMap,
+          tables,
+          tableName,
+          typeName,
+          typeNameMapper,
+          table,
+          pkNames,
+          parsedInfo
+        });
+        const plan = resolveConflictPlan({
+          table,
+          values: input,
+          onConflict: args.onConflict,
+          pkNames,
+          uniqueSets,
+          excludedRef: excludedColumnRef,
+          withTarget: true,
+          buildWhere: (where) => extractFilters(table, tableName, where, relationFilterCtx(filterCtx, tableName))
+        });
+        const executor = resolveExecutor(db, context);
+        let query = executor.insert(table).values(input).returning(columns);
+        query = plan.action === "NOTHING" ? query.onConflictDoNothing(plan.target ? { target: plan.target } : void 0) : query.onConflictDoUpdate({ target: plan.target, set: plan.set, setWhere: plan.setWhere });
+        const result = await query;
+        if (single && !result[0]) {
+          return void 0;
+        }
+        const enriched = hasRelations ? await eagerLoadMutationRelations(executor, tableName, result, pkNames, withParams) : result;
+        return single ? remapToGraphQLSingleOutput(enriched[0], tableName, table, relationMap) : remapToGraphQLArrayOutput(enriched, tableName, table, relationMap);
+      } catch (e) {
+        throw toGraphQLError(e);
+      }
+    },
+    args: queryArgs
+  };
+};
+var generateUpdate3 = (db, tableName, table, tables, relationMap, setArgs, filterArgs, fieldName, typeName, typeNameMapper, filterCtx) => {
   const queryArgs = {
     set: {
-      type: new GraphQLNonNull5(setArgs)
+      type: new GraphQLNonNull6(setArgs)
     },
     where: {
       type: filterArgs
@@ -2290,10 +3490,10 @@ var generateUpdate3 = (db, tableName, table, tables, relationMap, setArgs, filte
   const pkNames = sqlitePrimaryKeyPropNames(table);
   return {
     name: fieldName,
-    resolver: async (_source, args, _context, info) => {
+    resolver: async (_source, args, context, info) => {
       try {
         const { where, set } = args;
-        const parsedInfo = parseResolveInfo3(info, {
+        const parsedInfo = parseResolveInfo4(info, {
           deep: true
         });
         const { columns, hasRelations, withParams } = prepareMutationRelationColumns({
@@ -2308,16 +3508,17 @@ var generateUpdate3 = (db, tableName, table, tables, relationMap, setArgs, filte
         });
         const input = remapFromGraphQLSingleInput(set, table);
         if (!Object.keys(input).length) {
-          throw new GraphQLError5("Unable to update with no values specified!");
+          throw new GraphQLError6("Unable to update with no values specified!");
         }
-        let query = db.update(table).set(input);
+        const executor = resolveExecutor(db, context);
+        let query = executor.update(table).set(input);
         if (where) {
-          const filters = extractFilters(table, tableName, where);
+          const filters = extractFilters(table, tableName, where, relationFilterCtx(filterCtx, tableName));
           query = query.where(filters);
         }
         query = query.returning(columns);
         const result = await query;
-        const enriched = hasRelations ? await eagerLoadMutationRelations(db, tableName, result, pkNames, withParams) : result;
+        const enriched = hasRelations ? await eagerLoadMutationRelations(executor, tableName, result, pkNames, withParams) : result;
         return remapToGraphQLArrayOutput(enriched, tableName, table, relationMap);
       } catch (e) {
         throw toGraphQLError(e);
@@ -2326,7 +3527,7 @@ var generateUpdate3 = (db, tableName, table, tables, relationMap, setArgs, filte
     args: queryArgs
   };
 };
-var generateDelete3 = (db, tableName, table, filterArgs, fieldName, typeName) => {
+var generateDelete3 = (db, tableName, table, filterArgs, fieldName, typeName, filterCtx, selectionCtx) => {
   const queryArgs = {
     where: {
       type: filterArgs
@@ -2334,19 +3535,21 @@ var generateDelete3 = (db, tableName, table, filterArgs, fieldName, typeName) =>
   };
   return {
     name: fieldName,
-    resolver: async (_source, args, _context, info) => {
+    resolver: async (_source, args, context, info) => {
       try {
         const { where } = args;
-        const parsedInfo = parseResolveInfo3(info, {
+        const parsedInfo = parseResolveInfo4(info, {
           deep: true
         });
         const columns = extractSelectedColumnsFromTreeSQLFormat(
           parsedInfo.fieldsByTypeName[typeName],
-          table
+          table,
+          selectionCtx
         );
-        let query = db.delete(table);
+        const executor = resolveExecutor(db, context);
+        let query = executor.delete(table);
         if (where) {
-          const filters = extractFilters(table, tableName, where);
+          const filters = extractFilters(table, tableName, where, relationFilterCtx(filterCtx, tableName));
           query = query.where(filters);
         }
         query = query.returning(columns);
@@ -2359,7 +3562,8 @@ var generateDelete3 = (db, tableName, table, filterArgs, fieldName, typeName) =>
     args: queryArgs
   };
 };
-var generateSchemaData3 = (db, schema, relations, relationsDepthLimit, prefixes, suffixes, typeNameMapper, shouldEagerLoad = () => true) => {
+var generateSchemaData3 = (db, schema, relations, options) => {
+  const { relationsDepthLimit, prefixes, suffixes, conflictDoNothing, typeNameMapper, shouldEagerLoad, features } = options;
   const rawSchema = schema;
   const schemaEntries = Object.entries(rawSchema);
   const tableEntries = schemaEntries.filter(([_key, value]) => is6(value, SQLiteTable));
@@ -2372,7 +3576,8 @@ var generateSchemaData3 = (db, schema, relations, relationsDepthLimit, prefixes,
   const namedRelations = buildNamedRelations(relations ?? {}, tableEntries);
   attachTargetPrimaryKeys(namedRelations, tables, sqlitePrimaryKeyPropNames);
   const eagerRelations = pruneNonEagerRelations(namedRelations, shouldEagerLoad);
-  const resolverFactory = createRelationResolverFactory(db, tables);
+  const filterCtx = { tables, relationMap: namedRelations };
+  const resolverFactory = createRelationResolverFactory(db, tables, filterCtx);
   const cacheCtx = {
     genericFilterCache: /* @__PURE__ */ new Map(),
     objectTypeCache: /* @__PURE__ */ new Map(),
@@ -2380,8 +3585,11 @@ var generateSchemaData3 = (db, schema, relations, relationsDepthLimit, prefixes,
     fullyBuiltTables: /* @__PURE__ */ new Set(),
     relationTypeCache: /* @__PURE__ */ new Map(),
     orderTypeCache: /* @__PURE__ */ new WeakMap(),
-    filterTypeCache: /* @__PURE__ */ new WeakMap()
+    filterTypeCache: /* @__PURE__ */ new WeakMap(),
+    listRelationFilterCache: /* @__PURE__ */ new Map(),
+    aggregateTypeCache: /* @__PURE__ */ new Map()
   };
+  const relationAggregateFactory = features.relationAggregates ? createRelationAggregateFactory(db, tables, cacheCtx, typeNameMapper, filterCtx) : void 0;
   const queries = {};
   const mutations = {};
   const gqlSchemaTypes = Object.fromEntries(
@@ -2397,7 +3605,8 @@ var generateSchemaData3 = (db, schema, relations, relationsDepthLimit, prefixes,
         typeNameMapper,
         prefixes.insert,
         prefixes.update,
-        resolverFactory
+        resolverFactory,
+        relationAggregateFactory
       )
     ])
   );
@@ -2410,8 +3619,11 @@ var generateSchemaData3 = (db, schema, relations, relationsDepthLimit, prefixes,
       typeName,
       listFieldName,
       singleFieldName,
+      aggregateFieldName,
       createArrayFieldName,
       createSingleFieldName,
+      upsertArrayFieldName,
+      upsertSingleFieldName,
       updateFieldName,
       deleteFieldName
     } = computeResolverFieldNames(tableName, typeNameMapper, prefixes, suffixes);
@@ -2424,7 +3636,9 @@ var generateSchemaData3 = (db, schema, relations, relationsDepthLimit, prefixes,
       tableFilters,
       listFieldName,
       typeName,
-      typeNameMapper
+      typeNameMapper,
+      filterCtx,
+      features.distinct
     );
     const selectSingleGenerated = generateSelectSingle3(
       db,
@@ -2435,9 +3649,10 @@ var generateSchemaData3 = (db, schema, relations, relationsDepthLimit, prefixes,
       tableFilters,
       singleFieldName,
       typeName,
-      typeNameMapper
+      typeNameMapper,
+      filterCtx
     );
-    const insertArrGenerated = generateInsertArray3(
+    const insertArrGenerated = features.insert ? generateInsertArray3(
       db,
       tableName,
       schema[tableName],
@@ -2446,9 +3661,10 @@ var generateSchemaData3 = (db, schema, relations, relationsDepthLimit, prefixes,
       insertInput,
       createArrayFieldName,
       typeName,
-      typeNameMapper
-    );
-    const insertSingleGenerated = generateInsertSingle3(
+      typeNameMapper,
+      conflictDoNothing
+    ) : void 0;
+    const insertSingleGenerated = features.insert ? generateInsertSingle3(
       db,
       tableName,
       schema[tableName],
@@ -2457,9 +3673,48 @@ var generateSchemaData3 = (db, schema, relations, relationsDepthLimit, prefixes,
       insertInput,
       createSingleFieldName,
       typeName,
-      typeNameMapper
-    );
-    const updateGenerated = generateUpdate3(
+      typeNameMapper,
+      conflictDoNothing
+    ) : void 0;
+    const uniqueSets = features.upsert ? getUniqueColumnSets(schema[tableName], getTableConfig3) : [];
+    const onConflictInput = features.upsert ? generateOnConflictInput({
+      table: schema[tableName],
+      typeName,
+      uniqueSets,
+      tableFilters,
+      withTarget: true
+    }) : void 0;
+    const upsertArrGenerated = onConflictInput ? generateUpsert3(
+      db,
+      tableName,
+      schema[tableName],
+      tables,
+      eagerRelations,
+      insertInput,
+      onConflictInput,
+      uniqueSets,
+      upsertArrayFieldName,
+      typeName,
+      false,
+      typeNameMapper,
+      filterCtx
+    ) : void 0;
+    const upsertSingleGenerated = onConflictInput ? generateUpsert3(
+      db,
+      tableName,
+      schema[tableName],
+      tables,
+      eagerRelations,
+      insertInput,
+      onConflictInput,
+      uniqueSets,
+      upsertSingleFieldName,
+      typeName,
+      true,
+      typeNameMapper,
+      filterCtx
+    ) : void 0;
+    const updateGenerated = features.update ? generateUpdate3(
       db,
       tableName,
       schema[tableName],
@@ -2469,16 +3724,29 @@ var generateSchemaData3 = (db, schema, relations, relationsDepthLimit, prefixes,
       tableFilters,
       updateFieldName,
       typeName,
-      typeNameMapper
-    );
-    const deleteGenerated = generateDelete3(
+      typeNameMapper,
+      filterCtx
+    ) : void 0;
+    const deleteGenerated = features.delete ? generateDelete3(
       db,
       tableName,
       schema[tableName],
       tableFilters,
       deleteFieldName,
-      typeName
-    );
+      typeName,
+      filterCtx,
+      { tableName, relationMap: namedRelations, tables }
+    ) : void 0;
+    const aggregateType = features.aggregates ? generateAggregateTypes(schema[tableName], tableName, typeName, cacheCtx) : void 0;
+    const aggregateGenerated = features.aggregates ? generateAggregate(
+      db,
+      tableName,
+      schema[tableName],
+      typeName,
+      aggregateFieldName,
+      tableFilters,
+      filterCtx
+    ) : void 0;
     queries[selectArrGenerated.name] = {
       type: selectArrOutput,
       args: selectArrGenerated.args,
@@ -2489,31 +3757,71 @@ var generateSchemaData3 = (db, schema, relations, relationsDepthLimit, prefixes,
       args: selectSingleGenerated.args,
       resolve: selectSingleGenerated.resolver
     };
-    mutations[insertArrGenerated.name] = {
-      type: arrTableItemOutput,
-      args: insertArrGenerated.args,
-      resolve: insertArrGenerated.resolver
-    };
-    mutations[insertSingleGenerated.name] = {
-      type: singleTableItemOutput,
-      args: insertSingleGenerated.args,
-      resolve: insertSingleGenerated.resolver
-    };
-    mutations[updateGenerated.name] = {
-      type: arrTableItemOutput,
-      args: updateGenerated.args,
-      resolve: updateGenerated.resolver
-    };
-    mutations[deleteGenerated.name] = {
-      type: arrTableItemOutput,
-      args: deleteGenerated.args,
-      resolve: deleteGenerated.resolver
-    };
-    [insertInput, updateInput, tableFilters, tableOrder].forEach((e) => {
+    if (aggregateGenerated && aggregateType) {
+      queries[aggregateGenerated.name] = {
+        type: new GraphQLNonNull6(aggregateType),
+        args: aggregateGenerated.args,
+        resolve: aggregateGenerated.resolver
+      };
+    }
+    if (insertArrGenerated) {
+      mutations[insertArrGenerated.name] = {
+        type: arrTableItemOutput,
+        args: insertArrGenerated.args,
+        resolve: insertArrGenerated.resolver
+      };
+    }
+    if (insertSingleGenerated) {
+      mutations[insertSingleGenerated.name] = {
+        type: singleTableItemOutput,
+        args: insertSingleGenerated.args,
+        resolve: insertSingleGenerated.resolver
+      };
+    }
+    if (upsertArrGenerated) {
+      mutations[upsertArrGenerated.name] = {
+        type: arrTableItemOutput,
+        args: upsertArrGenerated.args,
+        resolve: upsertArrGenerated.resolver
+      };
+    }
+    if (upsertSingleGenerated) {
+      mutations[upsertSingleGenerated.name] = {
+        type: singleTableItemOutput,
+        args: upsertSingleGenerated.args,
+        resolve: upsertSingleGenerated.resolver
+      };
+    }
+    if (updateGenerated) {
+      mutations[updateGenerated.name] = {
+        type: arrTableItemOutput,
+        args: updateGenerated.args,
+        resolve: updateGenerated.resolver
+      };
+    }
+    if (deleteGenerated) {
+      mutations[deleteGenerated.name] = {
+        type: arrTableItemOutput,
+        args: deleteGenerated.args,
+        resolve: deleteGenerated.resolver
+      };
+    }
+    const activeInputs = [
+      // The insert input types the upsert mutations too, so either feature keeps it.
+      ...features.insert || onConflictInput ? [insertInput] : [],
+      ...onConflictInput ? [onConflictInput] : [],
+      ...features.update ? [updateInput] : [],
+      tableFilters,
+      tableOrder
+    ];
+    activeInputs.forEach((e) => {
       inputs[e.name] = e;
     });
     outputs[selectSingleOutput.name] = selectSingleOutput;
     outputs[singleTableItemOutput.name] = singleTableItemOutput;
+    if (aggregateType) {
+      outputs[aggregateType.name] = aggregateType;
+    }
   }
   const fieldResolvers = {};
   for (const [tableName, tableRelations] of Object.entries(namedRelations)) {
@@ -2546,13 +3854,23 @@ var buildSchema = (db, config) => {
   const prefixes = {
     insert: config?.prefixes?.insert ?? "create",
     delete: config?.prefixes?.delete ?? "delete",
-    update: config?.prefixes?.update ?? "update"
+    update: config?.prefixes?.update ?? "update",
+    upsert: config?.prefixes?.upsert ?? "upsert"
   };
   const suffixes = {
     list: config?.suffixes?.list ?? "",
     single: config?.suffixes?.single ?? "Single"
   };
   const typeNameMapper = config?.typeNameMapper;
+  const features = {
+    aggregates: config?.features?.aggregates ?? true,
+    relationAggregates: config?.features?.relationAggregates ?? true,
+    distinct: config?.features?.distinct ?? true,
+    insert: config?.features?.insert ?? true,
+    update: config?.features?.update ?? true,
+    delete: config?.features?.delete ?? true,
+    upsert: config?.features?.upsert ?? false
+  };
   const eagerOpt = config?.eagerLoadRelations;
   const shouldEagerLoad = eagerOpt === void 0 || eagerOpt === true ? () => true : eagerOpt === false ? () => false : eagerOpt;
   if (!typeNameMapper && suffixes.list === suffixes.single) {
@@ -2572,54 +3890,40 @@ var buildSchema = (db, config) => {
       );
     }
   }
+  const generatorOptions = {
+    relationsDepthLimit: config?.relationsDepthLimit,
+    prefixes,
+    suffixes,
+    conflictDoNothing: config?.conflictDoNothing ?? false,
+    typeNameMapper,
+    shouldEagerLoad,
+    features
+  };
   let generatorOutput;
   if (is7(db, MySqlDatabase)) {
-    generatorOutput = generateSchemaData(
-      db,
-      schema,
-      relations,
-      config?.relationsDepthLimit,
-      prefixes,
-      suffixes,
-      typeNameMapper,
-      shouldEagerLoad
-    );
+    generatorOutput = generateSchemaData(db, schema, relations, generatorOptions);
   } else if (is7(db, PgAsyncDatabase)) {
-    generatorOutput = generateSchemaData2(
-      db,
-      schema,
-      relations,
-      config?.relationsDepthLimit,
-      prefixes,
-      suffixes,
-      config?.conflictDoNothing ?? false,
-      typeNameMapper,
-      shouldEagerLoad
-    );
+    generatorOutput = generateSchemaData2(db, schema, relations, generatorOptions);
   } else if (is7(db, BaseSQLiteDatabase)) {
-    generatorOutput = generateSchemaData3(
-      db,
-      schema,
-      relations,
-      config?.relationsDepthLimit,
-      prefixes,
-      suffixes,
-      typeNameMapper,
-      shouldEagerLoad
-    );
+    generatorOutput = generateSchemaData3(db, schema, relations, generatorOptions);
   } else {
     throw new Error("Drizzle-GraphQL Error: Unknown database instance type");
   }
+  const onError = config?.onError;
+  applyErrorMapper(
+    generatorOutput,
+    onError ? (error) => onError(error) ?? defaultErrorMapper(error) : defaultErrorMapper
+  );
   const { queries, mutations, inputs, types } = generatorOutput;
   const graphQLSchemaConfig = {
     types: [...Object.values(inputs), ...Object.values(types)],
-    query: new GraphQLObjectType4({
+    query: new GraphQLObjectType5({
       name: "Query",
       fields: queries
     })
   };
-  if (config?.mutations !== false) {
-    const mutation = new GraphQLObjectType4({
+  if (config?.mutations !== false && Object.keys(mutations).length) {
+    const mutation = new GraphQLObjectType5({
       name: "Mutation",
       fields: mutations
     });
@@ -2629,8 +3933,15 @@ var buildSchema = (db, config) => {
   return { schema: outputSchema, entities: generatorOutput };
 };
 export {
+  GraphQLBigIntString,
+  GraphQLDate,
+  GraphQLDateTime,
+  GraphQLJSON,
+  GraphQLUUID,
   buildSchema,
   createRelationResolverFactory,
+  defaultErrorMapper,
+  drizzleExecutorKey,
   extractFilters,
   extractOrderBy,
   extractRelationJoinColumns