@vantreeseba/drizzle-graphql 1.0.2 → 2.0.0

package/dist/index.cjs

@@ -31,8 +31,10 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var index_exports = {};
 __export(index_exports, {
   buildSchema: () => buildSchema,
+  createRelationResolverFactory: () => createRelationResolverFactory,
   extractFilters: () => extractFilters,
-  extractOrderBy: () => extractOrderBy
+  extractOrderBy: () => extractOrderBy,
+  extractRelationJoinColumns: () => extractRelationJoinColumns
 });
 module.exports = __toCommonJS(index_exports);
 var import_drizzle_orm7 = require("drizzle-orm");
@@ -51,11 +53,56 @@ var import_graphql_parse_resolve_info = require("graphql-parse-resolve-info");
 var import_drizzle_orm3 = require("drizzle-orm");
 var import_graphql3 = require("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
 var import_pluralize = __toESM(require("pluralize"), 1);
 var uncapitalize = (input) => input?.length ? `${input[0].toLocaleLowerCase()}${input.length > 1 ? input.slice(1, input.length) : ""}` : input;
 var capitalize = (input) => input?.length ? `${input[0].toLocaleUpperCase()}${input.length > 1 ? input.slice(1, input.length) : ""}` : input;
-var singularize = (input) => import_pluralize.default.singular(input);
 
 // src/util/data-mappers/index.ts
 var import_drizzle_orm = require("drizzle-orm");
@@ -115,6 +162,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 && (0, import_drizzle_orm.is)(relEntry.relation, import_drizzle_orm.One)) {
+        queryOutput[key] = null;
+        continue;
+      }
       delete queryOutput[key];
       continue;
     }
@@ -362,26 +414,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 = (0, import_drizzle_orm2.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"];
@@ -403,7 +435,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)) {
@@ -436,6 +471,129 @@ 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 = (0, import_drizzle_orm3.getColumns)(parentTable);
+  const localColPropName = Object.entries(parentCols).find(([, c]) => c === sourceCol)?.[0];
+  const targetCols = (0, import_drizzle_orm3.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 = (0, import_drizzle_orm3.getColumns)(targetTable);
+  const orderExprs = [
+    ...orderByArg ? extractOrderBy(targetTable, orderByArg) : [],
+    ...primaryKeyOrderExprs(targetTable, pkNames)
+  ];
+  const orderClause = orderExprs.length ? import_drizzle_orm3.sql` order by ${import_drizzle_orm3.sql.join(orderExprs, import_drizzle_orm3.sql`, `)}` : import_drizzle_orm3.sql``;
+  const RN = "__drizzle_graphql_rn";
+  const rowNumber = import_drizzle_orm3.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 = [(0, import_drizzle_orm3.gt)(sub[RN], lower)];
+  if (limit != null) {
+    windowConds.push((0, import_drizzle_orm3.lte)(sub[RN], lower + limit));
+  }
+  const rows = await db.select().from(sub).where((0, import_drizzle_orm3.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 = (0, import_drizzle_orm3.and)(
+        (0, import_drizzle_orm3.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 = (0, import_drizzle_orm3.getColumns)(table);
   const treeEntries = Object.entries(tree);
@@ -613,34 +771,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 import_graphql3.GraphQLInputObjectType({
-    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 import_graphql3.GraphQLInputObjectType({
-    name: `${toTypeName(tableName, singularTypes)}Filters`,
+    name: `${resolveTypeName(tableName, typeNameMapper)}Filters`,
     fields: {
       ...filterColumns,
       OR: {
         type: new import_graphql3.GraphQLList(
           new import_graphql3.GraphQLNonNull(
             new import_graphql3.GraphQLInputObjectType({
-              name: `${toTypeName(tableName, singularTypes)}FiltersOr`,
+              name: `${resolveTypeName(tableName, typeNameMapper)}FiltersOr`,
               fields: filterColumns
             })
           )
@@ -648,16 +804,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,
@@ -681,7 +845,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 import_graphql3.GraphQLObjectType({
       name: typeName,
       fields: () => ({ ...tableFields, ...container.fields })
@@ -705,10 +869,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) {
@@ -721,11 +887,12 @@ var generateSelectFields = (tables, tableName, relationMap, fromTableName, fromR
         }
         const capturedTargetContainer = targetContainer;
         relType = new import_graphql3.GraphQLObjectType({
-          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,
@@ -733,7 +900,8 @@ var generateSelectFields = (tables, tableName, relationMap, fromTableName, fromR
             type: relType,
             args: {
               where: { type: relSelectData.filters }
-            }
+            },
+            resolve
           }
         ]);
         continue;
@@ -747,7 +915,8 @@ var generateSelectFields = (tables, tableName, relationMap, fromTableName, fromR
             orderBy: { type: relSelectData.order },
             offset: { type: import_graphql3.GraphQLInt },
             limit: { type: import_graphql3.GraphQLInt }
-          }
+          },
+          resolve
         }
       ]);
     }
@@ -773,7 +942,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,
@@ -785,12 +954,14 @@ var generateTableTypes = (tableName, tables, relationMap, withReturning, relatio
     true,
     relationsDepthLimit,
     cacheCtx,
-    singularTypes
+    typeNameMapper,
+    /* @__PURE__ */ new Set(),
+    resolverFactory,
+    0
   );
   const table = tables[tableName];
   const columns = (0, import_drizzle_orm3.getColumns)(table);
   const columnEntries = Object.entries(columns);
-  const _insertNested = drizzleRelationToGraphQLInsertType(tables, relationMap[tableName] ?? {});
   const insertFields = Object.fromEntries(
     columnEntries.map(([columnName, columnDescription]) => [
       columnName,
@@ -804,15 +975,15 @@ var generateTableTypes = (tableName, tables, relationMap, withReturning, relatio
     ])
   );
   const insertInput = new import_graphql3.GraphQLInputObjectType({
-    name: `${capitalize(insertPrefix)}${toTypeName(tableName, singularTypes)}Input`,
+    name: `${capitalize(insertPrefix)}${resolveTypeName(tableName, typeNameMapper)}Input`,
     fields: insertFields
   });
   const updateInput = new import_graphql3.GraphQLInputObjectType({
-    name: `${capitalize(updatePrefix)}${toTypeName(tableName, singularTypes)}Input`,
+    name: `${capitalize(updatePrefix)}${resolveTypeName(tableName, typeNameMapper)}Input`,
     fields: updateFields
   });
   const selectSingleOutput = cacheCtx.objectTypeCache.get(tableName) ?? new import_graphql3.GraphQLObjectType({
-    name: toTypeName(tableName, singularTypes),
+    name: resolveTypeName(tableName, typeNameMapper),
     fields: { ...tableFields, ...relationFields }
   });
   const selectArrOutput = new import_graphql3.GraphQLNonNull(new import_graphql3.GraphQLList(new import_graphql3.GraphQLNonNull(selectSingleOutput)));
@@ -872,55 +1043,28 @@ var extractFiltersColumn = (column, columnName, operators) => {
     }
     return variants2.length ? variants2.length > 1 ? (0, import_drizzle_orm3.or)(...variants2) : variants2[0] : void 0;
   }
+  const singleValueOps = { eq: import_drizzle_orm3.eq, ne: import_drizzle_orm3.ne, gt: import_drizzle_orm3.gt, gte: import_drizzle_orm3.gte, lt: import_drizzle_orm3.lt, lte: import_drizzle_orm3.lte };
+  const stringValueOps = { like: import_drizzle_orm3.like, notLike: import_drizzle_orm3.notLike, ilike: import_drizzle_orm3.ilike, notIlike: import_drizzle_orm3.notIlike };
+  const arrayValueOps = { inArray: import_drizzle_orm3.inArray, notInArray: import_drizzle_orm3.notInArray };
+  const nullableOps = { isNull: import_drizzle_orm3.isNull, isNotNull: import_drizzle_orm3.isNotNull };
   const variants = [];
   for (const [operatorName, operatorValue] of entries) {
     if (operatorValue === null || operatorValue === false) {
       continue;
     }
-    let operator;
-    switch (operatorName) {
-      case "eq":
-        operator = operator ?? import_drizzle_orm3.eq;
-      case "ne":
-        operator = operator ?? import_drizzle_orm3.ne;
-      case "gt":
-        operator = operator ?? import_drizzle_orm3.gt;
-      case "gte":
-        operator = operator ?? import_drizzle_orm3.gte;
-      case "lt":
-        operator = operator ?? import_drizzle_orm3.lt;
-      case "lte": {
-        operator = operator ?? import_drizzle_orm3.lte;
-        const singleValue = remapFromGraphQLCore(operatorValue, column, columnName);
-        variants.push(operator(column, singleValue));
-        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 import_graphql3.GraphQLError(`WHERE ${columnName}: Unable to use operator ${operatorName} with an empty array!`);
       }
-      case "like":
-        operator = operator ?? import_drizzle_orm3.like;
-      case "notLike":
-        operator = operator ?? import_drizzle_orm3.notLike;
-      case "ilike":
-        operator = operator ?? import_drizzle_orm3.ilike;
-      case "notIlike":
-        operator = operator ?? import_drizzle_orm3.notIlike;
-        variants.push(operator(column, operatorValue));
-        break;
-      case "inArray":
-        operator = operator ?? import_drizzle_orm3.inArray;
-      case "notInArray": {
-        operator = operator ?? import_drizzle_orm3.notInArray;
-        if (!operatorValue.length) {
-          throw new import_graphql3.GraphQLError(`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;
-      }
-      case "isNull":
-        operator = operator ?? import_drizzle_orm3.isNull;
-      case "isNotNull":
-        operator = operator ?? import_drizzle_orm3.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 ? (0, import_drizzle_orm3.and)(...variants) : variants[0] : void 0;
@@ -956,7 +1100,7 @@ var extractFilters = (table, tableName, filters) => {
   }
   return variants.length ? variants.length > 1 ? (0, import_drizzle_orm3.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;
@@ -966,8 +1110,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;
@@ -986,140 +1131,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 = (0, import_drizzle_orm3.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 = (0, import_drizzle_orm3.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 = (0, import_drizzle_orm3.getColumns)(table);
+  return pkNames.map((n) => cols[n]).filter(Boolean).map((col) => (0, import_drizzle_orm3.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 import_graphql3.GraphQLError(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: import_graphql3.GraphQLInt },
+  limit: { type: import_graphql3.GraphQLInt },
+  orderBy: { type: orderArgs },
+  where: { type: filterArgs }
+});
+var selectSingleArgs = (orderArgs, filterArgs) => ({
+  offset: { type: import_graphql3.GraphQLInt },
+  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) => (0, import_drizzle_orm3.inArray)(aliased[pkName], ids);
+  } else {
+    whereRaw = (aliased) => {
+      const lhs = import_drizzle_orm3.sql.join(
+        pkNames.map((n) => import_drizzle_orm3.sql`${aliased[n]}`),
+        import_drizzle_orm3.sql`, `
+      );
+      const tuples = import_drizzle_orm3.sql.join(
+        keyableRows.map(
+          (row) => import_drizzle_orm3.sql`(${import_drizzle_orm3.sql.join(
+            pkNames.map((n) => import_drizzle_orm3.sql`${row[n]}`),
+            import_drizzle_orm3.sql`, `
+          )})`
+        ),
+        import_drizzle_orm3.sql`, `
+      );
+      return import_drizzle_orm3.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: import_graphql4.GraphQLInt
-    },
-    limit: {
-      type: import_graphql4.GraphQLInt
-    },
-    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 = (0, import_graphql_parse_resolve_info.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 = (0, import_graphql_parse_resolve_info.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 import_graphql4.GraphQLError(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: import_graphql4.GraphQLInt
-    },
-    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 = (0, import_graphql_parse_resolve_info.parseResolveInfo)(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 = (0, import_graphql_parse_resolve_info.parseResolveInfo)(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 import_graphql4.GraphQLError(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 import_graphql4.GraphQLNonNull(new import_graphql4.GraphQLList(new import_graphql4.GraphQLNonNull(baseType)))
     }
   };
   return {
-    name: queryName,
+    name: fieldName,
     resolver: async (_source, args, _context, _info) => {
       try {
         const input = remapFromGraphQLArrayInput(args.values, table);
@@ -1129,41 +1413,33 @@ var generateInsertArray = (db, tableName, table, baseType) => {
         await db.insert(table).values(input);
         return { isSuccess: true };
       } catch (e) {
-        if (e instanceof Error) {
-          throw new import_graphql4.GraphQLError(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 import_graphql4.GraphQLNonNull(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 import_graphql4.GraphQLError(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 import_graphql4.GraphQLNonNull(setArgs)
@@ -1173,7 +1449,7 @@ var generateUpdate = (db, tableName, table, setArgs, filterArgs) => {
     }
   };
   return {
-    name: queryName,
+    name: fieldName,
     resolver: async (_source, args, _context, _info) => {
       try {
         const { where, set } = args;
@@ -1189,24 +1465,20 @@ var generateUpdate = (db, tableName, table, setArgs, filterArgs) => {
         await query;
         return { isSuccess: true };
       } catch (e) {
-        if (e instanceof Error) {
-          throw new import_graphql4.GraphQLError(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;
@@ -1218,48 +1490,14 @@ var generateDelete = (db, tableName, table, filterArgs) => {
         await query;
         return { isSuccess: true };
       } catch (e) {
-        if (e instanceof Error) {
-          throw new import_graphql4.GraphQLError(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, import_mysql_core2.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]) => (0, import_drizzle_orm4.is)(value, import_mysql_core2.MySqlTable));
@@ -1269,13 +1507,18 @@ var generateSchemaData = (db, schema, relations, relationsDepthLimit, prefixes,
       "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 = {};
@@ -1289,9 +1532,10 @@ var generateSchemaData = (db, schema, relations, relationsDepthLimit, prefixes,
         false,
         relationsDepthLimit,
         cacheCtx,
-        singularTypes,
+        typeNameMapper,
         prefixes.insert,
-        prefixes.update
+        prefixes.update,
+        resolverFactory
       )
     ])
   );
@@ -1310,30 +1554,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,
@@ -1369,7 +1649,21 @@ 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 = (0, import_drizzle_orm4.is)(relEntry.relation ?? relEntry, import_drizzle_orm4.One);
+      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
@@ -1377,151 +1671,113 @@ var import_drizzle_orm5 = require("drizzle-orm");
 var import_pg_core2 = require("drizzle-orm/pg-core");
 var import_graphql5 = require("graphql");
 var import_graphql_parse_resolve_info2 = require("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: import_graphql5.GraphQLInt
-    },
-    limit: {
-      type: import_graphql5.GraphQLInt
-    },
-    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 = (0, import_graphql_parse_resolve_info2.parseResolveInfo)(info, {
-          deep: true
-        });
-        const selectedColumns = extractSelectedColumnsFromTree(parsedInfo.fieldsByTypeName[typeName], table);
-        let result;
+        const parsedInfo = (0, import_graphql_parse_resolve_info2.parseResolveInfo)(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 import_graphql5.GraphQLError(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));
         }
-        throw e;
+        if (orderBy) {
+          q = q.orderBy(...extractOrderBy(table, orderBy));
+        }
+        if (offset) {
+          q = q.offset(offset);
+        }
+        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: import_graphql5.GraphQLInt
-    },
-    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 = (0, import_graphql_parse_resolve_info2.parseResolveInfo)(info, {
-          deep: true
-        });
-        const selectedColumns = extractSelectedColumnsFromTree(parsedInfo.fieldsByTypeName[typeName], table);
-        let result;
+        const parsedInfo = (0, import_graphql_parse_resolve_info2.parseResolveInfo)(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 import_graphql5.GraphQLError(e.message);
+        if (orderBy) {
+          q = q.orderBy(...extractOrderBy(table, orderBy));
+        }
+        if (offset) {
+          q = q.offset(offset);
         }
-        throw e;
+        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, import_pg_core2.getTableConfig);
+var generateInsertArray2 = (db, tableName, table, tables, relationMap, baseType, fieldName, typeName, typeNameMapper, conflictDoNothing = false) => {
   const queryArgs = {
     values: {
       type: new import_graphql5.GraphQLNonNull(new import_graphql5.GraphQLList(new import_graphql5.GraphQLNonNull(baseType)))
     }
   };
+  const pkNames = pgPrimaryKeyPropNames(table);
   return {
-    name: queryName,
+    name: fieldName,
     resolver: async (_source, args, _context, info) => {
       try {
         const input = remapFromGraphQLArrayInput(args.values, table);
@@ -1531,47 +1787,55 @@ var generateInsertArray2 = (db, tableName, table, baseType, prefix, conflictDoNo
         const parsedInfo = (0, import_graphql_parse_resolve_info2.parseResolveInfo)(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 import_graphql5.GraphQLError(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 import_graphql5.GraphQLNonNull(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 = (0, import_graphql_parse_resolve_info2.parseResolveInfo)(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();
@@ -1580,20 +1844,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 import_graphql5.GraphQLError(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 import_graphql5.GraphQLNonNull(setArgs)
@@ -1602,18 +1862,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 = (0, import_graphql_parse_resolve_info2.parseResolveInfo)(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 import_graphql5.GraphQLError("Unable to update with no values specified!");
@@ -1625,27 +1892,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 import_graphql5.GraphQLError(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;
@@ -1665,16 +1928,13 @@ 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 import_graphql5.GraphQLError(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]) => (0, import_drizzle_orm5.is)(value, import_pg_core2.PgTable));
   const tables = Object.fromEntries(tableEntries);
@@ -1684,12 +1944,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 = {};
@@ -1703,9 +1968,10 @@ function generateSchemaData2(db, schema, relations, relationsDepthLimit, prefixe
         true,
         relationsDepthLimit,
         cacheCtx,
-        singularTypes,
+        typeNameMapper,
         prefixes.insert,
-        prefixes.update
+        prefixes.update,
+        resolverFactory
       )
     ])
   );
@@ -1714,60 +1980,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,
@@ -1805,7 +2091,21 @@ 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 = (0, import_drizzle_orm5.is)(relEntry.relation ?? relEntry, import_drizzle_orm5.One);
+      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
@@ -1813,126 +2113,82 @@ var import_drizzle_orm6 = require("drizzle-orm");
 var import_sqlite_core2 = require("drizzle-orm/sqlite-core");
 var import_graphql6 = require("graphql");
 var import_graphql_parse_resolve_info3 = require("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: import_graphql6.GraphQLInt
-    },
-    limit: {
-      type: import_graphql6.GraphQLInt
-    },
-    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 = (0, import_graphql_parse_resolve_info3.parseResolveInfo)(info, {
-          deep: true
+        const parsedInfo = (0, import_graphql_parse_resolve_info3.parseResolveInfo)(info, { deep: true });
+        return await runRelationalSelect({
+          queryBase,
+          tables,
+          tableName,
+          table,
+          relationMap,
+          typeName,
+          typeNameMapper,
+          parsedInfo,
+          ...args,
+          single: false
         });
-        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 result = await query;
-        return remapToGraphQLArrayOutput(result, tableName, table, relationMap);
       } catch (e) {
-        if (e instanceof Error) {
-          throw new import_graphql6.GraphQLError(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: import_graphql6.GraphQLInt
-    },
-    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 = (0, import_graphql_parse_resolve_info3.parseResolveInfo)(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 = (0, import_graphql_parse_resolve_info3.parseResolveInfo)(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 import_graphql6.GraphQLError(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, import_sqlite_core2.getTableConfig);
+var generateInsertArray3 = (db, tableName, table, tables, relationMap, baseType, fieldName, typeName, typeNameMapper) => {
   const queryArgs = {
     values: {
       type: new import_graphql6.GraphQLNonNull(new import_graphql6.GraphQLList(new import_graphql6.GraphQLNonNull(baseType)))
     }
   };
+  const pkNames = sqlitePrimaryKeyPropNames(table);
   return {
-    name: queryName,
+    name: fieldName,
     resolver: async (_source, args, _context, info) => {
       try {
         const input = remapFromGraphQLArrayInput(args.values, table);
@@ -1942,61 +2198,65 @@ var generateInsertArray3 = (db, tableName, table, baseType, singularTypes = fals
         const parsedInfo = (0, import_graphql_parse_resolve_info3.parseResolveInfo)(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 import_graphql6.GraphQLError(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 import_graphql6.GraphQLNonNull(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 = (0, import_graphql_parse_resolve_info3.parseResolveInfo)(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 import_graphql6.GraphQLError(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 import_graphql6.GraphQLNonNull(setArgs)
@@ -2005,18 +2265,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 = (0, import_graphql_parse_resolve_info3.parseResolveInfo)(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 import_graphql6.GraphQLError("Unable to update with no values specified!");
@@ -2028,27 +2295,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 import_graphql6.GraphQLError(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;
@@ -2068,16 +2331,13 @@ 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 import_graphql6.GraphQLError(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]) => (0, import_drizzle_orm6.is)(value, import_sqlite_core2.SQLiteTable));
@@ -2088,12 +2348,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 = {};
@@ -2107,9 +2372,10 @@ var generateSchemaData3 = (db, schema, relations, relationsDepthLimit, prefixes,
         true,
         relationsDepthLimit,
         cacheCtx,
-        singularTypes,
+        typeNameMapper,
         prefixes.insert,
-        prefixes.update
+        prefixes.update,
+        resolverFactory
       )
     ])
   );
@@ -2118,54 +2384,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,
@@ -2203,28 +2493,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 = (0, import_drizzle_orm6.is)(relEntry.relation ?? relEntry, import_drizzle_orm6.One);
+      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(
@@ -2236,11 +2549,6 @@ 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 ((0, import_drizzle_orm7.is)(db, import_mysql_core3.MySqlDatabase)) {
@@ -2251,7 +2559,8 @@ var buildSchema = (db, config) => {
       config?.relationsDepthLimit,
       prefixes,
       suffixes,
-      singularTypes
+      typeNameMapper,
+      shouldEagerLoad
     );
   } else if ((0, import_drizzle_orm7.is)(db, import_pg_core3.PgAsyncDatabase)) {
     generatorOutput = generateSchemaData2(
@@ -2262,7 +2571,8 @@ var buildSchema = (db, config) => {
       prefixes,
       suffixes,
       config?.conflictDoNothing ?? false,
-      singularTypes
+      typeNameMapper,
+      shouldEagerLoad
     );
   } else if ((0, import_drizzle_orm7.is)(db, import_sqlite_core3.BaseSQLiteDatabase)) {
     generatorOutput = generateSchemaData3(
@@ -2272,7 +2582,8 @@ var buildSchema = (db, config) => {
       config?.relationsDepthLimit,
       prefixes,
       suffixes,
-      singularTypes
+      typeNameMapper,
+      shouldEagerLoad
     );
   } else {
     throw new Error("Drizzle-GraphQL Error: Unknown database instance type");
@@ -2298,7 +2609,9 @@ var buildSchema = (db, config) => {
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   buildSchema,
+  createRelationResolverFactory,
   extractFilters,
-  extractOrderBy
+  extractOrderBy,
+  extractRelationJoinColumns
 });
 //# sourceMappingURL=index.cjs.map