drizzle-graphql-plus 0.8.38 → 0.8.39

package/index.cjs

@@ -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-directive/utils.ts
+// src/export-directive[DEPRECATED]/utils.ts
 var utils_exports = {};
 __export(utils_exports, {
   extractExportDirectives: () => extractExportDirectives,
@@ -39,16 +39,105 @@ __export(utils_exports, {
   hasExportVariables: () => hasExportVariables,
   isExportVariable: () => isExportVariable,
   processExports: () => processExports,
-  resolveExportVariables: () => resolveExportVariables
+  processExportsSync: () => processExportsSync,
+  resolveExportVariables: () => resolveExportVariables,
+  resolveGraphQLVariables: () => resolveGraphQLVariables
 });
+async function resolveGraphQLVariables(args, graphqlVariables, info) {
+  if (Array.isArray(args)) {
+    return Promise.all(
+      args.map((item) => resolveGraphQLVariables(item, graphqlVariables, info))
+    );
+  }
+  if (typeof args === "object" && args !== null) {
+    const resolved = {};
+    for (const [key, value] of Object.entries(args)) {
+      if (Array.isArray(value) && value.length === 1 && value[0] === "") {
+        let foundUpdatedVariable = false;
+        for (const [varName, varValue] of Object.entries(graphqlVariables)) {
+          if (Array.isArray(varValue) && varValue.length > 0 && varValue[0] !== "") {
+            console.log(`\u{1F50D} Found updated variable ${varName}:`, varValue);
+            resolved[key] = varValue;
+            foundUpdatedVariable = true;
+            break;
+          }
+        }
+        if (!foundUpdatedVariable && info.parentType && (info.parentType.name === "Query" || info.parentType.name === "Mutation")) {
+          const context = info.context || {};
+          if (context.exportStore) {
+            console.log(
+              `\u{1F50D} No updated variables yet, checking for pending exports...`
+            );
+            const potentialExports = Object.keys(graphqlVariables).map(
+              (varName) => varName.startsWith("_") ? `$${varName}` : `$_${varName}`
+            );
+            console.log(
+              `\u{1F50D} Potential export names to wait for:`,
+              potentialExports
+            );
+            for (const exportName of potentialExports) {
+              try {
+                const exportedValue = await context.exportStore.waitFor(
+                  exportName,
+                  2e3,
+                  false
+                );
+                if (exportedValue && Array.isArray(exportedValue) && exportedValue.length > 0) {
+                  console.log(
+                    `\u2705 Found exported value for ${exportName}:`,
+                    exportedValue
+                  );
+                  resolved[key] = exportedValue;
+                  foundUpdatedVariable = true;
+                  break;
+                }
+              } catch (error) {
+                console.log(
+                  `\u26A0\uFE0F Export ${exportName} not available yet:`,
+                  error.message
+                );
+              }
+            }
+          } else {
+            console.log(
+              `\u{1F6A8} No export store available in context to wait for exports`
+            );
+          }
+        } else {
+        }
+        if (!(key in resolved)) {
+          resolved[key] = value;
+        }
+      } else if (typeof value === "object" && value !== null) {
+        resolved[key] = await resolveGraphQLVariables(
+          value,
+          graphqlVariables,
+          info
+        );
+      } else {
+        resolved[key] = value;
+      }
+    }
+    return resolved;
+  }
+  return args;
+}
 function isExportVariable(value) {
-  return typeof value === "string" && value.startsWith("$_") && value.length > 2;
+  if (typeof value !== "string") {
+    return false;
+  }
+  return value.startsWith("$_") && value.length > 2 || value.startsWith("EXPORT_VAR:") && value.length > 11;
 }
 function getVariableName(value) {
   if (!isExportVariable(value)) {
     return null;
   }
-  return value.slice(2);
+  if (value.startsWith("$_")) {
+    return value.slice(2);
+  } else if (value.startsWith("EXPORT_VAR:")) {
+    return value.slice(11);
+  }
+  return null;
 }
 async function resolveExportVariables(args, exportStore, timeout = 5e3) {
   if (isExportVariable(args)) {
@@ -61,14 +150,19 @@ async function resolveExportVariables(args, exportStore, timeout = 5e3) {
       args.map(async (item) => {
         if (isExportVariable(item)) {
           const varName = getVariableName(item);
-          return await exportStore.waitFor(varName, timeout, false);
+          const resolvedValue = await exportStore.waitFor(
+            varName,
+            timeout,
+            false
+          );
+          return Array.isArray(resolvedValue) ? resolvedValue : [resolvedValue];
         } else if (typeof item === "object" && item !== null) {
           return await resolveExportVariables(item, exportStore, timeout);
         }
         return item;
       })
     );
-    return resolved;
+    return resolved.flat();
   }
   if (typeof args === "object" && args !== null) {
     const resolved = {};
@@ -151,39 +245,140 @@ function hasExportVariables(args) {
   }
   return false;
 }
-function processExports(result, selectionSet, exportStore, isArrayItem = false) {
+async function processExportsSync(result, fieldNode, exportStore, context) {
+  if (!result || !fieldNode)
+    return;
+  const selfExportName = getExportDirective(fieldNode);
+  if (selfExportName && result !== void 0 && result !== null) {
+    if (!fieldNode.selectionSet) {
+      exportStore.set(selfExportName, result);
+    } else {
+    }
+  } else {
+  }
+  if (fieldNode.selectionSet && result !== void 0 && result !== null) {
+    if (Array.isArray(result)) {
+      result.forEach((item, index) => {
+        if (item && typeof item === "object") {
+          processExports(
+            item,
+            fieldNode.selectionSet,
+            exportStore,
+            true,
+            context
+          );
+        }
+      });
+    } else if (typeof result === "object") {
+      processExports(
+        result,
+        fieldNode.selectionSet,
+        exportStore,
+        false,
+        context
+      );
+    }
+  } else {
+  }
+}
+function processExports(result, selectionSet, exportStore, isArrayItem = false, context) {
   if (!result || !selectionSet)
     return;
   for (const selection of selectionSet.selections) {
     if (selection.kind !== "Field")
       continue;
     const resultKey = selection.alias?.value ?? selection.name.value;
-    if (!(resultKey in result))
+    if (!(resultKey in result)) {
       continue;
+    }
     const value = result[resultKey];
+    console.log(
+      "\u{1F527} Field value:",
+      typeof value,
+      Array.isArray(value) ? `array[${value.length}]` : "single"
+    );
     const exportName = getExportDirective(selection);
     if (exportName) {
-      if (isArrayItem) {
-        exportStore.accumulate(exportName, value);
+      if (exportName.startsWith("$_")) {
+        const varName = exportName.slice(2);
+        const fullVarName = `_${varName}`;
+        console.log(
+          `\u{1F527} Updating GraphQL variable '${fullVarName}' with value:`,
+          value
+        );
+        if (context && context._graphqlVariables) {
+          const variableValues = context._graphqlVariables;
+          console.log(`\u{1F50D} Current variables before update:`, variableValues);
+          if (Array.isArray(variableValues[fullVarName]) && variableValues[fullVarName].length === 1 && variableValues[fullVarName][0] === "") {
+            variableValues[fullVarName] = [];
+          }
+          if (isArrayItem) {
+            if (Array.isArray(variableValues[fullVarName])) {
+              variableValues[fullVarName] = [
+                ...variableValues[fullVarName],
+                value
+              ];
+            } else {
+              variableValues[fullVarName] = [value];
+            }
+          } else {
+            if (Array.isArray(value)) {
+              variableValues[fullVarName] = value;
+            } else {
+              variableValues[fullVarName] = [value];
+            }
+          }
+          console.log(
+            `\u2705 Updated GraphQL variable '${fullVarName}' to:`,
+            variableValues[fullVarName]
+          );
+        } else {
+          console.log(
+            `\u26A0\uFE0F Could not access GraphQL variables to update '${fullVarName}'`
+          );
+        }
+        if (isArrayItem) {
+          exportStore.accumulate(exportName, value);
+        } else {
+          exportStore.set(exportName, value);
+        }
       } else {
-        exportStore.set(exportName, value);
+        if (isArrayItem) {
+          exportStore.accumulate(exportName, value);
+        } else {
+          console.log(`\u{1F527} Setting ${exportName} with value:`, value);
+          exportStore.set(exportName, value);
+        }
       }
+    } else {
     }
     if (selection.selectionSet && value !== null && value !== void 0) {
       if (Array.isArray(value)) {
         value.forEach((item) => {
           if (item && typeof item === "object") {
-            processExports(item, selection.selectionSet, exportStore, true);
+            processExports(
+              item,
+              selection.selectionSet,
+              exportStore,
+              true,
+              context
+            );
           }
         });
       } else if (typeof value === "object") {
-        processExports(value, selection.selectionSet, exportStore, isArrayItem);
+        processExports(
+          value,
+          selection.selectionSet,
+          exportStore,
+          isArrayItem,
+          context
+        );
       }
     }
   }
 }
 var init_utils = __esm({
-  "src/export-directive/utils.ts"() {
+  "src/export-directive[DEPRECATED]/utils.ts"() {
     "use strict";
   }
 });
@@ -192,14 +387,9 @@ var init_utils = __esm({
 var src_exports = {};
 __export(src_exports, {
   ExportStore: () => ExportStore,
-  SerialExecutor: () => SerialExecutor,
   buildSchemaSDLWithDataLoader: () => buildSchemaSDL,
   cleanupDataLoaderContext: () => cleanupDataLoaderContext,
   createDataLoaderContext: () => createDataLoaderContext,
-  createExportMiddleware: () => createExportMiddleware,
-  createExportResolverMap: () => createExportResolverMap,
-  createSerialMiddleware: () => createSerialMiddleware,
-  createSerialResolverMap: () => createSerialResolverMap,
   exportDirectiveTypeDefs: () => exportDirectiveTypeDefs,
   makeScalarAcceptExports: () => makeScalarAcceptExports,
   serialDirectiveTypeDefs: () => serialDirectiveTypeDefs,
@@ -207,7 +397,9 @@ __export(src_exports, {
   setCustomGraphQLTypes: () => setCustomGraphQLTypes,
   useDataLoaderCleanup: () => useDataLoaderCleanup,
   useDataLoaderCleanupOnly: () => useDataLoaderCleanupOnly,
-  useDataLoaderContext: () => useDataLoaderContext
+  useDataLoaderContext: () => useDataLoaderContext,
+  useExportDirective: () => useExportDirective,
+  useSerialDirective: () => useSerialDirective
 });
 module.exports = __toCommonJS(src_exports);
 
@@ -911,8 +1103,8 @@ var RelationDataLoader = class {
       const uniqueParentIds = Array.from(new Set(allParentIds));
       let resolvedWhere = firstKey.where;
       if (resolvedWhere && this.context?.exportStore) {
-        const { hasExportVariables: hasExportVariables2, resolveExportVariables: resolveExportVariables2 } = await Promise.resolve().then(() => (init_utils(), utils_exports));
-        if (hasExportVariables2(resolvedWhere)) {
+        const { hasExportVariables: hasExportVariables3, resolveExportVariables: resolveExportVariables3 } = await Promise.resolve().then(() => (init_utils(), utils_exports));
+        if (hasExportVariables3(resolvedWhere)) {
           try {
             if (this.debugConfig?.exportVariables) {
               console.log(
@@ -920,7 +1112,7 @@ var RelationDataLoader = class {
                 resolvedWhere
               );
             }
-            resolvedWhere = await resolveExportVariables2(
+            resolvedWhere = await resolveExportVariables3(
               resolvedWhere,
               this.context.exportStore
             );
@@ -1553,12 +1745,6 @@ var generateMutations = (db, tables, relations, debugConfig) => {
   return { mutations, deleteResultResolvers };
 };
 
-// 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_schema2 = require("@graphql-tools/schema");
 var buildSchemaSDL = (db, config) => {
@@ -1650,185 +1836,160 @@ var useDataLoaderCleanupOnly = () => ({
   })
 });
 
-// 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);
+// src/serial-directive-envelop-hooks/plugin.ts
+var import_graphql5 = require("graphql");
+
+// src/serial-directive-envelop-hooks/utils.ts
+function hasSerialDirective(document, operationName) {
+  const operation = document.definitions.find((def) => {
+    if (def.kind !== "OperationDefinition")
+      return false;
+    const opDef = def;
+    if (operationName) {
+      return opDef.name?.value === operationName;
     }
-  }
+    return true;
+  });
+  if (!operation)
+    return false;
+  return operation.directives?.some(
+    (directive) => directive.name.value === "serial"
+  ) || false;
+}
+var SerialExecutor = class {
+  queue = Promise.resolve();
   /**
-   * Clear the execution queue for a specific path
-   * @param parentPath - The path to clear
+   * Add a task to the execution queue
+   * @param task - Function that returns a promise
+   * @returns Promise that resolves when the task completes
    */
-  clearPath(parentPath) {
-    this.executionQueue.delete(parentPath);
+  enqueue(task) {
+    const promise = this.queue.then(task, task);
+    this.queue = promise.then(
+      () => {
+      },
+      () => {
+      }
+    );
+    return promise;
   }
   /**
-   * Clear all execution queues
+   * Reset the queue
    */
-  clearAll() {
-    this.executionQueue.clear();
+  reset() {
+    this.queue = Promise.resolve();
   }
 };
-
-// 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 createSerialExecutor() {
+  return new SerialExecutor();
 }
-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) {
+function logSerialExecution(message, 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
-    });
+    console.log(`[SERIAL-HOOK] ${message}`, 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
+// src/serial-directive-envelop-hooks/plugin.ts
+var processedSchemas = /* @__PURE__ */ new WeakSet();
+var useSerialDirective = () => {
+  return {
+    onExecute({ args }) {
+      const shouldExecuteSerially = hasSerialDirective(
+        args.document,
+        args.operationName || void 0
+      );
+      if (!shouldExecuteSerially) {
+        return void 0;
+      }
+      logSerialExecution("Serial execution enabled for operation", {
+        operationName: args.operationName
       });
-      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;
+      if (!args.contextValue) {
+        args.contextValue = {};
       }
-    };
-  };
-}
-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;
+      const context = args.contextValue;
+      if (!context.serialExecutor) {
+        context.serialExecutor = createSerialExecutor();
+      }
+      const createWrappedResolver = (originalResolver) => {
+        return (source, fieldArgs, fieldContext, info) => {
+          const ctx = fieldContext;
+          const serialExecutor = ctx.serialExecutor;
+          const isRootField = !info.path.prev || info.path.prev.key === void 0;
+          if (!isRootField || !serialExecutor) {
+            if (originalResolver) {
+              return originalResolver(source, fieldArgs, fieldContext, info);
+            }
+            const fieldName = info.fieldName;
+            return source?.[fieldName];
+          }
+          logSerialExecution("Queuing root field for serial execution", {
+            field: `${info.parentType.name}.${info.fieldName}`
+          });
+          return serialExecutor.enqueue(async () => {
+            logSerialExecution("Executing root field", {
+              field: `${info.parentType.name}.${info.fieldName}`
+            });
+            let result;
+            if (originalResolver) {
+              result = await originalResolver(source, fieldArgs, fieldContext, info);
+            } else {
+              const fieldName = info.fieldName;
+              result = source?.[fieldName];
+            }
+            logSerialExecution("Root field execution completed", {
+              field: `${info.parentType.name}.${info.fieldName}`
+            });
+            return result;
+          });
+        };
+      };
+      if (args.schema && !processedSchemas.has(args.schema)) {
+        processedSchemas.add(args.schema);
+        logSerialExecution("Wrapping schema resolvers for @serial support");
+        const typeMap = args.schema.getTypeMap();
+        for (const typeName in typeMap) {
+          const type = typeMap[typeName];
+          if (type instanceof import_graphql5.GraphQLObjectType && !typeName.startsWith("__")) {
+            const fields = type.getFields();
+            for (const fieldName in fields) {
+              const field = fields[fieldName];
+              if (!field) {
+                continue;
+              }
+              if (field.resolve) {
+                field.resolve = createWrappedResolver(field.resolve);
+              }
+            }
+          }
+        }
       }
+      args.fieldResolver = createWrappedResolver(args.fieldResolver);
+      return {
+        onExecuteDone() {
+          logSerialExecution("Serial execution completed", {
+            operationName: args.operationName
+          });
+        }
+      };
     }
-  }
-  return wrappedResolvers;
-}
+  };
+};
+
+// src/serial-directive-envelop-hooks/directive-definitions.ts
+var serialDirectiveTypeDefs = `
+  """
+  Forces query fields to execute sequentially instead of in parallel.
+  Root-level fields will execute one after another in the order they appear.
+  Nested fields within each parent will also execute sequentially.
+  """
+  directive @serial on QUERY
+`;
 
-// src/export-directive/ExportStore.ts
+// src/export-directive-envelop-hooks/plugin.ts
+var import_graphql7 = require("graphql");
+
+// src/export-directive-envelop-hooks/ExportStore.ts
 var ExportStore = class {
   store = /* @__PURE__ */ new Map();
   pending = /* @__PURE__ */ new Map();
@@ -1933,75 +2094,15 @@ var ExportStore = class {
   }
 };
 
-// src/export-directive/middleware.ts
-init_utils();
-function createExportMiddleware() {
-  return (next) => {
-    return async (source, args, context, info) => {
-      if (!context.exportStore) {
-        context.exportStore = new ExportStore();
-      }
-      const exportStore = context.exportStore;
-      let resolvedArgs = args;
-      if (args && typeof args === "object" && hasExportVariables(args)) {
-        try {
-          resolvedArgs = await resolveExportVariables(args, exportStore, 1e4);
-        } catch (error) {
-          throw new Error(
-            `Export variable resolution failed in ${info.parentType.name}.${info.fieldName}: ${error instanceof Error ? error.message : String(error)}`
-          );
-        }
-      }
-      const result = await next(source, resolvedArgs, context, info);
-      const fieldNode = info.fieldNodes[0];
-      if (!fieldNode)
-        return result;
-      const selfExportName = getExportDirective(fieldNode);
-      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, true);
-            }
-          });
-        } else if (typeof result === "object") {
-          processExports(result, fieldNode.selectionSet, exportStore, false);
-        }
-      }
-      return result;
-    };
-  };
-}
-function createExportResolverMap() {
-  return {
-    // Apply to all resolvers (Query.*, Mutation.*, etc.)
-    "*.*": [createExportMiddleware()]
-  };
-}
-
-// src/export-directive/index.ts
-init_utils();
-
-// src/export-directive/makeScalarAcceptExports.ts
-var import_graphql5 = require("graphql");
+// src/export-directive-envelop-hooks/utils.ts
+var import_graphql6 = require("graphql");
 function makeScalarAcceptExports(originalScalar) {
   const config = originalScalar.toConfig();
-  return new import_graphql5.GraphQLScalarType({
+  return new import_graphql6.GraphQLScalarType({
     ...config,
     name: config.name,
     // Keep original name to override it in schema
-    description: `${config.description} (Wrapped with makeScalarAcceptExports to accept $_ export variables)`,
+    description: config.description + " (Wrapped with makeScalarAcceptExports to accept $_ export variables)",
     serialize: config.serialize,
     parseValue(value) {
       if (typeof value === "string" && (value.startsWith("$_") || value === "")) {
@@ -2013,18 +2114,527 @@ function makeScalarAcceptExports(originalScalar) {
       return value;
     },
     parseLiteral(ast, variables) {
-      if (ast.kind === import_graphql5.Kind.STRING) {
+      if (ast.kind === import_graphql6.Kind.STRING) {
         if (ast.value.startsWith("$_") || ast.value === "") {
           return ast.value;
         }
       }
-      if (config.parseLiteral) {
+      if (config.parseLiteral && ast) {
         return config.parseLiteral(ast, variables);
       }
       return void 0;
     }
   });
 }
+function isExportVariable2(value) {
+  if (typeof value !== "string") {
+    return false;
+  }
+  return value.startsWith("$_") && value.length > 2 || value.startsWith("EXPORT_VAR:") && value.length > 11;
+}
+function getVariableName2(value) {
+  if (!isExportVariable2(value)) {
+    return null;
+  }
+  if (value.startsWith("$_")) {
+    return value.slice(2);
+  } else if (value.startsWith("EXPORT_VAR:")) {
+    return value.slice(11);
+  }
+  return null;
+}
+async function resolveExportVariables2(args, exportStore, timeout = 5e3) {
+  if (isExportVariable2(args)) {
+    const varName = getVariableName2(args);
+    const resolvedValue = await exportStore.waitFor(varName, timeout, false);
+    return resolvedValue;
+  }
+  if (Array.isArray(args)) {
+    const resolved = await Promise.all(
+      args.map(async (item) => {
+        if (isExportVariable2(item)) {
+          const varName = getVariableName2(item);
+          const resolvedValue = await exportStore.waitFor(
+            varName,
+            timeout,
+            false
+          );
+          return Array.isArray(resolvedValue) ? resolvedValue : [resolvedValue];
+        } else if (typeof item === "object" && item !== null) {
+          return await resolveExportVariables2(item, exportStore, timeout);
+        }
+        return item;
+      })
+    );
+    return resolved.flat();
+  }
+  if (typeof args === "object" && args !== null) {
+    const resolved = {};
+    for (const [key, value] of Object.entries(args)) {
+      if (isExportVariable2(value)) {
+        const varName = getVariableName2(value);
+        const resolvedValue = await exportStore.waitFor(
+          varName,
+          timeout,
+          false
+        );
+        resolved[key] = resolvedValue;
+      } else if (typeof value === "object" && value !== null) {
+        resolved[key] = await resolveExportVariables2(
+          value,
+          exportStore,
+          timeout
+        );
+      } else {
+        resolved[key] = value;
+      }
+    }
+    return resolved;
+  }
+  return args;
+}
+function getExportDirective2(fieldNode) {
+  if (!fieldNode || !fieldNode.directives) {
+    return null;
+  }
+  const exportDirective = fieldNode.directives.find(
+    (directive) => directive.name.value === "export"
+  );
+  if (!exportDirective) {
+    return null;
+  }
+  const asArg = exportDirective.arguments?.find(
+    (arg) => arg.name.value === "as"
+  );
+  if (!asArg || asArg.value.kind !== "StringValue") {
+    return null;
+  }
+  return asArg.value.value;
+}
+function hasExportVariables2(args) {
+  if (isExportVariable2(args)) {
+    return true;
+  }
+  if (Array.isArray(args)) {
+    return args.some((item) => hasExportVariables2(item));
+  }
+  if (typeof args === "object" && args !== null) {
+    for (const value of Object.values(args)) {
+      if (hasExportVariables2(value)) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+function processExports2(result, selectionSet, exportStore, variables, isArrayItem = false) {
+  if (!result || !selectionSet)
+    return;
+  for (const selection of selectionSet.selections) {
+    if (selection.kind !== "Field")
+      continue;
+    const resultKey = selection.alias?.value ?? selection.name.value;
+    if (!(resultKey in result)) {
+      continue;
+    }
+    const value = result[resultKey];
+    const exportName = getExportDirective2(selection);
+    if (exportName) {
+      logExportExecution("Found @export directive: " + exportName, {
+        isArrayItem,
+        value: typeof value
+      });
+      if (isArrayItem) {
+        exportStore.accumulate(exportName, value);
+      } else {
+        exportStore.set(exportName, value);
+      }
+      if (variables && exportName.startsWith("$_")) {
+        const varName = "_" + exportName.slice(2);
+        if (isArrayItem) {
+          if (!variables[varName]) {
+            variables[varName] = [];
+          }
+          if (Array.isArray(variables[varName])) {
+            if (!variables[varName].includes(value)) {
+              variables[varName].push(value);
+            }
+          }
+        } else {
+          variables[varName] = value;
+        }
+        logExportExecution(
+          "Updated GraphQL variable: " + varName,
+          variables[varName]
+        );
+      }
+    }
+    if (selection.selectionSet && value !== null && value !== void 0) {
+      if (Array.isArray(value)) {
+        value.forEach((item) => {
+          if (item && typeof item === "object") {
+            processExports2(
+              item,
+              selection.selectionSet,
+              exportStore,
+              variables,
+              true
+            );
+          }
+        });
+      } else if (typeof value === "object") {
+        processExports2(
+          value,
+          selection.selectionSet,
+          exportStore,
+          variables,
+          isArrayItem
+        );
+      }
+    }
+  }
+}
+async function resolveGraphQLVariables2(args, fieldNode, exportStore, timeout = 5e3) {
+  if (!fieldNode.arguments || !args)
+    return;
+  logExportExecution("resolveGraphQLVariables starting", {
+    argsKeys: Object.keys(args)
+  });
+  for (const arg of fieldNode.arguments) {
+    const argName = arg.name.value;
+    if (argName in args) {
+      await traverseASTAndResolve(
+        arg.value,
+        args,
+        argName,
+        exportStore,
+        timeout
+      );
+    } else {
+      logExportExecution("argName not in args", argName);
+    }
+  }
+}
+function normalizeFilterOperators(obj) {
+  if (!obj || typeof obj !== "object")
+    return;
+  if (Array.isArray(obj)) {
+    obj.forEach((item) => normalizeFilterOperators(item));
+    return;
+  }
+  for (const key of Object.keys(obj)) {
+    const value = obj[key];
+    if (key === "in" && value !== void 0 && !("inArray" in obj)) {
+      obj.inArray = value;
+      delete obj.in;
+    } else if (value && typeof value === "object") {
+      normalizeFilterOperators(value);
+    }
+  }
+}
+async function traverseASTAndResolve(node, parentObj, key, exportStore, timeout) {
+  logExportExecution("traverseASTAndResolve", { kind: node.kind, key });
+  if (node.kind === import_graphql6.Kind.VARIABLE) {
+    const varName = node.name.value;
+    const candidateNames = ["$" + varName, varName];
+    if (varName.startsWith("_")) {
+      candidateNames.push("$" + varName);
+    } else {
+      candidateNames.push("$_" + varName);
+    }
+    const currentValue = parentObj[key];
+    const isDefault = currentValue === void 0 || currentValue === "" || Array.isArray(currentValue) && (currentValue.length === 0 || currentValue.length === 1 && currentValue[0] === "");
+    logExportExecution("Checking variable", {
+      varName,
+      currentValue,
+      isDefault
+    });
+    if (isDefault) {
+      const exportName = "$" + varName;
+      logExportExecution("Waiting for export variable mapping", {
+        varName,
+        exportName
+      });
+      try {
+        const val = await exportStore.waitFor(exportName, timeout, true);
+        if (val !== void 0) {
+          parentObj[key] = val;
+          logExportExecution(
+            "Resolved variable " + varName + " to export " + exportName,
+            val
+          );
+        } else {
+          logExportExecution(
+            "Export variable resolved to undefined (allowed)",
+            exportName
+          );
+        }
+      } catch (e) {
+        logExportExecution(
+          "Timeout waiting for variable " + varName + " as export " + exportName
+        );
+      }
+    }
+  } else if (node.kind === import_graphql6.Kind.OBJECT) {
+    let obj = parentObj[key];
+    if (!obj || typeof obj !== "object") {
+      obj = {};
+      parentObj[key] = obj;
+    }
+    for (const field of node.fields) {
+      const fieldName = field.name.value;
+      await traverseASTAndResolve(
+        field.value,
+        obj,
+        fieldName,
+        exportStore,
+        timeout
+      );
+    }
+  } else if (node.kind === import_graphql6.Kind.LIST) {
+    let list = parentObj[key];
+    if (!Array.isArray(list)) {
+      list = new Array(node.values.length).fill(void 0);
+      parentObj[key] = list;
+    }
+    const len = Math.min(list.length, node.values.length);
+    for (let i = 0; i < len; i++) {
+      await traverseASTAndResolve(
+        node.values[i],
+        list,
+        i,
+        exportStore,
+        timeout
+      );
+    }
+  }
+}
+function logExportExecution(message, data) {
+  if (process.env["DEBUG_EXPORT"]) {
+    console.log("[EXPORT-HOOK] " + message, data || "");
+  }
+}
+
+// src/export-directive-envelop-hooks/plugin.ts
+var processedSchemas2 = /* @__PURE__ */ new WeakSet();
+var useExportDirective = () => {
+  return {
+    onExecute({ args, setExecuteFn }) {
+      if (!args.contextValue) {
+        args.contextValue = {};
+      }
+      const context = args.contextValue;
+      if (!context.exportStore) {
+        context.exportStore = new ExportStore();
+        logExportExecution("Created new ExportStore in context");
+      }
+      const exportStore = context.exportStore;
+      const initialVariables = args.variableValues || {};
+      if (!context._graphqlVariables) {
+        context._graphqlVariables = { ...initialVariables };
+        logExportExecution(
+          "Stored GraphQL variables reference",
+          Object.keys(initialVariables)
+        );
+      }
+      const createWrappedResolver = (originalResolver) => {
+        return async (source, fieldArgs, fieldContext, info) => {
+          const ctx = fieldContext;
+          const store = ctx.exportStore;
+          const isComments = info.fieldName === "comments" || info.fieldName === "commentFindMany";
+          if (isComments) {
+            logExportExecution("DEBUG Resolver Called", {
+              fieldName: info.fieldName,
+              args: JSON.stringify(fieldArgs),
+              variables: JSON.stringify(ctx._graphqlVariables)
+            });
+          }
+          let currentArgs = fieldArgs;
+          if (ctx._graphqlVariables && info.parentType instanceof import_graphql7.GraphQLObjectType) {
+            const fieldNode2 = info.fieldNodes[0];
+            if (!fieldNode2) {
+              if (isComments) {
+                logExportExecution("DEBUG fieldNode NOT FOUND");
+              }
+            } else {
+              const fieldName = fieldNode2.name.value;
+              const fieldDef = info.parentType.getFields()[fieldName];
+              if (isComments && !fieldDef) {
+                logExportExecution("DEBUG fieldDef NOT FOUND");
+              }
+              if (fieldDef) {
+                try {
+                  if (isComments) {
+                    logExportExecution("DEBUG calling getArgumentValues", {
+                      fieldNodeName: fieldNode2.name.value,
+                      fieldDefName: fieldDef.name,
+                      variablesKeys: Object.keys(
+                        ctx._graphqlVariables || {}
+                      )
+                    });
+                  }
+                  const freshArgs = (0, import_graphql7.getArgumentValues)(
+                    fieldDef,
+                    fieldNode2,
+                    ctx._graphqlVariables
+                  );
+                  if (isComments) {
+                    logExportExecution("DEBUG getArgumentValues result", {
+                      freshArgsKeys: Object.keys(freshArgs || {}),
+                      freshArgs: JSON.stringify(freshArgs)
+                    });
+                  }
+                  if (freshArgs) {
+                    currentArgs = freshArgs;
+                  }
+                } catch (e) {
+                  logExportExecution(
+                    "Failed to re-resolve args for " + info.fieldName,
+                    e
+                  );
+                }
+              }
+            }
+          }
+          let resolvedArgs = currentArgs;
+          const fieldNode = info.fieldNodes[0];
+          if (currentArgs && typeof currentArgs === "object") {
+            if (fieldNode) {
+              try {
+                await resolveGraphQLVariables2(
+                  currentArgs,
+                  fieldNode,
+                  store,
+                  1e4
+                );
+              } catch (error) {
+                logExportExecution("GraphQL variable resolution failed", error);
+              }
+            }
+            normalizeFilterOperators(currentArgs);
+            if (hasExportVariables2(currentArgs)) {
+              try {
+                resolvedArgs = await resolveExportVariables2(
+                  currentArgs,
+                  store,
+                  1e4
+                );
+              } catch (error) {
+                throw new Error(
+                  "Export variable resolution failed in " + info.parentType.name + "." + info.fieldName + ": " + (error instanceof Error ? error.message : String(error))
+                );
+              }
+            }
+          }
+          let result;
+          if (originalResolver) {
+            result = await originalResolver(
+              source,
+              resolvedArgs,
+              fieldContext,
+              info
+            );
+          } else {
+            const fieldName = info.fieldName;
+            result = source?.[fieldName];
+          }
+          if (fieldNode) {
+            const selfExportName = getExportDirective2(fieldNode);
+            if (selfExportName && result !== void 0 && result !== null) {
+              if (!fieldNode.selectionSet) {
+                logExportExecution(
+                  "Setting field-level export: " + selfExportName,
+                  { value: result }
+                );
+                store.set(selfExportName, result);
+                if (selfExportName.startsWith("$_")) {
+                  const varName = "_" + selfExportName.slice(2);
+                  if (ctx._graphqlVariables) {
+                    const currentVal = ctx._graphqlVariables[varName];
+                    if (Array.isArray(currentVal)) {
+                      if (!currentVal.includes(result) && result !== "") {
+                        currentVal.push(result);
+                      }
+                    } else {
+                      ctx._graphqlVariables[varName] = result;
+                    }
+                    logExportExecution(
+                      "Updated GraphQL variable: " + varName,
+                      ctx._graphqlVariables[varName]
+                    );
+                  }
+                }
+              }
+            }
+            if (fieldNode && fieldNode.selectionSet && result !== void 0 && result !== null) {
+              if (Array.isArray(result)) {
+                result.forEach((item) => {
+                  if (item && typeof item === "object") {
+                    processExports2(
+                      item,
+                      fieldNode.selectionSet,
+                      store,
+                      ctx._graphqlVariables,
+                      true
+                    );
+                  }
+                });
+              } else if (typeof result === "object") {
+                processExports2(
+                  result,
+                  fieldNode.selectionSet,
+                  store,
+                  ctx._graphqlVariables,
+                  false
+                );
+              }
+            }
+          }
+          return result;
+        };
+      };
+      if (args.schema && !processedSchemas2.has(args.schema)) {
+        processedSchemas2.add(args.schema);
+        logExportExecution("Wrapping schema resolvers");
+        const typeMap = args.schema.getTypeMap();
+        for (const typeName in typeMap) {
+          const type = typeMap[typeName];
+          if (type instanceof import_graphql7.GraphQLObjectType && !typeName.startsWith("__")) {
+            const fields = type.getFields();
+            for (const fieldName in fields) {
+              const field = fields[fieldName];
+              if (!field) {
+                continue;
+              }
+              if (field.resolve) {
+                field.resolve = createWrappedResolver(field.resolve);
+              }
+            }
+          }
+        }
+      }
+      args.fieldResolver = createWrappedResolver(args.fieldResolver);
+      return {
+        onExecuteDone() {
+          logExportExecution("Export execution completed", {
+            exports: exportStore.getAll(),
+            variables: context._graphqlVariables || {}
+          });
+        }
+      };
+    }
+  };
+};
+
+// src/export-directive-envelop-hooks/directive-definitions.ts
+var exportDirectiveTypeDefs = `
+  """
+  Exports a field value for use by other fields in the same query.
+  The exported value can be referenced using the pattern $_variableName or EXPORT_VAR:variableName.
+  Supports accumulation when used on array items.
+  """
+  directive @export(as: String!) on FIELD
+`;
 
 // src/helpers.ts
 var import_drizzle_orm9 = require("drizzle-orm");
@@ -2056,14 +2666,9 @@ function setCustomGraphQLTypes(table, columnTypes) {
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   ExportStore,
-  SerialExecutor,
   buildSchemaSDLWithDataLoader,
   cleanupDataLoaderContext,
   createDataLoaderContext,
-  createExportMiddleware,
-  createExportResolverMap,
-  createSerialMiddleware,
-  createSerialResolverMap,
   exportDirectiveTypeDefs,
   makeScalarAcceptExports,
   serialDirectiveTypeDefs,
@@ -2071,6 +2676,8 @@ function setCustomGraphQLTypes(table, columnTypes) {
   setCustomGraphQLTypes,
   useDataLoaderCleanup,
   useDataLoaderCleanupOnly,
-  useDataLoaderContext
+  useDataLoaderContext,
+  useExportDirective,
+  useSerialDirective
 });
 //# sourceMappingURL=index.cjs.map