drizzle-graphql-plus 0.8.32 → 0.8.34

package/index.cjs

@@ -1,20 +1,30 @@
 "use strict";
+var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
 };
-var __copyProps = (to, from, except, desc3) => {
+var __copyProps = (to, from, except, desc4) => {
   if (from && typeof from === "object" || typeof from === "function") {
     for (let key of __getOwnPropNames(from))
       if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc3 = __getOwnPropDesc(from, key)) || desc3.enumerable });
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc4 = __getOwnPropDesc(from, key)) || desc4.enumerable });
   }
   return to;
 };
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/index.ts
@@ -22,10 +32,17 @@ var src_exports = {};
 __export(src_exports, {
   buildSchema: () => buildSchema,
   buildSchemaSDL: () => buildSchemaSDL,
+  buildSchemaSDLWithDataLoader: () => buildSchemaSDL2,
+  cleanupDataLoaderContext: () => cleanupDataLoaderContext,
+  createDataLoaderContext: () => createDataLoaderContext,
   createExportMiddleware: () => createExportMiddleware,
+  exportDirectiveTypeDefs: () => exportDirectiveTypeDefs,
   makeScalarAcceptExports: () => makeScalarAcceptExports,
   setCustomGraphQL: () => setCustomGraphQL,
-  setCustomGraphQLTypes: () => setCustomGraphQLTypes
+  setCustomGraphQLTypes: () => setCustomGraphQLTypes,
+  useDataLoaderCleanup: () => useDataLoaderCleanup,
+  useDataLoaderCleanupOnly: () => useDataLoaderCleanupOnly,
+  useDataLoaderContext: () => useDataLoaderContext
 });
 module.exports = __toCommonJS(src_exports);
 
@@ -2462,13 +2479,13 @@ ${fields.join("\n")}
       );
       const hasDefault = column.hasDefault || column.default !== void 0;
       const isAutoIncrement = column.autoIncrement || column.generatedAlwaysAs;
-      const isNotNull3 = column.notNull;
-      const shouldBeOptional = hasDefault || isAutoIncrement || isPrimaryKey && !isNotNull3;
+      const isNotNull4 = column.notNull;
+      const shouldBeOptional = hasDefault || isAutoIncrement || isPrimaryKey && !isNotNull4;
       let insertFieldType;
       if (shouldBeOptional) {
         insertFieldType = typeStr.endsWith("!") ? typeStr.slice(0, -1) : typeStr;
       } else {
-        insertFieldType = isNotNull3 && !typeStr.endsWith("!") ? `${typeStr}!` : typeStr;
+        insertFieldType = isNotNull4 && !typeStr.endsWith("!") ? `${typeStr}!` : typeStr;
       }
       insertFields.push(`  ${columnName}: ${insertFieldType}`);
     }
@@ -3266,6 +3283,1281 @@ var buildSchemaSDL = (db, config) => {
   };
 };
 
+// src/build-schema-sdl-with-dl/index.ts
+var import_drizzle_orm19 = require("drizzle-orm");
+var import_sqlite_core7 = require("drizzle-orm/sqlite-core");
+
+// src/build-schema-sdl-with-dl/generator/schema/generation.ts
+var import_drizzle_orm13 = require("drizzle-orm");
+var generateTypes2 = (db, schema) => {
+  const tables = {};
+  const schemaEntries = Object.entries(schema);
+  const tableEntries = [];
+  for (const [key, value] of schemaEntries) {
+    if (value && typeof value === "object" && "getSQL" in value) {
+      const table = value;
+      const tableName = key;
+      const columns = (0, import_drizzle_orm13.getTableColumns)(table);
+      tables[tableName] = {
+        name: tableName,
+        table,
+        columns
+      };
+      tableEntries.push([tableName, table]);
+    }
+  }
+  const rawRelations = schemaEntries.filter(([key, value]) => (0, import_drizzle_orm13.is)(value, import_drizzle_orm13.Relations)).map(([key, value]) => [
+    tableEntries.find(
+      ([tableName, tableValue]) => tableValue === value.table
+    )[0],
+    value
+  ]).map(([tableName, relValue]) => [
+    tableName,
+    relValue.config((0, import_drizzle_orm13.createTableRelationsHelpers)(tables[tableName].table))
+  ]);
+  const namedRelations = Object.fromEntries(
+    rawRelations.map(([relName, config]) => {
+      const namedConfig = Object.fromEntries(
+        Object.entries(config).map(([innerRelName, innerRelValue]) => [
+          innerRelName,
+          {
+            relation: innerRelValue,
+            targetTableName: tableEntries.find(
+              ([tableName, tableValue]) => tableValue === innerRelValue.referencedTable
+            )[0]
+          }
+        ])
+      );
+      return [relName, namedConfig];
+    })
+  );
+  return { tables, relations: namedRelations };
+};
+
+// src/build-schema-sdl-with-dl/generator/schema/type-defs.ts
+var import_drizzle_orm14 = require("drizzle-orm");
+var import_mysql_core5 = require("drizzle-orm/mysql-core");
+var import_pg_core5 = require("drizzle-orm/pg-core");
+var import_sqlite_core6 = require("drizzle-orm/sqlite-core");
+var allowedNameChars3 = /^[a-zA-Z0-9_]+$/;
+var customScalars2 = /* @__PURE__ */ new Set();
+var enumDefinitions2 = /* @__PURE__ */ new Map();
+var requiredFieldFilters2 = /* @__PURE__ */ new Set();
+var foreignKeyTypes2 = /* @__PURE__ */ new Map();
+var columnToSDL2 = (column, columnName, tableName, forceNullable = false, isPrimaryKey = false) => {
+  let baseType;
+  if (column.customGraphqlType) {
+    baseType = column.customGraphqlType;
+  } else if (isPrimaryKey) {
+    baseType = "ID";
+  } else {
+    const foreignKeyType = foreignKeyTypes2.get(`${tableName}.${columnName}`);
+    if (foreignKeyType) {
+      baseType = foreignKeyType;
+    } else {
+      switch (column.dataType) {
+        case "boolean":
+          baseType = "Boolean";
+          break;
+        case "json":
+          if (column.columnType === "PgGeometryObject") {
+            baseType = "PgGeometryObject";
+            customScalars2.add("PgGeometryObject");
+          } else {
+            baseType = "JSON";
+            customScalars2.add("JSON");
+          }
+          break;
+        case "date":
+          baseType = "Date";
+          customScalars2.add("Date");
+          break;
+        case "string":
+          if (column.enumValues?.length) {
+            const enumName = `${capitalize(tableName)}${capitalize(
+              columnName
+            )}Enum`;
+            baseType = enumName;
+            if (!enumDefinitions2.has(enumName)) {
+              enumDefinitions2.set(enumName, {
+                name: enumName,
+                values: column.enumValues.map(
+                  (e, index) => allowedNameChars3.test(e) ? e : `Option${index}`
+                )
+              });
+            }
+          } else {
+            baseType = "String";
+          }
+          break;
+        case "bigint":
+          baseType = "BigInt";
+          customScalars2.add("BigInt");
+          break;
+        case "number":
+          if ((0, import_drizzle_orm14.is)(column, import_pg_core5.PgInteger) || (0, import_drizzle_orm14.is)(column, import_pg_core5.PgSerial) || (0, import_drizzle_orm14.is)(column, import_mysql_core5.MySqlInt) || (0, import_drizzle_orm14.is)(column, import_mysql_core5.MySqlSerial) || (0, import_drizzle_orm14.is)(column, import_sqlite_core6.SQLiteInteger)) {
+            baseType = "Int";
+          } else {
+            baseType = "Float";
+          }
+          break;
+        case "buffer":
+          baseType = "[Int!]";
+          break;
+        case "array":
+          if (column.columnType === "PgVector") {
+            baseType = "[Float!]";
+          } else if (column.columnType === "PgGeometry") {
+            baseType = "[Float!]";
+          } else {
+            const scalarName = `${capitalize(tableName)}${capitalize(
+              columnName
+            )}Array`;
+            baseType = scalarName;
+            customScalars2.add(scalarName);
+          }
+          break;
+        case "custom":
+        default:
+          if (column.columnType) {
+            baseType = column.columnType;
+            customScalars2.add(column.columnType);
+          } else {
+            const customScalarName = `${capitalize(tableName)}${capitalize(
+              columnName
+            )}`;
+            baseType = customScalarName;
+            customScalars2.add(customScalarName);
+          }
+          break;
+      }
+    }
+  }
+  if (!forceNullable && column.notNull) {
+    return `${baseType}!`;
+  }
+  return baseType;
+};
+var generateTypeDefs2 = (tables, relations) => {
+  const typeDefs = [];
+  customScalars2.clear();
+  enumDefinitions2.clear();
+  requiredFieldFilters2.clear();
+  foreignKeyTypes2.clear();
+  for (const [tableName, tableRelations] of Object.entries(relations)) {
+    const tableInfo = tables[tableName];
+    if (!tableInfo)
+      continue;
+    for (const [relationName, relationInfo] of Object.entries(tableRelations)) {
+      const relation = relationInfo.relation;
+      if (!(0, import_drizzle_orm14.is)(relation, import_drizzle_orm14.One))
+        continue;
+      const config = relation.config;
+      if (!config?.fields || !config?.references)
+        continue;
+      const referencedTableName = relationInfo.targetTableName;
+      const referencedTable = tables[referencedTableName];
+      if (!referencedTable)
+        continue;
+      for (let i = 0; i < config.fields.length; i++) {
+        const field = config.fields[i];
+        const reference = config.references[i];
+        if (!field || !reference)
+          continue;
+        const fieldColumnName = field.name;
+        const referenceColumnName = reference.name;
+        const foreignKeyColumn = Object.values(tableInfo.columns).find(
+          (col) => col.name === fieldColumnName
+        );
+        const referencedColumn = Object.values(referencedTable.columns).find(
+          (col) => col.name === referenceColumnName
+        );
+        if (!foreignKeyColumn || !referencedColumn)
+          continue;
+        const foreignKeyPropertyName = Object.keys(tableInfo.columns).find(
+          (key) => tableInfo.columns[key] === foreignKeyColumn
+        );
+        if (!foreignKeyPropertyName)
+          continue;
+        const referencedCustomType = referencedColumn.customGraphqlType;
+        const foreignKeyHasCustomType = !!foreignKeyColumn.customGraphqlType;
+        const referencedIsPrimaryKey = referencedColumn.primary || false;
+        if (!foreignKeyHasCustomType) {
+          if (referencedCustomType) {
+            foreignKeyTypes2.set(
+              `${tableName}.${foreignKeyPropertyName}`,
+              referencedCustomType
+            );
+          } else if (referencedIsPrimaryKey) {
+            foreignKeyTypes2.set(`${tableName}.${foreignKeyPropertyName}`, "ID");
+          }
+        }
+      }
+    }
+  }
+  for (const [tableName, tableInfo] of Object.entries(tables)) {
+    const typeName = capitalize(tableName);
+    const fields = [];
+    for (const [columnName, column] of Object.entries(tableInfo.columns)) {
+      const isPrimaryKey = column.primary || false;
+      const typeStr = columnToSDL2(
+        column,
+        columnName,
+        tableName,
+        false,
+        isPrimaryKey
+      );
+      const description = column.customGraphqlDescription;
+      if (description) {
+        fields.push(`  """${description}"""`);
+      }
+      fields.push(`  ${columnName}: ${typeStr}`);
+    }
+    const tableRelations = relations[tableName];
+    if (tableRelations) {
+      for (const [relationName, relationInfo] of Object.entries(
+        tableRelations
+      )) {
+        const isOne = (0, import_drizzle_orm14.is)(relationInfo.relation, import_drizzle_orm14.One);
+        const targetTableName = relationInfo.targetTableName;
+        const targetTypeName = capitalize(targetTableName);
+        if (isOne) {
+          fields.push(
+            `  ${relationName}(where: ${targetTypeName}Filters): ${targetTypeName}`
+          );
+        } else {
+          fields.push(
+            `  ${relationName}(where: ${targetTypeName}Filters, orderBy: ${targetTypeName}OrderBy, limit: Int, offset: Int): [${targetTypeName}!]!`
+          );
+        }
+      }
+    }
+    typeDefs.push(`type ${typeName} {
+${fields.join("\n")}
+}`);
+    const insertFields = [];
+    for (const [columnName, column] of Object.entries(tableInfo.columns)) {
+      const isPrimaryKey = column.primary || false;
+      const typeStr = columnToSDL2(
+        column,
+        columnName,
+        tableName,
+        false,
+        isPrimaryKey
+      );
+      const hasDefault = column.hasDefault || column.default !== void 0;
+      const isAutoIncrement = column.autoIncrement || column.generatedAlwaysAs;
+      const isNotNull4 = column.notNull;
+      const shouldBeOptional = hasDefault || isAutoIncrement || isPrimaryKey && !isNotNull4;
+      let insertFieldType;
+      if (shouldBeOptional) {
+        insertFieldType = typeStr.endsWith("!") ? typeStr.slice(0, -1) : typeStr;
+      } else {
+        insertFieldType = isNotNull4 && !typeStr.endsWith("!") ? `${typeStr}!` : typeStr;
+      }
+      insertFields.push(`  ${columnName}: ${insertFieldType}`);
+    }
+    if (insertFields.length > 0) {
+      typeDefs.push(
+        `input ${typeName}InsertInput {
+${insertFields.join("\n")}
+}`
+      );
+    }
+    const updateFields = [];
+    for (const [columnName, column] of Object.entries(tableInfo.columns)) {
+      const isPrimaryKey = column.primary || false;
+      const typeStr = columnToSDL2(
+        column,
+        columnName,
+        tableName,
+        true,
+        isPrimaryKey
+      );
+      updateFields.push(`  ${columnName}: ${typeStr}`);
+    }
+    typeDefs.push(
+      `input ${typeName}UpdateInput {
+${updateFields.join("\n")}
+}`
+    );
+    const whereFields = [];
+    for (const [columnName, column] of Object.entries(tableInfo.columns)) {
+      const isPrimaryKey = column.primary || false;
+      const typeStr = columnToSDL2(
+        column,
+        columnName,
+        tableName,
+        true,
+        isPrimaryKey
+      );
+      const normalizedType = typeStr.replace(/[^a-zA-Z0-9]/g, "");
+      const filterTypeName = `${normalizedType}FieldFilter`;
+      requiredFieldFilters2.add(
+        JSON.stringify({ normalizedType, baseType: typeStr })
+      );
+      whereFields.push(`  ${columnName}: ${filterTypeName}`);
+    }
+    whereFields.push(`  OR: [${typeName}Filters!]`);
+    typeDefs.push(`input ${typeName}Filters {
+${whereFields.join("\n")}
+}`);
+    const orderByFields = [];
+    for (const columnName of Object.keys(tableInfo.columns)) {
+      orderByFields.push(`  ${columnName}: InnerOrder`);
+    }
+    typeDefs.push(`input ${typeName}OrderBy {
+${orderByFields.join("\n")}
+}`);
+    typeDefs.push(`type ${typeName}DeleteResult {
+  deletedItems: [DeletedItem!]!
+  ${tableName}FindMany(where: ${typeName}Filters, orderBy: ${typeName}OrderBy, limit: Int, offset: Int): [${typeName}!]!
+}`);
+  }
+  const allDefs = [];
+  customScalars2.add("JSON");
+  if (customScalars2.size > 0) {
+    for (const scalarName of Array.from(customScalars2).sort()) {
+      allDefs.push(`scalar ${scalarName}`);
+    }
+  }
+  if (enumDefinitions2.size > 0) {
+    for (const enumDef of Array.from(enumDefinitions2.values())) {
+      const valueStrings = enumDef.values.map((v) => `  ${v}`);
+      allDefs.push(`enum ${enumDef.name} {
+${valueStrings.join("\n")}
+}`);
+    }
+  }
+  allDefs.push(`enum OrderByDirection {
+  asc
+  desc
+}`);
+  allDefs.push(`type DeletedItem {
+  id: ID!
+}`);
+  allDefs.push(`input InnerOrder {
+  direction: OrderByDirection!
+  priority: Int!
+}`);
+  const filterTypesAdded = /* @__PURE__ */ new Set();
+  for (const filterInfoJson of Array.from(requiredFieldFilters2)) {
+    const { normalizedType, baseType } = JSON.parse(filterInfoJson);
+    const filterTypeName = `${normalizedType}FieldFilter`;
+    if (filterTypesAdded.has(filterTypeName))
+      continue;
+    filterTypesAdded.add(filterTypeName);
+    const filterFields = [];
+    filterFields.push(`  eq: ${baseType}`);
+    filterFields.push(`  ne: ${baseType}`);
+    filterFields.push(`  lt: ${baseType}`);
+    filterFields.push(`  lte: ${baseType}`);
+    filterFields.push(`  gt: ${baseType}`);
+    filterFields.push(`  gte: ${baseType}`);
+    filterFields.push(`  like: String`);
+    filterFields.push(`  notLike: String`);
+    filterFields.push(`  ilike: String`);
+    filterFields.push(`  notIlike: String`);
+    filterFields.push(`  inArray: [${baseType}!]`);
+    filterFields.push(`  notInArray: [${baseType}!]`);
+    filterFields.push(`  isNull: Boolean`);
+    filterFields.push(`  isNotNull: Boolean`);
+    filterFields.push(`  OR: [${filterTypeName}!]`);
+    allDefs.push(`input ${filterTypeName} {
+${filterFields.join("\n")}
+}`);
+  }
+  allDefs.push(...typeDefs);
+  return allDefs.join("\n\n");
+};
+var generateQueryTypeDefs2 = (tables) => {
+  const queryFields = [];
+  for (const tableName of Object.keys(tables)) {
+    const typeName = capitalize(tableName);
+    queryFields.push(
+      `  ${tableName}FindMany(where: ${typeName}Filters, orderBy: ${typeName}OrderBy, limit: Int, offset: Int): [${typeName}!]!`
+    );
+    queryFields.push(
+      `  ${tableName}FindFirst(where: ${typeName}Filters, orderBy: ${typeName}OrderBy): ${typeName}`
+    );
+  }
+  return `type Query {
+${queryFields.join("\n")}
+}`;
+};
+var generateMutationTypeDefs2 = (tables) => {
+  const mutationFields = [];
+  for (const tableName of Object.keys(tables)) {
+    const typeName = capitalize(tableName);
+    mutationFields.push(
+      `  ${tableName}InsertMany(values: [${typeName}InsertInput!]!): [${typeName}!]!`
+    );
+    mutationFields.push(
+      `  ${tableName}UpdateMany(where: ${typeName}Filters, set: ${typeName}UpdateInput!): [${typeName}!]!`
+    );
+    mutationFields.push(
+      `  ${tableName}DeleteMany(where: ${typeName}Filters): ${typeName}DeleteResult!`
+    );
+  }
+  return `type Mutation {
+${mutationFields.join("\n")}
+}`;
+};
+
+// src/build-schema-sdl-with-dl/generator/queries/dataloader-resolvers.ts
+var import_graphql12 = require("graphql");
+var import_graphql_parse_resolve_info5 = require("graphql-parse-resolve-info");
+var import_drizzle_orm18 = require("drizzle-orm");
+
+// src/build-schema-sdl-with-dl/generator/utils/selection.ts
+var import_drizzle_orm16 = require("drizzle-orm");
+
+// src/build-schema-sdl-with-dl/generator/utils/filters.ts
+var import_drizzle_orm15 = require("drizzle-orm");
+var import_graphql11 = require("graphql");
+var extractFiltersColumn3 = (column, columnName, operators) => {
+  const entries = Object.entries(operators);
+  if (!entries.length)
+    return void 0;
+  if (operators.OR && operators.OR.length > 0) {
+    if (entries.length > 1) {
+      throw new import_graphql11.GraphQLError(
+        `WHERE ${columnName}: Cannot specify both fields and 'OR' in column operators!`
+      );
+    }
+    const variants2 = [];
+    for (const variant of operators.OR) {
+      const extracted = extractFiltersColumn3(column, columnName, variant);
+      if (extracted)
+        variants2.push(extracted);
+    }
+    return variants2.length ? variants2.length > 1 ? (0, import_drizzle_orm15.or)(...variants2) : variants2[0] : void 0;
+  }
+  const variants = [];
+  for (const [operatorName, operatorValue] of entries) {
+    if (operatorValue === null || operatorValue === false)
+      continue;
+    switch (operatorName) {
+      case "eq":
+      case "ne":
+      case "gt":
+      case "gte":
+      case "lt":
+      case "lte": {
+        const singleValue = remapFromGraphQLCore(
+          operatorValue,
+          column,
+          columnName
+        );
+        const opMap = { eq: import_drizzle_orm15.eq, ne: import_drizzle_orm15.ne, gt: import_drizzle_orm15.gt, gte: import_drizzle_orm15.gte, lt: import_drizzle_orm15.lt, lte: import_drizzle_orm15.lte };
+        variants.push(opMap[operatorName](column, singleValue));
+        break;
+      }
+      case "like":
+      case "notLike":
+      case "ilike":
+      case "notIlike": {
+        const opMap = { like: import_drizzle_orm15.like, notLike: import_drizzle_orm15.notLike, ilike: import_drizzle_orm15.ilike, notIlike: import_drizzle_orm15.notIlike };
+        variants.push(opMap[operatorName](column, operatorValue));
+        break;
+      }
+      case "inArray":
+      case "notInArray": {
+        if (!operatorValue.length) {
+          throw new import_graphql11.GraphQLError(
+            `WHERE ${columnName}: Unable to use operator ${operatorName} with an empty array!`
+          );
+        }
+        const arrayValue = operatorValue.map(
+          (val) => remapFromGraphQLCore(val, column, columnName)
+        );
+        const opMap = { inArray: import_drizzle_orm15.inArray, notInArray: import_drizzle_orm15.notInArray };
+        variants.push(opMap[operatorName](column, arrayValue));
+        break;
+      }
+      case "isNull":
+      case "isNotNull": {
+        const opMap = { isNull: import_drizzle_orm15.isNull, isNotNull: import_drizzle_orm15.isNotNull };
+        variants.push(opMap[operatorName](column));
+        break;
+      }
+    }
+  }
+  return variants.length ? variants.length > 1 ? (0, import_drizzle_orm15.and)(...variants) : variants[0] : void 0;
+};
+var buildWhereClause2 = (tableInfo, where) => {
+  if (!where || Object.keys(where).length === 0) {
+    return void 0;
+  }
+  if (where.OR && where.OR.length > 0) {
+    if (Object.keys(where).length > 1) {
+      throw new import_graphql11.GraphQLError(
+        `WHERE ${tableInfo.name}: Cannot specify both fields and 'OR' in table filters!`
+      );
+    }
+    const variants = [];
+    for (const variant of where.OR) {
+      const extracted = buildWhereClause2(tableInfo, variant);
+      if (extracted)
+        variants.push(extracted);
+    }
+    return variants.length ? variants.length > 1 ? (0, import_drizzle_orm15.or)(...variants) : variants[0] : void 0;
+  }
+  const conditions = [];
+  for (const [columnName, operators] of Object.entries(where)) {
+    if (columnName === "OR")
+      continue;
+    if (!operators || Object.keys(operators).length === 0)
+      continue;
+    const column = tableInfo.columns[columnName];
+    if (!column)
+      continue;
+    const extracted = extractFiltersColumn3(
+      column,
+      columnName,
+      operators
+    );
+    if (extracted)
+      conditions.push(extracted);
+  }
+  if (conditions.length === 0)
+    return void 0;
+  if (conditions.length === 1)
+    return conditions[0];
+  return (0, import_drizzle_orm15.and)(...conditions);
+};
+
+// src/build-schema-sdl-with-dl/generator/utils/selection.ts
+var buildOrderByClause2 = (tableInfo, orderBy) => {
+  if (!orderBy || Object.keys(orderBy).length === 0) {
+    return void 0;
+  }
+  const orderEntries = Object.entries(orderBy).map(([columnName, field]) => ({
+    columnName,
+    ...field
+  }));
+  orderEntries.sort((a, b) => a.priority - b.priority);
+  const orderClauses = [];
+  for (const entry of orderEntries) {
+    const column = tableInfo.columns[entry.columnName];
+    if (column) {
+      orderClauses.push(
+        entry.direction === "desc" ? (0, import_drizzle_orm16.desc)(column) : (0, import_drizzle_orm16.asc)(column)
+      );
+    }
+  }
+  return orderClauses.length > 0 ? orderClauses : void 0;
+};
+
+// src/build-schema-sdl-with-dl/generator/utils/dataloader.ts
+var import_dataloader = __toESM(require("dataloader"), 1);
+var import_drizzle_orm17 = require("drizzle-orm");
+var RelationDataLoader = class {
+  constructor(queryBase, tableInfo, relations) {
+    this.queryBase = queryBase;
+    this.tableInfo = tableInfo;
+    this.relations = relations;
+  }
+  loaders = /* @__PURE__ */ new Map();
+  createLoaderKey(key) {
+    return JSON.stringify({
+      relationName: key.relationName,
+      foreignKey: key.foreignKey,
+      isReversedRelation: key.isReversedRelation,
+      where: key.where,
+      orderBy: key.orderBy,
+      limit: key.limit,
+      offset: key.offset,
+      columns: key.columns
+    });
+  }
+  getOrCreateLoader(loaderKey) {
+    if (!this.loaders.has(loaderKey)) {
+      const loader = new import_dataloader.default(
+        async (keys) => this.batchLoadRelations(keys)
+      );
+      this.loaders.set(loaderKey, loader);
+    }
+    return this.loaders.get(loaderKey);
+  }
+  async batchLoadRelations(keys) {
+    const groupedKeys = /* @__PURE__ */ new Map();
+    for (const key of keys) {
+      const configKey = this.createLoaderKey(key);
+      if (!groupedKeys.has(configKey)) {
+        groupedKeys.set(configKey, []);
+      }
+      groupedKeys.get(configKey).push(key);
+    }
+    const results = [];
+    for (const [configKey, groupKeys] of Array.from(groupedKeys)) {
+      const firstKey = groupKeys[0];
+      if (!firstKey) {
+        continue;
+      }
+      const allParentIds = groupKeys.flatMap((key) => key.parentIds);
+      const uniqueParentIds = Array.from(new Set(allParentIds));
+      const whereClause = this.buildBatchWhereClause(
+        uniqueParentIds,
+        firstKey.isReversedRelation,
+        firstKey.foreignKey,
+        firstKey.where
+      );
+      if (!whereClause) {
+        results.push(...groupKeys.map(() => []));
+        continue;
+      }
+      let query = this.queryBase.findMany({
+        columns: {
+          ...firstKey.columns || {},
+          // Always include the foreign key column for mapping
+          [firstKey.foreignKey]: true
+        },
+        where: whereClause,
+        orderBy: firstKey.orderBy ? buildOrderByClause2(this.tableInfo, firstKey.orderBy) : void 0,
+        limit: firstKey.limit,
+        offset: firstKey.offset
+      });
+      console.log(`DataLoader executing query for relation ${firstKey.relationName} with foreign key ${firstKey.foreignKey}`);
+      const batchResults = await query;
+      console.log(`DataLoader got ${batchResults.length} results:`, batchResults);
+      const resultsByParentId = /* @__PURE__ */ new Map();
+      for (const result of batchResults) {
+        const parentId = result[firstKey.foreignKey];
+        if (!resultsByParentId.has(parentId)) {
+          resultsByParentId.set(parentId, []);
+        }
+        resultsByParentId.get(parentId).push(result);
+      }
+      for (const key of groupKeys) {
+        const keyResults = key.parentIds.map((parentId) => ({
+          parentId,
+          data: resultsByParentId.get(parentId) || []
+        }));
+        results.push(keyResults);
+      }
+    }
+    return results;
+  }
+  buildBatchWhereClause(parentIds, isReversedRelation, foreignKeyName, additionalWhere) {
+    const foreignKeyColumn = this.tableInfo.columns[foreignKeyName];
+    if (!foreignKeyColumn) {
+      console.error(`Foreign key column ${foreignKeyName} not found in table ${this.tableInfo.name}`);
+      console.error(`Available columns:`, Object.keys(this.tableInfo.columns));
+      return void 0;
+    }
+    const parentIdClause = (0, import_drizzle_orm17.inArray)(foreignKeyColumn, parentIds);
+    if (!additionalWhere) {
+      return parentIdClause;
+    }
+    const additionalClause = buildWhereClause2(this.tableInfo, additionalWhere);
+    return additionalClause ? (0, import_drizzle_orm17.and)(parentIdClause, additionalClause) : parentIdClause;
+  }
+  async loadRelation(relationName, parentIds, foreignKey, options = {}, isReversedRelation = false) {
+    const key = {
+      relationName,
+      parentIds,
+      foreignKey,
+      isReversedRelation,
+      ...options
+    };
+    const loaderKey = this.createLoaderKey(key);
+    const loader = this.getOrCreateLoader(loaderKey);
+    const result = await loader.load(key);
+    return result;
+  }
+  // Clear all loaders (call this at the end of each request)
+  clearAll() {
+    for (const loader of Array.from(this.loaders.values())) {
+      loader.clearAll();
+    }
+    this.loaders.clear();
+  }
+};
+function getRelationLoader(context, tableName, queryBase, tableInfo, relations) {
+  if (!context.relationLoaders.has(tableName)) {
+    context.relationLoaders.set(
+      tableName,
+      new RelationDataLoader(queryBase, tableInfo, relations)
+    );
+  }
+  return context.relationLoaders.get(tableName);
+}
+
+// src/build-schema-sdl-with-dl/generator/queries/dataloader-resolvers.ts
+var createDataLoaderFindManyResolver = (queryBase, tableInfo, tables, relations) => {
+  return async (parent, args, context, info) => {
+    try {
+      const { where, orderBy, limit, offset } = args;
+      const parsedInfo = (0, import_graphql_parse_resolve_info5.parseResolveInfo)(info, {
+        deep: true
+      });
+      const allFields = {};
+      if (parsedInfo.fieldsByTypeName) {
+        for (const fields of Object.values(parsedInfo.fieldsByTypeName)) {
+          Object.assign(allFields, fields);
+        }
+      }
+      const allColumns = {};
+      for (const columnName of Object.keys(tableInfo.columns)) {
+        allColumns[columnName] = true;
+      }
+      const mainResults = await queryBase.findMany({
+        columns: allColumns,
+        offset,
+        limit,
+        orderBy: buildOrderByClause2(tableInfo, orderBy),
+        where: buildWhereClause2(tableInfo, where)
+        // No 'with' clause - we'll load relations separately
+      });
+      if (mainResults.length === 0) {
+        return mainResults;
+      }
+      const enhancedResults = await loadRelationsWithDataLoader(
+        mainResults,
+        tableInfo,
+        tables,
+        relations,
+        allFields,
+        context
+      );
+      return enhancedResults;
+    } catch (e) {
+      if (typeof e === "object" && e !== null && "message" in e) {
+        throw new import_graphql12.GraphQLError(String(e.message));
+      }
+      throw e;
+    }
+  };
+};
+var createDataLoaderFindFirstResolver = (queryBase, tableInfo, tables, relations) => {
+  return async (parent, args, context, info) => {
+    try {
+      const { where, orderBy } = args;
+      const parsedInfo = (0, import_graphql_parse_resolve_info5.parseResolveInfo)(info, {
+        deep: true
+      });
+      const allFields = {};
+      if (parsedInfo.fieldsByTypeName) {
+        for (const fields of Object.values(parsedInfo.fieldsByTypeName)) {
+          Object.assign(allFields, fields);
+        }
+      }
+      const allColumns = {};
+      for (const columnName of Object.keys(tableInfo.columns)) {
+        allColumns[columnName] = true;
+      }
+      const mainResult = await queryBase.findFirst({
+        columns: allColumns,
+        orderBy: buildOrderByClause2(tableInfo, orderBy),
+        where: buildWhereClause2(tableInfo, where)
+        // No 'with' clause
+      });
+      if (!mainResult) {
+        return null;
+      }
+      const [enhancedResult] = await loadRelationsWithDataLoader(
+        [mainResult],
+        tableInfo,
+        tables,
+        relations,
+        allFields,
+        context
+      );
+      return enhancedResult || null;
+    } catch (e) {
+      if (typeof e === "object" && e !== null && "message" in e) {
+        throw new import_graphql12.GraphQLError(String(e.message));
+      }
+      throw e;
+    }
+  };
+};
+async function loadRelationsWithDataLoader(mainResults, tableInfo, tables, relations, fields, context) {
+  const tableRelations = relations[tableInfo.name];
+  if (!tableRelations) {
+    return mainResults;
+  }
+  for (const mainResult of mainResults) {
+    for (const [relName, { relation }] of Object.entries(tableRelations)) {
+      const relationField = fields[relName];
+      if (!relationField)
+        continue;
+      if ((0, import_drizzle_orm18.is)(relation, import_drizzle_orm18.One)) {
+        mainResult[relName] = null;
+      } else {
+        mainResult[relName] = [];
+      }
+    }
+  }
+  const primaryKeyColumn = Object.values(tableInfo.columns).find((col) => col.primary);
+  if (!primaryKeyColumn) {
+    throw new Error(`No primary key found for table ${tableInfo.name}`);
+  }
+  const parentIds = mainResults.map((result) => result[primaryKeyColumn.name]);
+  const relationPromises = [];
+  for (const [relName, { targetTableName, relation }] of Object.entries(tableRelations)) {
+    const relationField = fields[relName];
+    if (!relationField)
+      continue;
+    const targetTable = tables[targetTableName];
+    if (!targetTable)
+      continue;
+    const relationFields = {};
+    if (relationField.fieldsByTypeName) {
+      for (const typeFields of Object.values(relationField.fieldsByTypeName)) {
+        Object.assign(relationFields, typeFields);
+      }
+    }
+    const allTargetColumns = {};
+    for (const columnName of Object.keys(targetTable.columns)) {
+      allTargetColumns[columnName] = true;
+    }
+    const relationArgs = relationField.args;
+    const relationOptions = {
+      columns: allTargetColumns,
+      where: relationArgs?.where,
+      orderBy: relationArgs?.orderBy,
+      limit: relationArgs?.limit,
+      offset: relationArgs?.offset
+    };
+    let foreignKeyName;
+    let isReversedRelation = false;
+    const relationConfig = relation.config;
+    console.log(`Processing relation ${relName} for table ${tableInfo.name} -> ${targetTableName}`);
+    if (relationConfig?.fields && relationConfig.fields.length > 0) {
+      if ((0, import_drizzle_orm18.is)(relation, import_drizzle_orm18.One)) {
+        const fieldColumn = relationConfig.fields[0];
+        const referenceColumn = relationConfig.references[0];
+        const referenceKeyName = Object.keys(targetTable.columns).find(
+          (key) => targetTable.columns[key] === referenceColumn
+        ) || referenceColumn.name;
+        foreignKeyName = referenceKeyName;
+        isReversedRelation = false;
+        console.log(`One-to-one relation: foreignKey=${foreignKeyName}, isReversed=${isReversedRelation}`);
+      } else {
+        const fieldColumn = relationConfig.fields[0];
+        const referenceColumn = relationConfig.references[0];
+        foreignKeyName = Object.keys(targetTable.columns).find(
+          (key) => targetTable.columns[key] === referenceColumn
+        ) || referenceColumn.name;
+        isReversedRelation = false;
+        console.log(`Many-to-one relation: foreignKey=${foreignKeyName}, isReversed=${isReversedRelation}`);
+      }
+    } else if (relationConfig?.references && relationConfig.references.length > 0) {
+      foreignKeyName = relationConfig.references[0].name;
+      isReversedRelation = true;
+      console.log(`References-only relation: foreignKey=${foreignKeyName}, isReversed=${isReversedRelation}`);
+    } else {
+      if ((0, import_drizzle_orm18.is)(relation, import_drizzle_orm18.One)) {
+        let possibleForeignKeys = Object.entries(targetTable.columns).filter(([name, col]) => {
+          const lowerName = name.toLowerCase();
+          const tableName = tableInfo.name.toLowerCase();
+          return lowerName.endsWith("id") && (lowerName.includes(tableName) || lowerName === `${tableName}id` || lowerName === `${tableName}_id`);
+        });
+        if (possibleForeignKeys.length > 0) {
+          foreignKeyName = possibleForeignKeys[0][0];
+          isReversedRelation = true;
+        } else {
+          possibleForeignKeys = Object.entries(tableInfo.columns).filter(([name, col]) => {
+            const lowerName = name.toLowerCase();
+            const targetName = targetTableName.toLowerCase();
+            return lowerName.endsWith("id") && (lowerName.includes(targetName) || lowerName === `${targetName}id` || lowerName === `${targetName}_id`);
+          });
+          if (possibleForeignKeys.length > 0) {
+            foreignKeyName = possibleForeignKeys[0][0];
+            isReversedRelation = false;
+          } else {
+            console.warn(`Could not determine foreign key for one-to-one relation ${relName}`);
+            console.warn(`Available columns in current table ${tableInfo.name}:`, Object.keys(tableInfo.columns));
+            console.warn(`Available columns in target table ${targetTableName}:`, Object.keys(targetTable.columns));
+            continue;
+          }
+        }
+      } else {
+        let possibleForeignKeys = Object.entries(targetTable.columns).filter(([name, col]) => {
+          const lowerName = name.toLowerCase();
+          const tableName = tableInfo.name.toLowerCase();
+          return lowerName.endsWith("id") && (lowerName.includes(tableName) || lowerName === `${tableName}id` || lowerName === `${tableName}_id` || // Special case for author -> user relationship
+          tableName === "user" && lowerName === "authorid" || tableName === "user" && lowerName === "author_id");
+        });
+        if (possibleForeignKeys.length > 0) {
+          foreignKeyName = possibleForeignKeys[0][0];
+          isReversedRelation = true;
+        } else {
+          console.warn(`Could not determine foreign key for one-to-many relation ${relName}. Looking for foreign key in target table ${targetTableName} that references ${tableInfo.name}`);
+          console.warn(`Available columns in ${targetTableName}:`, Object.keys(targetTable.columns));
+          continue;
+        }
+      }
+    }
+    let actualParentIds = parentIds;
+    if (relationConfig?.fields && relationConfig.fields.length > 0) {
+      const fieldColumn = relationConfig.fields[0];
+      const fieldKeyName = Object.keys(tableInfo.columns).find(
+        (key) => tableInfo.columns[key] === fieldColumn
+      ) || fieldColumn.name;
+      if (tableInfo.columns[fieldKeyName]) {
+        actualParentIds = mainResults.map((result) => result[fieldKeyName]).filter((id) => id != null);
+        console.log(`Extracted foreign key values for many-to-one relation:`, actualParentIds);
+      }
+    }
+    const targetQueryBase = context.db?.query?.[targetTableName];
+    if (!targetQueryBase) {
+      console.warn(`No query base found for target table ${targetTableName}`);
+      continue;
+    }
+    const relationLoader = getRelationLoader(
+      context,
+      targetTableName,
+      targetQueryBase,
+      targetTable,
+      relations[targetTableName] || {}
+    );
+    console.log(`Created relation loader for ${targetTableName}, calling loadRelation with parentIds:`, actualParentIds);
+    const relationPromise = relationLoader.loadRelation(
+      relName,
+      actualParentIds,
+      foreignKeyName,
+      relationOptions,
+      isReversedRelation
+    ).then(async (relationResults) => {
+      console.log(`Relation ${relName} loaded, got ${relationResults.length} results:`, relationResults);
+      const relationMap = /* @__PURE__ */ new Map();
+      for (const result of relationResults) {
+        relationMap.set(result.parentId, result.data);
+      }
+      const hasNestedRelations = Object.keys(relationFields).some(
+        (fieldName) => !targetTable.columns[fieldName]
+      );
+      if (hasNestedRelations && relationResults.some((r) => r.data.length > 0)) {
+        const allRelationData = relationResults.flatMap((r) => r.data);
+        const enhancedRelationData = await loadRelationsWithDataLoader(
+          allRelationData,
+          targetTable,
+          tables,
+          relations,
+          relationFields,
+          context
+        );
+        let dataIndex = 0;
+        for (const result of relationResults) {
+          const enhancedData = enhancedRelationData.slice(dataIndex, dataIndex + result.data.length);
+          relationMap.set(result.parentId, enhancedData);
+          dataIndex += result.data.length;
+        }
+      }
+      for (const mainResult of mainResults) {
+        const parentId = mainResult[primaryKeyColumn.name];
+        if (relationConfig?.fields && relationConfig.fields.length > 0) {
+          const fieldColumn = relationConfig.fields[0];
+          const fieldKeyName = Object.keys(tableInfo.columns).find(
+            (key) => tableInfo.columns[key] === fieldColumn
+          ) || fieldColumn.name;
+          if (tableInfo.columns[fieldKeyName]) {
+            const foreignKeyValue = mainResult[fieldKeyName];
+            const relationData2 = relationMap.get(foreignKeyValue) || [];
+            mainResult[relName] = relationData2[0] || null;
+            continue;
+          }
+        }
+        const relationData = relationMap.get(parentId) || [];
+        if ((0, import_drizzle_orm18.is)(relation, import_drizzle_orm18.One)) {
+          mainResult[relName] = relationData[0] || null;
+        } else {
+          mainResult[relName] = relationData;
+        }
+      }
+    });
+    relationPromises.push(relationPromise);
+  }
+  await Promise.all(relationPromises);
+  return mainResults;
+}
+
+// src/build-schema-sdl-with-dl/generator/queries/index.ts
+var generateQueries2 = (db, tables, relations) => {
+  const queries = {};
+  for (const [tableName, tableInfo] of Object.entries(tables)) {
+    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?`
+      );
+    }
+    queries[`${tableName}FindMany`] = createDataLoaderFindManyResolver(
+      queryBase,
+      tableInfo,
+      tables,
+      relations
+    );
+    queries[`${tableName}FindFirst`] = createDataLoaderFindFirstResolver(
+      queryBase,
+      tableInfo,
+      tables,
+      relations
+    );
+  }
+  return queries;
+};
+
+// src/build-schema-sdl-with-dl/generator/mutations/resolvers.ts
+var import_graphql13 = require("graphql");
+var createInsertManyResolver2 = (db, queryBase, tableInfo, tables, relations, primaryKeyColumn) => {
+  const queryResolver = createDataLoaderFindManyResolver(queryBase, tableInfo, tables, relations);
+  return async (parent, args, context, info) => {
+    try {
+      const { values } = args;
+      if (!values || values.length === 0) {
+        throw new import_graphql13.GraphQLError("No values provided for insert");
+      }
+      const remappedValues = remapFromGraphQLArrayInput(
+        values,
+        tableInfo.table
+      );
+      const insertedRows = await db.insert(tableInfo.table).values(remappedValues).returning({
+        [primaryKeyColumn.name]: primaryKeyColumn
+      });
+      const insertedIds = insertedRows.map(
+        (row) => row[primaryKeyColumn.name]
+      );
+      const result = await queryResolver(
+        parent,
+        {
+          where: {
+            [primaryKeyColumn.name]: { inArray: insertedIds }
+          }
+        },
+        context,
+        info
+      );
+      return result;
+    } catch (e) {
+      if (typeof e === "object" && e !== null && "message" in e) {
+        throw new import_graphql13.GraphQLError(String(e.message));
+      }
+      throw e;
+    }
+  };
+};
+var createUpdateManyResolver2 = (db, queryBase, tableInfo, tables, relations, primaryKeyColumn) => {
+  const queryResolver = createDataLoaderFindManyResolver(queryBase, tableInfo, tables, relations);
+  return async (parent, args, context, info) => {
+    try {
+      const { where, set } = args;
+      if (!set || Object.keys(set).length === 0) {
+        throw new import_graphql13.GraphQLError("No values provided for update");
+      }
+      const remappedSet = remapFromGraphQLSingleInput(set, tableInfo.table);
+      const whereClause = buildWhereClause2(tableInfo, where);
+      let query = db.update(tableInfo.table).set(remappedSet);
+      if (whereClause) {
+        query = query.where(whereClause);
+      }
+      const updatedRows = await query.returning({
+        [primaryKeyColumn.name]: primaryKeyColumn
+      });
+      const updatedIds = updatedRows.map(
+        (row) => row[primaryKeyColumn.name]
+      );
+      const result = await queryResolver(
+        parent,
+        {
+          where: {
+            [primaryKeyColumn.name]: { inArray: updatedIds }
+          }
+        },
+        context,
+        info
+      );
+      return result;
+    } catch (e) {
+      if (typeof e === "object" && e !== null && "message" in e) {
+        throw new import_graphql13.GraphQLError(String(e.message));
+      }
+      throw e;
+    }
+  };
+};
+var createDeleteManyResolver2 = (db, queryBase, tableInfo, tables, relations, primaryKeyColumn) => {
+  const queryResolver = createDataLoaderFindManyResolver(queryBase, tableInfo, tables, relations);
+  return async (parent, args, context, info) => {
+    try {
+      const { where } = args;
+      const whereClause = buildWhereClause2(tableInfo, where);
+      let deleteQuery = db.delete(tableInfo.table);
+      if (whereClause) {
+        deleteQuery = deleteQuery.where(whereClause);
+      }
+      const deletedRows = await deleteQuery.returning({
+        [primaryKeyColumn.name]: primaryKeyColumn
+      });
+      const deletedItems = deletedRows.map((row) => ({
+        id: row[primaryKeyColumn.name]
+      }));
+      return {
+        deletedItems,
+        [tableInfo.name + "FindMany"]: queryResolver
+      };
+    } catch (e) {
+      if (typeof e === "object" && e !== null && "message" in e) {
+        throw new import_graphql13.GraphQLError(String(e.message));
+      }
+      throw e;
+    }
+  };
+};
+
+// src/build-schema-sdl-with-dl/generator/mutations/index.ts
+var generateMutations2 = (db, tables, relations) => {
+  const mutations = {};
+  const deleteResultResolvers = {};
+  for (const [tableName, tableInfo] of Object.entries(tables)) {
+    const capitalizedName = capitalize(tableName);
+    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 primaryKeyColumn = Object.values(tableInfo.columns).find(
+      (col) => col.primary || col.name === "id"
+    );
+    if (!primaryKeyColumn) {
+      throw new Error(
+        `Drizzle-GraphQL Error: Table ${tableName} does not have a primary key column`
+      );
+    }
+    mutations[`${tableName}InsertMany`] = createInsertManyResolver2(
+      db,
+      queryBase,
+      tableInfo,
+      tables,
+      relations,
+      primaryKeyColumn
+    );
+    mutations[`${tableName}UpdateMany`] = createUpdateManyResolver2(
+      db,
+      queryBase,
+      tableInfo,
+      tables,
+      relations,
+      primaryKeyColumn
+    );
+    mutations[`${tableName}DeleteMany`] = createDeleteManyResolver2(
+      db,
+      queryBase,
+      tableInfo,
+      tables,
+      relations,
+      primaryKeyColumn
+    );
+    deleteResultResolvers[`${capitalizedName}DeleteResult`] = {
+      [`${tableName}FindMany`]: (parent, args, context, info) => {
+        const resolverFn = parent[`${tableName}FindMany`];
+        if (typeof resolverFn === "function") {
+          return resolverFn(parent, args, context, info);
+        }
+        return [];
+      }
+    };
+  }
+  return { mutations, deleteResultResolvers };
+};
+
+// src/export-tool/directive-definitions.ts
+var exportDirectiveTypeDefs = `directive @export(as: String!) on FIELD`;
+
+// src/build-schema-sdl-with-dl/index.ts
+var import_schema3 = require("@graphql-tools/schema");
+var buildSchemaSDL2 = (db) => {
+  const schema = db._.fullSchema;
+  if (!schema) {
+    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!"
+    );
+  }
+  if (!(0, import_drizzle_orm19.is)(db, import_sqlite_core7.BaseSQLiteDatabase)) {
+    throw new Error(
+      "Drizzle-GraphQL Error: buildSchemaSDL currently only supports SQLite databases"
+    );
+  }
+  const { tables, relations } = generateTypes2(db, schema);
+  const typeDefsArray = [];
+  typeDefsArray.push(generateTypeDefs2(tables, relations));
+  typeDefsArray.push(generateQueryTypeDefs2(tables));
+  typeDefsArray.push(generateMutationTypeDefs2(tables));
+  const typeDefs = typeDefsArray.join("\n\n");
+  const queries = generateQueries2(db, tables, relations);
+  const { mutations, deleteResultResolvers } = generateMutations2(
+    db,
+    tables,
+    relations
+  );
+  const resolvers = {
+    Query: queries,
+    Mutation: mutations,
+    ...deleteResultResolvers
+  };
+  return {
+    typeDefs,
+    resolvers
+  };
+};
+
+// src/build-schema-sdl-with-dl/generator/utils/context.ts
+function createDataLoaderContext() {
+  return {
+    relationLoaders: /* @__PURE__ */ new Map()
+  };
+}
+function cleanupDataLoaderContext(context) {
+  for (const loader of Array.from(context.relationLoaders.values())) {
+    loader.clearAll();
+  }
+  context.relationLoaders.clear();
+}
+
+// src/build-schema-sdl-with-dl/generator/utils/envelop-plugin.ts
+var useDataLoaderCleanup = (options) => ({
+  onContextBuilding: ({ context, extendContext }) => {
+    const dataLoaderContext = createDataLoaderContext();
+    const contextExtension = dataLoaderContext;
+    if (options?.db) {
+      contextExtension.db = options.db;
+    }
+    extendContext(contextExtension);
+  },
+  onExecute: ({ args }) => ({
+    onExecuteDone: () => {
+      const context = args.contextValue;
+      if (context && context.relationLoaders) {
+        cleanupDataLoaderContext(context);
+      }
+    }
+  })
+});
+var useDataLoaderContext = (options) => ({
+  onContextBuilding: ({ context, extendContext }) => {
+    const dataLoaderContext = createDataLoaderContext();
+    const contextExtension = dataLoaderContext;
+    if (options?.db) {
+      contextExtension.db = options.db;
+    }
+    extendContext(contextExtension);
+  }
+});
+var useDataLoaderCleanupOnly = () => ({
+  onExecute: ({ args }) => ({
+    onExecuteDone: () => {
+      const context = args.contextValue;
+      if (context && context.relationLoaders) {
+        cleanupDataLoaderContext(context);
+      }
+    }
+  })
+});
+
 // src/export-tool/ExportStore.ts
 var ExportStore = class {
   store = /* @__PURE__ */ new Map();
@@ -3388,10 +4680,10 @@ function createExportMiddleware() {
 }
 
 // src/export-tool/makeScalarAcceptExports.ts
-var import_graphql11 = require("graphql");
+var import_graphql14 = require("graphql");
 function makeScalarAcceptExports(originalScalar) {
   const config = originalScalar.toConfig();
-  return new import_graphql11.GraphQLScalarType({
+  return new import_graphql14.GraphQLScalarType({
     ...config,
     name: config.name,
     // Keep original name to override it in schema
@@ -3407,7 +4699,7 @@ function makeScalarAcceptExports(originalScalar) {
       return value;
     },
     parseLiteral(ast, variables) {
-      if (ast.kind === import_graphql11.Kind.STRING) {
+      if (ast.kind === import_graphql14.Kind.STRING) {
         if (ast.value.startsWith("$_") || ast.value === "") {
           return ast.value;
         }
@@ -3421,13 +4713,13 @@ function makeScalarAcceptExports(originalScalar) {
 }
 
 // src/helpers.ts
-var import_drizzle_orm13 = require("drizzle-orm");
+var import_drizzle_orm20 = require("drizzle-orm");
 function setCustomGraphQL(table, columnConfig) {
   for (const [columnName, config] of Object.entries(columnConfig)) {
     const column = table[columnName];
     if (!column) {
       console.warn(
-        `Warning: Column "${columnName}" not found in table "${(0, import_drizzle_orm13.getTableName)(
+        `Warning: Column "${columnName}" not found in table "${(0, import_drizzle_orm20.getTableName)(
           table
         )}"`
       );
@@ -3451,9 +4743,16 @@ function setCustomGraphQLTypes(table, columnTypes) {
 0 && (module.exports = {
   buildSchema,
   buildSchemaSDL,
+  buildSchemaSDLWithDataLoader,
+  cleanupDataLoaderContext,
+  createDataLoaderContext,
   createExportMiddleware,
+  exportDirectiveTypeDefs,
   makeScalarAcceptExports,
   setCustomGraphQL,
-  setCustomGraphQLTypes
+  setCustomGraphQLTypes,
+  useDataLoaderCleanup,
+  useDataLoaderCleanupOnly,
+  useDataLoaderContext
 });
 //# sourceMappingURL=index.cjs.map