drizzle-graphql-plus 0.8.36 → 0.8.38

package/index.cjs

@@ -12,11 +12,11 @@ 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;
 };
@@ -30,7 +30,7 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
-// src/export-tool/utils.ts
+// src/export-directive/utils.ts
 var utils_exports = {};
 __export(utils_exports, {
   extractExportDirectives: () => extractExportDirectives,
@@ -50,19 +50,20 @@ function getVariableName(value) {
   }
   return value.slice(2);
 }
-async function resolveExportVariables(args, exportStore, timeout, allowNull = true) {
+async function resolveExportVariables(args, exportStore, timeout = 5e3) {
   if (isExportVariable(args)) {
     const varName = getVariableName(args);
-    return await exportStore.waitFor(varName, timeout, allowNull);
+    const resolvedValue = await exportStore.waitFor(varName, timeout, false);
+    return resolvedValue;
   }
   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);
+          return await exportStore.waitFor(varName, timeout, false);
         } else if (typeof item === "object" && item !== null) {
-          return await resolveExportVariables(item, exportStore, timeout, allowNull);
+          return await resolveExportVariables(item, exportStore, timeout);
         }
         return item;
       })
@@ -74,20 +75,21 @@ async function resolveExportVariables(args, exportStore, timeout, allowNull = tr
     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,
+        const resolvedValue = await exportStore.waitFor(
+          varName,
           timeout,
-          allowNull
+          false
         );
+        if (key === "OR" && Array.isArray(resolvedValue)) {
+          resolved[key] = resolvedValue.map((id) => ({ id: { eq: id } }));
+        } else {
+          resolved[key] = resolvedValue;
+        }
       } else if (typeof value === "object" && value !== null) {
         resolved[key] = await resolveExportVariables(
           value,
           exportStore,
-          timeout,
-          allowNull
+          timeout
         );
       } else {
         resolved[key] = value;
@@ -149,7 +151,7 @@ function hasExportVariables(args) {
   }
   return false;
 }
-function processExports(result, selectionSet, exportStore) {
+function processExports(result, selectionSet, exportStore, isArrayItem = false) {
   if (!result || !selectionSet)
     return;
   for (const selection of selectionSet.selections) {
@@ -161,23 +163,27 @@ function processExports(result, selectionSet, exportStore) {
     const value = result[resultKey];
     const exportName = getExportDirective(selection);
     if (exportName) {
-      exportStore.set(exportName, value);
+      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);
+            processExports(item, selection.selectionSet, exportStore, true);
           }
         });
       } else if (typeof value === "object") {
-        processExports(value, selection.selectionSet, exportStore);
+        processExports(value, selection.selectionSet, exportStore, isArrayItem);
       }
     }
   }
 }
 var init_utils = __esm({
-  "src/export-tool/utils.ts"() {
+  "src/export-directive/utils.ts"() {
     "use strict";
   }
 });
@@ -185,3147 +191,33 @@ var init_utils = __esm({
 // src/index.ts
 var src_exports = {};
 __export(src_exports, {
-  buildSchema: () => buildSchema,
-  buildSchemaSDL: () => buildSchemaSDL,
-  buildSchemaSDLWithDataLoader: () => buildSchemaSDL2,
+  ExportStore: () => ExportStore,
+  SerialExecutor: () => SerialExecutor,
+  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/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);
-  }
-  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 queryOutput;
-};
-var remapToGraphQLArrayOutput = (queryOutput, tableName, table, relationMap) => {
-  for (const entry of queryOutput) {
-    remapToGraphQLSingleOutput(entry, tableName, table, relationMap);
-  }
-  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"}`
-        );
-      }
-    }
-    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_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 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!`);
-  }
-};
-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
-    };
-  }
-  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 {
-          }
-        }
-      }
-    }
-  }
-  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 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]
-            ]);
-          }
-        }
-      }
-    }
-  }
-  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/buildSchemaSDL/generator/utils/selection.ts
-init_utils();
-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!"
-    );
-  }
-  if (!(0, import_drizzle_orm12.is)(db, import_sqlite_core5.BaseSQLiteDatabase)) {
-    throw new Error(
-      "Drizzle-GraphQL Error: buildSchemaSDL currently only supports SQLite databases"
-    );
-  }
-  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
-    }
-  };
-};
+  createDataLoaderContext: () => createDataLoaderContext,
+  createExportMiddleware: () => createExportMiddleware,
+  createExportResolverMap: () => createExportResolverMap,
+  createSerialMiddleware: () => createSerialMiddleware,
+  createSerialResolverMap: () => createSerialResolverMap,
+  exportDirectiveTypeDefs: () => exportDirectiveTypeDefs,
+  makeScalarAcceptExports: () => makeScalarAcceptExports,
+  serialDirectiveTypeDefs: () => serialDirectiveTypeDefs,
+  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 = [];
@@ -3333,7 +225,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,
@@ -3342,14 +234,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]) => {
@@ -3371,23 +263,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 {
@@ -3398,15 +295,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) {
@@ -3414,11 +311,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}`
                 )
               });
             }
@@ -3428,10 +325,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";
@@ -3450,20 +347,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;
       }
@@ -3474,19 +371,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)
@@ -3520,12 +417,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");
           }
         }
       }
@@ -3536,7 +433,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,
@@ -3554,7 +451,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) {
@@ -3574,7 +471,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,
@@ -3583,13 +480,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}`);
     }
@@ -3603,7 +500,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,
@@ -3620,7 +517,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,
@@ -3629,7 +526,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}`);
@@ -3651,14 +548,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")}
@@ -3677,7 +574,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))
@@ -3706,7 +603,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);
@@ -3721,7 +618,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);
@@ -3741,33 +638,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) {
@@ -3785,7 +759,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;
       }
@@ -3793,51 +767,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)) {
@@ -3848,7 +822,7 @@ var buildWhereClause2 = (tableInfo, where) => {
     const column = tableInfo.columns[columnName];
     if (!column)
       continue;
-    const extracted = extractFiltersColumn3(
+    const extracted = extractFiltersColumn(
       column,
       columnName,
       operators
@@ -3860,11 +834,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;
   }
@@ -3878,7 +852,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)
       );
     }
   }
@@ -3887,7 +861,7 @@ 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, context, debugConfig) {
     this.queryBase = queryBase;
@@ -3941,15 +915,27 @@ var RelationDataLoader = class {
         if (hasExportVariables2(resolvedWhere)) {
           try {
             if (this.debugConfig?.exportVariables) {
-              console.log(`\u{1F50D} DataLoader: Resolving export variables in where clause:`, resolvedWhere);
+              console.log(
+                `\u{1F50D} DataLoader: Resolving export variables in where clause:`,
+                resolvedWhere
+              );
             }
-            resolvedWhere = await resolveExportVariables2(resolvedWhere, this.context.exportStore);
+            resolvedWhere = await resolveExportVariables2(
+              resolvedWhere,
+              this.context.exportStore
+            );
             if (this.debugConfig?.exportVariables) {
-              console.log(`\u2705 DataLoader: Successfully resolved to:`, resolvedWhere);
+              console.log(
+                `\u2705 DataLoader: Successfully resolved to:`,
+                resolvedWhere
+              );
             }
           } catch (error) {
             if (this.debugConfig?.exportVariables) {
-              console.warn(`\u274C DataLoader: Failed to resolve export variables:`, error);
+              console.warn(
+                `\u274C DataLoader: Failed to resolve export variables:`,
+                error
+              );
             }
           }
         }
@@ -3972,16 +958,21 @@ 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
       });
       if (this.debugConfig?.dataLoader) {
-        console.log(`DataLoader executing query for relation ${firstKey.relationName} with foreign key ${firstKey.foreignKey}`);
+        console.log(
+          `DataLoader executing query for relation ${firstKey.relationName} with foreign key ${firstKey.foreignKey}`
+        );
       }
       const batchResults = await query;
       if (this.debugConfig?.dataLoader) {
-        console.log(`DataLoader got ${batchResults.length} results:`, batchResults);
+        console.log(
+          `DataLoader got ${batchResults.length} results:`,
+          batchResults
+        );
       }
       const resultsByParentId = /* @__PURE__ */ new Map();
       for (const result of batchResults) {
@@ -3992,10 +983,12 @@ var RelationDataLoader = class {
         resultsByParentId.get(parentId).push(result);
       }
       for (const key of groupKeys) {
-        const keyResults = key.parentIds.map((parentId) => ({
-          parentId,
-          data: resultsByParentId.get(parentId) || []
-        }));
+        const keyResults = key.parentIds.map(
+          (parentId) => ({
+            parentId,
+            data: resultsByParentId.get(parentId) || []
+          })
+        );
         results.push(keyResults);
       }
     }
@@ -4004,16 +997,18 @@ var RelationDataLoader = class {
   buildBatchWhereClause(parentIds, isReversedRelation, foreignKeyName, additionalWhere) {
     const foreignKeyColumn = this.tableInfo.columns[foreignKeyName];
     if (!foreignKeyColumn) {
-      console.error(`Foreign key column ${foreignKeyName} not found in table ${this.tableInfo.name}`);
+      console.error(
+        `Foreign key column ${foreignKeyName} not found in table ${this.tableInfo.name}`
+      );
       console.error(`Available columns:`, Object.keys(this.tableInfo.columns));
       return void 0;
     }
-    const parentIdClause = (0, import_drizzle_orm17.inArray)(foreignKeyColumn, parentIds);
+    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 = {
@@ -4040,7 +1035,13 @@ function getRelationLoader(context, tableName, queryBase, tableInfo, relations,
   if (!context.relationLoaders.has(tableName)) {
     context.relationLoaders.set(
       tableName,
-      new RelationDataLoader(queryBase, tableInfo, relations, context, debugConfig)
+      new RelationDataLoader(
+        queryBase,
+        tableInfo,
+        relations,
+        context,
+        debugConfig
+      )
       // Pass debug config
     );
   }
@@ -4052,7 +1053,7 @@ var createDataLoaderFindManyResolver = (queryBase, tableInfo, tables, relations,
   return async (parent, args, context, info) => {
     try {
       const { where, orderBy, limit, offset } = args;
-      const parsedInfo = (0, import_graphql_parse_resolve_info5.parseResolveInfo)(info, {
+      const parsedInfo = (0, import_graphql_parse_resolve_info.parseResolveInfo)(info, {
         deep: true
       });
       const allFields = {};
@@ -4069,8 +1070,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) {
@@ -4088,7 +1089,7 @@ var createDataLoaderFindManyResolver = (queryBase, tableInfo, tables, relations,
       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;
     }
@@ -4098,7 +1099,7 @@ var createDataLoaderFindFirstResolver = (queryBase, tableInfo, tables, relations
   return async (parent, args, context, info) => {
     try {
       const { where, orderBy } = args;
-      const parsedInfo = (0, import_graphql_parse_resolve_info5.parseResolveInfo)(info, {
+      const parsedInfo = (0, import_graphql_parse_resolve_info.parseResolveInfo)(info, {
         deep: true
       });
       const allFields = {};
@@ -4113,8 +1114,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) {
@@ -4132,7 +1133,7 @@ var createDataLoaderFindFirstResolver = (queryBase, tableInfo, tables, relations
       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;
     }
@@ -4148,7 +1149,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] = [];
@@ -4193,7 +1194,7 @@ async function loadRelationsWithDataLoader(mainResults, tableInfo, tables, relat
       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(
@@ -4222,7 +1223,7 @@ async function loadRelationsWithDataLoader(mainResults, tableInfo, tables, relat
         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();
@@ -4344,7 +1345,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;
@@ -4358,7 +1359,7 @@ async function loadRelationsWithDataLoader(mainResults, tableInfo, tables, relat
 }
 
 // src/build-schema-sdl-with-dl/generator/queries/index.ts
-var generateQueries2 = (db, tables, relations, debugConfig) => {
+var generateQueries = (db, tables, relations, debugConfig) => {
   const queries = {};
   for (const [tableName, tableInfo] of Object.entries(tables)) {
     const queryBase = db.query[tableName];
@@ -4386,14 +1387,14 @@ var generateQueries2 = (db, tables, relations, debugConfig) => {
 };
 
 // src/build-schema-sdl-with-dl/generator/mutations/resolvers.ts
-var import_graphql13 = require("graphql");
-var createInsertManyResolver2 = (db, queryBase, tableInfo, tables, relations, primaryKeyColumn, debugConfig) => {
+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,
@@ -4418,22 +1419,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, debugConfig) => {
+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);
@@ -4457,18 +1458,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, debugConfig) => {
+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);
@@ -4485,7 +1486,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;
     }
@@ -4493,7 +1494,7 @@ var createDeleteManyResolver2 = (db, queryBase, tableInfo, tables, relations, pr
 };
 
 // src/build-schema-sdl-with-dl/generator/mutations/index.ts
-var generateMutations2 = (db, tables, relations, debugConfig) => {
+var generateMutations = (db, tables, relations, debugConfig) => {
   const mutations = {};
   const deleteResultResolvers = {};
   for (const [tableName, tableInfo] of Object.entries(tables)) {
@@ -4512,7 +1513,7 @@ var generateMutations2 = (db, tables, relations, debugConfig) => {
         `Drizzle-GraphQL Error: Table ${tableName} does not have a primary key column`
       );
     }
-    mutations[`${tableName}InsertMany`] = createInsertManyResolver2(
+    mutations[`${tableName}InsertMany`] = createInsertManyResolver(
       db,
       queryBase,
       tableInfo,
@@ -4521,7 +1522,7 @@ var generateMutations2 = (db, tables, relations, debugConfig) => {
       primaryKeyColumn,
       debugConfig
     );
-    mutations[`${tableName}UpdateMany`] = createUpdateManyResolver2(
+    mutations[`${tableName}UpdateMany`] = createUpdateManyResolver(
       db,
       queryBase,
       tableInfo,
@@ -4530,7 +1531,7 @@ var generateMutations2 = (db, tables, relations, debugConfig) => {
       primaryKeyColumn,
       debugConfig
     );
-    mutations[`${tableName}DeleteMany`] = createDeleteManyResolver2(
+    mutations[`${tableName}DeleteMany`] = createDeleteManyResolver(
       db,
       queryBase,
       tableInfo,
@@ -4552,31 +1553,34 @@ var generateMutations2 = (db, tables, relations, debugConfig) => {
   return { mutations, deleteResultResolvers };
 };
 
-// src/export-tool/directive-definitions.ts
+// src/export-directive/directive-definitions.ts
 var exportDirectiveTypeDefs = `directive @export(as: String!) on FIELD`;
 
+// src/serial-directive/directive-definitions.ts
+var serialDirectiveTypeDefs = `directive @serial on QUERY | MUTATION | SUBSCRIPTION`;
+
 // src/build-schema-sdl-with-dl/index.ts
-var import_schema3 = require("@graphql-tools/schema");
-var buildSchemaSDL2 = (db, config) => {
+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, config?.debug);
-  const { mutations, deleteResultResolvers } = generateMutations2(
+  const queries = generateQueries(db, tables, relations, config?.debug);
+  const { mutations, deleteResultResolvers } = generateMutations(
     db,
     tables,
     relations,
@@ -4646,10 +1650,189 @@ var useDataLoaderCleanupOnly = () => ({
   })
 });
 
-// src/export-tool/ExportStore.ts
+// src/serial-directive/SerialExecutor.ts
+var SerialExecutor = class {
+  executionQueue = /* @__PURE__ */ new Map();
+  isEnabled = false;
+  /**
+   * Enable serial execution for the current operation
+   */
+  enable() {
+    this.isEnabled = true;
+  }
+  /**
+   * Disable serial execution for the current operation
+   */
+  disable() {
+    this.isEnabled = false;
+    this.executionQueue.clear();
+  }
+  /**
+   * Check if serial execution is enabled
+   */
+  isSerialEnabled() {
+    return this.isEnabled;
+  }
+  /**
+   * Add a resolver promise to the execution queue
+   * @param parentPath - The path of the parent field
+   * @param resolverPromise - The resolver promise to queue
+   */
+  queueResolver(parentPath, resolverPromise) {
+    if (!this.isEnabled) {
+      return resolverPromise();
+    }
+    const queue = this.executionQueue.get(parentPath) || [];
+    const lastPromise = queue.length > 0 ? queue[queue.length - 1] : null;
+    const serialPromise = lastPromise ? lastPromise.then(() => resolverPromise()) : resolverPromise();
+    queue.push(serialPromise);
+    this.executionQueue.set(parentPath, queue);
+    return serialPromise;
+  }
+  /**
+   * Wait for all queued resolvers in a specific path to complete
+   * @param parentPath - The path to wait for
+   */
+  async waitForPath(parentPath) {
+    const queue = this.executionQueue.get(parentPath);
+    if (queue && queue.length > 0) {
+      await Promise.all(queue);
+    }
+  }
+  /**
+   * Wait for all queued resolvers to complete
+   */
+  async waitForAll() {
+    const allQueues = Array.from(this.executionQueue.values());
+    const allPromises = allQueues.flat();
+    if (allPromises.length > 0) {
+      await Promise.all(allPromises);
+    }
+  }
+  /**
+   * Clear the execution queue for a specific path
+   * @param parentPath - The path to clear
+   */
+  clearPath(parentPath) {
+    this.executionQueue.delete(parentPath);
+  }
+  /**
+   * Clear all execution queues
+   */
+  clearAll() {
+    this.executionQueue.clear();
+  }
+};
+
+// src/serial-directive/utils.ts
+function hasSerialDirective(info) {
+  const operation = info.operation;
+  return operation.directives?.some(
+    (directive) => directive.name.value === "serial"
+  ) || false;
+}
+function getFieldPath(info) {
+  const path = [];
+  let currentPath = info.path;
+  while (currentPath) {
+    if (typeof currentPath.key === "string") {
+      path.unshift(currentPath.key);
+    }
+    currentPath = currentPath.prev;
+  }
+  return path.join(".");
+}
+function getParentFieldPath(info) {
+  const path = [];
+  let currentPath = info.path.prev;
+  while (currentPath) {
+    if (typeof currentPath.key === "string") {
+      path.unshift(currentPath.key);
+    }
+    currentPath = currentPath.prev;
+  }
+  return path.join(".") || "root";
+}
+function isRootField(info) {
+  return !info.path.prev || info.path.prev.key === void 0;
+}
+function logSerialExecution(message, info, data) {
+  if (process.env["DEBUG_SERIAL"]) {
+    const fieldPath = getFieldPath(info);
+    const parentPath = getParentFieldPath(info);
+    console.log(`[SERIAL] ${message}`, {
+      field: `${info.parentType.name}.${info.fieldName}`,
+      fieldPath,
+      parentPath,
+      operation: info.operation.operation,
+      data
+    });
+  }
+}
+
+// src/serial-directive/middleware.ts
+function createSerialMiddleware() {
+  return (next) => {
+    return async (source, args, context, info) => {
+      if (!context.serialExecutor) {
+        context.serialExecutor = new SerialExecutor();
+      }
+      const serialExecutor = context.serialExecutor;
+      const shouldExecuteSerially = hasSerialDirective(info);
+      if (shouldExecuteSerially && !serialExecutor.isSerialEnabled()) {
+        serialExecutor.enable();
+        logSerialExecution("Serial execution enabled for operation", info);
+      }
+      if (!serialExecutor.isSerialEnabled()) {
+        return next(source, args, context, info);
+      }
+      const parentPath = getParentFieldPath(info);
+      const isRoot = isRootField(info);
+      logSerialExecution("Queuing resolver execution", info, {
+        parentPath,
+        isRoot,
+        fieldName: info.fieldName
+      });
+      const resolverPromise = () => {
+        logSerialExecution("Executing resolver", info);
+        return Promise.resolve(next(source, args, context, info));
+      };
+      try {
+        const result = await serialExecutor.queueResolver(
+          parentPath,
+          resolverPromise
+        );
+        logSerialExecution("Resolver execution completed", info);
+        return result;
+      } catch (error) {
+        logSerialExecution("Resolver execution failed", info, { error });
+        throw error;
+      }
+    };
+  };
+}
+function createSerialResolverMap(resolvers) {
+  const serialMiddleware = createSerialMiddleware();
+  const wrappedResolvers = {};
+  for (const typeName in resolvers) {
+    wrappedResolvers[typeName] = {};
+    for (const fieldName in resolvers[typeName]) {
+      const originalResolver = resolvers[typeName][fieldName];
+      if (typeof originalResolver === "function") {
+        wrappedResolvers[typeName][fieldName] = serialMiddleware(originalResolver);
+      } else {
+        wrappedResolvers[typeName][fieldName] = originalResolver;
+      }
+    }
+  }
+  return wrappedResolvers;
+}
+
+// src/export-directive/ExportStore.ts
 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
@@ -4662,6 +1845,33 @@ var ExportStore = class {
       this.pending.delete(name);
     }
   }
+  /**
+   * Accumulate values into an array with deduplication
+   * Works great with @serial directive to build arrays from sequential field exports
+   */
+  accumulate(name, value) {
+    if (!this.accumulators.has(name)) {
+      this.accumulators.set(name, /* @__PURE__ */ new Set());
+    }
+    const accumulator = this.accumulators.get(name);
+    if (value !== null && value !== void 0) {
+      if (Array.isArray(value)) {
+        value.forEach((item) => {
+          if (item !== null && item !== void 0) {
+            accumulator.add(item);
+          }
+        });
+      } else {
+        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
    */
@@ -4692,7 +1902,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}"`)
+              );
             }
           }
         }
@@ -4711,6 +1923,7 @@ var ExportStore = class {
   clear() {
     this.store.clear();
     this.pending.clear();
+    this.accumulators.clear();
   }
   /**
    * Get all stored values
@@ -4720,7 +1933,7 @@ var ExportStore = class {
   }
 };
 
-// src/export-tool/middleware.ts
+// src/export-directive/middleware.ts
 init_utils();
 function createExportMiddleware() {
   return (next) => {
@@ -4732,15 +1945,10 @@ function createExportMiddleware() {
       let resolvedArgs = args;
       if (args && typeof args === "object" && hasExportVariables(args)) {
         try {
-          resolvedArgs = await resolveExportVariables(args, exportStore);
+          resolvedArgs = await resolveExportVariables(args, exportStore, 1e4);
         } catch (error) {
-          if (error instanceof Error && error.message.includes("Timeout waiting for export variable")) {
-            throw new Error(
-              `Failed to resolve export variables in ${info.parentType.name}.${info.fieldName}: ${error.message}. Consider using a fallback value or checking if the exported field can return null.`
-            );
-          }
           throw new Error(
-            `Failed to resolve export variables in ${info.parentType.name}.${info.fieldName}: ${error instanceof Error ? error.message : String(error)}`
+            `Export variable resolution failed in ${info.parentType.name}.${info.fieldName}: ${error instanceof Error ? error.message : String(error)}`
           );
         }
       }
@@ -4749,33 +1957,47 @@ function createExportMiddleware() {
       if (!fieldNode)
         return result;
       const selfExportName = getExportDirective(fieldNode);
-      if (selfExportName && result !== void 0) {
-        exportStore.set(selfExportName, result);
+      if (selfExportName && result !== void 0 && result !== null) {
+        if (Array.isArray(result)) {
+          result.forEach((value) => {
+            if (value !== void 0 && value !== null) {
+              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;
     };
   };
 }
+function createExportResolverMap() {
+  return {
+    // Apply to all resolvers (Query.*, Mutation.*, etc.)
+    "*.*": [createExportMiddleware()]
+  };
+}
 
-// src/export-tool/index.ts
+// src/export-directive/index.ts
 init_utils();
 
-// src/export-tool/makeScalarAcceptExports.ts
-var import_graphql14 = require("graphql");
+// src/export-directive/makeScalarAcceptExports.ts
+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
@@ -4791,7 +2013,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;
         }
@@ -4805,13 +2027,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
         )}"`
       );
@@ -4833,14 +2055,18 @@ function setCustomGraphQLTypes(table, columnTypes) {
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  buildSchema,
-  buildSchemaSDL,
+  ExportStore,
+  SerialExecutor,
   buildSchemaSDLWithDataLoader,
   cleanupDataLoaderContext,
   createDataLoaderContext,
   createExportMiddleware,
+  createExportResolverMap,
+  createSerialMiddleware,
+  createSerialResolverMap,
   exportDirectiveTypeDefs,
   makeScalarAcceptExports,
+  serialDirectiveTypeDefs,
   setCustomGraphQL,
   setCustomGraphQLTypes,
   useDataLoaderCleanup,