@vantreeseba/drizzle-graphql 1.0.2 → 2.0.0

package/dist/index.js

@@ -1,5 +1,5 @@
 // src/index.ts
-import { is as is6 } from "drizzle-orm";
+import { is as is7 } from "drizzle-orm";
 import { MySqlDatabase } from "drizzle-orm/mysql-core";
 import { PgAsyncDatabase } from "drizzle-orm/pg-core";
 import { BaseSQLiteDatabase } from "drizzle-orm/sqlite-core";
@@ -9,12 +9,11 @@ import {
 } from "graphql";
 
 // src/util/builders/mysql.ts
-import { is as is3 } from "drizzle-orm";
-import { MySqlTable } from "drizzle-orm/mysql-core";
+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,
-  GraphQLInt as GraphQLInt3,
   GraphQLList as GraphQLList3,
   GraphQLNonNull as GraphQLNonNull3,
   GraphQLObjectType as GraphQLObjectType3
@@ -27,12 +26,12 @@ import {
   asc,
   desc,
   eq,
-  getColumns as getColumns2,
+  getColumns,
   gt,
   gte,
   ilike,
   inArray,
-  is as is2,
+  is as is3,
   isNotNull,
   isNull,
   like,
@@ -42,8 +41,9 @@ import {
   notIlike,
   notInArray,
   notLike,
-  One,
-  or
+  One as One2,
+  or,
+  sql
 } from "drizzle-orm";
 import {
   GraphQLBoolean as GraphQLBoolean2,
@@ -57,14 +57,59 @@ import {
   GraphQLString as GraphQLString2
 } from "graphql";
 
+// src/util/batch-loader/index.ts
+var DRIZZLE_LOADERS_KEY = /* @__PURE__ */ Symbol("drizzle-graphql-loaders");
+var BatchLoader = class {
+  constructor(batchFn) {
+    this.batchFn = batchFn;
+  }
+  batch = [];
+  scheduled = false;
+  load(key) {
+    return new Promise((resolve, reject) => {
+      this.batch.push({ key, resolve, reject });
+      if (!this.scheduled) {
+        this.scheduled = true;
+        Promise.resolve().then(() => this.dispatch());
+      }
+    });
+  }
+  async dispatch() {
+    const current = this.batch.splice(0);
+    this.scheduled = false;
+    try {
+      const results = await this.batchFn(current.map(({ key }) => key));
+      for (let i = 0; i < current.length; i++) {
+        current[i].resolve(results[i]);
+      }
+    } catch (err) {
+      for (const { reject } of current) {
+        reject(err);
+      }
+    }
+  }
+};
+var getOrCreateLoader = (context, key, batchFn) => {
+  if (!context || typeof context !== "object") {
+    return new BatchLoader(batchFn);
+  }
+  if (!context[DRIZZLE_LOADERS_KEY]) {
+    context[DRIZZLE_LOADERS_KEY] = /* @__PURE__ */ new Map();
+  }
+  const loaders = context[DRIZZLE_LOADERS_KEY];
+  if (!loaders.has(key)) {
+    loaders.set(key, new BatchLoader(batchFn));
+  }
+  return loaders.get(key);
+};
+
 // src/util/case-ops/index.ts
 import pluralize from "pluralize";
 var uncapitalize = (input) => input?.length ? `${input[0].toLocaleLowerCase()}${input.length > 1 ? input.slice(1, input.length) : ""}` : input;
 var capitalize = (input) => input?.length ? `${input[0].toLocaleUpperCase()}${input.length > 1 ? input.slice(1, input.length) : ""}` : input;
-var singularize = (input) => pluralize.singular(input);
 
 // src/util/data-mappers/index.ts
-import { getTableColumns } from "drizzle-orm";
+import { getTableColumns, is, One } from "drizzle-orm";
 import { GraphQLError } from "graphql";
 var remapToGraphQLCore = (key, value, tableName, column, relationMap) => {
   if (Array.isArray(value)) {
@@ -121,6 +166,11 @@ var remapToGraphQLCore = (key, value, tableName, column, relationMap) => {
 var remapToGraphQLSingleOutput = (queryOutput, tableName, table, relationMap) => {
   for (const [key, value] of Object.entries(queryOutput)) {
     if (value === void 0 || value === null) {
+      const relEntry = value === null ? relationMap?.[tableName]?.[key] : void 0;
+      if (relEntry && is(relEntry.relation, One)) {
+        queryOutput[key] = null;
+        continue;
+      }
       delete queryOutput[key];
       continue;
     }
@@ -258,7 +308,7 @@ var remapFromGraphQLArrayInput = (queryInput, table) => {
 };
 
 // src/util/type-converter/index.ts
-import { extractExtendedColumnType, getColumns, is } from "drizzle-orm";
+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 { SQLiteInteger } from "drizzle-orm/sqlite-core";
@@ -341,14 +391,14 @@ var columnToGraphQLCore = (column, columnName, tableName, isInput) => {
     case "number": {
       const dims = column.dimensions;
       if (dims !== void 0 && dims > 0) {
-        const baseDesc = is(column, PgInteger) || is(column, PgSerial) ? "Integer" : "Float";
+        const baseDesc = is2(column, PgInteger) || is2(column, PgSerial) ? "Integer" : "Float";
         const baseType2 = baseDesc === "Integer" ? GraphQLInt : GraphQLFloat;
         return {
           type: new GraphQLList(new GraphQLNonNull(baseType2)),
           description: `Array<${baseDesc}>`
         };
       }
-      return is(column, PgInteger) || is(column, PgSerial) || is(column, MySqlInt) || is(column, MySqlSerial) || is(column, SQLiteInteger) ? { type: GraphQLInt, description: "Integer" } : { type: GraphQLFloat, description: "Float" };
+      return is2(column, PgInteger) || is2(column, PgSerial) || is2(column, MySqlInt) || is2(column, MySqlSerial) || is2(column, SQLiteInteger) ? { type: GraphQLInt, description: "Integer" } : { type: GraphQLFloat, description: "Float" };
     }
     case "array": {
       if (column.columnType === "PgVector") {
@@ -378,26 +428,6 @@ var columnToGraphQLCore = (column, columnName, tableName, isInput) => {
       throw new Error(`Drizzle-GraphQL Error: Type ${column.dataType} is not implemented!`);
   }
 };
-var drizzleRelationToGraphQLInsertType = (tables, relationMap) => {
-  if (!relationMap) {
-    return null;
-  }
-  for (const [tableName, _val] of Object.entries(relationMap)) {
-    const table = tables[tableName];
-    if (!table) {
-      continue;
-    }
-    const columns = getColumns(table);
-    const columnEntries = Object.entries(columns).filter(([_key, value]) => value.primary);
-    const _connectFields = Object.fromEntries(
-      columnEntries.map(([columnName, columnDescription]) => [
-        columnName,
-        drizzleColumnToGraphQLType(columnDescription, columnName, tableName, false, true, true)
-      ])
-    );
-  }
-  return null;
-};
 var drizzleColumnToGraphQLType = (column, columnName, tableName, forceNullable = false, defaultIsNullable = false, isInput = false) => {
   const typeDesc = columnToGraphQLCore(column, columnName, tableName, isInput);
   const noDesc = ["string", "boolean", "number"];
@@ -419,7 +449,10 @@ var drizzleColumnToGraphQLType = (column, columnName, tableName, forceNullable =
 
 // src/util/builders/common.ts
 var rqbCrashTypes = ["SQLiteBigInt", "SQLiteBlobJson", "SQLiteBlobBuffer"];
-var toTypeName = (name, singular) => singular ? capitalize(singularize(name)) : capitalize(name);
+var resolveTypeName = (name, typeNameMapper) => {
+  const mapped = typeNameMapper?.(name);
+  return mapped ? capitalize(mapped.singular) : capitalize(name);
+};
 var buildNamedRelations = (relations, tableEntries) => {
   const namedRelations = {};
   for (const [relTableName, relConfig] of Object.entries(relations)) {
@@ -452,8 +485,131 @@ var buildNamedRelations = (relations, tableEntries) => {
   }
   return namedRelations;
 };
+var attachTargetPrimaryKeys = (namedRelations, tables, resolvePkNames) => {
+  const cache = /* @__PURE__ */ new Map();
+  for (const rels of Object.values(namedRelations)) {
+    for (const relEntry of Object.values(rels)) {
+      const { targetTableName } = relEntry;
+      let pk = cache.get(targetTableName);
+      if (!pk) {
+        const targetTable = tables[targetTableName];
+        pk = targetTable ? resolvePkNames(targetTable) : [];
+        cache.set(targetTableName, pk);
+      }
+      relEntry.targetPkNames = pk;
+    }
+  }
+};
+var extractRelationJoinColumns = (relEntry, parentTable, targetTable) => {
+  const rel = relEntry.relation ?? relEntry;
+  const sourceColumns = rel.sourceColumns;
+  const targetColumns = rel.targetColumns;
+  if (!sourceColumns?.length || !targetColumns?.length) {
+    return void 0;
+  }
+  const sourceCol = sourceColumns[0];
+  const targetCol = targetColumns[0];
+  const parentCols = getColumns(parentTable);
+  const localColPropName = Object.entries(parentCols).find(([, c]) => c === sourceCol)?.[0];
+  const targetCols = getColumns(targetTable);
+  const foreignColPropName = Object.entries(targetCols).find(([, c]) => c === targetCol)?.[0];
+  if (!localColPropName || !foreignColPropName) {
+    return void 0;
+  }
+  return { localColPropName, foreignCol: targetCol, foreignColPropName };
+};
+var batchedPaginatedRelationQuery = async (db, targetTable, foreignCol, whereCondition, orderByArg, limit, offset, pkNames) => {
+  const cols = getColumns(targetTable);
+  const orderExprs = [
+    ...orderByArg ? extractOrderBy(targetTable, orderByArg) : [],
+    ...primaryKeyOrderExprs(targetTable, pkNames)
+  ];
+  const orderClause = orderExprs.length ? sql` order by ${sql.join(orderExprs, sql`, `)}` : sql``;
+  const RN = "__drizzle_graphql_rn";
+  const rowNumber = sql`row_number() over (partition by ${foreignCol}${orderClause})`.as(RN);
+  const sub = db.select({ ...cols, [RN]: rowNumber }).from(targetTable).where(whereCondition).as("__paginated");
+  const lower = offset ?? 0;
+  const windowConds = [gt(sub[RN], lower)];
+  if (limit != null) {
+    windowConds.push(lte(sub[RN], lower + limit));
+  }
+  const rows = await db.select().from(sub).where(and(...windowConds)).orderBy(sub[RN]);
+  for (const row of rows) {
+    delete row[RN];
+  }
+  return rows;
+};
+var createRelationResolverFactory = (db, tables) => ({ tableName, relationName, relEntry, isOne }) => {
+  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, foreignColPropName } = joinCols;
+  const targetPkNames = relEntry.targetPkNames ?? [];
+  return async (parent, args, context) => {
+    if (parent[relationName] !== void 0) {
+      return parent[relationName];
+    }
+    const localValue = parent[localColPropName];
+    if (localValue == null) {
+      return isOne ? null : [];
+    }
+    const { where: whereArg, orderBy: orderByArg, limit, offset } = args ?? {};
+    const argsKey = JSON.stringify({
+      where: whereArg ?? null,
+      orderBy: orderByArg ?? null,
+      limit: limit ?? null,
+      offset: offset ?? null
+    });
+    const loaderKey = `${tableName}::${relationName}::${argsKey}`;
+    const loader = getOrCreateLoader(context, loaderKey, async (parentIds) => {
+      const uniqueIds = [...new Set(parentIds)];
+      const whereCondition = and(
+        inArray(foreignCol, uniqueIds),
+        whereArg ? extractFilters(targetTable, targetTableName, whereArg) : void 0
+      );
+      let rows;
+      if (limit != null || offset != null) {
+        rows = await batchedPaginatedRelationQuery(
+          db,
+          targetTable,
+          foreignCol,
+          whereCondition,
+          orderByArg,
+          limit ?? null,
+          offset ?? null,
+          targetPkNames
+        );
+      } else {
+        let q = db.select().from(targetTable).where(whereCondition);
+        if (orderByArg) {
+          q = q.orderBy(...extractOrderBy(targetTable, orderByArg));
+        }
+        rows = await q;
+      }
+      if (isOne) {
+        const byKey = new Map(rows.map((row) => [String(row[foreignColPropName]), row]));
+        remapToGraphQLArrayOutput(rows, targetTableName, targetTable);
+        return parentIds.map((id) => byKey.get(String(id)) ?? null);
+      }
+      const grouped = new Map(uniqueIds.map((id) => [String(id), []]));
+      for (const row of rows) {
+        grouped.get(String(row[foreignColPropName]))?.push(row);
+      }
+      remapToGraphQLArrayOutput(rows, targetTableName, targetTable);
+      return parentIds.map((id) => grouped.get(String(id)) ?? []);
+    });
+    return loader.load(localValue);
+  };
+};
 var extractSelectedColumnsFromTree = (tree, table) => {
-  const tableColumns = getColumns2(table);
+  const tableColumns = getColumns(table);
   const treeEntries = Object.entries(tree);
   const selectedColumns = [];
   for (const [_fieldName, fieldData] of treeEntries) {
@@ -470,7 +626,7 @@ var extractSelectedColumnsFromTree = (tree, table) => {
   return Object.fromEntries(selectedColumns);
 };
 var extractSelectedColumnsFromTreeSQLFormat = (tree, table) => {
-  const tableColumns = getColumns2(table);
+  const tableColumns = getColumns(table);
   const treeEntries = Object.entries(tree);
   const selectedColumns = [];
   for (const [_fieldName, fieldData] of treeEntries) {
@@ -585,7 +741,7 @@ var generateTableOrderCached = (table) => {
   }
   let remapped = {};
   try {
-    const columns = getColumns2(table);
+    const columns = getColumns(table);
     const columnEntries = Object.entries(columns);
     remapped = Object.fromEntries(
       columnEntries.map(([columnName, _columnDescription]) => [columnName, { type: innerOrder }])
@@ -600,7 +756,7 @@ var generateTableFilterValuesCached = (table, tableName, cacheCtx) => {
   if (filterMap.has(table)) {
     return filterMap.get(table);
   }
-  const columns = getColumns2(table);
+  const columns = getColumns(table);
   const columnEntries = Object.entries(columns);
   const remapped = Object.fromEntries(
     columnEntries.map(([columnName, columnDescription]) => [
@@ -618,7 +774,7 @@ var generateTableSelectTypeFieldsCached = (table, tableName) => {
   if (fieldMap.has(table)) {
     return fieldMap.get(table);
   }
-  const columns = getColumns2(table);
+  const columns = getColumns(table);
   const columnEntries = Object.entries(columns);
   const remapped = Object.fromEntries(
     columnEntries.map(([columnName, columnDescription]) => [
@@ -629,34 +785,32 @@ var generateTableSelectTypeFieldsCached = (table, tableName) => {
   fieldMap.set(table, remapped);
   return remapped;
 };
-var orderTypeMap = /* @__PURE__ */ new WeakMap();
-var generateTableOrderTypeCached = (table, tableName, singularTypes) => {
-  if (orderTypeMap.has(table)) {
-    return orderTypeMap.get(table);
+var generateTableOrderTypeCached = (table, tableName, typeNameMapper, cacheCtx) => {
+  if (cacheCtx.orderTypeCache.has(table)) {
+    return cacheCtx.orderTypeCache.get(table);
   }
   const orderColumns = generateTableOrderCached(table);
   const order = new GraphQLInputObjectType2({
-    name: `${toTypeName(tableName, singularTypes)}OrderBy`,
+    name: `${resolveTypeName(tableName, typeNameMapper)}OrderBy`,
     fields: orderColumns
   });
-  orderTypeMap.set(table, order);
+  cacheCtx.orderTypeCache.set(table, order);
   return order;
 };
-var filterTypeMap = /* @__PURE__ */ new WeakMap();
-var generateTableFilterTypeCached = (table, tableName, cacheCtx, singularTypes) => {
-  if (filterTypeMap.has(table)) {
-    return filterTypeMap.get(table);
+var generateTableFilterTypeCached = (table, tableName, cacheCtx, typeNameMapper) => {
+  if (cacheCtx.filterTypeCache.has(table)) {
+    return cacheCtx.filterTypeCache.get(table);
   }
   const filterColumns = generateTableFilterValuesCached(table, tableName, cacheCtx);
   const filters = new GraphQLInputObjectType2({
-    name: `${toTypeName(tableName, singularTypes)}Filters`,
+    name: `${resolveTypeName(tableName, typeNameMapper)}Filters`,
     fields: {
       ...filterColumns,
       OR: {
         type: new GraphQLList2(
           new GraphQLNonNull2(
             new GraphQLInputObjectType2({
-              name: `${toTypeName(tableName, singularTypes)}FiltersOr`,
+              name: `${resolveTypeName(tableName, typeNameMapper)}FiltersOr`,
               fields: filterColumns
             })
           )
@@ -664,16 +818,24 @@ var generateTableFilterTypeCached = (table, tableName, cacheCtx, singularTypes)
       }
     }
   });
-  filterTypeMap.set(table, filters);
+  cacheCtx.filterTypeCache.set(table, filters);
   return filters;
 };
-var generateSelectFields = (tables, tableName, relationMap, fromTableName, fromRelationName, withOrder, _relationsDepthLimit, cacheCtx, singularTypes, usedTables = /* @__PURE__ */ new Set()) => {
+var generateSelectFields = (tables, tableName, relationMap, fromTableName, fromRelationName, withOrder, relationsDepthLimit, cacheCtx, typeNameMapper, usedTables = /* @__PURE__ */ new Set(), resolverFactory, currentDepth = 0) => {
   const table = tables[tableName];
-  const order = withOrder ? generateTableOrderTypeCached(table, tableName, singularTypes) : void 0;
-  const filters = generateTableFilterTypeCached(table, tableName, cacheCtx, singularTypes);
+  const order = withOrder ? generateTableOrderTypeCached(table, tableName, typeNameMapper, cacheCtx) : void 0;
+  const filters = generateTableFilterTypeCached(table, tableName, cacheCtx, typeNameMapper);
   const tableFields = generateTableSelectTypeFieldsCached(table, tableName);
   const relationsForTable = relationMap[tableName];
   const relationEntries = relationsForTable ? Object.entries(relationsForTable) : [];
+  if (relationsDepthLimit !== void 0 && currentDepth >= relationsDepthLimit) {
+    return {
+      order,
+      filters,
+      tableFields,
+      relationFields: {}
+    };
+  }
   if (usedTables.has(tableName)) {
     return {
       order,
@@ -697,7 +859,7 @@ var generateSelectFields = (tables, tableName, relationMap, fromTableName, fromR
     cacheCtx.relationFieldContainers.set(tableName, container);
   }
   if (isRootCall && !cacheCtx.objectTypeCache.has(tableName)) {
-    const typeName = toTypeName(tableName, singularTypes);
+    const typeName = resolveTypeName(tableName, typeNameMapper);
     const shell = new GraphQLObjectType2({
       name: typeName,
       fields: () => ({ ...tableFields, ...container.fields })
@@ -711,7 +873,7 @@ var generateSelectFields = (tables, tableName, relationMap, fromTableName, fromR
     for (const [relationName, relEntry] of relationEntries) {
       const { targetTableName } = relEntry;
       const relation = relEntry.relation ?? relEntry;
-      const isOne = is2(relation, One);
+      const isOne = is3(relation, One2);
       const relSelectData = generateSelectFields(
         tables,
         targetTableName,
@@ -721,10 +883,12 @@ var generateSelectFields = (tables, tableName, relationMap, fromTableName, fromR
         relationName,
         // fromRelationName for the relation type
         !isOne,
-        void 0,
+        relationsDepthLimit,
         cacheCtx,
-        singularTypes,
-        nextUsedTables
+        typeNameMapper,
+        nextUsedTables,
+        resolverFactory,
+        currentDepth + 1
       );
       let relType = cacheCtx.objectTypeCache.get(targetTableName);
       if (!relType) {
@@ -737,11 +901,12 @@ var generateSelectFields = (tables, tableName, relationMap, fromTableName, fromR
         }
         const capturedTargetContainer = targetContainer;
         relType = new GraphQLObjectType2({
-          name: toTypeName(targetTableName, singularTypes),
+          name: resolveTypeName(targetTableName, typeNameMapper),
           fields: () => ({ ...targetTableFields, ...capturedTargetContainer.fields })
         });
         cacheCtx.objectTypeCache.set(targetTableName, relType);
       }
+      const resolve = resolverFactory?.({ tableName, relationName, relEntry, isOne });
       if (isOne) {
         rawRelationFields.push([
           relationName,
@@ -749,7 +914,8 @@ var generateSelectFields = (tables, tableName, relationMap, fromTableName, fromR
             type: relType,
             args: {
               where: { type: relSelectData.filters }
-            }
+            },
+            resolve
           }
         ]);
         continue;
@@ -763,7 +929,8 @@ var generateSelectFields = (tables, tableName, relationMap, fromTableName, fromR
             orderBy: { type: relSelectData.order },
             offset: { type: GraphQLInt2 },
             limit: { type: GraphQLInt2 }
-          }
+          },
+          resolve
         }
       ]);
     }
@@ -789,7 +956,7 @@ var generateSelectFields = (tables, tableName, relationMap, fromTableName, fromR
     relationFields: {}
   };
 };
-var generateTableTypes = (tableName, tables, relationMap, withReturning, relationsDepthLimit, cacheCtx, singularTypes = false, insertPrefix = "insertInto", updatePrefix = "update") => {
+var generateTableTypes = (tableName, tables, relationMap, withReturning, relationsDepthLimit, cacheCtx, typeNameMapper = void 0, insertPrefix = "create", updatePrefix = "update", resolverFactory) => {
   const { tableFields, relationFields, filters, order } = generateSelectFields(
     tables,
     tableName,
@@ -801,12 +968,14 @@ var generateTableTypes = (tableName, tables, relationMap, withReturning, relatio
     true,
     relationsDepthLimit,
     cacheCtx,
-    singularTypes
+    typeNameMapper,
+    /* @__PURE__ */ new Set(),
+    resolverFactory,
+    0
   );
   const table = tables[tableName];
-  const columns = getColumns2(table);
+  const columns = getColumns(table);
   const columnEntries = Object.entries(columns);
-  const _insertNested = drizzleRelationToGraphQLInsertType(tables, relationMap[tableName] ?? {});
   const insertFields = Object.fromEntries(
     columnEntries.map(([columnName, columnDescription]) => [
       columnName,
@@ -820,15 +989,15 @@ var generateTableTypes = (tableName, tables, relationMap, withReturning, relatio
     ])
   );
   const insertInput = new GraphQLInputObjectType2({
-    name: `${capitalize(insertPrefix)}${toTypeName(tableName, singularTypes)}Input`,
+    name: `${capitalize(insertPrefix)}${resolveTypeName(tableName, typeNameMapper)}Input`,
     fields: insertFields
   });
   const updateInput = new GraphQLInputObjectType2({
-    name: `${capitalize(updatePrefix)}${toTypeName(tableName, singularTypes)}Input`,
+    name: `${capitalize(updatePrefix)}${resolveTypeName(tableName, typeNameMapper)}Input`,
     fields: updateFields
   });
   const selectSingleOutput = cacheCtx.objectTypeCache.get(tableName) ?? new GraphQLObjectType2({
-    name: toTypeName(tableName, singularTypes),
+    name: resolveTypeName(tableName, typeNameMapper),
     fields: { ...tableFields, ...relationFields }
   });
   const selectArrOutput = new GraphQLNonNull2(new GraphQLList2(new GraphQLNonNull2(selectSingleOutput)));
@@ -866,7 +1035,7 @@ var extractOrderBy = (table, orderArgs) => {
       continue;
     }
     const { direction } = config;
-    res.push(direction === "asc" ? asc(getColumns2(table)[column]) : desc(getColumns2(table)[column]));
+    res.push(direction === "asc" ? asc(getColumns(table)[column]) : desc(getColumns(table)[column]));
   }
   return res;
 };
@@ -888,55 +1057,28 @@ var extractFiltersColumn = (column, columnName, operators) => {
     }
     return variants2.length ? variants2.length > 1 ? or(...variants2) : variants2[0] : void 0;
   }
+  const singleValueOps = { eq, ne, gt, gte, lt, lte };
+  const stringValueOps = { like, notLike, ilike, notIlike };
+  const arrayValueOps = { inArray, notInArray };
+  const nullableOps = { isNull, isNotNull };
   const variants = [];
   for (const [operatorName, operatorValue] of entries) {
     if (operatorValue === null || operatorValue === false) {
       continue;
     }
-    let operator;
-    switch (operatorName) {
-      case "eq":
-        operator = operator ?? eq;
-      case "ne":
-        operator = operator ?? ne;
-      case "gt":
-        operator = operator ?? gt;
-      case "gte":
-        operator = operator ?? gte;
-      case "lt":
-        operator = operator ?? lt;
-      case "lte": {
-        operator = operator ?? lte;
-        const singleValue = remapFromGraphQLCore(operatorValue, column, columnName);
-        variants.push(operator(column, singleValue));
-        break;
-      }
-      case "like":
-        operator = operator ?? like;
-      case "notLike":
-        operator = operator ?? notLike;
-      case "ilike":
-        operator = operator ?? ilike;
-      case "notIlike":
-        operator = operator ?? notIlike;
-        variants.push(operator(column, operatorValue));
-        break;
-      case "inArray":
-        operator = operator ?? inArray;
-      case "notInArray": {
-        operator = operator ?? notInArray;
-        if (!operatorValue.length) {
-          throw new GraphQLError2(`WHERE ${columnName}: Unable to use operator ${operatorName} with an empty array!`);
-        }
-        const arrayValue = operatorValue.map((val) => remapFromGraphQLCore(val, column, columnName));
-        variants.push(operator(column, arrayValue));
-        break;
+    if (operatorName in singleValueOps) {
+      const singleValue = remapFromGraphQLCore(operatorValue, column, columnName);
+      variants.push(singleValueOps[operatorName](column, singleValue));
+    } else if (operatorName in stringValueOps) {
+      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!`);
       }
-      case "isNull":
-        operator = operator ?? isNull;
-      case "isNotNull":
-        operator = operator ?? isNotNull;
-        variants.push(operator(column));
+      const arrayValue = operatorValue.map((val) => remapFromGraphQLCore(val, column, columnName));
+      variants.push(arrayValueOps[operatorName](column, arrayValue));
+    } else if (operatorName in nullableOps) {
+      variants.push(nullableOps[operatorName](column));
     }
   }
   return variants.length ? variants.length > 1 ? and(...variants) : variants[0] : void 0;
@@ -967,12 +1109,12 @@ var extractFilters = (table, tableName, filters) => {
     if (operators === null) {
       continue;
     }
-    const column = getColumns2(table)[columnName];
+    const column = getColumns(table)[columnName];
     variants.push(extractFiltersColumn(column, columnName, operators));
   }
   return variants.length ? variants.length > 1 ? and(...variants) : variants[0] : void 0;
 };
-var extractRelationsParamsInner = (relationMap, tables, tableName, typeName, originField, singularTypes = false, _isInitial = false) => {
+var extractRelationsParamsInner = (relationMap, tables, tableName, typeName, originField, typeNameMapper, _isInitial = false) => {
   const relationsForTable = relationMap[tableName];
   if (!relationsForTable) {
     return void 0;
@@ -982,8 +1124,9 @@ var extractRelationsParamsInner = (relationMap, tables, tableName, typeName, ori
     return void 0;
   }
   const args = {};
-  for (const [relName, { targetTableName }] of Object.entries(relationsForTable)) {
-    const relTypeName = toTypeName(targetTableName, singularTypes);
+  for (const [relName, relEntry] of Object.entries(relationsForTable)) {
+    const { targetTableName, targetPkNames } = relEntry;
+    const relTypeName = resolveTypeName(targetTableName, typeNameMapper);
     const field = baseField[relName] ?? Object.values(baseField).find((f) => f.name === relName);
     if (!field) {
       continue;
@@ -1002,140 +1145,279 @@ var extractRelationsParamsInner = (relationMap, tables, tableName, typeName, ori
     const limit = relationArgs?.limit ?? void 0;
     const relWhere = relationArgs?.where;
     thisRecord.where = relWhere ? { RAW: (aliasedTable) => extractFilters(aliasedTable, relName, relWhere) } : void 0;
-    thisRecord.orderBy = relationArgs?.orderBy ? (aliasedTable) => extractOrderBy(aliasedTable, relationArgs.orderBy) : 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.offset = offset;
     thisRecord.limit = limit;
-    const relWith = relationField ? extractRelationsParamsInner(relationMap, tables, targetTableName, relTypeName, relationField, singularTypes) : void 0;
+    const relWith = relationField ? extractRelationsParamsInner(relationMap, tables, targetTableName, relTypeName, relationField, typeNameMapper) : void 0;
     thisRecord.with = relWith;
     args[relName] = thisRecord;
   }
   return args;
 };
-var extractRelationsParams = (relationMap, tables, tableName, info, typeName, singularTypes = false) => {
+var extractRelationsParams = (relationMap, tables, tableName, info, typeName, typeNameMapper) => {
   if (!info) {
     return void 0;
   }
-  return extractRelationsParamsInner(relationMap, tables, tableName, typeName, info, singularTypes, true);
+  return extractRelationsParamsInner(relationMap, tables, tableName, typeName, info, typeNameMapper, true);
+};
+var pruneNonEagerRelations = (relationMap, shouldEagerLoad) => {
+  const out = {};
+  for (const [tableName, rels] of Object.entries(relationMap)) {
+    out[tableName] = Object.fromEntries(
+      Object.entries(rels).filter(([relationName]) => shouldEagerLoad(tableName, relationName))
+    );
+  }
+  return out;
+};
+var getPrimaryKeyPropNames = (table, compositePkColumnNames) => {
+  const cols = getColumns(table);
+  const entries = Object.entries(cols);
+  const inlinePks = entries.filter(([, c]) => c.primary).map(([k]) => k);
+  if (inlinePks.length) {
+    return inlinePks;
+  }
+  if (compositePkColumnNames?.length) {
+    const wanted = new Set(compositePkColumnNames);
+    const fromComposite = entries.filter(([, c]) => wanted.has(c.name)).map(([k]) => k);
+    if (fromComposite.length) {
+      return fromComposite;
+    }
+  }
+  return [];
+};
+var withPrimaryKeyColumns = (columns, table, pkNames) => {
+  const allCols = getColumns(table);
+  for (const pk of pkNames) {
+    if (!(pk in columns) && allCols[pk]) {
+      columns[pk] = allCols[pk];
+    }
+  }
+  return columns;
+};
+var getPrimaryKeyPropNamesFromConfig = (table, getTableConfig4) => {
+  const compositePkColumnNames = getTableConfig4(table).primaryKeys.flatMap((pk) => pk.columns.map((c) => c.name));
+  return getPrimaryKeyPropNames(table, compositePkColumnNames);
+};
+var primaryKeyOrderExprs = (table, pkNames) => {
+  const cols = getColumns(table);
+  return pkNames.map((n) => cols[n]).filter(Boolean).map((col) => asc(col));
+};
+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 columns = hasRelations ? withPrimaryKeyColumns(baseColumns, table, pkNames) : baseColumns;
+  return { columns, hasRelations, withParams };
+};
+var toGraphQLError = (e) => e instanceof Error ? new GraphQLError2(e.message) : e;
+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 createArrayFieldName = `${prefixes.insert}${mapped ? capitalize(mapped.plural) : capitalize(tableName)}`;
+  const createSingleFieldName = mapped ? `${prefixes.insert}${capitalize(mapped.singular)}` : `${prefixes.insert}${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,
+    createArrayFieldName,
+    createSingleFieldName,
+    updateFieldName,
+    deleteFieldName
+  };
+};
+var selectArrayArgs = (orderArgs, filterArgs) => ({
+  offset: { type: GraphQLInt2 },
+  limit: { type: GraphQLInt2 },
+  orderBy: { type: orderArgs },
+  where: { type: filterArgs }
+});
+var selectSingleArgs = (orderArgs, filterArgs) => ({
+  offset: { type: GraphQLInt2 },
+  orderBy: { type: orderArgs },
+  where: { type: filterArgs }
+});
+var runRelationalSelect = async (opts) => {
+  const {
+    queryBase,
+    tables,
+    tableName,
+    table,
+    relationMap,
+    typeName,
+    typeNameMapper,
+    parsedInfo,
+    offset,
+    orderBy,
+    where,
+    single
+  } = opts;
+  const params = {
+    columns: extractSelectedColumnsFromTree(parsedInfo.fieldsByTypeName[typeName], table),
+    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
+  };
+  if (single) {
+    const result2 = await queryBase.findFirst(params);
+    return result2 ? remapToGraphQLSingleOutput(result2, tableName, table, relationMap) : void 0;
+  }
+  params.limit = opts.limit;
+  const result = await queryBase.findMany(params);
+  return remapToGraphQLArrayOutput(result, tableName, table, relationMap);
+};
+var eagerLoadMutationRelations = async (db, tableName, rows, pkNames, withParams) => {
+  if (!rows.length || !pkNames.length || !withParams || !Object.keys(withParams).length) {
+    return rows;
+  }
+  const queryBase = db.query?.[tableName];
+  if (!queryBase) {
+    return rows;
+  }
+  const keyableRows = rows.filter((row) => pkNames.every((n) => row[n] != null));
+  if (!keyableRows.length) {
+    return rows;
+  }
+  const pkColumns = {};
+  for (const pk of pkNames) {
+    pkColumns[pk] = true;
+  }
+  const relationNames = Object.keys(withParams);
+  const keyOf = (row) => JSON.stringify(pkNames.map((n) => typeof row[n] === "bigint" ? row[n].toString() : row[n]));
+  let whereRaw;
+  if (pkNames.length === 1) {
+    const pkName = pkNames[0];
+    const ids = keyableRows.map((r) => r[pkName]);
+    whereRaw = (aliased) => inArray(aliased[pkName], ids);
+  } else {
+    whereRaw = (aliased) => {
+      const lhs = sql.join(
+        pkNames.map((n) => sql`${aliased[n]}`),
+        sql`, `
+      );
+      const tuples = sql.join(
+        keyableRows.map(
+          (row) => sql`(${sql.join(
+            pkNames.map((n) => sql`${row[n]}`),
+            sql`, `
+          )})`
+        ),
+        sql`, `
+      );
+      return sql`(${lhs}) in (${tuples})`;
+    };
+  }
+  let enriched;
+  try {
+    enriched = await queryBase.findMany({
+      columns: pkColumns,
+      where: { RAW: whereRaw },
+      with: withParams
+    });
+  } catch (err) {
+    console.warn(
+      `[drizzle-graphql] eager-loading relations for a "${tableName}" mutation failed; falling back to lazy resolution.`,
+      err
+    );
+    return rows;
+  }
+  const byKey = new Map(enriched.map((e) => [keyOf(e), e]));
+  for (const row of rows) {
+    const match = byKey.get(keyOf(row));
+    if (!match) {
+      continue;
+    }
+    for (const rel of relationNames) {
+      row[rel] = match[rel];
+    }
+  }
+  return rows;
 };
 
 // src/util/builders/mysql.ts
-var toTypeName2 = (name, singular) => singular ? capitalize(singularize(name)) : capitalize(name);
-var generateSelectArray = (db, tableName, tables, relationMap, orderArgs, filterArgs, listSuffix, singularTypes) => {
-  const queryName = `${uncapitalize(tableName)}${listSuffix}`;
+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?`
     );
   }
-  const queryArgs = {
-    offset: {
-      type: GraphQLInt3
-    },
-    limit: {
-      type: GraphQLInt3
-    },
-    orderBy: {
-      type: orderArgs
-    },
-    where: {
-      type: filterArgs
-    }
-  };
-  const typeName = toTypeName2(tableName, singularTypes);
+  const queryArgs = selectArrayArgs(orderArgs, filterArgs);
   const table = tables[tableName];
   return {
-    name: queryName,
+    name: fieldName,
     resolver: async (_source, args, _context, info) => {
       try {
-        const { offset, limit, orderBy, where } = args;
-        const parsedInfo = parseResolveInfo(info, {
-          deep: true
-        });
-        const query = queryBase.findMany({
-          columns: extractSelectedColumnsFromTree(parsedInfo.fieldsByTypeName[typeName], table),
-          offset,
-          limit,
-          // drizzle-orm v1 RQB calls orderBy 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: (aliased) => extractFilters(aliased, tableName, where) } : void 0,
-          with: relationMap[tableName] ? extractRelationsParams(relationMap, tables, tableName, parsedInfo, typeName, singularTypes) : void 0
+        const parsedInfo = parseResolveInfo(info, { deep: true });
+        return await runRelationalSelect({
+          queryBase,
+          tables,
+          tableName,
+          table,
+          relationMap,
+          typeName,
+          typeNameMapper,
+          parsedInfo,
+          ...args,
+          single: false
         });
-        const result = await query;
-        return remapToGraphQLArrayOutput(result, tableName, table, relationMap);
       } catch (e) {
-        if (e instanceof Error) {
-          throw new GraphQLError3(e.message);
-        }
-        throw e;
+        throw toGraphQLError(e);
       }
     },
     args: queryArgs
   };
 };
-var generateSelectSingle = (db, tableName, tables, relationMap, orderArgs, filterArgs, singleSuffix, singularTypes) => {
-  const queryName = `${uncapitalize(tableName)}${singleSuffix}`;
+var generateSelectSingle = (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?`
     );
   }
-  const queryArgs = {
-    offset: {
-      type: GraphQLInt3
-    },
-    orderBy: {
-      type: orderArgs
-    },
-    where: {
-      type: filterArgs
-    }
-  };
-  const typeName = toTypeName2(tableName, singularTypes);
+  const queryArgs = selectSingleArgs(orderArgs, filterArgs);
   const table = tables[tableName];
   return {
-    name: queryName,
+    name: fieldName,
     resolver: async (_source, args, _context, info) => {
       try {
-        const { offset, orderBy, where } = args;
-        const parsedInfo = parseResolveInfo(info, {
-          deep: true
+        const parsedInfo = parseResolveInfo(info, { deep: true });
+        return await runRelationalSelect({
+          queryBase,
+          tables,
+          tableName,
+          table,
+          relationMap,
+          typeName,
+          typeNameMapper,
+          parsedInfo,
+          ...args,
+          single: true
         });
-        const query = queryBase.findFirst({
-          columns: extractSelectedColumnsFromTree(parsedInfo.fieldsByTypeName[typeName], table),
-          offset,
-          // drizzle-orm v1 RQB calls orderBy 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: (aliased) => extractFilters(aliased, tableName, where) } : void 0,
-          with: relationMap[tableName] ? extractRelationsParams(relationMap, tables, tableName, parsedInfo, typeName, singularTypes) : void 0
-        });
-        const result = await query;
-        if (!result) {
-          return void 0;
-        }
-        return remapToGraphQLSingleOutput(result, tableName, table, relationMap);
       } catch (e) {
-        if (e instanceof Error) {
-          throw new GraphQLError3(e.message);
-        }
-        throw e;
+        throw toGraphQLError(e);
       }
     },
     args: queryArgs
   };
 };
-var generateInsertArray = (db, tableName, table, baseType) => {
-  const queryName = `insertInto${capitalize(tableName)}`;
+var generateInsertArray = (db, _tableName, table, baseType, fieldName) => {
   const queryArgs = {
     values: {
       type: new GraphQLNonNull3(new GraphQLList3(new GraphQLNonNull3(baseType)))
     }
   };
   return {
-    name: queryName,
+    name: fieldName,
     resolver: async (_source, args, _context, _info) => {
       try {
         const input = remapFromGraphQLArrayInput(args.values, table);
@@ -1145,41 +1427,33 @@ var generateInsertArray = (db, tableName, table, baseType) => {
         await db.insert(table).values(input);
         return { isSuccess: true };
       } catch (e) {
-        if (e instanceof Error) {
-          throw new GraphQLError3(e.message);
-        }
-        throw e;
+        throw toGraphQLError(e);
       }
     },
     args: queryArgs
   };
 };
-var generateInsertSingle = (db, tableName, table, baseType) => {
-  const queryName = `insertInto${capitalize(tableName)}Single`;
+var generateInsertSingle = (db, _tableName, table, baseType, fieldName) => {
   const queryArgs = {
     values: {
       type: new GraphQLNonNull3(baseType)
     }
   };
   return {
-    name: queryName,
+    name: fieldName,
     resolver: async (_source, args, _context, _info) => {
       try {
         const input = remapFromGraphQLSingleInput(args.values, table);
         await db.insert(table).values(input);
         return { isSuccess: true };
       } catch (e) {
-        if (e instanceof Error) {
-          throw new GraphQLError3(e.message);
-        }
-        throw e;
+        throw toGraphQLError(e);
       }
     },
     args: queryArgs
   };
 };
-var generateUpdate = (db, tableName, table, setArgs, filterArgs) => {
-  const queryName = `update${capitalize(tableName)}`;
+var generateUpdate = (db, tableName, table, setArgs, filterArgs, fieldName) => {
   const queryArgs = {
     set: {
       type: new GraphQLNonNull3(setArgs)
@@ -1189,7 +1463,7 @@ var generateUpdate = (db, tableName, table, setArgs, filterArgs) => {
     }
   };
   return {
-    name: queryName,
+    name: fieldName,
     resolver: async (_source, args, _context, _info) => {
       try {
         const { where, set } = args;
@@ -1205,24 +1479,20 @@ var generateUpdate = (db, tableName, table, setArgs, filterArgs) => {
         await query;
         return { isSuccess: true };
       } catch (e) {
-        if (e instanceof Error) {
-          throw new GraphQLError3(e.message);
-        }
-        throw e;
+        throw toGraphQLError(e);
       }
     },
     args: queryArgs
   };
 };
-var generateDelete = (db, tableName, table, filterArgs) => {
-  const queryName = `deleteFrom${capitalize(tableName)}`;
+var generateDelete = (db, tableName, table, filterArgs, fieldName) => {
   const queryArgs = {
     where: {
       type: filterArgs
     }
   };
   return {
-    name: queryName,
+    name: fieldName,
     resolver: async (_source, args, _context, _info) => {
       try {
         const { where } = args;
@@ -1234,64 +1504,35 @@ var generateDelete = (db, tableName, table, filterArgs) => {
         await query;
         return { isSuccess: true };
       } catch (e) {
-        if (e instanceof Error) {
-          throw new GraphQLError3(e.message);
-        }
-        throw e;
+        throw toGraphQLError(e);
       }
     },
     args: queryArgs
   };
 };
-var buildNamedRelations2 = (relations, tableEntries) => {
-  const namedRelations = {};
-  for (const [relTableName, relConfig] of Object.entries(relations)) {
-    if (!relConfig?.relations) {
-      continue;
-    }
-    const namedConfig = {};
-    for (const [innerRelName, innerRelValue] of Object.entries(relConfig.relations)) {
-      const targetTable = innerRelValue.targetTable ?? innerRelValue.referencedTable;
-      const directTargetName = innerRelValue.targetTableName;
-      let targetTableName;
-      if (directTargetName) {
-        const targetEntry = tableEntries.find(([key]) => key === directTargetName);
-        targetTableName = targetEntry?.[0];
-      } else if (targetTable) {
-        const targetEntry = tableEntries.find(([, tableValue]) => tableValue === targetTable);
-        targetTableName = targetEntry?.[0];
-      }
-      if (!targetTableName) {
-        continue;
-      }
-      namedConfig[innerRelName] = {
-        relation: innerRelValue,
-        targetTableName
-      };
-    }
-    if (Object.keys(namedConfig).length > 0) {
-      namedRelations[relTableName] = namedConfig;
-    }
-  }
-  return namedRelations;
-};
-var generateSchemaData = (db, schema, relations, relationsDepthLimit, prefixes, suffixes, singularTypes = false) => {
+var mysqlPrimaryKeyPropNames = (table) => getPrimaryKeyPropNamesFromConfig(table, getTableConfig);
+var generateSchemaData = (db, schema, relations, relationsDepthLimit, prefixes, suffixes, typeNameMapper, shouldEagerLoad = () => true) => {
   const rawSchema = schema;
   const schemaEntries = Object.entries(rawSchema);
-  const tableEntries = schemaEntries.filter(([_key, value]) => is3(value, MySqlTable));
+  const tableEntries = schemaEntries.filter(([_key, value]) => is4(value, MySqlTable));
   const tables = Object.fromEntries(tableEntries);
   if (!tableEntries.length) {
     throw new Error(
       "Drizzle-GraphQL Error: No tables detected in Drizzle-ORM's database instance. Did you forget to pass schema to drizzle constructor?"
     );
   }
-  const namedRelations = buildNamedRelations2(relations ?? {}, tableEntries);
+  const namedRelations = buildNamedRelations(relations ?? {}, tableEntries);
+  attachTargetPrimaryKeys(namedRelations, tables, mysqlPrimaryKeyPropNames);
+  const eagerRelations = pruneNonEagerRelations(namedRelations, shouldEagerLoad);
+  const resolverFactory = createRelationResolverFactory(db, tables);
   const cacheCtx = {
     genericFilterCache: /* @__PURE__ */ new Map(),
     objectTypeCache: /* @__PURE__ */ new Map(),
     relationFieldContainers: /* @__PURE__ */ new Map(),
     fullyBuiltTables: /* @__PURE__ */ new Set(),
-    relationTypeCache: /* @__PURE__ */ new Map()
+    relationTypeCache: /* @__PURE__ */ new Map(),
+    orderTypeCache: /* @__PURE__ */ new WeakMap(),
+    filterTypeCache: /* @__PURE__ */ new WeakMap()
   };
   const queries = {};
   const mutations = {};
@@ -1305,9 +1546,10 @@ var generateSchemaData = (db, schema, relations, relationsDepthLimit, prefixes,
         false,
         relationsDepthLimit,
         cacheCtx,
-        singularTypes,
+        typeNameMapper,
         prefixes.insert,
-        prefixes.update
+        prefixes.update,
+        resolverFactory
       )
     ])
   );
@@ -1326,30 +1568,66 @@ var generateSchemaData = (db, schema, relations, relationsDepthLimit, prefixes,
   for (const [tableName, tableTypes] of Object.entries(gqlSchemaTypes)) {
     const { insertInput, updateInput, tableFilters, tableOrder } = tableTypes.inputs;
     const { selectSingleOutput, selectArrOutput } = tableTypes.outputs;
+    const {
+      typeName,
+      listFieldName,
+      singleFieldName,
+      createArrayFieldName,
+      createSingleFieldName,
+      updateFieldName,
+      deleteFieldName
+    } = computeResolverFieldNames(tableName, typeNameMapper, prefixes, suffixes);
     const selectArrGenerated = generateSelectArray(
       db,
       tableName,
       tables,
-      namedRelations,
+      eagerRelations,
       tableOrder,
       tableFilters,
-      suffixes.list,
-      singularTypes
+      listFieldName,
+      typeName,
+      typeNameMapper
     );
     const selectSingleGenerated = generateSelectSingle(
       db,
       tableName,
       tables,
-      namedRelations,
+      eagerRelations,
       tableOrder,
       tableFilters,
-      suffixes.single,
-      singularTypes
+      singleFieldName,
+      typeName,
+      typeNameMapper
+    );
+    const insertArrGenerated = generateInsertArray(
+      db,
+      tableName,
+      schema[tableName],
+      insertInput,
+      createArrayFieldName
+    );
+    const insertSingleGenerated = generateInsertSingle(
+      db,
+      tableName,
+      schema[tableName],
+      insertInput,
+      createSingleFieldName
+    );
+    const updateGenerated = generateUpdate(
+      db,
+      tableName,
+      schema[tableName],
+      updateInput,
+      tableFilters,
+      updateFieldName
+    );
+    const deleteGenerated = generateDelete(
+      db,
+      tableName,
+      schema[tableName],
+      tableFilters,
+      deleteFieldName
     );
-    const insertArrGenerated = generateInsertArray(db, tableName, schema[tableName], insertInput);
-    const insertSingleGenerated = generateInsertSingle(db, tableName, schema[tableName], insertInput);
-    const updateGenerated = generateUpdate(db, tableName, schema[tableName], updateInput, tableFilters);
-    const deleteGenerated = generateDelete(db, tableName, schema[tableName], tableFilters);
     queries[selectArrGenerated.name] = {
       type: selectArrOutput,
       args: selectArrGenerated.args,
@@ -1385,164 +1663,139 @@ var generateSchemaData = (db, schema, relations, relationsDepthLimit, prefixes,
     });
     outputs[selectSingleOutput.name] = selectSingleOutput;
   }
-  return { queries, mutations, inputs, types: outputs };
+  const fieldResolvers = {};
+  for (const [tableName, tableRelations] of Object.entries(namedRelations)) {
+    const relResolvers = {};
+    for (const [relName, relEntry] of Object.entries(tableRelations)) {
+      const isOne = is4(relEntry.relation ?? relEntry, One3);
+      const resolver = resolverFactory({ tableName, relationName: relName, relEntry, isOne });
+      if (resolver) {
+        relResolvers[relName] = resolver;
+      }
+    }
+    if (Object.keys(relResolvers).length > 0) {
+      fieldResolvers[tableName] = relResolvers;
+    }
+  }
+  return { queries, mutations, inputs, types: outputs, fieldResolvers };
 };
 
 // src/util/builders/pg.ts
-import { is as is4 } from "drizzle-orm";
-import { PgTable } from "drizzle-orm/pg-core";
+import { is as is5, One as One4 } from "drizzle-orm";
+import { getTableConfig as getTableConfig2, PgTable } from "drizzle-orm/pg-core";
 import {
   GraphQLError as GraphQLError4,
-  GraphQLInt as GraphQLInt4,
   GraphQLList as GraphQLList4,
   GraphQLNonNull as GraphQLNonNull4
 } from "graphql";
 import { parseResolveInfo as parseResolveInfo2 } from "graphql-parse-resolve-info";
-var toTypeName3 = (name, singular) => singular ? capitalize(singularize(name)) : capitalize(name);
-var generateSelectArray2 = (db, tableName, tables, relationMap, orderArgs, filterArgs, listSuffix, singularTypes) => {
-  const queryEntityBase = singularTypes ? singularize(uncapitalize(tableName)) : uncapitalize(tableName);
-  const queryName = `${queryEntityBase}${listSuffix}`;
+var generateSelectArray2 = (db, tableName, tables, relationMap, orderArgs, filterArgs, fieldName, typeName, typeNameMapper) => {
   const queryBase = db.query[tableName];
-  const queryArgs = {
-    offset: {
-      type: GraphQLInt4
-    },
-    limit: {
-      type: GraphQLInt4
-    },
-    orderBy: {
-      type: orderArgs
-    },
-    where: {
-      type: filterArgs
-    }
-  };
-  const typeName = toTypeName3(tableName, singularTypes);
+  const queryArgs = selectArrayArgs(orderArgs, filterArgs);
   const table = tables[tableName];
   return {
-    name: queryName,
+    name: fieldName,
     resolver: async (_source, args, _context, info) => {
       try {
-        const { offset, limit, orderBy, where } = args;
-        const parsedInfo = parseResolveInfo2(info, {
-          deep: true
-        });
-        const selectedColumns = extractSelectedColumnsFromTree(parsedInfo.fieldsByTypeName[typeName], table);
-        let result;
+        const parsedInfo = parseResolveInfo2(info, { deep: true });
         if (queryBase) {
-          const withParams = relationMap[tableName] ? extractRelationsParams(relationMap, tables, tableName, parsedInfo, typeName, singularTypes) : void 0;
-          result = await queryBase.findMany({
-            columns: selectedColumns,
-            offset,
-            limit,
-            // drizzle-orm v1 RQB calls orderBy with the aliased table proxy (e.g.
-            // d0, d1) — use it directly so column refs match the CTE alias.
-            orderBy: orderBy ? (aliasedTable) => extractOrderBy(aliasedTable, orderBy) : void 0,
-            where: where ? { RAW: (aliased) => extractFilters(aliased, tableName, where) } : void 0,
-            with: withParams
+          return await runRelationalSelect({
+            queryBase,
+            tables,
+            tableName,
+            table,
+            relationMap,
+            typeName,
+            typeNameMapper,
+            parsedInfo,
+            ...args,
+            single: false
           });
-        } else {
-          let q = db.select(selectedColumns).from(table);
-          if (where) {
-            q = q.where(extractFilters(table, tableName, where));
-          }
-          if (orderBy) {
-            q = q.orderBy(...extractOrderBy(table, orderBy));
-          }
-          if (offset) {
-            q = q.offset(offset);
-          }
-          if (limit) {
-            q = q.limit(limit);
-          }
-          result = await q;
         }
-        return remapToGraphQLArrayOutput(result, tableName, table, relationMap);
-      } catch (e) {
-        if (e instanceof Error) {
-          throw new GraphQLError4(e.message);
+        const { offset, limit, orderBy, where } = args;
+        const selectedColumnsSql = extractSelectedColumnsFromTreeSQLFormat(
+          parsedInfo.fieldsByTypeName[typeName],
+          table
+        );
+        let q = db.select(selectedColumnsSql).from(table);
+        if (where) {
+          q = q.where(extractFilters(table, tableName, where));
+        }
+        if (orderBy) {
+          q = q.orderBy(...extractOrderBy(table, orderBy));
+        }
+        if (offset) {
+          q = q.offset(offset);
         }
-        throw e;
+        if (limit) {
+          q = q.limit(limit);
+        }
+        return remapToGraphQLArrayOutput(await q, tableName, table, relationMap);
+      } catch (e) {
+        throw toGraphQLError(e);
       }
     },
     args: queryArgs
   };
 };
-var generateSelectSingle2 = (db, tableName, tables, relationMap, orderArgs, filterArgs, singleSuffix, singularTypes) => {
-  const queryEntityBase = singularTypes ? singularize(uncapitalize(tableName)) : uncapitalize(tableName);
-  const queryName = `${queryEntityBase}${singleSuffix}`;
+var generateSelectSingle2 = (db, tableName, tables, relationMap, orderArgs, filterArgs, fieldName, typeName, typeNameMapper) => {
   const queryBase = db.query[tableName];
-  const queryArgs = {
-    offset: {
-      type: GraphQLInt4
-    },
-    orderBy: {
-      type: orderArgs
-    },
-    where: {
-      type: filterArgs
-    }
-  };
-  const typeName = toTypeName3(tableName, singularTypes);
+  const queryArgs = selectSingleArgs(orderArgs, filterArgs);
   const table = tables[tableName];
   return {
-    name: queryName,
+    name: fieldName,
     resolver: async (_source, args, _context, info) => {
       try {
-        const { offset, orderBy, where } = args;
-        const parsedInfo = parseResolveInfo2(info, {
-          deep: true
-        });
-        const selectedColumns = extractSelectedColumnsFromTree(parsedInfo.fieldsByTypeName[typeName], table);
-        let result;
+        const parsedInfo = parseResolveInfo2(info, { deep: true });
         if (queryBase) {
-          result = await queryBase.findFirst({
-            columns: selectedColumns,
-            offset,
-            // drizzle-orm v1 RQB calls orderBy with the aliased table proxy (e.g.
-            // d0, d1) — use it directly so column refs match the CTE alias.
-            orderBy: orderBy ? (aliasedTable) => extractOrderBy(aliasedTable, orderBy) : void 0,
-            where: where ? { RAW: (aliased) => extractFilters(aliased, tableName, where) } : void 0,
-            with: relationMap[tableName] ? extractRelationsParams(relationMap, tables, tableName, parsedInfo, typeName, singularTypes) : void 0
+          return await runRelationalSelect({
+            queryBase,
+            tables,
+            tableName,
+            table,
+            relationMap,
+            typeName,
+            typeNameMapper,
+            parsedInfo,
+            ...args,
+            single: true
           });
-        } else {
-          let q = db.select(selectedColumns).from(table);
-          if (where) {
-            q = q.where(extractFilters(table, tableName, where));
-          }
-          if (orderBy) {
-            q = q.orderBy(...extractOrderBy(table, orderBy));
-          }
-          if (offset) {
-            q = q.offset(offset);
-          }
-          const rows = await q.limit(1);
-          result = rows[0];
         }
-        if (!result) {
-          return void 0;
+        const { offset, orderBy, where } = args;
+        const selectedColumnsSql = extractSelectedColumnsFromTreeSQLFormat(
+          parsedInfo.fieldsByTypeName[typeName],
+          table
+        );
+        let q = db.select(selectedColumnsSql).from(table);
+        if (where) {
+          q = q.where(extractFilters(table, tableName, where));
         }
-        return remapToGraphQLSingleOutput(result, tableName, table, relationMap);
-      } catch (e) {
-        if (e instanceof Error) {
-          throw new GraphQLError4(e.message);
+        if (orderBy) {
+          q = q.orderBy(...extractOrderBy(table, orderBy));
         }
-        throw e;
+        if (offset) {
+          q = q.offset(offset);
+        }
+        const rows = await q.limit(1);
+        const result = rows[0];
+        return result ? remapToGraphQLSingleOutput(result, tableName, table, relationMap) : void 0;
+      } catch (e) {
+        throw toGraphQLError(e);
       }
     },
     args: queryArgs
   };
 };
-var generateInsertArray2 = (db, tableName, table, baseType, prefix, conflictDoNothing = false, singularTypes = false) => {
-  const queryName = `${prefix}${capitalize(tableName)}`;
-  const typeName = toTypeName3(tableName, singularTypes);
+var pgPrimaryKeyPropNames = (table) => getPrimaryKeyPropNamesFromConfig(table, getTableConfig2);
+var generateInsertArray2 = (db, tableName, table, tables, relationMap, baseType, fieldName, typeName, typeNameMapper, conflictDoNothing = false) => {
   const queryArgs = {
     values: {
       type: new GraphQLNonNull4(new GraphQLList4(new GraphQLNonNull4(baseType)))
     }
   };
+  const pkNames = pgPrimaryKeyPropNames(table);
   return {
-    name: queryName,
+    name: fieldName,
     resolver: async (_source, args, _context, info) => {
       try {
         const input = remapFromGraphQLArrayInput(args.values, table);
@@ -1552,47 +1805,55 @@ var generateInsertArray2 = (db, tableName, table, baseType, prefix, conflictDoNo
         const parsedInfo = parseResolveInfo2(info, {
           deep: true
         });
-        const columns = extractSelectedColumnsFromTreeSQLFormat(
-          parsedInfo.fieldsByTypeName[typeName],
-          table
-        );
+        const { columns, hasRelations, withParams } = prepareMutationRelationColumns({
+          relationMap,
+          tables,
+          tableName,
+          typeName,
+          typeNameMapper,
+          table,
+          pkNames,
+          parsedInfo
+        });
         let query = db.insert(table).values(input).returning(columns);
         if (conflictDoNothing) {
           query = query.onConflictDoNothing();
         }
         const result = await query;
-        return remapToGraphQLArrayOutput(result, tableName, table);
+        const enriched = hasRelations ? await eagerLoadMutationRelations(db, tableName, result, pkNames, withParams) : result;
+        return remapToGraphQLArrayOutput(enriched, tableName, table, relationMap);
       } catch (e) {
-        if (e instanceof Error) {
-          throw new GraphQLError4(e.message);
-        }
-        throw e;
+        throw toGraphQLError(e);
       }
     },
     args: queryArgs
   };
 };
-var generateInsertSingle2 = (db, tableName, table, baseType, prefix, conflictDoNothing = false, singularTypes = false) => {
-  const queryEntityBase = singularTypes ? singularize(capitalize(tableName)) : capitalize(tableName);
-  const queryName = singularTypes ? `${prefix}${queryEntityBase}` : `${prefix}${queryEntityBase}Single`;
-  const typeName = toTypeName3(tableName, singularTypes);
+var generateInsertSingle2 = (db, tableName, table, tables, relationMap, baseType, fieldName, typeName, typeNameMapper, conflictDoNothing = false) => {
   const queryArgs = {
     values: {
       type: new GraphQLNonNull4(baseType)
     }
   };
+  const pkNames = pgPrimaryKeyPropNames(table);
   return {
-    name: queryName,
+    name: fieldName,
     resolver: async (_source, args, _context, info) => {
       try {
         const input = remapFromGraphQLSingleInput(args.values, table);
         const parsedInfo = parseResolveInfo2(info, {
           deep: true
         });
-        const columns = extractSelectedColumnsFromTreeSQLFormat(
-          parsedInfo.fieldsByTypeName[typeName],
-          table
-        );
+        const { columns, hasRelations, withParams } = prepareMutationRelationColumns({
+          relationMap,
+          tables,
+          tableName,
+          typeName,
+          typeNameMapper,
+          table,
+          pkNames,
+          parsedInfo
+        });
         let query = db.insert(table).values(input).returning(columns);
         if (conflictDoNothing) {
           query = query.onConflictDoNothing();
@@ -1601,20 +1862,16 @@ var generateInsertSingle2 = (db, tableName, table, baseType, prefix, conflictDoN
         if (!result[0]) {
           return void 0;
         }
-        return remapToGraphQLSingleOutput(result[0], tableName, table);
+        const enriched = hasRelations ? await eagerLoadMutationRelations(db, tableName, result, pkNames, withParams) : result;
+        return remapToGraphQLSingleOutput(enriched[0], tableName, table, relationMap);
       } catch (e) {
-        if (e instanceof Error) {
-          throw new GraphQLError4(e.message);
-        }
-        throw e;
+        throw toGraphQLError(e);
       }
     },
     args: queryArgs
   };
 };
-var generateUpdate2 = (db, tableName, table, setArgs, filterArgs, prefix, singularTypes = false) => {
-  const queryName = `${prefix}${capitalize(tableName)}`;
-  const typeName = toTypeName3(tableName, singularTypes);
+var generateUpdate2 = (db, tableName, table, tables, relationMap, setArgs, filterArgs, fieldName, typeName, typeNameMapper) => {
   const queryArgs = {
     set: {
       type: new GraphQLNonNull4(setArgs)
@@ -1623,18 +1880,25 @@ var generateUpdate2 = (db, tableName, table, setArgs, filterArgs, prefix, singul
       type: filterArgs
     }
   };
+  const pkNames = pgPrimaryKeyPropNames(table);
   return {
-    name: queryName,
+    name: fieldName,
     resolver: async (_source, args, _context, info) => {
       try {
         const { where, set } = args;
         const parsedInfo = parseResolveInfo2(info, {
           deep: true
         });
-        const columns = extractSelectedColumnsFromTreeSQLFormat(
-          parsedInfo.fieldsByTypeName[typeName],
-          table
-        );
+        const { columns, hasRelations, withParams } = prepareMutationRelationColumns({
+          relationMap,
+          tables,
+          tableName,
+          typeName,
+          typeNameMapper,
+          table,
+          pkNames,
+          parsedInfo
+        });
         const input = remapFromGraphQLSingleInput(set, table);
         if (!Object.keys(input).length) {
           throw new GraphQLError4("Unable to update with no values specified!");
@@ -1646,27 +1910,23 @@ var generateUpdate2 = (db, tableName, table, setArgs, filterArgs, prefix, singul
         }
         query = query.returning(columns);
         const result = await query;
-        return remapToGraphQLArrayOutput(result, tableName, table);
+        const enriched = hasRelations ? await eagerLoadMutationRelations(db, tableName, result, pkNames, withParams) : result;
+        return remapToGraphQLArrayOutput(enriched, tableName, table, relationMap);
       } catch (e) {
-        if (e instanceof Error) {
-          throw new GraphQLError4(e.message);
-        }
-        throw e;
+        throw toGraphQLError(e);
       }
     },
     args: queryArgs
   };
 };
-var generateDelete2 = (db, tableName, table, filterArgs, prefix, singularTypes = false) => {
-  const queryName = `${prefix}${capitalize(tableName)}`;
-  const typeName = toTypeName3(tableName, singularTypes);
+var generateDelete2 = (db, tableName, table, filterArgs, fieldName, typeName) => {
   const queryArgs = {
     where: {
       type: filterArgs
     }
   };
   return {
-    name: queryName,
+    name: fieldName,
     resolver: async (_source, args, _context, info) => {
       try {
         const { where } = args;
@@ -1686,18 +1946,15 @@ var generateDelete2 = (db, tableName, table, filterArgs, prefix, singularTypes =
         const result = await query;
         return remapToGraphQLArrayOutput(result, tableName, table);
       } catch (e) {
-        if (e instanceof Error) {
-          throw new GraphQLError4(e.message);
-        }
-        throw e;
+        throw toGraphQLError(e);
       }
     },
     args: queryArgs
   };
 };
-function generateSchemaData2(db, schema, relations, relationsDepthLimit, prefixes, suffixes, conflictDoNothing = false, singularTypes = false) {
+function generateSchemaData2(db, schema, relations, relationsDepthLimit, prefixes, suffixes, conflictDoNothing = false, typeNameMapper, shouldEagerLoad = () => true) {
   const schemaEntries = Object.entries(schema);
-  const tableEntries = schemaEntries.filter(([_key, value]) => is4(value, PgTable));
+  const tableEntries = schemaEntries.filter(([_key, value]) => is5(value, PgTable));
   const tables = Object.fromEntries(tableEntries);
   if (!tableEntries.length) {
     throw new Error(
@@ -1705,12 +1962,17 @@ 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 cacheCtx = {
     genericFilterCache: /* @__PURE__ */ new Map(),
     objectTypeCache: /* @__PURE__ */ new Map(),
     relationFieldContainers: /* @__PURE__ */ new Map(),
     fullyBuiltTables: /* @__PURE__ */ new Set(),
-    relationTypeCache: /* @__PURE__ */ new Map()
+    relationTypeCache: /* @__PURE__ */ new Map(),
+    orderTypeCache: /* @__PURE__ */ new WeakMap(),
+    filterTypeCache: /* @__PURE__ */ new WeakMap()
   };
   const queries = {};
   const mutations = {};
@@ -1724,9 +1986,10 @@ function generateSchemaData2(db, schema, relations, relationsDepthLimit, prefixe
         true,
         relationsDepthLimit,
         cacheCtx,
-        singularTypes,
+        typeNameMapper,
         prefixes.insert,
-        prefixes.update
+        prefixes.update,
+        resolverFactory
       )
     ])
   );
@@ -1735,60 +1998,80 @@ function generateSchemaData2(db, schema, relations, relationsDepthLimit, prefixe
   for (const [tableName, tableTypes] of Object.entries(gqlSchemaTypes)) {
     const { insertInput, updateInput, tableFilters, tableOrder } = tableTypes.inputs;
     const { selectSingleOutput, selectArrOutput, singleTableItemOutput, arrTableItemOutput } = tableTypes.outputs;
+    const {
+      typeName,
+      listFieldName,
+      singleFieldName,
+      createArrayFieldName,
+      createSingleFieldName,
+      updateFieldName,
+      deleteFieldName
+    } = computeResolverFieldNames(tableName, typeNameMapper, prefixes, suffixes);
     const selectArrGenerated = generateSelectArray2(
       db,
       tableName,
       tables,
-      namedRelations,
+      eagerRelations,
       tableOrder,
       tableFilters,
-      suffixes.list,
-      singularTypes
+      listFieldName,
+      typeName,
+      typeNameMapper
     );
     const selectSingleGenerated = generateSelectSingle2(
       db,
       tableName,
       tables,
-      namedRelations,
+      eagerRelations,
       tableOrder,
       tableFilters,
-      suffixes.single,
-      singularTypes
+      singleFieldName,
+      typeName,
+      typeNameMapper
     );
     const insertArrGenerated = generateInsertArray2(
       db,
       tableName,
       schema[tableName],
+      tables,
+      eagerRelations,
       insertInput,
-      prefixes.insert,
-      conflictDoNothing,
-      singularTypes
+      createArrayFieldName,
+      typeName,
+      typeNameMapper,
+      conflictDoNothing
     );
     const insertSingleGenerated = generateInsertSingle2(
       db,
       tableName,
       schema[tableName],
+      tables,
+      eagerRelations,
       insertInput,
-      prefixes.insert,
-      conflictDoNothing,
-      singularTypes
+      createSingleFieldName,
+      typeName,
+      typeNameMapper,
+      conflictDoNothing
     );
     const updateGenerated = generateUpdate2(
       db,
       tableName,
       schema[tableName],
+      tables,
+      eagerRelations,
       updateInput,
       tableFilters,
-      prefixes.update,
-      singularTypes
+      updateFieldName,
+      typeName,
+      typeNameMapper
     );
     const deleteGenerated = generateDelete2(
       db,
       tableName,
       schema[tableName],
       tableFilters,
-      prefixes.delete,
-      singularTypes
+      deleteFieldName,
+      typeName
     );
     queries[selectArrGenerated.name] = {
       type: selectArrOutput,
@@ -1826,139 +2109,108 @@ function generateSchemaData2(db, schema, relations, relationsDepthLimit, prefixe
     outputs[selectSingleOutput.name] = selectSingleOutput;
     outputs[singleTableItemOutput.name] = singleTableItemOutput;
   }
-  return { queries, mutations, inputs, types: outputs };
+  const fieldResolvers = {};
+  for (const [tableName, tableRelations] of Object.entries(namedRelations)) {
+    const relResolvers = {};
+    for (const [relName, relEntry] of Object.entries(tableRelations)) {
+      const isOne = is5(relEntry.relation ?? relEntry, One4);
+      const resolver = resolverFactory({ tableName, relationName: relName, relEntry, isOne });
+      if (resolver) {
+        relResolvers[relName] = resolver;
+      }
+    }
+    if (Object.keys(relResolvers).length > 0) {
+      fieldResolvers[tableName] = relResolvers;
+    }
+  }
+  return { queries, mutations, inputs, types: outputs, fieldResolvers };
 }
 
 // src/util/builders/sqlite.ts
-import { is as is5 } from "drizzle-orm";
-import { SQLiteTable } from "drizzle-orm/sqlite-core";
+import { is as is6, One as One5 } from "drizzle-orm";
+import { getTableConfig as getTableConfig3, SQLiteTable } from "drizzle-orm/sqlite-core";
 import {
   GraphQLError as GraphQLError5,
-  GraphQLInt as GraphQLInt5,
   GraphQLList as GraphQLList5,
   GraphQLNonNull as GraphQLNonNull5
 } from "graphql";
 import { parseResolveInfo as parseResolveInfo3 } from "graphql-parse-resolve-info";
-var toTypeName4 = (name, singular) => singular ? capitalize(singularize(name)) : capitalize(name);
-var generateSelectArray3 = (db, tableName, tables, relationMap, orderArgs, filterArgs, listSuffix, singularTypes) => {
-  const queryEntityBase = singularTypes ? singularize(uncapitalize(tableName)) : uncapitalize(tableName);
-  const queryName = `${queryEntityBase}${listSuffix}`;
+var generateSelectArray3 = (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?`
     );
   }
-  const queryArgs = {
-    offset: {
-      type: GraphQLInt5
-    },
-    limit: {
-      type: GraphQLInt5
-    },
-    orderBy: {
-      type: orderArgs
-    },
-    where: {
-      type: filterArgs
-    }
-  };
-  const typeName = toTypeName4(tableName, singularTypes);
+  const queryArgs = selectArrayArgs(orderArgs, filterArgs);
   const table = tables[tableName];
   return {
-    name: queryName,
+    name: fieldName,
     resolver: async (_source, args, _context, info) => {
       try {
-        const { offset, limit, orderBy, where } = args;
-        const parsedInfo = parseResolveInfo3(info, {
-          deep: true
-        });
-        const query = queryBase.findMany({
-          columns: extractSelectedColumnsFromTree(parsedInfo.fieldsByTypeName[typeName], table),
-          offset,
-          limit,
-          // drizzle-orm v1 RQB calls orderBy 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: (aliased) => extractFilters(aliased, tableName, where) } : void 0,
-          with: relationMap[tableName] ? extractRelationsParams(relationMap, tables, tableName, parsedInfo, typeName, singularTypes) : void 0
+        const parsedInfo = parseResolveInfo3(info, { deep: true });
+        return await runRelationalSelect({
+          queryBase,
+          tables,
+          tableName,
+          table,
+          relationMap,
+          typeName,
+          typeNameMapper,
+          parsedInfo,
+          ...args,
+          single: false
         });
-        const result = await query;
-        return remapToGraphQLArrayOutput(result, tableName, table, relationMap);
       } catch (e) {
-        if (e instanceof Error) {
-          throw new GraphQLError5(e.message);
-        }
-        throw e;
+        throw toGraphQLError(e);
       }
     },
     args: queryArgs
   };
 };
-var generateSelectSingle3 = (db, tableName, tables, relationMap, orderArgs, filterArgs, singleSuffix, singularTypes) => {
-  const queryEntityBase = singularTypes ? singularize(uncapitalize(tableName)) : uncapitalize(tableName);
-  const queryName = `${queryEntityBase}${singleSuffix}`;
+var generateSelectSingle3 = (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?`
     );
   }
-  const queryArgs = {
-    offset: {
-      type: GraphQLInt5
-    },
-    orderBy: {
-      type: orderArgs
-    },
-    where: {
-      type: filterArgs
-    }
-  };
-  const typeName = toTypeName4(tableName, singularTypes);
+  const queryArgs = selectSingleArgs(orderArgs, filterArgs);
   const table = tables[tableName];
   return {
-    name: queryName,
+    name: fieldName,
     resolver: async (_source, args, _context, info) => {
       try {
-        const { offset, orderBy, where } = args;
-        const parsedInfo = parseResolveInfo3(info, {
-          deep: true
-        });
-        const query = queryBase.findFirst({
-          columns: extractSelectedColumnsFromTree(parsedInfo.fieldsByTypeName[typeName], table),
-          offset,
-          // drizzle-orm v1 RQB calls orderBy 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: (aliased) => extractFilters(aliased, tableName, where) } : void 0,
-          with: relationMap[tableName] ? extractRelationsParams(relationMap, tables, tableName, parsedInfo, typeName, singularTypes) : void 0
+        const parsedInfo = parseResolveInfo3(info, { deep: true });
+        return await runRelationalSelect({
+          queryBase,
+          tables,
+          tableName,
+          table,
+          relationMap,
+          typeName,
+          typeNameMapper,
+          parsedInfo,
+          ...args,
+          single: true
         });
-        const result = await query;
-        if (!result) {
-          return void 0;
-        }
-        return remapToGraphQLSingleOutput(result, tableName, table, relationMap);
       } catch (e) {
-        if (e instanceof Error) {
-          throw new GraphQLError5(e.message);
-        }
-        throw e;
+        throw toGraphQLError(e);
       }
     },
     args: queryArgs
   };
 };
-var generateInsertArray3 = (db, tableName, table, baseType, singularTypes = false) => {
-  const queryName = `insertInto${capitalize(tableName)}`;
-  const typeName = toTypeName4(tableName, singularTypes);
+var sqlitePrimaryKeyPropNames = (table) => getPrimaryKeyPropNamesFromConfig(table, getTableConfig3);
+var generateInsertArray3 = (db, tableName, table, tables, relationMap, baseType, fieldName, typeName, typeNameMapper) => {
   const queryArgs = {
     values: {
       type: new GraphQLNonNull5(new GraphQLList5(new GraphQLNonNull5(baseType)))
     }
   };
+  const pkNames = sqlitePrimaryKeyPropNames(table);
   return {
-    name: queryName,
+    name: fieldName,
     resolver: async (_source, args, _context, info) => {
       try {
         const input = remapFromGraphQLArrayInput(args.values, table);
@@ -1968,61 +2220,65 @@ var generateInsertArray3 = (db, tableName, table, baseType, singularTypes = fals
         const parsedInfo = parseResolveInfo3(info, {
           deep: true
         });
-        const columns = extractSelectedColumnsFromTreeSQLFormat(
-          parsedInfo.fieldsByTypeName[typeName],
-          table
-        );
+        const { columns, hasRelations, withParams } = prepareMutationRelationColumns({
+          relationMap,
+          tables,
+          tableName,
+          typeName,
+          typeNameMapper,
+          table,
+          pkNames,
+          parsedInfo
+        });
         const result = await db.insert(table).values(input).returning(columns).onConflictDoNothing();
-        return remapToGraphQLArrayOutput(result, tableName, table);
+        const enriched = hasRelations ? await eagerLoadMutationRelations(db, tableName, result, pkNames, withParams) : result;
+        return remapToGraphQLArrayOutput(enriched, tableName, table, relationMap);
       } catch (e) {
-        if (e instanceof Error) {
-          throw new GraphQLError5(e.message);
-        }
-        throw e;
+        throw toGraphQLError(e);
       }
     },
     args: queryArgs
   };
 };
-var generateInsertSingle3 = (db, tableName, table, baseType, singularTypes = false) => {
-  const queryEntityBase = singularTypes ? singularize(capitalize(tableName)) : capitalize(tableName);
-  const queryName = singularTypes ? `insertInto${queryEntityBase}` : `insertInto${queryEntityBase}Single`;
-  const typeName = toTypeName4(tableName, singularTypes);
+var generateInsertSingle3 = (db, tableName, table, tables, relationMap, baseType, fieldName, typeName, typeNameMapper) => {
   const queryArgs = {
     values: {
       type: new GraphQLNonNull5(baseType)
     }
   };
+  const pkNames = sqlitePrimaryKeyPropNames(table);
   return {
-    name: queryName,
+    name: fieldName,
     resolver: async (_source, args, _context, info) => {
       try {
         const input = remapFromGraphQLSingleInput(args.values, table);
         const parsedInfo = parseResolveInfo3(info, {
           deep: true
         });
-        const columns = extractSelectedColumnsFromTreeSQLFormat(
-          parsedInfo.fieldsByTypeName[typeName],
-          table
-        );
+        const { columns, hasRelations, withParams } = prepareMutationRelationColumns({
+          relationMap,
+          tables,
+          tableName,
+          typeName,
+          typeNameMapper,
+          table,
+          pkNames,
+          parsedInfo
+        });
         const result = await db.insert(table).values(input).returning(columns).onConflictDoNothing();
         if (!result[0]) {
           return void 0;
         }
-        return remapToGraphQLSingleOutput(result[0], tableName, table);
+        const enriched = hasRelations ? await eagerLoadMutationRelations(db, tableName, result, pkNames, withParams) : result;
+        return remapToGraphQLSingleOutput(enriched[0], tableName, table, relationMap);
       } catch (e) {
-        if (e instanceof Error) {
-          throw new GraphQLError5(e.message);
-        }
-        throw e;
+        throw toGraphQLError(e);
       }
     },
     args: queryArgs
   };
 };
-var generateUpdate3 = (db, tableName, table, setArgs, filterArgs, singularTypes = false) => {
-  const queryName = `update${capitalize(tableName)}`;
-  const typeName = toTypeName4(tableName, singularTypes);
+var generateUpdate3 = (db, tableName, table, tables, relationMap, setArgs, filterArgs, fieldName, typeName, typeNameMapper) => {
   const queryArgs = {
     set: {
       type: new GraphQLNonNull5(setArgs)
@@ -2031,18 +2287,25 @@ var generateUpdate3 = (db, tableName, table, setArgs, filterArgs, singularTypes
       type: filterArgs
     }
   };
+  const pkNames = sqlitePrimaryKeyPropNames(table);
   return {
-    name: queryName,
+    name: fieldName,
     resolver: async (_source, args, _context, info) => {
       try {
         const { where, set } = args;
         const parsedInfo = parseResolveInfo3(info, {
           deep: true
         });
-        const columns = extractSelectedColumnsFromTreeSQLFormat(
-          parsedInfo.fieldsByTypeName[typeName],
-          table
-        );
+        const { columns, hasRelations, withParams } = prepareMutationRelationColumns({
+          relationMap,
+          tables,
+          tableName,
+          typeName,
+          typeNameMapper,
+          table,
+          pkNames,
+          parsedInfo
+        });
         const input = remapFromGraphQLSingleInput(set, table);
         if (!Object.keys(input).length) {
           throw new GraphQLError5("Unable to update with no values specified!");
@@ -2054,27 +2317,23 @@ var generateUpdate3 = (db, tableName, table, setArgs, filterArgs, singularTypes
         }
         query = query.returning(columns);
         const result = await query;
-        return remapToGraphQLArrayOutput(result, tableName, table);
+        const enriched = hasRelations ? await eagerLoadMutationRelations(db, tableName, result, pkNames, withParams) : result;
+        return remapToGraphQLArrayOutput(enriched, tableName, table, relationMap);
       } catch (e) {
-        if (e instanceof Error) {
-          throw new GraphQLError5(e.message);
-        }
-        throw e;
+        throw toGraphQLError(e);
       }
     },
     args: queryArgs
   };
 };
-var generateDelete3 = (db, tableName, table, filterArgs, singularTypes = false) => {
-  const queryName = `deleteFrom${capitalize(tableName)}`;
-  const typeName = toTypeName4(tableName, singularTypes);
+var generateDelete3 = (db, tableName, table, filterArgs, fieldName, typeName) => {
   const queryArgs = {
     where: {
       type: filterArgs
     }
   };
   return {
-    name: queryName,
+    name: fieldName,
     resolver: async (_source, args, _context, info) => {
       try {
         const { where } = args;
@@ -2094,19 +2353,16 @@ var generateDelete3 = (db, tableName, table, filterArgs, singularTypes = false)
         const result = await query;
         return remapToGraphQLArrayOutput(result, tableName, table);
       } catch (e) {
-        if (e instanceof Error) {
-          throw new GraphQLError5(e.message);
-        }
-        throw e;
+        throw toGraphQLError(e);
       }
     },
     args: queryArgs
   };
 };
-var generateSchemaData3 = (db, schema, relations, relationsDepthLimit, prefixes, suffixes, singularTypes = false) => {
+var generateSchemaData3 = (db, schema, relations, relationsDepthLimit, prefixes, suffixes, typeNameMapper, shouldEagerLoad = () => true) => {
   const rawSchema = schema;
   const schemaEntries = Object.entries(rawSchema);
-  const tableEntries = schemaEntries.filter(([_key, value]) => is5(value, SQLiteTable));
+  const tableEntries = schemaEntries.filter(([_key, value]) => is6(value, SQLiteTable));
   const tables = Object.fromEntries(tableEntries);
   if (!tableEntries.length) {
     throw new Error(
@@ -2114,12 +2370,17 @@ 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 cacheCtx = {
     genericFilterCache: /* @__PURE__ */ new Map(),
     objectTypeCache: /* @__PURE__ */ new Map(),
     relationFieldContainers: /* @__PURE__ */ new Map(),
     fullyBuiltTables: /* @__PURE__ */ new Set(),
-    relationTypeCache: /* @__PURE__ */ new Map()
+    relationTypeCache: /* @__PURE__ */ new Map(),
+    orderTypeCache: /* @__PURE__ */ new WeakMap(),
+    filterTypeCache: /* @__PURE__ */ new WeakMap()
   };
   const queries = {};
   const mutations = {};
@@ -2133,9 +2394,10 @@ var generateSchemaData3 = (db, schema, relations, relationsDepthLimit, prefixes,
         true,
         relationsDepthLimit,
         cacheCtx,
-        singularTypes,
+        typeNameMapper,
         prefixes.insert,
-        prefixes.update
+        prefixes.update,
+        resolverFactory
       )
     ])
   );
@@ -2144,54 +2406,78 @@ var generateSchemaData3 = (db, schema, relations, relationsDepthLimit, prefixes,
   for (const [tableName, tableTypes] of Object.entries(gqlSchemaTypes)) {
     const { insertInput, updateInput, tableFilters, tableOrder } = tableTypes.inputs;
     const { selectSingleOutput, selectArrOutput, singleTableItemOutput, arrTableItemOutput } = tableTypes.outputs;
+    const {
+      typeName,
+      listFieldName,
+      singleFieldName,
+      createArrayFieldName,
+      createSingleFieldName,
+      updateFieldName,
+      deleteFieldName
+    } = computeResolverFieldNames(tableName, typeNameMapper, prefixes, suffixes);
     const selectArrGenerated = generateSelectArray3(
       db,
       tableName,
       tables,
-      namedRelations,
+      eagerRelations,
       tableOrder,
       tableFilters,
-      suffixes.list,
-      singularTypes
+      listFieldName,
+      typeName,
+      typeNameMapper
     );
     const selectSingleGenerated = generateSelectSingle3(
       db,
       tableName,
       tables,
-      namedRelations,
+      eagerRelations,
       tableOrder,
       tableFilters,
-      suffixes.single,
-      singularTypes
+      singleFieldName,
+      typeName,
+      typeNameMapper
     );
     const insertArrGenerated = generateInsertArray3(
       db,
       tableName,
       schema[tableName],
+      tables,
+      eagerRelations,
       insertInput,
-      singularTypes
+      createArrayFieldName,
+      typeName,
+      typeNameMapper
     );
     const insertSingleGenerated = generateInsertSingle3(
       db,
       tableName,
       schema[tableName],
+      tables,
+      eagerRelations,
       insertInput,
-      singularTypes
+      createSingleFieldName,
+      typeName,
+      typeNameMapper
     );
     const updateGenerated = generateUpdate3(
       db,
       tableName,
       schema[tableName],
+      tables,
+      eagerRelations,
       updateInput,
       tableFilters,
-      singularTypes
+      updateFieldName,
+      typeName,
+      typeNameMapper
     );
     const deleteGenerated = generateDelete3(
       db,
       tableName,
       schema[tableName],
       tableFilters,
-      singularTypes
+      deleteFieldName,
+      typeName
     );
     queries[selectArrGenerated.name] = {
       type: selectArrOutput,
@@ -2229,28 +2515,51 @@ var generateSchemaData3 = (db, schema, relations, relationsDepthLimit, prefixes,
     outputs[selectSingleOutput.name] = selectSingleOutput;
     outputs[singleTableItemOutput.name] = singleTableItemOutput;
   }
-  return { queries, mutations, inputs, types: outputs };
+  const fieldResolvers = {};
+  for (const [tableName, tableRelations] of Object.entries(namedRelations)) {
+    const relResolvers = {};
+    for (const [relName, relEntry] of Object.entries(tableRelations)) {
+      const isOne = is6(relEntry.relation ?? relEntry, One5);
+      const resolver = resolverFactory({ tableName, relationName: relName, relEntry, isOne });
+      if (resolver) {
+        relResolvers[relName] = resolver;
+      }
+    }
+    if (Object.keys(relResolvers).length > 0) {
+      fieldResolvers[tableName] = relResolvers;
+    }
+  }
+  return { queries, mutations, inputs, types: outputs, fieldResolvers };
 };
 
 // src/index.ts
 var buildSchema = (db, config) => {
-  const schema = db._.fullSchema;
   const relations = db._.relations;
-  if (!schema) {
+  const schema = db._.fullSchema ?? Object.fromEntries(
+    Object.entries(relations).filter(([, config2]) => config2?.table != null).map(([key, config2]) => [key, config2.table])
+  );
+  if (!schema || !Object.keys(schema).length) {
     throw new Error(
-      "Drizzle-GraphQL Error: Schema not found in drizzle instance. Make sure you're using drizzle-orm v0.30.9 or above and schema is passed to drizzle constructor!"
+      "Drizzle-GraphQL Error: Schema not found in drizzle instance. Pass relations (from buildRelations/defineRelations) to the drizzle constructor so drizzle-graphql can detect your tables."
     );
   }
   const prefixes = {
-    insert: config?.prefixes?.insert ?? "insertInto",
-    delete: config?.prefixes?.delete ?? "deleteFrom",
+    insert: config?.prefixes?.insert ?? "create",
+    delete: config?.prefixes?.delete ?? "delete",
     update: config?.prefixes?.update ?? "update"
   };
   const suffixes = {
     list: config?.suffixes?.list ?? "",
     single: config?.suffixes?.single ?? "Single"
   };
-  const singularTypes = config?.singularTypes ?? false;
+  const typeNameMapper = config?.typeNameMapper;
+  const eagerOpt = config?.eagerLoadRelations;
+  const shouldEagerLoad = eagerOpt === void 0 || eagerOpt === true ? () => true : eagerOpt === false ? () => false : eagerOpt;
+  if (!typeNameMapper && suffixes.list === suffixes.single) {
+    throw new Error(
+      "Drizzle-GraphQL Error: List and single query suffixes cannot be the same. This would create conflicting GraphQL field names."
+    );
+  }
   if (typeof config?.relationsDepthLimit === "number") {
     if (config.relationsDepthLimit < 0) {
       throw new Error(
@@ -2262,14 +2571,9 @@ var buildSchema = (db, config) => {
         "Drizzle-GraphQL Error: config.relationsDepthLimit is supposed to be nonnegative integer or undefined!"
       );
     }
-    if (suffixes.list === suffixes.single) {
-      throw new Error(
-        "Drizzle-GraphQL Error: List and single query suffixes cannot be the same. This would create conflicting GraphQL field names."
-      );
-    }
   }
   let generatorOutput;
-  if (is6(db, MySqlDatabase)) {
+  if (is7(db, MySqlDatabase)) {
     generatorOutput = generateSchemaData(
       db,
       schema,
@@ -2277,9 +2581,10 @@ var buildSchema = (db, config) => {
       config?.relationsDepthLimit,
       prefixes,
       suffixes,
-      singularTypes
+      typeNameMapper,
+      shouldEagerLoad
     );
-  } else if (is6(db, PgAsyncDatabase)) {
+  } else if (is7(db, PgAsyncDatabase)) {
     generatorOutput = generateSchemaData2(
       db,
       schema,
@@ -2288,9 +2593,10 @@ var buildSchema = (db, config) => {
       prefixes,
       suffixes,
       config?.conflictDoNothing ?? false,
-      singularTypes
+      typeNameMapper,
+      shouldEagerLoad
     );
-  } else if (is6(db, BaseSQLiteDatabase)) {
+  } else if (is7(db, BaseSQLiteDatabase)) {
     generatorOutput = generateSchemaData3(
       db,
       schema,
@@ -2298,7 +2604,8 @@ var buildSchema = (db, config) => {
       config?.relationsDepthLimit,
       prefixes,
       suffixes,
-      singularTypes
+      typeNameMapper,
+      shouldEagerLoad
     );
   } else {
     throw new Error("Drizzle-GraphQL Error: Unknown database instance type");
@@ -2323,7 +2630,9 @@ var buildSchema = (db, config) => {
 };
 export {
   buildSchema,
+  createRelationResolverFactory,
   extractFilters,
-  extractOrderBy
+  extractOrderBy,
+  extractRelationJoinColumns
 };
 //# sourceMappingURL=index.js.map