npm - drizzle-graphql-plus - Versions diffs - 0.8.35 → 0.8.37 - Mend

drizzle-graphql-plus 0.8.35 → 0.8.37

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (7) hide show

package/index.cjs CHANGED Viewed

@@ -5,15 +5,18 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
 };
-var __copyProps = (to, from, except, desc4) => {
+var __copyProps = (to, from, except, desc2) => {
   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: !(desc4 = __getOwnPropDesc(from, key)) || desc4.enumerable });
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc2 = __getOwnPropDesc(from, key)) || desc2.enumerable });
   }
   return to;
 };
@@ -27,3269 +30,191 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-// src/index.ts
-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,
-  useDataLoaderCleanup: () => useDataLoaderCleanup,
-  useDataLoaderCleanupOnly: () => useDataLoaderCleanupOnly,
-  useDataLoaderContext: () => useDataLoaderContext
+// src/export-tool/utils.ts
+var utils_exports = {};
+__export(utils_exports, {
+  extractExportDirectives: () => extractExportDirectives,
+  getExportDirective: () => getExportDirective,
+  getVariableName: () => getVariableName,
+  hasExportVariables: () => hasExportVariables,
+  isExportVariable: () => isExportVariable,
+  processExports: () => processExports,
+  resolveExportVariables: () => resolveExportVariables
 });
-module.exports = __toCommonJS(src_exports);
-// src/buildSchema.ts
-var import_drizzle_orm7 = require("drizzle-orm");
-var import_mysql_core3 = require("drizzle-orm/mysql-core");
-var import_pg_core3 = require("drizzle-orm/pg-core");
-var import_sqlite_core3 = require("drizzle-orm/sqlite-core");
-var import_graphql7 = require("graphql");
-// src/util/builders/mysql.ts
-var import_drizzle_orm4 = require("drizzle-orm");
-var import_mysql_core2 = require("drizzle-orm/mysql-core");
-var import_graphql4 = require("graphql");
-// src/util/builders/common.ts
-var import_drizzle_orm3 = require("drizzle-orm");
-var import_graphql3 = require("graphql");
-// src/util/case-ops/index.ts
-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;
-// src/util/data-mappers/index.ts
-var import_drizzle_orm = require("drizzle-orm");
-var import_graphql = require("graphql");
-var remapToGraphQLCore = (key, value, tableName, column, relationMap) => {
-  if (value instanceof Date)
-    return value.toISOString();
-  if (value instanceof Buffer)
-    return Array.from(value);
-  if (typeof value === "bigint")
-    return value.toString();
-  if (Array.isArray(value)) {
-    const relations = relationMap?.[tableName];
-    if (relations?.[key]) {
-      return remapToGraphQLArrayOutput(
-        value,
-        relations[key].targetTableName,
-        relations[key].relation.referencedTable,
-        relationMap
-      );
-    }
-    if (column.columnType === "PgGeometry" || column.columnType === "PgVector")
-      return value;
-    return value.map((arrVal) => remapToGraphQLCore(key, arrVal, tableName, column, relationMap));
-  }
-  if (typeof value === "object") {
-    const relations = relationMap?.[tableName];
-    if (relations?.[key]) {
-      return remapToGraphQLSingleOutput(
-        value,
-        relations[key].targetTableName,
-        relations[key].relation.referencedTable,
-        relationMap
-      );
-    }
-    if (column.columnType === "PgGeometryObject")
-      return value;
-    return JSON.stringify(value);
+function isExportVariable(value) {
+  return typeof value === "string" && value.startsWith("$_") && value.length > 2;
+}
+function getVariableName(value) {
+  if (!isExportVariable(value)) {
+    return null;
   }
-  return value;
-};
-var remapToGraphQLSingleOutput = (queryOutput, tableName, table, relationMap) => {
-  for (const [key, value] of Object.entries(queryOutput)) {
-    if (value === void 0 || value === null) {
-      delete queryOutput[key];
-    } else {
-      queryOutput[key] = remapToGraphQLCore(key, value, tableName, table[key], relationMap);
-    }
+  return value.slice(2);
+}
+async function resolveExportVariables(args, exportStore, timeout, allowNull = true) {
+  if (isExportVariable(args)) {
+    const varName = getVariableName(args);
+    return await exportStore.waitFor(varName, timeout, allowNull);
   }
-  return queryOutput;
-};
-var remapToGraphQLArrayOutput = (queryOutput, tableName, table, relationMap) => {
-  for (const entry of queryOutput) {
-    remapToGraphQLSingleOutput(entry, tableName, table, relationMap);
+  if (Array.isArray(args)) {
+    const resolved = await Promise.all(
+      args.map(async (item) => {
+        if (isExportVariable(item)) {
+          const varName = getVariableName(item);
+          return await exportStore.waitFor(varName, timeout, allowNull);
+        } else if (typeof item === "object" && item !== null) {
+          return await resolveExportVariables(
+            item,
+            exportStore,
+            timeout,
+            allowNull
+          );
+        }
+        return item;
+      })
+    );
+    return resolved;
   }
-  return queryOutput;
-};
-var remapFromGraphQLCore = (value, column, columnName) => {
-  switch (column.dataType) {
-    case "date": {
-      const formatted = new Date(value);
-      if (Number.isNaN(formatted.getTime()))
-        throw new import_graphql.GraphQLError(`Field '${columnName}' is not a valid date!`);
-      return formatted;
-    }
-    case "buffer": {
-      if (!Array.isArray(value)) {
-        throw new import_graphql.GraphQLError(`Field '${columnName}' is not an array!`);
-      }
-      return Buffer.from(value);
-    }
-    case "json": {
-      if (column.columnType === "PgGeometryObject")
-        return value;
-      try {
-        return JSON.parse(value);
-      } catch (e) {
-        throw new import_graphql.GraphQLError(
-          `Invalid JSON in field '${columnName}':
-${e instanceof Error ? e.message : "Unknown error"}`
+  if (typeof args === "object" && args !== null) {
+    const resolved = {};
+    for (const [key, value] of Object.entries(args)) {
+      if (isExportVariable(value)) {
+        const varName = getVariableName(value);
+        resolved[key] = await exportStore.waitFor(varName, timeout, allowNull);
+      } else if (Array.isArray(value)) {
+        resolved[key] = await resolveExportVariables(
+          value,
+          exportStore,
+          timeout,
+          allowNull
         );
-      }
-    }
-    case "array": {
-      if (!Array.isArray(value)) {
-        throw new import_graphql.GraphQLError(`Field '${columnName}' is not an array!`);
-      }
-      if (column.columnType === "PgGeometry" && value.length !== 2) {
-        throw new import_graphql.GraphQLError(
-          `Invalid float tuple in field '${columnName}': expected array with length of 2, received ${value.length}`
+      } else if (typeof value === "object" && value !== null) {
+        resolved[key] = await resolveExportVariables(
+          value,
+          exportStore,
+          timeout,
+          allowNull
         );
+      } else {
+        resolved[key] = value;
       }
-      return value;
-    }
-    case "bigint": {
-      try {
-        return BigInt(value);
-      } catch (error) {
-        throw new import_graphql.GraphQLError(`Field '${columnName}' is not a BigInt!`);
-      }
-    }
-    default: {
-      return value;
-    }
-  }
-};
-var remapFromGraphQLSingleInput = (queryInput, table) => {
-  for (const [key, value] of Object.entries(queryInput)) {
-    if (value === void 0) {
-      delete queryInput[key];
-    } else {
-      const column = (0, import_drizzle_orm.getTableColumns)(table)[key];
-      if (!column)
-        throw new import_graphql.GraphQLError(`Unknown column: ${key}`);
-      if (value === null && column.notNull) {
-        delete queryInput[key];
-        continue;
-      }
-      queryInput[key] = remapFromGraphQLCore(value, column, key);
     }
+    return resolved;
   }
-  return queryInput;
-};
-var remapFromGraphQLArrayInput = (queryInput, table) => {
-  for (const entry of queryInput)
-    remapFromGraphQLSingleInput(entry, table);
-  return queryInput;
-};
-// src/util/type-converter/index.ts
-var import_drizzle_orm2 = require("drizzle-orm");
-var import_mysql_core = require("drizzle-orm/mysql-core");
-var import_pg_core = require("drizzle-orm/pg-core");
-var import_sqlite_core = require("drizzle-orm/sqlite-core");
-var import_graphql2 = require("graphql");
-var allowedNameChars = /^[a-zA-Z0-9_]+$/;
-var enumMap = /* @__PURE__ */ new WeakMap();
-var generateEnumCached = (column, columnName, tableName) => {
-  if (enumMap.has(column))
-    return enumMap.get(column);
-  const gqlEnum = new import_graphql2.GraphQLEnumType({
-    name: `${capitalize(tableName)}${capitalize(columnName)}Enum`,
-    values: Object.fromEntries(column.enumValues.map((e, index) => [allowedNameChars.test(e) ? e : `Option${index}`, {
-      value: e,
-      description: `Value: ${e}`
-    }]))
-  });
-  enumMap.set(column, gqlEnum);
-  return gqlEnum;
-};
-var geoXyType = new import_graphql2.GraphQLObjectType({
-  name: "PgGeometryObject",
-  fields: {
-    x: { type: import_graphql2.GraphQLFloat },
-    y: { type: import_graphql2.GraphQLFloat }
-  }
-});
-var geoXyInputType = new import_graphql2.GraphQLInputObjectType({
-  name: "PgGeometryObjectInput",
-  fields: {
-    x: { type: import_graphql2.GraphQLFloat },
-    y: { type: import_graphql2.GraphQLFloat }
-  }
-});
-var columnToGraphQLCore = (column, columnName, tableName, isInput) => {
-  switch (column.dataType) {
-    case "boolean":
-      return { type: import_graphql2.GraphQLBoolean, description: "Boolean" };
-    case "json":
-      return column.columnType === "PgGeometryObject" ? {
-        type: isInput ? geoXyInputType : geoXyType,
-        description: "Geometry points XY"
-      } : { type: import_graphql2.GraphQLString, description: "JSON" };
-    case "date":
-      return { type: import_graphql2.GraphQLString, description: "Date" };
-    case "string":
-      if (column.enumValues?.length)
-        return { type: generateEnumCached(column, columnName, tableName) };
-      return { type: import_graphql2.GraphQLString, description: "String" };
-    case "bigint":
-      return { type: import_graphql2.GraphQLString, description: "BigInt" };
-    case "number":
-      return (0, import_drizzle_orm2.is)(column, import_pg_core.PgInteger) || (0, import_drizzle_orm2.is)(column, import_pg_core.PgSerial) || (0, import_drizzle_orm2.is)(column, import_mysql_core.MySqlInt) || (0, import_drizzle_orm2.is)(column, import_mysql_core.MySqlSerial) || (0, import_drizzle_orm2.is)(column, import_sqlite_core.SQLiteInteger) ? { type: import_graphql2.GraphQLInt, description: "Integer" } : { type: import_graphql2.GraphQLFloat, description: "Float" };
-    case "buffer":
-      return { type: new import_graphql2.GraphQLList(new import_graphql2.GraphQLNonNull(import_graphql2.GraphQLInt)), description: "Buffer" };
-    case "array": {
-      if (column.columnType === "PgVector") {
-        return {
-          type: new import_graphql2.GraphQLList(new import_graphql2.GraphQLNonNull(import_graphql2.GraphQLFloat)),
-          description: "Array<Float>"
-        };
-      }
-      if (column.columnType === "PgGeometry") {
-        return {
-          type: new import_graphql2.GraphQLList(new import_graphql2.GraphQLNonNull(import_graphql2.GraphQLFloat)),
-          description: "Tuple<[Float, Float]>"
-        };
-      }
-      const innerType = columnToGraphQLCore(
-        column.baseColumn,
-        columnName,
-        tableName,
-        isInput
-      );
-      return {
-        type: new import_graphql2.GraphQLList(new import_graphql2.GraphQLNonNull(innerType.type)),
-        description: `Array<${innerType.description}>`
-      };
-    }
-    case "custom":
-    default:
-      throw new Error(`Drizzle-GraphQL Error: Type ${column.dataType} is not implemented!`);
+  return args;
+}
+function getExportDirective(fieldNode) {
+  const node = fieldNode;
+  if (!node || !node.directives) {
+    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"];
-  if (noDesc.find((e) => e === column.dataType))
-    delete typeDesc.description;
-  if (forceNullable)
-    return typeDesc;
-  if (column.notNull && !(defaultIsNullable && (column.hasDefault || column.defaultFn))) {
-    return {
-      type: new import_graphql2.GraphQLNonNull(typeDesc.type),
-      description: typeDesc.description
-    };
+  const exportDirective = node.directives.find(
+    (directive) => directive.name.value === "export"
+  );
+  if (!exportDirective) {
+    return null;
   }
-  return typeDesc;
-};
-// src/util/builders/common.ts
-var rqbCrashTypes = ["SQLiteBigInt", "SQLiteBlobJson", "SQLiteBlobBuffer"];
-var extractSelectedColumnsFromTree = (tree, table) => {
-  const tableColumns = (0, import_drizzle_orm3.getTableColumns)(table);
-  const treeEntries = Object.entries(tree);
-  const selectedColumns = [];
-  for (const [fieldName, fieldData] of treeEntries) {
-    if (tableColumns[fieldData.name]) {
-      selectedColumns.push([fieldData.name, true]);
-      continue;
-    }
-    if (fieldData.fieldsByTypeName) {
-      for (const [typeName, typeFields] of Object.entries(
-        fieldData.fieldsByTypeName
-      )) {
-        for (const [subFieldName, subFieldData] of Object.entries(typeFields)) {
-          if (tableColumns[subFieldData.name]) {
-            selectedColumns.push([subFieldData.name, true]);
-          } else {
-          }
-        }
-      }
-    }
+  const asArg = exportDirective.arguments?.find(
+    (arg) => arg.name.value === "as"
+  );
+  if (!asArg || asArg.value.kind !== "StringValue") {
+    return null;
   }
-  if (!selectedColumns.length) {
-    const columnKeys = Object.entries(tableColumns);
-    const columnName = columnKeys.find(
-      (e) => rqbCrashTypes.find((haram) => e[1].columnType !== haram)
-    )?.[0] ?? columnKeys[0][0];
-    selectedColumns.push([columnName, true]);
+  return asArg.value.value;
+}
+function extractExportDirectives(info) {
+  const exports2 = /* @__PURE__ */ new Map();
+  const fieldNode = info.fieldNodes[0];
+  if (!fieldNode || !fieldNode.selectionSet) {
+    return exports2;
   }
-  return Object.fromEntries(selectedColumns);
-};
-var extractSelectedColumnsFromTreeSQLFormat = (tree, table) => {
-  const tableColumns = (0, import_drizzle_orm3.getTableColumns)(table);
-  const treeEntries = Object.entries(tree);
-  const selectedColumns = [];
-  for (const [fieldName, fieldData] of treeEntries) {
-    if (tableColumns[fieldData.name]) {
-      selectedColumns.push([fieldData.name, tableColumns[fieldData.name]]);
-      continue;
-    }
-    if (fieldData.fieldsByTypeName) {
-      for (const [typeName, typeFields] of Object.entries(
-        fieldData.fieldsByTypeName
-      )) {
-        for (const [subFieldName, subFieldData] of Object.entries(typeFields)) {
-          if (tableColumns[subFieldData.name]) {
-            selectedColumns.push([
-              subFieldData.name,
-              tableColumns[subFieldData.name]
-            ]);
-          }
-        }
+  for (const selection of fieldNode.selectionSet.selections) {
+    if (selection.kind === "Field") {
+      const exportName = getExportDirective(selection);
+      if (exportName) {
+        const fieldName = selection.name.value;
+        exports2.set(fieldName, exportName);
       }
     }
   }
-  if (!selectedColumns.length) {
-    const columnKeys = Object.entries(tableColumns);
-    const columnName = columnKeys.find(
-      (e) => rqbCrashTypes.find((haram) => e[1].columnType !== haram)
-    )?.[0] ?? columnKeys[0][0];
-    selectedColumns.push([columnName, tableColumns[columnName]]);
-  }
-  return Object.fromEntries(selectedColumns);
-};
-var innerOrder = new import_graphql3.GraphQLInputObjectType({
-  name: "InnerOrder",
-  fields: {
-    direction: {
-      type: new import_graphql3.GraphQLNonNull(
-        new import_graphql3.GraphQLEnumType({
-          name: "OrderDirection",
-          description: "Order by direction",
-          values: {
-            asc: {
-              value: "asc",
-              description: "Ascending order"
-            },
-            desc: {
-              value: "desc",
-              description: "Descending order"
-            }
-          }
-        })
-      )
-    },
-    priority: {
-      type: new import_graphql3.GraphQLNonNull(import_graphql3.GraphQLInt),
-      description: "Priority of current field"
-    }
-  }
-});
-var generateColumnFilterValues = (column, tableName, columnName) => {
-  const columnGraphQLType = drizzleColumnToGraphQLType(
-    column,
-    columnName,
-    tableName,
-    true,
-    false,
-    true
-  );
-  const columnArr = new import_graphql3.GraphQLList(new import_graphql3.GraphQLNonNull(columnGraphQLType.type));
-  const baseFields = {
-    eq: {
-      type: columnGraphQLType.type,
-      description: columnGraphQLType.description
-    },
-    ne: {
-      type: columnGraphQLType.type,
-      description: columnGraphQLType.description
-    },
-    lt: {
-      type: columnGraphQLType.type,
-      description: columnGraphQLType.description
-    },
-    lte: {
-      type: columnGraphQLType.type,
-      description: columnGraphQLType.description
-    },
-    gt: {
-      type: columnGraphQLType.type,
-      description: columnGraphQLType.description
-    },
-    gte: {
-      type: columnGraphQLType.type,
-      description: columnGraphQLType.description
-    },
-    like: { type: import_graphql3.GraphQLString },
-    notLike: { type: import_graphql3.GraphQLString },
-    ilike: { type: import_graphql3.GraphQLString },
-    notIlike: { type: import_graphql3.GraphQLString },
-    inArray: {
-      type: columnArr,
-      description: `Array<${columnGraphQLType.description}>`
-    },
-    notInArray: {
-      type: columnArr,
-      description: `Array<${columnGraphQLType.description}>`
-    },
-    isNull: { type: import_graphql3.GraphQLBoolean },
-    isNotNull: { type: import_graphql3.GraphQLBoolean }
-  };
-  const type = new import_graphql3.GraphQLInputObjectType({
-    name: `${capitalize(tableName)}${capitalize(columnName)}Filters`,
-    fields: {
-      ...baseFields,
-      OR: {
-        type: new import_graphql3.GraphQLList(
-          new import_graphql3.GraphQLNonNull(
-            new import_graphql3.GraphQLInputObjectType({
-              name: `${capitalize(tableName)}${capitalize(
-                columnName
-              )}filtersOr`,
-              fields: {
-                ...baseFields
-              }
-            })
-          )
-        )
-      }
-    }
-  });
-  return type;
-};
-var orderMap = /* @__PURE__ */ new WeakMap();
-var generateTableOrderCached = (table) => {
-  if (orderMap.has(table))
-    return orderMap.get(table);
-  const columns = (0, import_drizzle_orm3.getTableColumns)(table);
-  const columnEntries = Object.entries(columns);
-  const remapped = Object.fromEntries(
-    columnEntries.map(([columnName, columnDescription]) => [
-      columnName,
-      { type: innerOrder }
-    ])
-  );
-  orderMap.set(table, remapped);
-  return remapped;
-};
-var filterMap = /* @__PURE__ */ new WeakMap();
-var generateTableFilterValuesCached = (table, tableName) => {
-  if (filterMap.has(table))
-    return filterMap.get(table);
-  const columns = (0, import_drizzle_orm3.getTableColumns)(table);
-  const columnEntries = Object.entries(columns);
-  const remapped = Object.fromEntries(
-    columnEntries.map(([columnName, columnDescription]) => [
-      columnName,
-      {
-        type: generateColumnFilterValues(
-          columnDescription,
-          tableName,
-          columnName
-        )
-      }
-    ])
-  );
-  filterMap.set(table, remapped);
-  return remapped;
-};
-var fieldMap = /* @__PURE__ */ new WeakMap();
-var generateTableSelectTypeFieldsCached = (table, tableName) => {
-  if (fieldMap.has(table))
-    return fieldMap.get(table);
-  const columns = (0, import_drizzle_orm3.getTableColumns)(table);
-  const columnEntries = Object.entries(columns);
-  const remapped = Object.fromEntries(
-    columnEntries.map(([columnName, columnDescription]) => [
-      columnName,
-      drizzleColumnToGraphQLType(columnDescription, columnName, tableName)
-    ])
-  );
-  fieldMap.set(table, remapped);
-  return remapped;
-};
-var orderTypeMap = /* @__PURE__ */ new WeakMap();
-var generateTableOrderTypeCached = (table, tableName) => {
-  if (orderTypeMap.has(table))
-    return orderTypeMap.get(table);
-  const orderColumns = generateTableOrderCached(table);
-  const order = new import_graphql3.GraphQLInputObjectType({
-    name: `${capitalize(tableName)}OrderBy`,
-    fields: orderColumns
-  });
-  orderTypeMap.set(table, order);
-  return order;
-};
-var filterTypeMap = /* @__PURE__ */ new WeakMap();
-var generateTableFilterTypeCached = (table, tableName) => {
-  if (filterTypeMap.has(table))
-    return filterTypeMap.get(table);
-  const filterColumns = generateTableFilterValuesCached(table, tableName);
-  const filters = new import_graphql3.GraphQLInputObjectType({
-    name: `${capitalize(tableName)}Filters`,
-    fields: {
-      ...filterColumns,
-      OR: {
-        type: new import_graphql3.GraphQLList(
-          new import_graphql3.GraphQLNonNull(
-            new import_graphql3.GraphQLInputObjectType({
-              name: `${capitalize(tableName)}FiltersOr`,
-              fields: filterColumns
-            })
-          )
-        )
-      }
-    }
-  });
-  filterTypeMap.set(table, filters);
-  return filters;
-};
-var interfaceTypeMap = /* @__PURE__ */ new WeakMap();
-var generateTableInterfaceTypeCached = (table, tableName) => {
-  if (interfaceTypeMap.has(table))
-    return interfaceTypeMap.get(table);
-  const tableFields = generateTableSelectTypeFieldsCached(table, tableName);
-  const interfaceType = new import_graphql3.GraphQLInterfaceType({
-    name: `${capitalize(tableName)}Fields`,
-    fields: tableFields,
-    resolveType(obj) {
-      if (obj.__typename) {
-        return obj.__typename;
-      }
-      return null;
-    }
-  });
-  interfaceTypeMap.set(table, interfaceType);
-  return interfaceType;
-};
-var generateSelectFields = (tables, tableName, relationMap, typeName, withOrder, relationsDepthLimit, currentDepth = 0, usedTables = /* @__PURE__ */ new Set()) => {
-  const relations = relationMap[tableName];
-  const relationEntries = relations ? Object.entries(relations) : [];
-  const table = tables[tableName];
-  const order = withOrder ? generateTableOrderTypeCached(table, tableName) : void 0;
-  const filters = generateTableFilterTypeCached(table, tableName);
-  const tableFields = generateTableSelectTypeFieldsCached(table, tableName);
-  if (usedTables.has(tableName) || typeof relationsDepthLimit === "number" && currentDepth >= relationsDepthLimit || !relationEntries.length) {
-    return {
-      order,
-      filters,
-      tableFields,
-      relationFields: {}
-    };
-  }
-  const rawRelationFields = [];
-  const updatedUsedTables = new Set(usedTables).add(tableName);
-  const newDepth = currentDepth + 1;
-  for (const [relationName, { targetTableName, relation }] of relationEntries) {
-    const relTypeName = `${typeName}${capitalize(relationName)}Relation`;
-    const isOne = (0, import_drizzle_orm3.is)(relation, import_drizzle_orm3.One);
-    const relData = generateSelectFields(
-      tables,
-      targetTableName,
-      relationMap,
-      relTypeName,
-      !isOne,
-      relationsDepthLimit,
-      newDepth,
-      updatedUsedTables
-    );
-    const targetTable = tables[targetTableName];
-    const targetInterface = generateTableInterfaceTypeCached(
-      targetTable,
-      targetTableName
-    );
-    const relType = new import_graphql3.GraphQLObjectType({
-      name: relTypeName,
-      fields: { ...relData.tableFields, ...relData.relationFields },
-      interfaces: [targetInterface]
-    });
-    if (isOne) {
-      rawRelationFields.push([
-        relationName,
-        {
-          type: relType,
-          args: {
-            where: { type: relData.filters }
-          }
-        }
-      ]);
-      continue;
-    }
-    rawRelationFields.push([
-      relationName,
-      {
-        type: new import_graphql3.GraphQLNonNull(new import_graphql3.GraphQLList(new import_graphql3.GraphQLNonNull(relType))),
-        args: {
-          where: { type: relData.filters },
-          orderBy: { type: relData.order },
-          offset: { type: import_graphql3.GraphQLInt },
-          limit: { type: import_graphql3.GraphQLInt }
-        }
-      }
-    ]);
-  }
-  const relationFields = Object.fromEntries(rawRelationFields);
-  return {
-    order,
-    filters,
-    tableFields,
-    relationFields
-  };
-};
-var generateTableTypes = (tableName, tables, relationMap, withReturning, relationsDepthLimit) => {
-  const stylizedName = capitalize(tableName);
-  const { tableFields, relationFields, filters, order } = generateSelectFields(
-    tables,
-    tableName,
-    relationMap,
-    stylizedName,
-    true,
-    relationsDepthLimit
-  );
-  const table = tables[tableName];
-  const columns = (0, import_drizzle_orm3.getTableColumns)(table);
-  const columnEntries = Object.entries(columns);
-  const insertFields = Object.fromEntries(
-    columnEntries.map(([columnName, columnDescription]) => [
-      columnName,
-      drizzleColumnToGraphQLType(
-        columnDescription,
-        columnName,
-        tableName,
-        false,
-        true,
-        true
-      )
-    ])
-  );
-  const updateFields = Object.fromEntries(
-    columnEntries.map(([columnName, columnDescription]) => [
-      columnName,
-      drizzleColumnToGraphQLType(
-        columnDescription,
-        columnName,
-        tableName,
-        true,
-        false,
-        true
-      )
-    ])
-  );
-  const insertInput = new import_graphql3.GraphQLInputObjectType({
-    name: `${stylizedName}InsertInput`,
-    fields: insertFields
-  });
-  const tableFieldsInterface = generateTableInterfaceTypeCached(
-    table,
-    tableName
-  );
-  const selectSingleOutput = new import_graphql3.GraphQLObjectType({
-    name: `${stylizedName}SelectItem`,
-    fields: { ...tableFields, ...relationFields },
-    interfaces: [tableFieldsInterface]
-  });
-  const selectArrOutput = new import_graphql3.GraphQLNonNull(
-    new import_graphql3.GraphQLList(new import_graphql3.GraphQLNonNull(selectSingleOutput))
-  );
-  const singleTableItemOutput = withReturning ? new import_graphql3.GraphQLObjectType({
-    name: `${stylizedName}Item`,
-    fields: tableFields,
-    interfaces: [tableFieldsInterface]
-  }) : void 0;
-  const arrTableItemOutput = withReturning ? new import_graphql3.GraphQLNonNull(
-    new import_graphql3.GraphQLList(new import_graphql3.GraphQLNonNull(singleTableItemOutput))
-  ) : void 0;
-  const updateInput = new import_graphql3.GraphQLInputObjectType({
-    name: `${stylizedName}UpdateInput`,
-    fields: updateFields
-  });
-  const inputs = {
-    insertInput,
-    updateInput,
-    tableOrder: order,
-    tableFilters: filters
-  };
-  const outputs = withReturning ? {
-    selectSingleOutput,
-    selectArrOutput,
-    singleTableItemOutput,
-    arrTableItemOutput,
-    tableFieldsInterface
-  } : {
-    selectSingleOutput,
-    selectArrOutput,
-    tableFieldsInterface
-  };
-  return {
-    inputs,
-    outputs
-  };
-};
-var extractOrderBy = (table, orderArgs) => {
-  const res = [];
-  for (const [column, config] of Object.entries(orderArgs).sort(
-    (a, b) => (b[1]?.priority ?? 0) - (a[1]?.priority ?? 0)
-  )) {
-    if (!config)
-      continue;
-    const { direction } = config;
-    res.push(
-      direction === "asc" ? (0, import_drizzle_orm3.asc)((0, import_drizzle_orm3.getTableColumns)(table)[column]) : (0, import_drizzle_orm3.desc)((0, import_drizzle_orm3.getTableColumns)(table)[column])
-    );
-  }
-  return res;
-};
-var extractFiltersColumn = (column, columnName, operators) => {
-  if (!operators.OR?.length)
-    delete operators.OR;
-  const entries = Object.entries(
-    operators
-  );
-  if (operators.OR) {
-    if (entries.length > 1) {
-      throw new import_graphql3.GraphQLError(
-        `WHERE ${columnName}: Cannot specify both fields and 'OR' in column operators!`
-      );
-    }
-    const variants2 = [];
-    for (const variant of operators.OR) {
-      const extracted = extractFiltersColumn(column, columnName, variant);
-      if (extracted)
-        variants2.push(extracted);
-    }
-    return variants2.length ? variants2.length > 1 ? (0, import_drizzle_orm3.or)(...variants2) : variants2[0] : void 0;
-  }
-  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;
-      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));
-    }
-  }
-  return variants.length ? variants.length > 1 ? (0, import_drizzle_orm3.and)(...variants) : variants[0] : void 0;
-};
-var extractFilters = (table, tableName, filters) => {
-  if (!filters.OR?.length)
-    delete filters.OR;
-  const entries = Object.entries(filters);
-  if (!entries.length)
-    return;
-  if (filters.OR) {
-    if (entries.length > 1) {
-      throw new import_graphql3.GraphQLError(
-        `WHERE ${tableName}: Cannot specify both fields and 'OR' in table filters!`
-      );
-    }
-    const variants2 = [];
-    for (const variant of filters.OR) {
-      const extracted = extractFilters(table, tableName, variant);
-      if (extracted)
-        variants2.push(extracted);
-    }
-    return variants2.length ? variants2.length > 1 ? (0, import_drizzle_orm3.or)(...variants2) : variants2[0] : void 0;
-  }
-  const variants = [];
-  for (const [columnName, operators] of entries) {
-    if (operators === null)
-      continue;
-    const column = (0, import_drizzle_orm3.getTableColumns)(table)[columnName];
-    variants.push(extractFiltersColumn(column, columnName, operators));
-  }
-  return variants.length ? variants.length > 1 ? (0, import_drizzle_orm3.and)(...variants) : variants[0] : void 0;
-};
-var extractRelationsParamsInner = (relationMap, tables, tableName, typeName, originField, isInitial = false) => {
-  const relations = relationMap[tableName];
-  if (!relations)
-    return void 0;
-  const baseField = Object.entries(originField.fieldsByTypeName).find(
-    ([key, value]) => key === typeName
-  )?.[1];
-  if (!baseField)
-    return void 0;
-  const args = {};
-  for (const [relName, { targetTableName, relation }] of Object.entries(
-    relations
-  )) {
-    const relTypeName = `${isInitial ? capitalize(tableName) : typeName}${capitalize(relName)}Relation`;
-    const relationField = Object.values(baseField).find(
-      (field) => field.name === relName
-    );
-    if (!relationField)
-      continue;
-    const allFields = {};
-    if (relationField.fieldsByTypeName) {
-      for (const [typeName2, typeFields] of Object.entries(
-        relationField.fieldsByTypeName
-      )) {
-        Object.assign(allFields, typeFields);
-      }
-    }
-    const columns = extractSelectedColumnsFromTree(
-      allFields,
-      tables[targetTableName]
-    );
-    const thisRecord = {};
-    thisRecord.columns = columns;
-    const relationArgs = relationField?.args;
-    const orderBy = relationArgs?.orderBy ? extractOrderBy(tables[targetTableName], relationArgs.orderBy) : void 0;
-    const where = relationArgs?.where ? extractFilters(tables[targetTableName], relName, relationArgs?.where) : void 0;
-    const offset = relationArgs?.offset ?? void 0;
-    const limit = relationArgs?.limit ?? void 0;
-    thisRecord.orderBy = orderBy;
-    thisRecord.where = where;
-    thisRecord.offset = offset;
-    thisRecord.limit = limit;
-    const relWith = relationField ? extractRelationsParamsInner(
-      relationMap,
-      tables,
-      targetTableName,
-      relTypeName,
-      relationField
-    ) : void 0;
-    thisRecord.with = relWith;
-    args[relName] = thisRecord;
-  }
-  return args;
-};
-var extractRelationsParams = (relationMap, tables, tableName, info, typeName) => {
-  if (!info)
-    return void 0;
-  return extractRelationsParamsInner(
-    relationMap,
-    tables,
-    tableName,
-    typeName,
-    info,
-    true
-  );
-};
-// src/util/builders/mysql.ts
-var import_graphql_parse_resolve_info = require("graphql-parse-resolve-info");
-var generateSelectArray = (db, tableName, tables, relationMap, orderArgs, filterArgs) => {
-  const queryName = `${uncapitalize(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 queryArgs = {
-    offset: {
-      type: import_graphql4.GraphQLInt
-    },
-    limit: {
-      type: import_graphql4.GraphQLInt
-    },
-    orderBy: {
-      type: orderArgs
-    },
-    where: {
-      type: filterArgs
-    }
-  };
-  const typeName = `${capitalize(tableName)}SelectItem`;
-  const table = tables[tableName];
-  return {
-    name: queryName,
-    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 allFields = {};
-        if (parsedInfo.fieldsByTypeName) {
-          for (const fields of Object.values(parsedInfo.fieldsByTypeName)) {
-            Object.assign(allFields, fields);
-          }
-        }
-        const query = queryBase.findMany({
-          columns: extractSelectedColumnsFromTree(allFields, table),
-          offset,
-          limit,
-          orderBy: orderBy ? extractOrderBy(table, orderBy) : void 0,
-          where: where ? extractFilters(table, tableName, where) : void 0,
-          with: relationMap[tableName] ? extractRelationsParams(
-            relationMap,
-            tables,
-            tableName,
-            parsedInfo,
-            typeName
-          ) : void 0
-        });
-        const result = await query;
-        return remapToGraphQLArrayOutput(result, tableName, table, relationMap);
-      } catch (e) {
-        if (typeof e === "object" && typeof e.message === "string") {
-          throw new import_graphql4.GraphQLError(e.message);
-        }
-        throw e;
-      }
-    },
-    args: queryArgs
-  };
-};
-var generateSelectSingle = (db, tableName, tables, relationMap, orderArgs, filterArgs) => {
-  const queryName = `${uncapitalize(tableName)}Single`;
-  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 = `${capitalize(tableName)}SelectItem`;
-  const table = tables[tableName];
-  return {
-    name: queryName,
-    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 allFields = {};
-        if (parsedInfo.fieldsByTypeName) {
-          for (const fields of Object.values(parsedInfo.fieldsByTypeName)) {
-            Object.assign(allFields, fields);
-          }
-        }
-        const query = queryBase.findFirst({
-          columns: extractSelectedColumnsFromTree(allFields, table),
-          offset,
-          orderBy: orderBy ? extractOrderBy(table, orderBy) : void 0,
-          where: where ? extractFilters(table, tableName, where) : void 0,
-          with: relationMap[tableName] ? extractRelationsParams(
-            relationMap,
-            tables,
-            tableName,
-            parsedInfo,
-            typeName
-          ) : void 0
-        });
-        const result = await query;
-        if (!result)
-          return void 0;
-        return remapToGraphQLSingleOutput(
-          result,
-          tableName,
-          table,
-          relationMap
-        );
-      } catch (e) {
-        if (typeof e === "object" && typeof e.message === "string") {
-          throw new import_graphql4.GraphQLError(e.message);
-        }
-        throw e;
-      }
-    },
-    args: queryArgs
-  };
-};
-var generateInsertArray = (db, tableName, table, baseType) => {
-  const queryName = `insertInto${capitalize(tableName)}`;
-  const queryArgs = {
-    values: {
-      type: new import_graphql4.GraphQLNonNull(new import_graphql4.GraphQLList(new import_graphql4.GraphQLNonNull(baseType)))
-    }
-  };
-  return {
-    name: queryName,
-    resolver: async (source, args, context, info) => {
-      try {
-        const input = remapFromGraphQLArrayInput(args.values, table);
-        if (!input.length)
-          throw new import_graphql4.GraphQLError("No values were provided!");
-        await db.insert(table).values(input);
-        return { isSuccess: true };
-      } catch (e) {
-        if (typeof e === "object" && typeof e.message === "string") {
-          throw new import_graphql4.GraphQLError(e.message);
-        }
-        throw e;
-      }
-    },
-    args: queryArgs
-  };
-};
-var generateInsertSingle = (db, tableName, table, baseType) => {
-  const queryName = `insertInto${capitalize(tableName)}Single`;
-  const queryArgs = {
-    values: {
-      type: new import_graphql4.GraphQLNonNull(baseType)
-    }
-  };
-  return {
-    name: queryName,
-    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 (typeof e === "object" && typeof e.message === "string") {
-          throw new import_graphql4.GraphQLError(e.message);
-        }
-        throw e;
-      }
-    },
-    args: queryArgs
-  };
-};
-var generateUpdate = (db, tableName, table, setArgs, filterArgs) => {
-  const queryName = `update${capitalize(tableName)}`;
-  const queryArgs = {
-    set: {
-      type: new import_graphql4.GraphQLNonNull(setArgs)
-    },
-    where: {
-      type: filterArgs
-    }
-  };
-  return {
-    name: queryName,
-    resolver: async (source, args, context, info) => {
-      try {
-        const { where, set } = args;
-        const input = remapFromGraphQLSingleInput(set, table);
-        if (!Object.keys(input).length)
-          throw new import_graphql4.GraphQLError("Unable to update with no values specified!");
-        let query = db.update(table).set(input);
-        if (where) {
-          const filters = extractFilters(table, tableName, where);
-          query = query.where(filters);
-        }
-        await query;
-        return { isSuccess: true };
-      } catch (e) {
-        if (typeof e === "object" && typeof e.message === "string") {
-          throw new import_graphql4.GraphQLError(e.message);
-        }
-        throw e;
-      }
-    },
-    args: queryArgs
-  };
-};
-var generateDelete = (db, tableName, table, filterArgs) => {
-  const queryName = `deleteFrom${tableName}`;
-  const queryArgs = {
-    where: {
-      type: filterArgs
-    }
-  };
-  return {
-    name: queryName,
-    resolver: async (source, args, context, info) => {
-      try {
-        const { where } = args;
-        let query = db.delete(table);
-        if (where) {
-          const filters = extractFilters(table, tableName, where);
-          query = query.where(filters);
-        }
-        await query;
-        return { isSuccess: true };
-      } catch (e) {
-        if (typeof e === "object" && typeof e.message === "string") {
-          throw new import_graphql4.GraphQLError(e.message);
-        }
-        throw e;
-      }
-    },
-    args: queryArgs
-  };
-};
-var generateSchemaData = (db, schema, relationsDepthLimit) => {
-  const rawSchema = schema;
-  const schemaEntries = Object.entries(rawSchema);
-  const tableEntries = schemaEntries.filter(
-    ([key, value]) => (0, import_drizzle_orm4.is)(value, import_mysql_core2.MySqlTable)
-  );
-  const tables = Object.fromEntries(tableEntries);
-  if (!tableEntries.length) {
-    throw new Error(
-      "Drizzle-GraphQL Error: No tables detected in Drizzle-ORM's database instance. Did you forget to pass schema to drizzle constructor?"
-    );
-  }
-  const rawRelations = schemaEntries.filter(([key, value]) => (0, import_drizzle_orm4.is)(value, import_drizzle_orm4.Relations)).map(([key, value]) => [
-    tableEntries.find(
-      ([tableName, tableValue]) => tableValue === value.table
-    )[0],
-    value
-  ]).map(([tableName, relValue]) => [
-    tableName,
-    relValue.config((0, import_drizzle_orm4.createTableRelationsHelpers)(tables[tableName]))
-  ]);
-  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];
-    })
-  );
-  const queries = {};
-  const mutations = {};
-  const gqlSchemaTypes = Object.fromEntries(
-    Object.entries(tables).map(([tableName, table]) => [
-      tableName,
-      generateTableTypes(
-        tableName,
-        tables,
-        namedRelations,
-        false,
-        relationsDepthLimit
-      )
-    ])
-  );
-  const mutationReturnType = new import_graphql4.GraphQLObjectType({
-    name: `MutationReturn`,
-    fields: {
-      isSuccess: {
-        type: new import_graphql4.GraphQLNonNull(import_graphql4.GraphQLBoolean)
-      }
-    }
-  });
-  const inputs = {};
-  const interfaces = {};
-  const outputs = {
-    MutationReturn: mutationReturnType
-  };
-  for (const [tableName, tableTypes] of Object.entries(gqlSchemaTypes)) {
-    const { insertInput, updateInput, tableFilters, tableOrder } = tableTypes.inputs;
-    const { selectSingleOutput, selectArrOutput, tableFieldsInterface } = tableTypes.outputs;
-    const selectArrGenerated = generateSelectArray(
-      db,
-      tableName,
-      tables,
-      namedRelations,
-      tableOrder,
-      tableFilters
-    );
-    const selectSingleGenerated = generateSelectSingle(
-      db,
-      tableName,
-      tables,
-      namedRelations,
-      tableOrder,
-      tableFilters
-    );
-    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,
-      resolve: selectArrGenerated.resolver
-    };
-    queries[selectSingleGenerated.name] = {
-      type: selectSingleOutput,
-      args: selectSingleGenerated.args,
-      resolve: selectSingleGenerated.resolver
-    };
-    mutations[insertArrGenerated.name] = {
-      type: mutationReturnType,
-      args: insertArrGenerated.args,
-      resolve: insertArrGenerated.resolver
-    };
-    mutations[insertSingleGenerated.name] = {
-      type: mutationReturnType,
-      args: insertSingleGenerated.args,
-      resolve: insertSingleGenerated.resolver
-    };
-    mutations[updateGenerated.name] = {
-      type: mutationReturnType,
-      args: updateGenerated.args,
-      resolve: updateGenerated.resolver
-    };
-    mutations[deleteGenerated.name] = {
-      type: mutationReturnType,
-      args: deleteGenerated.args,
-      resolve: deleteGenerated.resolver
-    };
-    [insertInput, updateInput, tableFilters, tableOrder].forEach(
-      (e) => inputs[e.name] = e
-    );
-    outputs[selectSingleOutput.name] = selectSingleOutput;
-    interfaces[tableFieldsInterface.name] = tableFieldsInterface;
-  }
-  return { queries, mutations, inputs, interfaces, types: outputs };
-};
-// src/util/builders/pg.ts
-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 generateSelectArray2 = (db, tableName, tables, relationMap, orderArgs, filterArgs) => {
-  const queryName = `${uncapitalize(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 queryArgs = {
-    offset: {
-      type: import_graphql5.GraphQLInt
-    },
-    limit: {
-      type: import_graphql5.GraphQLInt
-    },
-    orderBy: {
-      type: orderArgs
-    },
-    where: {
-      type: filterArgs
-    }
-  };
-  const typeName = `${capitalize(tableName)}SelectItem`;
-  const table = tables[tableName];
-  return {
-    name: queryName,
-    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 query = queryBase.findMany({
-          columns: extractSelectedColumnsFromTree(
-            parsedInfo.fieldsByTypeName[typeName],
-            table
-          ),
-          offset,
-          limit,
-          orderBy: orderBy ? extractOrderBy(table, orderBy) : void 0,
-          where: where ? extractFilters(table, tableName, where) : void 0,
-          with: relationMap[tableName] ? extractRelationsParams(
-            relationMap,
-            tables,
-            tableName,
-            parsedInfo,
-            typeName
-          ) : void 0
-        });
-        const result = await query;
-        return remapToGraphQLArrayOutput(result, tableName, table, relationMap);
-      } catch (e) {
-        if (typeof e === "object" && typeof e.message === "string") {
-          throw new import_graphql5.GraphQLError(e.message);
-        }
-        throw e;
-      }
-    },
-    args: queryArgs
-  };
-};
-var generateSelectSingle2 = (db, tableName, tables, relationMap, orderArgs, filterArgs) => {
-  const queryName = `${uncapitalize(tableName)}Single`;
-  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_graphql5.GraphQLInt
-    },
-    orderBy: {
-      type: orderArgs
-    },
-    where: {
-      type: filterArgs
-    }
-  };
-  const typeName = `${capitalize(tableName)}SelectItem`;
-  const table = tables[tableName];
-  return {
-    name: queryName,
-    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 allFields = {};
-        if (parsedInfo.fieldsByTypeName) {
-          for (const fields of Object.values(parsedInfo.fieldsByTypeName)) {
-            Object.assign(allFields, fields);
-          }
-        }
-        const query = queryBase.findFirst({
-          columns: extractSelectedColumnsFromTree(allFields, table),
-          offset,
-          orderBy: orderBy ? extractOrderBy(table, orderBy) : void 0,
-          where: where ? extractFilters(table, tableName, where) : void 0,
-          with: relationMap[tableName] ? extractRelationsParams(
-            relationMap,
-            tables,
-            tableName,
-            parsedInfo,
-            typeName
-          ) : void 0
-        });
-        const result = await query;
-        if (!result)
-          return void 0;
-        return remapToGraphQLSingleOutput(
-          result,
-          tableName,
-          table,
-          relationMap
-        );
-      } catch (e) {
-        if (typeof e === "object" && typeof e.message === "string") {
-          throw new import_graphql5.GraphQLError(e.message);
-        }
-        throw e;
-      }
-    },
-    args: queryArgs
-  };
-};
-var generateInsertArray2 = (db, tableName, table, baseType) => {
-  const queryName = `insertInto${capitalize(tableName)}`;
-  const typeName = `${capitalize(tableName)}Item`;
-  const queryArgs = {
-    values: {
-      type: new import_graphql5.GraphQLNonNull(new import_graphql5.GraphQLList(new import_graphql5.GraphQLNonNull(baseType)))
-    }
-  };
-  return {
-    name: queryName,
-    resolver: async (source, args, context, info) => {
-      try {
-        const input = remapFromGraphQLArrayInput(args.values, table);
-        if (!input.length)
-          throw new import_graphql5.GraphQLError("No values were provided!");
-        const parsedInfo = (0, import_graphql_parse_resolve_info2.parseResolveInfo)(info, {
-          deep: true
-        });
-        const columns = extractSelectedColumnsFromTreeSQLFormat(
-          parsedInfo.fieldsByTypeName[typeName],
-          table
-        );
-        const result = await db.insert(table).values(input).returning(columns).onConflictDoNothing();
-        return remapToGraphQLArrayOutput(result, tableName, table);
-      } catch (e) {
-        if (typeof e === "object" && typeof e.message === "string") {
-          throw new import_graphql5.GraphQLError(e.message);
-        }
-        throw e;
-      }
-    },
-    args: queryArgs
-  };
-};
-var generateInsertSingle2 = (db, tableName, table, baseType) => {
-  const queryName = `insertInto${capitalize(tableName)}Single`;
-  const typeName = `${capitalize(tableName)}Item`;
-  const queryArgs = {
-    values: {
-      type: new import_graphql5.GraphQLNonNull(baseType)
-    }
-  };
-  return {
-    name: queryName,
-    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 result = await db.insert(table).values(input).returning(columns).onConflictDoNothing();
-        if (!result[0])
-          return void 0;
-        return remapToGraphQLSingleOutput(result[0], tableName, table);
-      } catch (e) {
-        if (typeof e === "object" && typeof e.message === "string") {
-          throw new import_graphql5.GraphQLError(e.message);
-        }
-        throw e;
-      }
-    },
-    args: queryArgs
-  };
-};
-var generateUpdate2 = (db, tableName, table, setArgs, filterArgs) => {
-  const queryName = `update${capitalize(tableName)}`;
-  const typeName = `${capitalize(tableName)}Item`;
-  const queryArgs = {
-    set: {
-      type: new import_graphql5.GraphQLNonNull(setArgs)
-    },
-    where: {
-      type: filterArgs
-    }
-  };
-  return {
-    name: queryName,
-    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 input = remapFromGraphQLSingleInput(set, table);
-        if (!Object.keys(input).length)
-          throw new import_graphql5.GraphQLError("Unable to update with no values specified!");
-        let query = db.update(table).set(input);
-        if (where) {
-          const filters = extractFilters(table, tableName, where);
-          query = query.where(filters);
-        }
-        query = query.returning(columns);
-        const result = await query;
-        return remapToGraphQLArrayOutput(result, tableName, table);
-      } catch (e) {
-        if (typeof e === "object" && typeof e.message === "string") {
-          throw new import_graphql5.GraphQLError(e.message);
-        }
-        throw e;
-      }
-    },
-    args: queryArgs
-  };
-};
-var generateDelete2 = (db, tableName, table, filterArgs) => {
-  const queryName = `deleteFrom${capitalize(tableName)}`;
-  const typeName = `${capitalize(tableName)}Item`;
-  const queryArgs = {
-    where: {
-      type: filterArgs
-    }
-  };
-  return {
-    name: queryName,
-    resolver: async (source, args, context, info) => {
-      try {
-        const { where } = args;
-        const parsedInfo = (0, import_graphql_parse_resolve_info2.parseResolveInfo)(info, {
-          deep: true
-        });
-        const columns = extractSelectedColumnsFromTreeSQLFormat(
-          parsedInfo.fieldsByTypeName[typeName],
-          table
-        );
-        let query = db.delete(table);
-        if (where) {
-          const filters = extractFilters(table, tableName, where);
-          query = query.where(filters);
-        }
-        query = query.returning(columns);
-        const result = await query;
-        return remapToGraphQLArrayOutput(result, tableName, table);
-      } catch (e) {
-        if (typeof e === "object" && typeof e.message === "string") {
-          throw new import_graphql5.GraphQLError(e.message);
-        }
-        throw e;
-      }
-    },
-    args: queryArgs
-  };
-};
-var generateSchemaData2 = (db, schema, relationsDepthLimit) => {
-  const rawSchema = schema;
-  const schemaEntries = Object.entries(rawSchema);
-  const tableEntries = schemaEntries.filter(
-    ([key, value]) => (0, import_drizzle_orm5.is)(value, import_pg_core2.PgTable)
-  );
-  const tables = Object.fromEntries(tableEntries);
-  if (!tableEntries.length) {
-    throw new Error(
-      "Drizzle-GraphQL Error: No tables detected in Drizzle-ORM's database instance. Did you forget to pass schema to drizzle constructor?"
-    );
-  }
-  const rawRelations = schemaEntries.filter(([key, value]) => (0, import_drizzle_orm5.is)(value, import_drizzle_orm5.Relations)).map(([key, value]) => [
-    tableEntries.find(
-      ([tableName, tableValue]) => tableValue === value.table
-    )[0],
-    value
-  ]).map(([tableName, relValue]) => [
-    tableName,
-    relValue.config((0, import_drizzle_orm5.createTableRelationsHelpers)(tables[tableName]))
-  ]);
-  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];
-    })
-  );
-  const queries = {};
-  const mutations = {};
-  const gqlSchemaTypes = Object.fromEntries(
-    Object.entries(tables).map(([tableName, table]) => [
-      tableName,
-      generateTableTypes(
-        tableName,
-        tables,
-        namedRelations,
-        true,
-        relationsDepthLimit
-      )
-    ])
-  );
-  const inputs = {};
-  const interfaces = {};
-  const outputs = {};
-  for (const [tableName, tableTypes] of Object.entries(gqlSchemaTypes)) {
-    const { insertInput, updateInput, tableFilters, tableOrder } = tableTypes.inputs;
-    const {
-      selectSingleOutput,
-      selectArrOutput,
-      singleTableItemOutput,
-      arrTableItemOutput,
-      tableFieldsInterface
-    } = tableTypes.outputs;
-    const selectArrGenerated = generateSelectArray2(
-      db,
-      tableName,
-      tables,
-      namedRelations,
-      tableOrder,
-      tableFilters
-    );
-    const selectSingleGenerated = generateSelectSingle2(
-      db,
-      tableName,
-      tables,
-      namedRelations,
-      tableOrder,
-      tableFilters
-    );
-    const insertArrGenerated = generateInsertArray2(
-      db,
-      tableName,
-      schema[tableName],
-      insertInput
-    );
-    const insertSingleGenerated = generateInsertSingle2(
-      db,
-      tableName,
-      schema[tableName],
-      insertInput
-    );
-    const updateGenerated = generateUpdate2(
-      db,
-      tableName,
-      schema[tableName],
-      updateInput,
-      tableFilters
-    );
-    const deleteGenerated = generateDelete2(
-      db,
-      tableName,
-      schema[tableName],
-      tableFilters
-    );
-    queries[selectArrGenerated.name] = {
-      type: selectArrOutput,
-      args: selectArrGenerated.args,
-      resolve: selectArrGenerated.resolver
-    };
-    queries[selectSingleGenerated.name] = {
-      type: selectSingleOutput,
-      args: selectSingleGenerated.args,
-      resolve: selectSingleGenerated.resolver
-    };
-    mutations[insertArrGenerated.name] = {
-      type: arrTableItemOutput,
-      args: insertArrGenerated.args,
-      resolve: insertArrGenerated.resolver
-    };
-    mutations[insertSingleGenerated.name] = {
-      type: singleTableItemOutput,
-      args: insertSingleGenerated.args,
-      resolve: insertSingleGenerated.resolver
-    };
-    mutations[updateGenerated.name] = {
-      type: arrTableItemOutput,
-      args: updateGenerated.args,
-      resolve: updateGenerated.resolver
-    };
-    mutations[deleteGenerated.name] = {
-      type: arrTableItemOutput,
-      args: deleteGenerated.args,
-      resolve: deleteGenerated.resolver
-    };
-    [insertInput, updateInput, tableFilters, tableOrder].forEach(
-      (e) => inputs[e.name] = e
-    );
-    outputs[selectSingleOutput.name] = selectSingleOutput;
-    outputs[singleTableItemOutput.name] = singleTableItemOutput;
-    interfaces[tableFieldsInterface.name] = tableFieldsInterface;
-  }
-  return { queries, mutations, inputs, interfaces, types: outputs };
-};
-// src/util/builders/sqlite.ts
-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 generateSelectArray3 = (db, tableName, tables, relationMap, orderArgs, filterArgs) => {
-  const queryName = `${uncapitalize(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 queryArgs = {
-    offset: {
-      type: import_graphql6.GraphQLInt
-    },
-    limit: {
-      type: import_graphql6.GraphQLInt
-    },
-    orderBy: {
-      type: orderArgs
-    },
-    where: {
-      type: filterArgs
-    }
-  };
-  const typeName = `${capitalize(tableName)}SelectItem`;
-  const table = tables[tableName];
-  return {
-    name: queryName,
-    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 allFields = {};
-        if (parsedInfo.fieldsByTypeName) {
-          for (const fields of Object.values(parsedInfo.fieldsByTypeName)) {
-            Object.assign(allFields, fields);
-          }
-        }
-        const query = queryBase.findMany({
-          columns: extractSelectedColumnsFromTree(allFields, table),
-          offset,
-          limit,
-          orderBy: orderBy ? extractOrderBy(table, orderBy) : void 0,
-          where: where ? extractFilters(table, tableName, where) : void 0,
-          with: relationMap[tableName] ? extractRelationsParams(
-            relationMap,
-            tables,
-            tableName,
-            parsedInfo,
-            typeName
-          ) : void 0
-        });
-        const result = await query;
-        return remapToGraphQLArrayOutput(result, tableName, table, relationMap);
-      } catch (e) {
-        if (typeof e === "object" && typeof e.message === "string") {
-          throw new import_graphql6.GraphQLError(e.message);
-        }
-        throw e;
-      }
-    },
-    args: queryArgs
-  };
-};
-var generateSelectSingle3 = (db, tableName, tables, relationMap, orderArgs, filterArgs) => {
-  const queryName = `${uncapitalize(tableName)}Single`;
-  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 = `${capitalize(tableName)}SelectItem`;
-  const table = tables[tableName];
-  return {
-    name: queryName,
-    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 allFields = {};
-        if (parsedInfo.fieldsByTypeName) {
-          for (const fields of Object.values(parsedInfo.fieldsByTypeName)) {
-            Object.assign(allFields, fields);
-          }
-        }
-        const query = queryBase.findFirst({
-          columns: extractSelectedColumnsFromTree(allFields, table),
-          offset,
-          orderBy: orderBy ? extractOrderBy(table, orderBy) : void 0,
-          where: where ? extractFilters(table, tableName, where) : void 0,
-          with: relationMap[tableName] ? extractRelationsParams(
-            relationMap,
-            tables,
-            tableName,
-            parsedInfo,
-            typeName
-          ) : void 0
-        });
-        const result = await query;
-        if (!result)
-          return void 0;
-        return remapToGraphQLSingleOutput(
-          result,
-          tableName,
-          table,
-          relationMap
-        );
-      } catch (e) {
-        if (typeof e === "object" && typeof e.message === "string") {
-          throw new import_graphql6.GraphQLError(e.message);
-        }
-        throw e;
-      }
-    },
-    args: queryArgs
-  };
-};
-var generateInsertArray3 = (db, tableName, table, baseType) => {
-  const queryName = `insertInto${capitalize(tableName)}`;
-  const typeName = `${capitalize(tableName)}Item`;
-  const queryArgs = {
-    values: {
-      type: new import_graphql6.GraphQLNonNull(new import_graphql6.GraphQLList(new import_graphql6.GraphQLNonNull(baseType)))
-    }
-  };
-  return {
-    name: queryName,
-    resolver: async (source, args, context, info) => {
-      try {
-        const input = remapFromGraphQLArrayInput(args.values, table);
-        if (!input.length)
-          throw new import_graphql6.GraphQLError("No values were provided!");
-        const parsedInfo = (0, import_graphql_parse_resolve_info3.parseResolveInfo)(info, {
-          deep: true
-        });
-        const columns = extractSelectedColumnsFromTreeSQLFormat(
-          parsedInfo.fieldsByTypeName[typeName],
-          table
-        );
-        const result = await db.insert(table).values(input).returning(columns).onConflictDoNothing();
-        return remapToGraphQLArrayOutput(result, tableName, table);
-      } catch (e) {
-        if (typeof e === "object" && typeof e.message === "string") {
-          throw new import_graphql6.GraphQLError(e.message);
-        }
-        throw e;
-      }
-    },
-    args: queryArgs
-  };
-};
-var generateInsertSingle3 = (db, tableName, table, baseType) => {
-  const queryName = `insertInto${capitalize(tableName)}Single`;
-  const typeName = `${capitalize(tableName)}Item`;
-  const queryArgs = {
-    values: {
-      type: new import_graphql6.GraphQLNonNull(baseType)
-    }
-  };
-  return {
-    name: queryName,
-    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 result = await db.insert(table).values(input).returning(columns).onConflictDoNothing();
-        if (!result[0])
-          return void 0;
-        return remapToGraphQLSingleOutput(result[0], tableName, table);
-      } catch (e) {
-        if (typeof e === "object" && typeof e.message === "string") {
-          throw new import_graphql6.GraphQLError(e.message);
-        }
-        throw e;
-      }
-    },
-    args: queryArgs
-  };
-};
-var generateUpdate3 = (db, tableName, table, setArgs, filterArgs) => {
-  const queryName = `update${capitalize(tableName)}`;
-  const typeName = `${capitalize(tableName)}Item`;
-  const queryArgs = {
-    set: {
-      type: new import_graphql6.GraphQLNonNull(setArgs)
-    },
-    where: {
-      type: filterArgs
-    }
-  };
-  return {
-    name: queryName,
-    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 input = remapFromGraphQLSingleInput(set, table);
-        if (!Object.keys(input).length)
-          throw new import_graphql6.GraphQLError("Unable to update with no values specified!");
-        let query = db.update(table).set(input);
-        if (where) {
-          const filters = extractFilters(table, tableName, where);
-          query = query.where(filters);
-        }
-        query = query.returning(columns);
-        const result = await query;
-        return remapToGraphQLArrayOutput(result, tableName, table);
-      } catch (e) {
-        if (typeof e === "object" && typeof e.message === "string") {
-          throw new import_graphql6.GraphQLError(e.message);
-        }
-        throw e;
-      }
-    },
-    args: queryArgs
-  };
-};
-var generateDelete3 = (db, tableName, table, filterArgs) => {
-  const queryName = `deleteFrom${capitalize(tableName)}`;
-  const typeName = `${capitalize(tableName)}Item`;
-  const queryArgs = {
-    where: {
-      type: filterArgs
-    }
-  };
-  return {
-    name: queryName,
-    resolver: async (source, args, context, info) => {
-      try {
-        const { where } = args;
-        const parsedInfo = (0, import_graphql_parse_resolve_info3.parseResolveInfo)(info, {
-          deep: true
-        });
-        const columns = extractSelectedColumnsFromTreeSQLFormat(
-          parsedInfo.fieldsByTypeName[typeName],
-          table
-        );
-        let query = db.delete(table);
-        if (where) {
-          const filters = extractFilters(table, tableName, where);
-          query = query.where(filters);
-        }
-        query = query.returning(columns);
-        const result = await query;
-        return remapToGraphQLArrayOutput(result, tableName, table);
-      } catch (e) {
-        if (typeof e === "object" && typeof e.message === "string") {
-          throw new import_graphql6.GraphQLError(e.message);
-        }
-        throw e;
-      }
-    },
-    args: queryArgs
-  };
-};
-var generateSchemaData3 = (db, schema, relationsDepthLimit) => {
-  const rawSchema = schema;
-  const schemaEntries = Object.entries(rawSchema);
-  const tableEntries = schemaEntries.filter(
-    ([key, value]) => (0, import_drizzle_orm6.is)(value, import_sqlite_core2.SQLiteTable)
-  );
-  const tables = Object.fromEntries(tableEntries);
-  if (!tableEntries.length) {
-    throw new Error(
-      "Drizzle-GraphQL Error: No tables detected in Drizzle-ORM's database instance. Did you forget to pass schema to drizzle constructor?"
-    );
-  }
-  const rawRelations = schemaEntries.filter(([key, value]) => (0, import_drizzle_orm6.is)(value, import_drizzle_orm6.Relations)).map(([key, value]) => [
-    tableEntries.find(
-      ([tableName, tableValue]) => tableValue === value.table
-    )[0],
-    value
-  ]).map(([tableName, relValue]) => [
-    tableName,
-    relValue.config((0, import_drizzle_orm6.createTableRelationsHelpers)(tables[tableName]))
-  ]);
-  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];
-    })
-  );
-  const queries = {};
-  const mutations = {};
-  const gqlSchemaTypes = Object.fromEntries(
-    Object.entries(tables).map(([tableName, table]) => [
-      tableName,
-      generateTableTypes(
-        tableName,
-        tables,
-        namedRelations,
-        true,
-        relationsDepthLimit
-      )
-    ])
-  );
-  const inputs = {};
-  const interfaces = {};
-  const outputs = {};
-  for (const [tableName, tableTypes] of Object.entries(gqlSchemaTypes)) {
-    const { insertInput, updateInput, tableFilters, tableOrder } = tableTypes.inputs;
-    const {
-      selectSingleOutput,
-      selectArrOutput,
-      singleTableItemOutput,
-      arrTableItemOutput,
-      tableFieldsInterface
-    } = tableTypes.outputs;
-    const selectArrGenerated = generateSelectArray3(
-      db,
-      tableName,
-      tables,
-      namedRelations,
-      tableOrder,
-      tableFilters
-    );
-    const selectSingleGenerated = generateSelectSingle3(
-      db,
-      tableName,
-      tables,
-      namedRelations,
-      tableOrder,
-      tableFilters
-    );
-    const insertArrGenerated = generateInsertArray3(
-      db,
-      tableName,
-      schema[tableName],
-      insertInput
-    );
-    const insertSingleGenerated = generateInsertSingle3(
-      db,
-      tableName,
-      schema[tableName],
-      insertInput
-    );
-    const updateGenerated = generateUpdate3(
-      db,
-      tableName,
-      schema[tableName],
-      updateInput,
-      tableFilters
-    );
-    const deleteGenerated = generateDelete3(
-      db,
-      tableName,
-      schema[tableName],
-      tableFilters
-    );
-    queries[selectArrGenerated.name] = {
-      type: selectArrOutput,
-      args: selectArrGenerated.args,
-      resolve: selectArrGenerated.resolver
-    };
-    queries[selectSingleGenerated.name] = {
-      type: selectSingleOutput,
-      args: selectSingleGenerated.args,
-      resolve: selectSingleGenerated.resolver
-    };
-    mutations[insertArrGenerated.name] = {
-      type: arrTableItemOutput,
-      args: insertArrGenerated.args,
-      resolve: insertArrGenerated.resolver
-    };
-    mutations[insertSingleGenerated.name] = {
-      type: singleTableItemOutput,
-      args: insertSingleGenerated.args,
-      resolve: insertSingleGenerated.resolver
-    };
-    mutations[updateGenerated.name] = {
-      type: arrTableItemOutput,
-      args: updateGenerated.args,
-      resolve: updateGenerated.resolver
-    };
-    mutations[deleteGenerated.name] = {
-      type: arrTableItemOutput,
-      args: deleteGenerated.args,
-      resolve: deleteGenerated.resolver
-    };
-    [insertInput, updateInput, tableFilters, tableOrder].forEach(
-      (e) => inputs[e.name] = e
-    );
-    outputs[selectSingleOutput.name] = selectSingleOutput;
-    outputs[singleTableItemOutput.name] = singleTableItemOutput;
-    interfaces[tableFieldsInterface.name] = tableFieldsInterface;
-  }
-  return { queries, mutations, inputs, interfaces, types: outputs };
-};
-// src/buildSchema.ts
-var buildSchema = (db, config) => {
-  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 (typeof config?.relationsDepthLimit === "number") {
-    if (config.relationsDepthLimit < 0) {
-      throw new Error(
-        "Drizzle-GraphQL Error: config.relationsDepthLimit is supposed to be nonnegative integer or undefined!"
-      );
-    }
-    if (config.relationsDepthLimit !== ~~config.relationsDepthLimit) {
-      throw new Error(
-        "Drizzle-GraphQL Error: config.relationsDepthLimit is supposed to be nonnegative integer or undefined!"
-      );
-    }
-  }
-  let generatorOutput;
-  if ((0, import_drizzle_orm7.is)(db, import_mysql_core3.MySqlDatabase)) {
-    generatorOutput = generateSchemaData(db, schema, config?.relationsDepthLimit);
-  } else if ((0, import_drizzle_orm7.is)(db, import_pg_core3.PgDatabase)) {
-    generatorOutput = generateSchemaData2(db, schema, config?.relationsDepthLimit);
-  } else if ((0, import_drizzle_orm7.is)(db, import_sqlite_core3.BaseSQLiteDatabase)) {
-    generatorOutput = generateSchemaData3(db, schema, config?.relationsDepthLimit);
-  } else
-    throw new Error("Drizzle-GraphQL Error: Unknown database instance type");
-  const { queries, mutations, inputs, types } = generatorOutput;
-  const graphQLSchemaConfig = {
-    types: [...Object.values(inputs), ...Object.values(types)],
-    query: new import_graphql7.GraphQLObjectType({
-      name: "Query",
-      fields: queries
-    })
-  };
-  if (config?.mutations !== false) {
-    const mutation = new import_graphql7.GraphQLObjectType({
-      name: "Mutation",
-      fields: mutations
-    });
-    graphQLSchemaConfig.mutation = mutation;
-  }
-  const outputSchema = new import_graphql7.GraphQLSchema(graphQLSchemaConfig);
-  return { schema: outputSchema, entities: generatorOutput };
-};
-// src/buildSchemaSDL/index.ts
-var import_drizzle_orm12 = require("drizzle-orm");
-var import_sqlite_core5 = require("drizzle-orm/sqlite-core");
-// src/buildSchemaSDL/generator/schema/generation.ts
-var import_drizzle_orm8 = require("drizzle-orm");
-var generateTypes = (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_orm8.getTableColumns)(table);
-      tables[tableName] = {
-        name: tableName,
-        table,
-        columns
-      };
-      tableEntries.push([tableName, table]);
-    }
-  }
-  const rawRelations = schemaEntries.filter(([key, value]) => (0, import_drizzle_orm8.is)(value, import_drizzle_orm8.Relations)).map(([key, value]) => [
-    tableEntries.find(
-      ([tableName, tableValue]) => tableValue === value.table
-    )[0],
-    value
-  ]).map(([tableName, relValue]) => [
-    tableName,
-    relValue.config((0, import_drizzle_orm8.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/buildSchemaSDL/generator/schema/type-defs.ts
-var import_drizzle_orm9 = require("drizzle-orm");
-var import_mysql_core4 = require("drizzle-orm/mysql-core");
-var import_pg_core4 = require("drizzle-orm/pg-core");
-var import_sqlite_core4 = require("drizzle-orm/sqlite-core");
-var allowedNameChars2 = /^[a-zA-Z0-9_]+$/;
-var customScalars = /* @__PURE__ */ new Set();
-var enumDefinitions = /* @__PURE__ */ new Map();
-var requiredFieldFilters = /* @__PURE__ */ new Set();
-var foreignKeyTypes = /* @__PURE__ */ new Map();
-var columnToSDL = (column, columnName, tableName, forceNullable = false, isPrimaryKey = false) => {
-  let baseType;
-  if (column.customGraphqlType) {
-    baseType = column.customGraphqlType;
-  } else if (isPrimaryKey) {
-    baseType = "ID";
-  } else {
-    const foreignKeyType = foreignKeyTypes.get(`${tableName}.${columnName}`);
-    if (foreignKeyType) {
-      baseType = foreignKeyType;
-    } else {
-      switch (column.dataType) {
-        case "boolean":
-          baseType = "Boolean";
-          break;
-        case "json":
-          if (column.columnType === "PgGeometryObject") {
-            baseType = "PgGeometryObject";
-            customScalars.add("PgGeometryObject");
-          } else {
-            baseType = "JSON";
-            customScalars.add("JSON");
-          }
-          break;
-        case "date":
-          baseType = "Date";
-          customScalars.add("Date");
-          break;
-        case "string":
-          if (column.enumValues?.length) {
-            const enumName = `${capitalize(tableName)}${capitalize(
-              columnName
-            )}Enum`;
-            baseType = enumName;
-            if (!enumDefinitions.has(enumName)) {
-              enumDefinitions.set(enumName, {
-                name: enumName,
-                values: column.enumValues.map(
-                  (e, index) => allowedNameChars2.test(e) ? e : `Option${index}`
-                )
-              });
-            }
-          } else {
-            baseType = "String";
-          }
-          break;
-        case "bigint":
-          baseType = "BigInt";
-          customScalars.add("BigInt");
-          break;
-        case "number":
-          if ((0, import_drizzle_orm9.is)(column, import_pg_core4.PgInteger) || (0, import_drizzle_orm9.is)(column, import_pg_core4.PgSerial) || (0, import_drizzle_orm9.is)(column, import_mysql_core4.MySqlInt) || (0, import_drizzle_orm9.is)(column, import_mysql_core4.MySqlSerial) || (0, import_drizzle_orm9.is)(column, import_sqlite_core4.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;
-            customScalars.add(scalarName);
-          }
-          break;
-        case "custom":
-        default:
-          if (column.columnType) {
-            baseType = column.columnType;
-            customScalars.add(column.columnType);
-          } else {
-            const customScalarName = `${capitalize(tableName)}${capitalize(
-              columnName
-            )}`;
-            baseType = customScalarName;
-            customScalars.add(customScalarName);
-          }
-          break;
-      }
-    }
-  }
-  if (!forceNullable && column.notNull) {
-    return `${baseType}!`;
-  }
-  return baseType;
-};
-var generateTypeDefs = (tables, relations) => {
-  const typeDefs = [];
-  customScalars.clear();
-  enumDefinitions.clear();
-  requiredFieldFilters.clear();
-  foreignKeyTypes.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_orm9.is)(relation, import_drizzle_orm9.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) {
-            foreignKeyTypes.set(
-              `${tableName}.${foreignKeyPropertyName}`,
-              referencedCustomType
-            );
-          } else if (referencedIsPrimaryKey) {
-            foreignKeyTypes.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 = columnToSDL(
-        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_orm9.is)(relationInfo.relation, import_drizzle_orm9.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 = columnToSDL(
-        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 = columnToSDL(
-        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 = columnToSDL(
-        column,
-        columnName,
-        tableName,
-        true,
-        isPrimaryKey
-      );
-      const normalizedType = typeStr.replace(/[^a-zA-Z0-9]/g, "");
-      const filterTypeName = `${normalizedType}FieldFilter`;
-      requiredFieldFilters.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 = [];
-  if (customScalars.size > 0) {
-    for (const scalarName of Array.from(customScalars).sort()) {
-      allDefs.push(`scalar ${scalarName}`);
-    }
-  }
-  if (enumDefinitions.size > 0) {
-    for (const enumDef of enumDefinitions.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 requiredFieldFilters) {
-    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 generateQueryTypeDefs = (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 generateMutationTypeDefs = (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/buildSchemaSDL/generator/queries/resolvers.ts
-var import_graphql9 = require("graphql");
-var import_graphql_parse_resolve_info4 = require("graphql-parse-resolve-info");
-// src/buildSchemaSDL/generator/utils/selection.ts
-var import_drizzle_orm11 = require("drizzle-orm");
-// src/buildSchemaSDL/generator/utils/filters.ts
-var import_drizzle_orm10 = require("drizzle-orm");
-var import_graphql8 = require("graphql");
-var extractFiltersColumn2 = (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_graphql8.GraphQLError(
-        `WHERE ${columnName}: Cannot specify both fields and 'OR' in column operators!`
-      );
-    }
-    const variants2 = [];
-    for (const variant of operators.OR) {
-      const extracted = extractFiltersColumn2(column, columnName, variant);
-      if (extracted)
-        variants2.push(extracted);
-    }
-    return variants2.length ? variants2.length > 1 ? (0, import_drizzle_orm10.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_orm10.eq, ne: import_drizzle_orm10.ne, gt: import_drizzle_orm10.gt, gte: import_drizzle_orm10.gte, lt: import_drizzle_orm10.lt, lte: import_drizzle_orm10.lte };
-        variants.push(opMap[operatorName](column, singleValue));
-        break;
-      }
-      case "like":
-      case "notLike":
-      case "ilike":
-      case "notIlike": {
-        const opMap = { like: import_drizzle_orm10.like, notLike: import_drizzle_orm10.notLike, ilike: import_drizzle_orm10.ilike, notIlike: import_drizzle_orm10.notIlike };
-        variants.push(opMap[operatorName](column, operatorValue));
-        break;
-      }
-      case "inArray":
-      case "notInArray": {
-        if (!operatorValue.length) {
-          throw new import_graphql8.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_orm10.inArray, notInArray: import_drizzle_orm10.notInArray };
-        variants.push(opMap[operatorName](column, arrayValue));
-        break;
-      }
-      case "isNull":
-      case "isNotNull": {
-        const opMap = { isNull: import_drizzle_orm10.isNull, isNotNull: import_drizzle_orm10.isNotNull };
-        variants.push(opMap[operatorName](column));
-        break;
-      }
-    }
-  }
-  return variants.length ? variants.length > 1 ? (0, import_drizzle_orm10.and)(...variants) : variants[0] : void 0;
-};
-var buildWhereClause = (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_graphql8.GraphQLError(
-        `WHERE ${tableInfo.name}: Cannot specify both fields and 'OR' in table filters!`
-      );
-    }
-    const variants = [];
-    for (const variant of where.OR) {
-      const extracted = buildWhereClause(tableInfo, variant);
-      if (extracted)
-        variants.push(extracted);
-    }
-    return variants.length ? variants.length > 1 ? (0, import_drizzle_orm10.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 = extractFiltersColumn2(
-      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_orm10.and)(...conditions);
-};
-// src/export-tool/utils.ts
-function isExportVariable(value) {
-  return typeof value === "string" && value.startsWith("$_") && value.length > 2;
-}
-function getVariableName(value) {
-  if (!isExportVariable(value)) {
-    return null;
-  }
-  return value.slice(2);
-}
-async function resolveExportVariables(args, exportStore, timeout, allowNull = true) {
-  if (isExportVariable(args)) {
-    const varName = getVariableName(args);
-    return await exportStore.waitFor(varName, timeout, allowNull);
-  }
-  if (Array.isArray(args)) {
-    const resolved = await Promise.all(
-      args.map(async (item) => {
-        if (isExportVariable(item)) {
-          const varName = getVariableName(item);
-          return await exportStore.waitFor(varName, timeout, allowNull);
-        } else if (typeof item === "object" && item !== null) {
-          return await resolveExportVariables(item, exportStore, timeout, allowNull);
-        }
-        return item;
-      })
-    );
-    return resolved;
-  }
-  if (typeof args === "object" && args !== null) {
-    const resolved = {};
-    for (const [key, value] of Object.entries(args)) {
-      if (isExportVariable(value)) {
-        const varName = getVariableName(value);
-        resolved[key] = await exportStore.waitFor(varName, timeout, allowNull);
-      } else if (Array.isArray(value)) {
-        resolved[key] = await resolveExportVariables(
-          value,
-          exportStore,
-          timeout,
-          allowNull
-        );
-      } else if (typeof value === "object" && value !== null) {
-        resolved[key] = await resolveExportVariables(
-          value,
-          exportStore,
-          timeout,
-          allowNull
-        );
-      } else {
-        resolved[key] = value;
-      }
-    }
-    return resolved;
-  }
-  return args;
-}
-function getExportDirective(fieldNode) {
-  const node = fieldNode;
-  if (!node || !node.directives) {
-    return null;
-  }
-  const exportDirective = node.directives.find(
-    (directive) => directive.name.value === "export"
-  );
-  if (!exportDirective) {
-    return null;
-  }
-  const asArg = exportDirective.arguments?.find(
-    (arg) => arg.name.value === "as"
-  );
-  if (!asArg || asArg.value.kind !== "StringValue") {
-    return null;
-  }
-  return asArg.value.value;
-}
-function hasExportVariables(args) {
-  if (isExportVariable(args)) {
-    return true;
-  }
-  if (Array.isArray(args)) {
-    return args.some((item) => hasExportVariables(item));
-  }
-  if (typeof args === "object" && args !== null) {
-    for (const value of Object.values(args)) {
-      if (hasExportVariables(value)) {
-        return true;
-      }
-    }
-  }
-  return false;
-}
-function processExports(result, selectionSet, exportStore) {
-  if (!result || !selectionSet)
-    return;
-  for (const selection of selectionSet.selections) {
-    if (selection.kind !== "Field")
-      continue;
-    const resultKey = selection.alias?.value ?? selection.name.value;
-    if (!(resultKey in result))
-      continue;
-    const value = result[resultKey];
-    const exportName = getExportDirective(selection);
-    if (exportName) {
-      exportStore.set(exportName, value);
-    }
-    if (selection.selectionSet && value !== null && value !== void 0) {
-      if (Array.isArray(value)) {
-        value.forEach((item) => {
-          if (item && typeof item === "object") {
-            processExports(item, selection.selectionSet, exportStore);
-          }
-        });
-      } else if (typeof value === "object") {
-        processExports(value, selection.selectionSet, exportStore);
-      }
-    }
-  }
-}
-// src/buildSchemaSDL/generator/utils/selection.ts
-var buildOrderByClause = (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_orm11.desc)(column) : (0, import_drizzle_orm11.asc)(column)
-      );
-    }
-  }
-  return orderClauses.length > 0 ? orderClauses : void 0;
-};
-var extractSelectedColumns = (fields, tableInfo) => {
-  const columns = {};
-  for (const fieldName of Object.keys(fields)) {
-    if (tableInfo.columns[fieldName]) {
-      columns[fieldName] = true;
-    }
-  }
-  return Object.keys(columns).length > 0 ? columns : {};
-};
-var extractRelationsParams2 = async (relationMap, tables, tableName, fields, context) => {
-  const relations = relationMap[tableName];
-  if (!relations)
-    return void 0;
-  const args = {};
-  for (const [relName, { targetTableName, relation }] of Object.entries(
-    relations
-  )) {
-    const relationField = fields[relName];
-    if (!relationField)
-      continue;
-    const allFields = {};
-    if (relationField.fieldsByTypeName) {
-      for (const typeFields of Object.values(relationField.fieldsByTypeName)) {
-        Object.assign(allFields, typeFields);
-      }
-    }
-    const targetTable = tables[targetTableName];
-    if (!targetTable)
-      continue;
-    const thisRecord = {
-      columns: extractSelectedColumns(allFields, targetTable)
-    };
-    const relationArgs = relationField.args;
-    if (relationArgs) {
-      if (relationArgs["where"]) {
-        let whereClause = relationArgs["where"];
-        if (context?.exportStore && hasExportVariables(whereClause)) {
-          try {
-            whereClause = await resolveExportVariables(whereClause, context.exportStore);
-          } catch (error) {
-            console.warn(`Failed to resolve export variables in nested relation ${relName}:`, error);
-          }
-        }
-        thisRecord.where = buildWhereClause(targetTable, whereClause);
-      }
-      if (relationArgs["orderBy"]) {
-        thisRecord.orderBy = buildOrderByClause(
-          targetTable,
-          relationArgs["orderBy"]
-        );
-      }
-      if (relationArgs["limit"] !== void 0) {
-        thisRecord.limit = relationArgs["limit"];
-      }
-      if (relationArgs["offset"] !== void 0) {
-        thisRecord.offset = relationArgs["offset"];
-      }
-    }
-    const nestedWith = await extractRelationsParams2(
-      relationMap,
-      tables,
-      targetTableName,
-      allFields,
-      context
-    );
-    if (nestedWith) {
-      thisRecord.with = nestedWith;
-    }
-    args[relName] = thisRecord;
-  }
-  return Object.keys(args).length > 0 ? args : void 0;
-};
-// src/buildSchemaSDL/generator/queries/resolvers.ts
-var createFindManyResolver = (queryBase, tableInfo, tables, relations) => {
-  return async (parent, args, context, info) => {
-    try {
-      const { where, orderBy, limit, offset } = args;
-      const parsedInfo = (0, import_graphql_parse_resolve_info4.parseResolveInfo)(info, {
-        deep: true
-      });
-      const allFields = {};
-      if (parsedInfo.fieldsByTypeName) {
-        for (const fields of Object.values(parsedInfo.fieldsByTypeName)) {
-          Object.assign(allFields, fields);
-        }
-      }
-      const result = await queryBase.findMany({
-        columns: extractSelectedColumns(allFields, tableInfo),
-        offset,
-        limit,
-        orderBy: buildOrderByClause(tableInfo, orderBy),
-        where: buildWhereClause(tableInfo, where),
-        with: await extractRelationsParams2(
-          relations,
-          tables,
-          tableInfo.name,
-          allFields,
-          context
-        )
-      });
-      return result;
-    } catch (e) {
-      if (typeof e === "object" && e !== null && "message" in e) {
-        throw new import_graphql9.GraphQLError(String(e.message));
-      }
-      throw e;
-    }
-  };
-};
-var createFindFirstResolver = (queryBase, tableInfo, tables, relations) => {
-  return async (parent, args, context, info) => {
-    try {
-      const { where, orderBy } = args;
-      const parsedInfo = (0, import_graphql_parse_resolve_info4.parseResolveInfo)(info, {
-        deep: true
-      });
-      const allFields = {};
-      if (parsedInfo.fieldsByTypeName) {
-        for (const fields of Object.values(parsedInfo.fieldsByTypeName)) {
-          Object.assign(allFields, fields);
-        }
-      }
-      const result = await queryBase.findFirst({
-        columns: extractSelectedColumns(allFields, tableInfo),
-        orderBy: buildOrderByClause(tableInfo, orderBy),
-        where: buildWhereClause(tableInfo, where),
-        with: await extractRelationsParams2(
-          relations,
-          tables,
-          tableInfo.name,
-          allFields,
-          context
-        )
-      });
-      return result || null;
-    } catch (e) {
-      if (typeof e === "object" && e !== null && "message" in e) {
-        throw new import_graphql9.GraphQLError(String(e.message));
-      }
-      throw e;
-    }
-  };
-};
-// src/buildSchemaSDL/generator/queries/index.ts
-var generateQueries = (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`] = createFindManyResolver(
-      queryBase,
-      tableInfo,
-      tables,
-      relations
-    );
-    queries[`${tableName}FindFirst`] = createFindFirstResolver(
-      queryBase,
-      tableInfo,
-      tables,
-      relations
-    );
-  }
-  return queries;
-};
-// src/buildSchemaSDL/generator/mutations/resolvers.ts
-var import_graphql10 = require("graphql");
-var createInsertManyResolver = (db, queryBase, tableInfo, tables, relations, primaryKeyColumn) => {
-  const queryResolver = createFindManyResolver(
-    queryBase,
-    tableInfo,
-    tables,
-    relations
-  );
-  return async (parent, args, context, info) => {
-    try {
-      const { values } = args;
-      if (!values || values.length === 0) {
-        throw new import_graphql10.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_graphql10.GraphQLError(String(e.message));
-      }
-      throw e;
-    }
-  };
-};
-var createUpdateManyResolver = (db, queryBase, tableInfo, tables, relations, primaryKeyColumn) => {
-  const queryResolver = createFindManyResolver(
-    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_graphql10.GraphQLError("No values provided for update");
-      }
-      const remappedSet = remapFromGraphQLSingleInput(set, tableInfo.table);
-      const whereClause = buildWhereClause(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_graphql10.GraphQLError(String(e.message));
-      }
-      throw e;
-    }
-  };
-};
-var createDeleteManyResolver = (db, queryBase, tableInfo, tables, relations, primaryKeyColumn) => {
-  const queryResolver = createFindManyResolver(
-    queryBase,
-    tableInfo,
-    tables,
-    relations
-  );
-  return async (parent, args, context, info) => {
-    try {
-      const { where } = args;
-      const whereClause = buildWhereClause(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_graphql10.GraphQLError(String(e.message));
-      }
-      throw e;
-    }
-  };
-};
-// src/buildSchemaSDL/generator/mutations/index.ts
-var generateMutations = (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`] = createInsertManyResolver(
-      db,
-      queryBase,
-      tableInfo,
-      tables,
-      relations,
-      primaryKeyColumn
-    );
-    mutations[`${tableName}UpdateMany`] = createUpdateManyResolver(
-      db,
-      queryBase,
-      tableInfo,
-      tables,
-      relations,
-      primaryKeyColumn
-    );
-    mutations[`${tableName}DeleteMany`] = createDeleteManyResolver(
-      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/buildSchemaSDL/index.ts
-var buildSchemaSDL = (db, config) => {
-  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!"
-    );
+  return exports2;
+}
+function hasExportVariables(args) {
+  if (isExportVariable(args)) {
+    return true;
   }
-  if (!(0, import_drizzle_orm12.is)(db, import_sqlite_core5.BaseSQLiteDatabase)) {
-    throw new Error(
-      "Drizzle-GraphQL Error: buildSchemaSDL currently only supports SQLite databases"
-    );
+  if (Array.isArray(args)) {
+    return args.some((item) => hasExportVariables(item));
   }
-  const { tables, relations } = generateTypes(db, schema);
-  const typeDefsArray = [];
-  typeDefsArray.push(generateTypeDefs(tables, relations));
-  typeDefsArray.push(generateQueryTypeDefs(tables));
-  typeDefsArray.push(generateMutationTypeDefs(tables));
-  const typeDefs = typeDefsArray.join("\n\n");
-  const queries = generateQueries(db, tables, relations);
-  const { mutations, deleteResultResolvers } = generateMutations(
-    db,
-    tables,
-    relations
-  );
-  return {
-    typeDefs,
-    resolvers: {
-      Query: queries,
-      Mutation: mutations,
-      ...deleteResultResolvers
+  if (typeof args === "object" && args !== null) {
+    for (const value of Object.values(args)) {
+      if (hasExportVariables(value)) {
+        return true;
+      }
     }
-  };
-};
+  }
+  return false;
+}
+function processExports(result, selectionSet, exportStore, isArrayItem = false) {
+  if (!result || !selectionSet)
+    return;
+  for (const selection of selectionSet.selections) {
+    if (selection.kind !== "Field")
+      continue;
+    const resultKey = selection.alias?.value ?? selection.name.value;
+    if (!(resultKey in result))
+      continue;
+    const value = result[resultKey];
+    const exportName = getExportDirective(selection);
+    if (exportName) {
+      if (isArrayItem) {
+        exportStore.accumulate(exportName, value);
+      } else {
+        exportStore.set(exportName, value);
+      }
+    }
+    if (selection.selectionSet && value !== null && value !== void 0) {
+      if (Array.isArray(value)) {
+        value.forEach((item) => {
+          if (item && typeof item === "object") {
+            processExports(item, selection.selectionSet, exportStore, true);
+          }
+        });
+      } else if (typeof value === "object") {
+        processExports(value, selection.selectionSet, exportStore, isArrayItem);
+      }
+    }
+  }
+}
+var init_utils = __esm({
+  "src/export-tool/utils.ts"() {
+    "use strict";
+  }
+});
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  buildSchemaSDLWithDataLoader: () => buildSchemaSDL,
+  cleanupDataLoaderContext: () => cleanupDataLoaderContext,
+  createDataLoaderContext: () => createDataLoaderContext,
+  createExportMiddleware: () => createExportMiddleware,
+  exportDirectiveTypeDefs: () => exportDirectiveTypeDefs,
+  makeScalarAcceptExports: () => makeScalarAcceptExports,
+  setCustomGraphQL: () => setCustomGraphQL,
+  setCustomGraphQLTypes: () => setCustomGraphQLTypes,
+  useDataLoaderCleanup: () => useDataLoaderCleanup,
+  useDataLoaderCleanupOnly: () => useDataLoaderCleanupOnly,
+  useDataLoaderContext: () => useDataLoaderContext
+});
+module.exports = __toCommonJS(src_exports);
 // src/build-schema-sdl-with-dl/index.ts
-var import_drizzle_orm19 = require("drizzle-orm");
-var import_sqlite_core7 = require("drizzle-orm/sqlite-core");
+var import_drizzle_orm8 = require("drizzle-orm");
+var import_sqlite_core2 = 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) => {
+var import_drizzle_orm = require("drizzle-orm");
+var generateTypes = (db, schema) => {
   const tables = {};
   const schemaEntries = Object.entries(schema);
   const tableEntries = [];
@@ -3297,7 +222,7 @@ var generateTypes2 = (db, schema) => {
     if (value && typeof value === "object" && "getSQL" in value) {
       const table = value;
       const tableName = key;
-      const columns = (0, import_drizzle_orm13.getTableColumns)(table);
+      const columns = (0, import_drizzle_orm.getTableColumns)(table);
       tables[tableName] = {
         name: tableName,
         table,
@@ -3306,14 +231,14 @@ var generateTypes2 = (db, schema) => {
       tableEntries.push([tableName, table]);
     }
   }
-  const rawRelations = schemaEntries.filter(([key, value]) => (0, import_drizzle_orm13.is)(value, import_drizzle_orm13.Relations)).map(([key, value]) => [
+  const rawRelations = schemaEntries.filter(([key, value]) => (0, import_drizzle_orm.is)(value, import_drizzle_orm.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))
+    relValue.config((0, import_drizzle_orm.createTableRelationsHelpers)(tables[tableName].table))
   ]);
   const namedRelations = Object.fromEntries(
     rawRelations.map(([relName, config]) => {
@@ -3335,23 +260,28 @@ var generateTypes2 = (db, schema) => {
 };
 // 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) => {
+var import_drizzle_orm2 = require("drizzle-orm");
+var import_mysql_core = require("drizzle-orm/mysql-core");
+var import_pg_core = require("drizzle-orm/pg-core");
+var import_sqlite_core = require("drizzle-orm/sqlite-core");
+// src/util/case-ops/index.ts
+var capitalize = (input) => input.length ? `${input[0].toLocaleUpperCase()}${input.length > 1 ? input.slice(1, input.length) : ""}` : input;
+// src/build-schema-sdl-with-dl/generator/schema/type-defs.ts
+var allowedNameChars = /^[a-zA-Z0-9_]+$/;
+var customScalars = /* @__PURE__ */ new Set();
+var enumDefinitions = /* @__PURE__ */ new Map();
+var requiredFieldFilters = /* @__PURE__ */ new Set();
+var foreignKeyTypes = /* @__PURE__ */ new Map();
+var columnToSDL = (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}`);
+    const foreignKeyType = foreignKeyTypes.get(`${tableName}.${columnName}`);
     if (foreignKeyType) {
       baseType = foreignKeyType;
     } else {
@@ -3362,15 +292,15 @@ var columnToSDL2 = (column, columnName, tableName, forceNullable = false, isPrim
         case "json":
           if (column.columnType === "PgGeometryObject") {
             baseType = "PgGeometryObject";
-            customScalars2.add("PgGeometryObject");
+            customScalars.add("PgGeometryObject");
           } else {
             baseType = "JSON";
-            customScalars2.add("JSON");
+            customScalars.add("JSON");
           }
           break;
         case "date":
           baseType = "Date";
-          customScalars2.add("Date");
+          customScalars.add("Date");
           break;
         case "string":
           if (column.enumValues?.length) {
@@ -3378,11 +308,11 @@ var columnToSDL2 = (column, columnName, tableName, forceNullable = false, isPrim
               columnName
             )}Enum`;
             baseType = enumName;
-            if (!enumDefinitions2.has(enumName)) {
-              enumDefinitions2.set(enumName, {
+            if (!enumDefinitions.has(enumName)) {
+              enumDefinitions.set(enumName, {
                 name: enumName,
                 values: column.enumValues.map(
-                  (e, index) => allowedNameChars3.test(e) ? e : `Option${index}`
+                  (e, index) => allowedNameChars.test(e) ? e : `Option${index}`
                 )
               });
             }
@@ -3392,10 +322,10 @@ var columnToSDL2 = (column, columnName, tableName, forceNullable = false, isPrim
           break;
         case "bigint":
           baseType = "BigInt";
-          customScalars2.add("BigInt");
+          customScalars.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)) {
+          if ((0, import_drizzle_orm2.is)(column, import_pg_core.PgInteger) || (0, import_drizzle_orm2.is)(column, import_pg_core.PgSerial) || (0, import_drizzle_orm2.is)(column, import_mysql_core.MySqlInt) || (0, import_drizzle_orm2.is)(column, import_mysql_core.MySqlSerial) || (0, import_drizzle_orm2.is)(column, import_sqlite_core.SQLiteInteger)) {
             baseType = "Int";
           } else {
             baseType = "Float";
@@ -3414,20 +344,20 @@ var columnToSDL2 = (column, columnName, tableName, forceNullable = false, isPrim
               columnName
             )}Array`;
             baseType = scalarName;
-            customScalars2.add(scalarName);
+            customScalars.add(scalarName);
           }
           break;
         case "custom":
         default:
           if (column.columnType) {
             baseType = column.columnType;
-            customScalars2.add(column.columnType);
+            customScalars.add(column.columnType);
           } else {
             const customScalarName = `${capitalize(tableName)}${capitalize(
               columnName
             )}`;
             baseType = customScalarName;
-            customScalars2.add(customScalarName);
+            customScalars.add(customScalarName);
           }
           break;
       }
@@ -3438,19 +368,19 @@ var columnToSDL2 = (column, columnName, tableName, forceNullable = false, isPrim
   }
   return baseType;
 };
-var generateTypeDefs2 = (tables, relations) => {
+var generateTypeDefs = (tables, relations) => {
   const typeDefs = [];
-  customScalars2.clear();
-  enumDefinitions2.clear();
-  requiredFieldFilters2.clear();
-  foreignKeyTypes2.clear();
+  customScalars.clear();
+  enumDefinitions.clear();
+  requiredFieldFilters.clear();
+  foreignKeyTypes.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))
+      if (!(0, import_drizzle_orm2.is)(relation, import_drizzle_orm2.One))
         continue;
       const config = relation.config;
       if (!config?.fields || !config?.references)
@@ -3484,12 +414,12 @@ var generateTypeDefs2 = (tables, relations) => {
         const referencedIsPrimaryKey = referencedColumn.primary || false;
         if (!foreignKeyHasCustomType) {
           if (referencedCustomType) {
-            foreignKeyTypes2.set(
+            foreignKeyTypes.set(
               `${tableName}.${foreignKeyPropertyName}`,
               referencedCustomType
             );
           } else if (referencedIsPrimaryKey) {
-            foreignKeyTypes2.set(`${tableName}.${foreignKeyPropertyName}`, "ID");
+            foreignKeyTypes.set(`${tableName}.${foreignKeyPropertyName}`, "ID");
           }
         }
       }
@@ -3500,7 +430,7 @@ var generateTypeDefs2 = (tables, relations) => {
     const fields = [];
     for (const [columnName, column] of Object.entries(tableInfo.columns)) {
       const isPrimaryKey = column.primary || false;
-      const typeStr = columnToSDL2(
+      const typeStr = columnToSDL(
         column,
         columnName,
         tableName,
@@ -3518,7 +448,7 @@ var generateTypeDefs2 = (tables, relations) => {
       for (const [relationName, relationInfo] of Object.entries(
         tableRelations
       )) {
-        const isOne = (0, import_drizzle_orm14.is)(relationInfo.relation, import_drizzle_orm14.One);
+        const isOne = (0, import_drizzle_orm2.is)(relationInfo.relation, import_drizzle_orm2.One);
         const targetTableName = relationInfo.targetTableName;
         const targetTypeName = capitalize(targetTableName);
         if (isOne) {
@@ -3538,7 +468,7 @@ ${fields.join("\n")}
     const insertFields = [];
     for (const [columnName, column] of Object.entries(tableInfo.columns)) {
       const isPrimaryKey = column.primary || false;
-      const typeStr = columnToSDL2(
+      const typeStr = columnToSDL(
         column,
         columnName,
         tableName,
@@ -3547,13 +477,13 @@ ${fields.join("\n")}
       );
       const hasDefault = column.hasDefault || column.default !== void 0;
       const isAutoIncrement = column.autoIncrement || column.generatedAlwaysAs;
-      const isNotNull4 = column.notNull;
-      const shouldBeOptional = hasDefault || isAutoIncrement || isPrimaryKey && !isNotNull4;
+      const isNotNull2 = column.notNull;
+      const shouldBeOptional = hasDefault || isAutoIncrement || isPrimaryKey && !isNotNull2;
       let insertFieldType;
       if (shouldBeOptional) {
         insertFieldType = typeStr.endsWith("!") ? typeStr.slice(0, -1) : typeStr;
       } else {
-        insertFieldType = isNotNull4 && !typeStr.endsWith("!") ? `${typeStr}!` : typeStr;
+        insertFieldType = isNotNull2 && !typeStr.endsWith("!") ? `${typeStr}!` : typeStr;
       }
       insertFields.push(`  ${columnName}: ${insertFieldType}`);
     }
@@ -3567,7 +497,7 @@ ${insertFields.join("\n")}
     const updateFields = [];
     for (const [columnName, column] of Object.entries(tableInfo.columns)) {
       const isPrimaryKey = column.primary || false;
-      const typeStr = columnToSDL2(
+      const typeStr = columnToSDL(
         column,
         columnName,
         tableName,
@@ -3584,7 +514,7 @@ ${updateFields.join("\n")}
     const whereFields = [];
     for (const [columnName, column] of Object.entries(tableInfo.columns)) {
       const isPrimaryKey = column.primary || false;
-      const typeStr = columnToSDL2(
+      const typeStr = columnToSDL(
         column,
         columnName,
         tableName,
@@ -3593,7 +523,7 @@ ${updateFields.join("\n")}
       );
       const normalizedType = typeStr.replace(/[^a-zA-Z0-9]/g, "");
       const filterTypeName = `${normalizedType}FieldFilter`;
-      requiredFieldFilters2.add(
+      requiredFieldFilters.add(
         JSON.stringify({ normalizedType, baseType: typeStr })
       );
       whereFields.push(`  ${columnName}: ${filterTypeName}`);
@@ -3615,14 +545,14 @@ ${orderByFields.join("\n")}
 }`);
   }
   const allDefs = [];
-  customScalars2.add("JSON");
-  if (customScalars2.size > 0) {
-    for (const scalarName of Array.from(customScalars2).sort()) {
+  customScalars.add("JSON");
+  if (customScalars.size > 0) {
+    for (const scalarName of Array.from(customScalars).sort()) {
       allDefs.push(`scalar ${scalarName}`);
     }
   }
-  if (enumDefinitions2.size > 0) {
-    for (const enumDef of Array.from(enumDefinitions2.values())) {
+  if (enumDefinitions.size > 0) {
+    for (const enumDef of Array.from(enumDefinitions.values())) {
       const valueStrings = enumDef.values.map((v) => `  ${v}`);
       allDefs.push(`enum ${enumDef.name} {
 ${valueStrings.join("\n")}
@@ -3641,7 +571,7 @@ ${valueStrings.join("\n")}
   priority: Int!
 }`);
   const filterTypesAdded = /* @__PURE__ */ new Set();
-  for (const filterInfoJson of Array.from(requiredFieldFilters2)) {
+  for (const filterInfoJson of Array.from(requiredFieldFilters)) {
     const { normalizedType, baseType } = JSON.parse(filterInfoJson);
     const filterTypeName = `${normalizedType}FieldFilter`;
     if (filterTypesAdded.has(filterTypeName))
@@ -3670,7 +600,7 @@ ${filterFields.join("\n")}
   allDefs.push(...typeDefs);
   return allDefs.join("\n\n");
 };
-var generateQueryTypeDefs2 = (tables) => {
+var generateQueryTypeDefs = (tables) => {
   const queryFields = [];
   for (const tableName of Object.keys(tables)) {
     const typeName = capitalize(tableName);
@@ -3685,7 +615,7 @@ var generateQueryTypeDefs2 = (tables) => {
 ${queryFields.join("\n")}
 }`;
 };
-var generateMutationTypeDefs2 = (tables) => {
+var generateMutationTypeDefs = (tables) => {
   const mutationFields = [];
   for (const tableName of Object.keys(tables)) {
     const typeName = capitalize(tableName);
@@ -3705,33 +635,110 @@ ${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");
+var import_graphql3 = require("graphql");
+var import_graphql_parse_resolve_info = require("graphql-parse-resolve-info");
+var import_drizzle_orm7 = require("drizzle-orm");
 // src/build-schema-sdl-with-dl/generator/utils/selection.ts
-var import_drizzle_orm16 = require("drizzle-orm");
+var import_drizzle_orm5 = require("drizzle-orm");
+// src/build-schema-sdl-with-dl/generator/utils/filters.ts
+var import_drizzle_orm4 = require("drizzle-orm");
+var import_graphql2 = require("graphql");
+// src/util/data-mappers/index.ts
+var import_drizzle_orm3 = require("drizzle-orm");
+var import_graphql = require("graphql");
+var remapFromGraphQLCore = (value, column, columnName) => {
+  switch (column.dataType) {
+    case "date": {
+      const formatted = new Date(value);
+      if (Number.isNaN(formatted.getTime()))
+        throw new import_graphql.GraphQLError(`Field '${columnName}' is not a valid date!`);
+      return formatted;
+    }
+    case "buffer": {
+      if (!Array.isArray(value)) {
+        throw new import_graphql.GraphQLError(`Field '${columnName}' is not an array!`);
+      }
+      return Buffer.from(value);
+    }
+    case "json": {
+      if (column.columnType === "PgGeometryObject")
+        return value;
+      try {
+        return JSON.parse(value);
+      } catch (e) {
+        throw new import_graphql.GraphQLError(
+          `Invalid JSON in field '${columnName}':
+${e instanceof Error ? e.message : "Unknown error"}`
+        );
+      }
+    }
+    case "array": {
+      if (!Array.isArray(value)) {
+        throw new import_graphql.GraphQLError(`Field '${columnName}' is not an array!`);
+      }
+      if (column.columnType === "PgGeometry" && value.length !== 2) {
+        throw new import_graphql.GraphQLError(
+          `Invalid float tuple in field '${columnName}': expected array with length of 2, received ${value.length}`
+        );
+      }
+      return value;
+    }
+    case "bigint": {
+      try {
+        return BigInt(value);
+      } catch (error) {
+        throw new import_graphql.GraphQLError(`Field '${columnName}' is not a BigInt!`);
+      }
+    }
+    default: {
+      return value;
+    }
+  }
+};
+var remapFromGraphQLSingleInput = (queryInput, table) => {
+  for (const [key, value] of Object.entries(queryInput)) {
+    if (value === void 0) {
+      delete queryInput[key];
+    } else {
+      const column = (0, import_drizzle_orm3.getTableColumns)(table)[key];
+      if (!column)
+        throw new import_graphql.GraphQLError(`Unknown column: ${key}`);
+      if (value === null && column.notNull) {
+        delete queryInput[key];
+        continue;
+      }
+      queryInput[key] = remapFromGraphQLCore(value, column, key);
+    }
+  }
+  return queryInput;
+};
+var remapFromGraphQLArrayInput = (queryInput, table) => {
+  for (const entry of queryInput)
+    remapFromGraphQLSingleInput(entry, table);
+  return queryInput;
+};
 // 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) => {
+var extractFiltersColumn = (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(
+      throw new import_graphql2.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);
+      const extracted = extractFiltersColumn(column, columnName, variant);
       if (extracted)
         variants2.push(extracted);
     }
-    return variants2.length ? variants2.length > 1 ? (0, import_drizzle_orm15.or)(...variants2) : variants2[0] : void 0;
+    return variants2.length ? variants2.length > 1 ? (0, import_drizzle_orm4.or)(...variants2) : variants2[0] : void 0;
   }
   const variants = [];
   for (const [operatorName, operatorValue] of entries) {
@@ -3749,7 +756,7 @@ var extractFiltersColumn3 = (column, columnName, operators) => {
           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 };
+        const opMap = { eq: import_drizzle_orm4.eq, ne: import_drizzle_orm4.ne, gt: import_drizzle_orm4.gt, gte: import_drizzle_orm4.gte, lt: import_drizzle_orm4.lt, lte: import_drizzle_orm4.lte };
         variants.push(opMap[operatorName](column, singleValue));
         break;
       }
@@ -3757,51 +764,51 @@ var extractFiltersColumn3 = (column, columnName, operators) => {
       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 };
+        const opMap = { like: import_drizzle_orm4.like, notLike: import_drizzle_orm4.notLike, ilike: import_drizzle_orm4.ilike, notIlike: import_drizzle_orm4.notIlike };
         variants.push(opMap[operatorName](column, operatorValue));
         break;
       }
       case "inArray":
       case "notInArray": {
         if (!operatorValue.length) {
-          throw new import_graphql11.GraphQLError(
+          throw new import_graphql2.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 };
+        const opMap = { inArray: import_drizzle_orm4.inArray, notInArray: import_drizzle_orm4.notInArray };
         variants.push(opMap[operatorName](column, arrayValue));
         break;
       }
       case "isNull":
       case "isNotNull": {
-        const opMap = { isNull: import_drizzle_orm15.isNull, isNotNull: import_drizzle_orm15.isNotNull };
+        const opMap = { isNull: import_drizzle_orm4.isNull, isNotNull: import_drizzle_orm4.isNotNull };
         variants.push(opMap[operatorName](column));
         break;
       }
     }
   }
-  return variants.length ? variants.length > 1 ? (0, import_drizzle_orm15.and)(...variants) : variants[0] : void 0;
+  return variants.length ? variants.length > 1 ? (0, import_drizzle_orm4.and)(...variants) : variants[0] : void 0;
 };
-var buildWhereClause2 = (tableInfo, where) => {
+var buildWhereClause = (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(
+      throw new import_graphql2.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);
+      const extracted = buildWhereClause(tableInfo, variant);
       if (extracted)
         variants.push(extracted);
     }
-    return variants.length ? variants.length > 1 ? (0, import_drizzle_orm15.or)(...variants) : variants[0] : void 0;
+    return variants.length ? variants.length > 1 ? (0, import_drizzle_orm4.or)(...variants) : variants[0] : void 0;
   }
   const conditions = [];
   for (const [columnName, operators] of Object.entries(where)) {
@@ -3812,7 +819,7 @@ var buildWhereClause2 = (tableInfo, where) => {
     const column = tableInfo.columns[columnName];
     if (!column)
       continue;
-    const extracted = extractFiltersColumn3(
+    const extracted = extractFiltersColumn(
       column,
       columnName,
       operators
@@ -3824,11 +831,11 @@ var buildWhereClause2 = (tableInfo, where) => {
     return void 0;
   if (conditions.length === 1)
     return conditions[0];
-  return (0, import_drizzle_orm15.and)(...conditions);
+  return (0, import_drizzle_orm4.and)(...conditions);
 };
 // src/build-schema-sdl-with-dl/generator/utils/selection.ts
-var buildOrderByClause2 = (tableInfo, orderBy) => {
+var buildOrderByClause = (tableInfo, orderBy) => {
   if (!orderBy || Object.keys(orderBy).length === 0) {
     return void 0;
   }
@@ -3842,7 +849,7 @@ var buildOrderByClause2 = (tableInfo, orderBy) => {
     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)
+        entry.direction === "desc" ? (0, import_drizzle_orm5.desc)(column) : (0, import_drizzle_orm5.asc)(column)
       );
     }
   }
@@ -3851,12 +858,14 @@ var buildOrderByClause2 = (tableInfo, orderBy) => {
 // 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 import_drizzle_orm6 = require("drizzle-orm");
 var RelationDataLoader = class {
-  constructor(queryBase, tableInfo, relations) {
+  constructor(queryBase, tableInfo, relations, context, debugConfig) {
     this.queryBase = queryBase;
     this.tableInfo = tableInfo;
     this.relations = relations;
+    this.context = context;
+    this.debugConfig = debugConfig;
   }
   loaders = /* @__PURE__ */ new Map();
   createLoaderKey(key) {
@@ -3897,11 +906,31 @@ var RelationDataLoader = class {
       }
       const allParentIds = groupKeys.flatMap((key) => key.parentIds);
       const uniqueParentIds = Array.from(new Set(allParentIds));
+      let resolvedWhere = firstKey.where;
+      if (resolvedWhere && this.context?.exportStore) {
+        const { hasExportVariables: hasExportVariables2, resolveExportVariables: resolveExportVariables2 } = await Promise.resolve().then(() => (init_utils(), utils_exports));
+        if (hasExportVariables2(resolvedWhere)) {
+          try {
+            if (this.debugConfig?.exportVariables) {
+              console.log(`\u{1F50D} DataLoader: Resolving export variables in where clause:`, resolvedWhere);
+            }
+            resolvedWhere = await resolveExportVariables2(resolvedWhere, this.context.exportStore);
+            if (this.debugConfig?.exportVariables) {
+              console.log(`\u2705 DataLoader: Successfully resolved to:`, resolvedWhere);
+            }
+          } catch (error) {
+            if (this.debugConfig?.exportVariables) {
+              console.warn(`\u274C DataLoader: Failed to resolve export variables:`, error);
+            }
+          }
+        }
+      }
       const whereClause = this.buildBatchWhereClause(
         uniqueParentIds,
         firstKey.isReversedRelation,
         firstKey.foreignKey,
-        firstKey.where
+        resolvedWhere
+        // Use resolved where clause
       );
       if (!whereClause) {
         results.push(...groupKeys.map(() => []));
@@ -3914,13 +943,17 @@ var RelationDataLoader = class {
           [firstKey.foreignKey]: true
         },
         where: whereClause,
-        orderBy: firstKey.orderBy ? buildOrderByClause2(this.tableInfo, firstKey.orderBy) : void 0,
+        orderBy: firstKey.orderBy ? buildOrderByClause(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}`);
+      if (this.debugConfig?.dataLoader) {
+        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);
+      if (this.debugConfig?.dataLoader) {
+        console.log(`DataLoader got ${batchResults.length} results:`, batchResults);
+      }
       const resultsByParentId = /* @__PURE__ */ new Map();
       for (const result of batchResults) {
         const parentId = result[firstKey.foreignKey];
@@ -3946,12 +979,12 @@ var RelationDataLoader = class {
       console.error(`Available columns:`, Object.keys(this.tableInfo.columns));
       return void 0;
     }
-    const parentIdClause = (0, import_drizzle_orm17.inArray)(foreignKeyColumn, parentIds);
+    const parentIdClause = (0, import_drizzle_orm6.inArray)(foreignKeyColumn, parentIds);
     if (!additionalWhere) {
       return parentIdClause;
     }
-    const additionalClause = buildWhereClause2(this.tableInfo, additionalWhere);
-    return additionalClause ? (0, import_drizzle_orm17.and)(parentIdClause, additionalClause) : parentIdClause;
+    const additionalClause = buildWhereClause(this.tableInfo, additionalWhere);
+    return additionalClause ? (0, import_drizzle_orm6.and)(parentIdClause, additionalClause) : parentIdClause;
   }
   async loadRelation(relationName, parentIds, foreignKey, options = {}, isReversedRelation = false) {
     const key = {
@@ -3974,22 +1007,23 @@ var RelationDataLoader = class {
     this.loaders.clear();
   }
 };
-function getRelationLoader(context, tableName, queryBase, tableInfo, relations) {
+function getRelationLoader(context, tableName, queryBase, tableInfo, relations, debugConfig) {
   if (!context.relationLoaders.has(tableName)) {
     context.relationLoaders.set(
       tableName,
-      new RelationDataLoader(queryBase, tableInfo, relations)
+      new RelationDataLoader(queryBase, tableInfo, relations, context, debugConfig)
+      // Pass debug config
     );
   }
   return context.relationLoaders.get(tableName);
 }
 // src/build-schema-sdl-with-dl/generator/queries/dataloader-resolvers.ts
-var createDataLoaderFindManyResolver = (queryBase, tableInfo, tables, relations) => {
+var createDataLoaderFindManyResolver = (queryBase, tableInfo, tables, relations, debugConfig) => {
   return async (parent, args, context, info) => {
     try {
       const { where, orderBy, limit, offset } = args;
-      const parsedInfo = (0, import_graphql_parse_resolve_info5.parseResolveInfo)(info, {
+      const parsedInfo = (0, import_graphql_parse_resolve_info.parseResolveInfo)(info, {
         deep: true
       });
       const allFields = {};
@@ -4006,8 +1040,8 @@ var createDataLoaderFindManyResolver = (queryBase, tableInfo, tables, relations)
         columns: allColumns,
         offset,
         limit,
-        orderBy: buildOrderByClause2(tableInfo, orderBy),
-        where: buildWhereClause2(tableInfo, where)
+        orderBy: buildOrderByClause(tableInfo, orderBy),
+        where: buildWhereClause(tableInfo, where)
         // No 'with' clause - we'll load relations separately
       });
       if (mainResults.length === 0) {
@@ -4019,22 +1053,23 @@ var createDataLoaderFindManyResolver = (queryBase, tableInfo, tables, relations)
         tables,
         relations,
         allFields,
-        context
+        context,
+        debugConfig
       );
       return enhancedResults;
     } catch (e) {
       if (typeof e === "object" && e !== null && "message" in e) {
-        throw new import_graphql12.GraphQLError(String(e.message));
+        throw new import_graphql3.GraphQLError(String(e.message));
       }
       throw e;
     }
   };
 };
-var createDataLoaderFindFirstResolver = (queryBase, tableInfo, tables, relations) => {
+var createDataLoaderFindFirstResolver = (queryBase, tableInfo, tables, relations, debugConfig) => {
   return async (parent, args, context, info) => {
     try {
       const { where, orderBy } = args;
-      const parsedInfo = (0, import_graphql_parse_resolve_info5.parseResolveInfo)(info, {
+      const parsedInfo = (0, import_graphql_parse_resolve_info.parseResolveInfo)(info, {
         deep: true
       });
       const allFields = {};
@@ -4049,8 +1084,8 @@ var createDataLoaderFindFirstResolver = (queryBase, tableInfo, tables, relations
       }
       const mainResult = await queryBase.findFirst({
         columns: allColumns,
-        orderBy: buildOrderByClause2(tableInfo, orderBy),
-        where: buildWhereClause2(tableInfo, where)
+        orderBy: buildOrderByClause(tableInfo, orderBy),
+        where: buildWhereClause(tableInfo, where)
         // No 'with' clause
       });
       if (!mainResult) {
@@ -4062,18 +1097,19 @@ var createDataLoaderFindFirstResolver = (queryBase, tableInfo, tables, relations
         tables,
         relations,
         allFields,
-        context
+        context,
+        debugConfig
       );
       return enhancedResult || null;
     } catch (e) {
       if (typeof e === "object" && e !== null && "message" in e) {
-        throw new import_graphql12.GraphQLError(String(e.message));
+        throw new import_graphql3.GraphQLError(String(e.message));
       }
       throw e;
     }
   };
 };
-async function loadRelationsWithDataLoader(mainResults, tableInfo, tables, relations, fields, context) {
+async function loadRelationsWithDataLoader(mainResults, tableInfo, tables, relations, fields, context, debugConfig) {
   const tableRelations = relations[tableInfo.name];
   if (!tableRelations) {
     return mainResults;
@@ -4083,7 +1119,7 @@ async function loadRelationsWithDataLoader(mainResults, tableInfo, tables, relat
       const relationField = fields[relName];
       if (!relationField)
         continue;
-      if ((0, import_drizzle_orm18.is)(relation, import_drizzle_orm18.One)) {
+      if ((0, import_drizzle_orm7.is)(relation, import_drizzle_orm7.One)) {
         mainResult[relName] = null;
       } else {
         mainResult[relName] = [];
@@ -4124,9 +1160,11 @@ async function loadRelationsWithDataLoader(mainResults, tableInfo, tables, relat
     let foreignKeyName;
     let isReversedRelation = false;
     const relationConfig = relation.config;
-    console.log(`Processing relation ${relName} for table ${tableInfo.name} -> ${targetTableName}`);
+    if (debugConfig?.dataLoader) {
+      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)) {
+      if ((0, import_drizzle_orm7.is)(relation, import_drizzle_orm7.One)) {
         const fieldColumn = relationConfig.fields[0];
         const referenceColumn = relationConfig.references[0];
         const referenceKeyName = Object.keys(targetTable.columns).find(
@@ -4134,7 +1172,9 @@ async function loadRelationsWithDataLoader(mainResults, tableInfo, tables, relat
         ) || referenceColumn.name;
         foreignKeyName = referenceKeyName;
         isReversedRelation = false;
-        console.log(`One-to-one relation: foreignKey=${foreignKeyName}, isReversed=${isReversedRelation}`);
+        if (debugConfig?.dataLoader) {
+          console.log(`One-to-one relation: foreignKey=${foreignKeyName}, isReversed=${isReversedRelation}`);
+        }
       } else {
         const fieldColumn = relationConfig.fields[0];
         const referenceColumn = relationConfig.references[0];
@@ -4142,14 +1182,18 @@ async function loadRelationsWithDataLoader(mainResults, tableInfo, tables, relat
           (key) => targetTable.columns[key] === referenceColumn
         ) || referenceColumn.name;
         isReversedRelation = false;
-        console.log(`Many-to-one relation: foreignKey=${foreignKeyName}, isReversed=${isReversedRelation}`);
+        if (debugConfig?.dataLoader) {
+          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}`);
+      if (debugConfig?.dataLoader) {
+        console.log(`References-only relation: foreignKey=${foreignKeyName}, isReversed=${isReversedRelation}`);
+      }
     } else {
-      if ((0, import_drizzle_orm18.is)(relation, import_drizzle_orm18.One)) {
+      if ((0, import_drizzle_orm7.is)(relation, import_drizzle_orm7.One)) {
         let possibleForeignKeys = Object.entries(targetTable.columns).filter(([name, col]) => {
           const lowerName = name.toLowerCase();
           const tableName = tableInfo.name.toLowerCase();
@@ -4199,7 +1243,9 @@ async function loadRelationsWithDataLoader(mainResults, tableInfo, tables, relat
       ) || 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);
+        if (debugConfig?.dataLoader) {
+          console.log(`Extracted foreign key values for many-to-one relation:`, actualParentIds);
+        }
       }
     }
     const targetQueryBase = context.db?.query?.[targetTableName];
@@ -4212,9 +1258,13 @@ async function loadRelationsWithDataLoader(mainResults, tableInfo, tables, relat
       targetTableName,
       targetQueryBase,
       targetTable,
-      relations[targetTableName] || {}
+      relations[targetTableName] || {},
+      debugConfig
+      // Pass debug config
     );
-    console.log(`Created relation loader for ${targetTableName}, calling loadRelation with parentIds:`, actualParentIds);
+    if (debugConfig?.dataLoader) {
+      console.log(`Created relation loader for ${targetTableName}, calling loadRelation with parentIds:`, actualParentIds);
+    }
     const relationPromise = relationLoader.loadRelation(
       relName,
       actualParentIds,
@@ -4222,7 +1272,9 @@ async function loadRelationsWithDataLoader(mainResults, tableInfo, tables, relat
       relationOptions,
       isReversedRelation
     ).then(async (relationResults) => {
-      console.log(`Relation ${relName} loaded, got ${relationResults.length} results:`, relationResults);
+      if (debugConfig?.dataLoader) {
+        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);
@@ -4238,7 +1290,8 @@ async function loadRelationsWithDataLoader(mainResults, tableInfo, tables, relat
           tables,
           relations,
           relationFields,
-          context
+          context,
+          debugConfig
         );
         let dataIndex = 0;
         for (const result of relationResults) {
@@ -4262,7 +1315,7 @@ async function loadRelationsWithDataLoader(mainResults, tableInfo, tables, relat
           }
         }
         const relationData = relationMap.get(parentId) || [];
-        if ((0, import_drizzle_orm18.is)(relation, import_drizzle_orm18.One)) {
+        if ((0, import_drizzle_orm7.is)(relation, import_drizzle_orm7.One)) {
           mainResult[relName] = relationData[0] || null;
         } else {
           mainResult[relName] = relationData;
@@ -4276,7 +1329,7 @@ async function loadRelationsWithDataLoader(mainResults, tableInfo, tables, relat
 }
 // src/build-schema-sdl-with-dl/generator/queries/index.ts
-var generateQueries2 = (db, tables, relations) => {
+var generateQueries = (db, tables, relations, debugConfig) => {
   const queries = {};
   for (const [tableName, tableInfo] of Object.entries(tables)) {
     const queryBase = db.query[tableName];
@@ -4289,27 +1342,29 @@ var generateQueries2 = (db, tables, relations) => {
       queryBase,
       tableInfo,
       tables,
-      relations
+      relations,
+      debugConfig
     );
     queries[`${tableName}FindFirst`] = createDataLoaderFindFirstResolver(
       queryBase,
       tableInfo,
       tables,
-      relations
+      relations,
+      debugConfig
     );
   }
   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);
+var import_graphql4 = require("graphql");
+var createInsertManyResolver = (db, queryBase, tableInfo, tables, relations, primaryKeyColumn, debugConfig) => {
+  const queryResolver = createDataLoaderFindManyResolver(queryBase, tableInfo, tables, relations, debugConfig);
   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");
+        throw new import_graphql4.GraphQLError("No values provided for insert");
       }
       const remappedValues = remapFromGraphQLArrayInput(
         values,
@@ -4334,22 +1389,22 @@ var createInsertManyResolver2 = (db, queryBase, tableInfo, tables, relations, pr
       return result;
     } catch (e) {
       if (typeof e === "object" && e !== null && "message" in e) {
-        throw new import_graphql13.GraphQLError(String(e.message));
+        throw new import_graphql4.GraphQLError(String(e.message));
       }
       throw e;
     }
   };
 };
-var createUpdateManyResolver2 = (db, queryBase, tableInfo, tables, relations, primaryKeyColumn) => {
-  const queryResolver = createDataLoaderFindManyResolver(queryBase, tableInfo, tables, relations);
+var createUpdateManyResolver = (db, queryBase, tableInfo, tables, relations, primaryKeyColumn, debugConfig) => {
+  const queryResolver = createDataLoaderFindManyResolver(queryBase, tableInfo, tables, relations, debugConfig);
   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");
+        throw new import_graphql4.GraphQLError("No values provided for update");
       }
       const remappedSet = remapFromGraphQLSingleInput(set, tableInfo.table);
-      const whereClause = buildWhereClause2(tableInfo, where);
+      const whereClause = buildWhereClause(tableInfo, where);
       let query = db.update(tableInfo.table).set(remappedSet);
       if (whereClause) {
         query = query.where(whereClause);
@@ -4373,18 +1428,18 @@ var createUpdateManyResolver2 = (db, queryBase, tableInfo, tables, relations, pr
       return result;
     } catch (e) {
       if (typeof e === "object" && e !== null && "message" in e) {
-        throw new import_graphql13.GraphQLError(String(e.message));
+        throw new import_graphql4.GraphQLError(String(e.message));
       }
       throw e;
     }
   };
 };
-var createDeleteManyResolver2 = (db, queryBase, tableInfo, tables, relations, primaryKeyColumn) => {
-  const queryResolver = createDataLoaderFindManyResolver(queryBase, tableInfo, tables, relations);
+var createDeleteManyResolver = (db, queryBase, tableInfo, tables, relations, primaryKeyColumn, debugConfig) => {
+  const queryResolver = createDataLoaderFindManyResolver(queryBase, tableInfo, tables, relations, debugConfig);
   return async (parent, args, context, info) => {
     try {
       const { where } = args;
-      const whereClause = buildWhereClause2(tableInfo, where);
+      const whereClause = buildWhereClause(tableInfo, where);
       let deleteQuery = db.delete(tableInfo.table);
       if (whereClause) {
         deleteQuery = deleteQuery.where(whereClause);
@@ -4401,7 +1456,7 @@ var createDeleteManyResolver2 = (db, queryBase, tableInfo, tables, relations, pr
       };
     } catch (e) {
       if (typeof e === "object" && e !== null && "message" in e) {
-        throw new import_graphql13.GraphQLError(String(e.message));
+        throw new import_graphql4.GraphQLError(String(e.message));
       }
       throw e;
     }
@@ -4409,7 +1464,7 @@ var createDeleteManyResolver2 = (db, queryBase, tableInfo, tables, relations, pr
 };
 // src/build-schema-sdl-with-dl/generator/mutations/index.ts
-var generateMutations2 = (db, tables, relations) => {
+var generateMutations = (db, tables, relations, debugConfig) => {
   const mutations = {};
   const deleteResultResolvers = {};
   for (const [tableName, tableInfo] of Object.entries(tables)) {
@@ -4428,29 +1483,32 @@ var generateMutations2 = (db, tables, relations) => {
         `Drizzle-GraphQL Error: Table ${tableName} does not have a primary key column`
       );
     }
-    mutations[`${tableName}InsertMany`] = createInsertManyResolver2(
+    mutations[`${tableName}InsertMany`] = createInsertManyResolver(
       db,
       queryBase,
       tableInfo,
       tables,
       relations,
-      primaryKeyColumn
+      primaryKeyColumn,
+      debugConfig
     );
-    mutations[`${tableName}UpdateMany`] = createUpdateManyResolver2(
+    mutations[`${tableName}UpdateMany`] = createUpdateManyResolver(
       db,
       queryBase,
       tableInfo,
       tables,
       relations,
-      primaryKeyColumn
+      primaryKeyColumn,
+      debugConfig
     );
-    mutations[`${tableName}DeleteMany`] = createDeleteManyResolver2(
+    mutations[`${tableName}DeleteMany`] = createDeleteManyResolver(
       db,
       queryBase,
       tableInfo,
       tables,
       relations,
-      primaryKeyColumn
+      primaryKeyColumn,
+      debugConfig
     );
     deleteResultResolvers[`${capitalizedName}DeleteResult`] = {
       [`${tableName}FindMany`]: (parent, args, context, info) => {
@@ -4469,30 +1527,31 @@ var generateMutations2 = (db, tables, relations) => {
 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) => {
+var import_schema2 = require("@graphql-tools/schema");
+var buildSchemaSDL = (db, config) => {
   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)) {
+  if (!(0, import_drizzle_orm8.is)(db, import_sqlite_core2.BaseSQLiteDatabase)) {
     throw new Error(
       "Drizzle-GraphQL Error: buildSchemaSDL currently only supports SQLite databases"
     );
   }
-  const { tables, relations } = generateTypes2(db, schema);
+  const { tables, relations } = generateTypes(db, schema);
   const typeDefsArray = [];
-  typeDefsArray.push(generateTypeDefs2(tables, relations));
-  typeDefsArray.push(generateQueryTypeDefs2(tables));
-  typeDefsArray.push(generateMutationTypeDefs2(tables));
+  typeDefsArray.push(generateTypeDefs(tables, relations));
+  typeDefsArray.push(generateQueryTypeDefs(tables));
+  typeDefsArray.push(generateMutationTypeDefs(tables));
   const typeDefs = typeDefsArray.join("\n\n");
-  const queries = generateQueries2(db, tables, relations);
-  const { mutations, deleteResultResolvers } = generateMutations2(
+  const queries = generateQueries(db, tables, relations, config?.debug);
+  const { mutations, deleteResultResolvers } = generateMutations(
     db,
     tables,
-    relations
+    relations,
+    config?.debug
   );
   const resolvers = {
     Query: queries,
@@ -4562,6 +1621,7 @@ var useDataLoaderCleanupOnly = () => ({
 var ExportStore = class {
   store = /* @__PURE__ */ new Map();
   pending = /* @__PURE__ */ new Map();
+  accumulators = /* @__PURE__ */ new Map();
   /**
    * Store a value for later retrieval
    * Resolves any pending promises waiting for this value
@@ -4574,6 +1634,32 @@ var ExportStore = class {
       this.pending.delete(name);
     }
   }
+  /**
+   * Accumulate values into an array with deduplication
+   * First call initializes an array, subsequent calls add to it
+   * Use this when the same export variable is used in multiple array items
+   */
+  accumulate(name, value) {
+    if (!this.accumulators.has(name)) {
+      this.accumulators.set(name, /* @__PURE__ */ new Set());
+    }
+    const accumulator = this.accumulators.get(name);
+    if (Array.isArray(value)) {
+      value.forEach((item) => {
+        if (item !== null && item !== void 0) {
+          accumulator.add(item);
+        }
+      });
+    } else if (value !== null && value !== void 0) {
+      accumulator.add(value);
+    }
+    const accumulatedArray = Array.from(accumulator);
+    this.store.set(name, accumulatedArray);
+    const callbacks = this.pending.get(name);
+    if (callbacks) {
+      callbacks.forEach((resolve) => resolve(accumulatedArray));
+    }
+  }
   /**
    * Get a value if it exists, otherwise return undefined
    */
@@ -4604,7 +1690,9 @@ var ExportStore = class {
             if (allowNull) {
               resolve(null);
             } else {
-              reject(new Error(`Timeout waiting for export variable "${name}"`));
+              reject(
+                new Error(`Timeout waiting for export variable "${name}"`)
+              );
             }
           }
         }
@@ -4623,6 +1711,7 @@ var ExportStore = class {
   clear() {
     this.store.clear();
     this.pending.clear();
+    this.accumulators.clear();
   }
   /**
    * Get all stored values
@@ -4633,6 +1722,7 @@ var ExportStore = class {
 };
 // src/export-tool/middleware.ts
+init_utils();
 function createExportMiddleware() {
   return (next) => {
     return async (source, args, context, info) => {
@@ -4661,17 +1751,23 @@ function createExportMiddleware() {
         return result;
       const selfExportName = getExportDirective(fieldNode);
       if (selfExportName && result !== void 0) {
-        exportStore.set(selfExportName, result);
+        if (Array.isArray(result)) {
+          result.forEach(
+            (value) => exportStore.accumulate(selfExportName, value)
+          );
+        } else {
+          exportStore.set(selfExportName, result);
+        }
       }
       if (fieldNode.selectionSet && result !== void 0 && result !== null) {
         if (Array.isArray(result)) {
           result.forEach((item) => {
             if (item && typeof item === "object") {
-              processExports(item, fieldNode.selectionSet, exportStore);
+              processExports(item, fieldNode.selectionSet, exportStore, true);
             }
           });
         } else if (typeof result === "object") {
-          processExports(result, fieldNode.selectionSet, exportStore);
+          processExports(result, fieldNode.selectionSet, exportStore, false);
         }
       }
       return result;
@@ -4679,11 +1775,14 @@ function createExportMiddleware() {
   };
 }
+// src/export-tool/index.ts
+init_utils();
 // src/export-tool/makeScalarAcceptExports.ts
-var import_graphql14 = require("graphql");
+var import_graphql5 = require("graphql");
 function makeScalarAcceptExports(originalScalar) {
   const config = originalScalar.toConfig();
-  return new import_graphql14.GraphQLScalarType({
+  return new import_graphql5.GraphQLScalarType({
     ...config,
     name: config.name,
     // Keep original name to override it in schema
@@ -4699,7 +1798,7 @@ function makeScalarAcceptExports(originalScalar) {
       return value;
     },
     parseLiteral(ast, variables) {
-      if (ast.kind === import_graphql14.Kind.STRING) {
+      if (ast.kind === import_graphql5.Kind.STRING) {
         if (ast.value.startsWith("$_") || ast.value === "") {
           return ast.value;
         }
@@ -4713,13 +1812,13 @@ function makeScalarAcceptExports(originalScalar) {
 }
 // src/helpers.ts
-var import_drizzle_orm20 = require("drizzle-orm");
+var import_drizzle_orm9 = 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_orm20.getTableName)(
+        `Warning: Column "${columnName}" not found in table "${(0, import_drizzle_orm9.getTableName)(
           table
         )}"`
       );
@@ -4741,8 +1840,6 @@ function setCustomGraphQLTypes(table, columnTypes) {
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  buildSchema,
-  buildSchemaSDL,
   buildSchemaSDLWithDataLoader,
   cleanupDataLoaderContext,
   createDataLoaderContext,