drizzle-graphql-plus 0.8.37 → 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-tool/utils.ts
+// src/export-directive[DEPRECATED]/utils.ts
 var utils_exports = {};
 __export(utils_exports, {
   extractExportDirectives: () => extractExportDirectives,
@@ -39,60 +39,151 @@ __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, 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);
-        } else if (typeof item === "object" && item !== null) {
-          return await resolveExportVariables(
-            item,
-            exportStore,
+          const resolvedValue = await exportStore.waitFor(
+            varName,
             timeout,
-            allowNull
+            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 = {};
     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;
@@ -154,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-tool/utils.ts"() {
+  "src/export-directive[DEPRECATED]/utils.ts"() {
     "use strict";
   }
 });
@@ -194,17 +386,20 @@ var init_utils = __esm({
 // src/index.ts
 var src_exports = {};
 __export(src_exports, {
+  ExportStore: () => ExportStore,
   buildSchemaSDLWithDataLoader: () => buildSchemaSDL,
   cleanupDataLoaderContext: () => cleanupDataLoaderContext,
   createDataLoaderContext: () => createDataLoaderContext,
-  createExportMiddleware: () => createExportMiddleware,
   exportDirectiveTypeDefs: () => exportDirectiveTypeDefs,
   makeScalarAcceptExports: () => makeScalarAcceptExports,
+  serialDirectiveTypeDefs: () => serialDirectiveTypeDefs,
   setCustomGraphQL: () => setCustomGraphQL,
   setCustomGraphQLTypes: () => setCustomGraphQLTypes,
   useDataLoaderCleanup: () => useDataLoaderCleanup,
   useDataLoaderCleanupOnly: () => useDataLoaderCleanupOnly,
-  useDataLoaderContext: () => useDataLoaderContext
+  useDataLoaderContext: () => useDataLoaderContext,
+  useExportDirective: () => useExportDirective,
+  useSerialDirective: () => useSerialDirective
 });
 module.exports = __toCommonJS(src_exports);
 
@@ -908,19 +1103,31 @@ 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(`\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 resolveExportVariables3(
+              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
+              );
             }
           }
         }
@@ -948,11 +1155,16 @@ var RelationDataLoader = class {
         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) {
@@ -963,10 +1175,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);
       }
     }
@@ -975,7 +1189,9 @@ 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;
     }
@@ -1011,7 +1227,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
     );
   }
@@ -1523,9 +1745,6 @@ var generateMutations = (db, tables, relations, debugConfig) => {
   return { mutations, deleteResultResolvers };
 };
 
-// src/export-tool/directive-definitions.ts
-var exportDirectiveTypeDefs = `directive @export(as: String!) on FIELD`;
-
 // src/build-schema-sdl-with-dl/index.ts
 var import_schema2 = require("@graphql-tools/schema");
 var buildSchemaSDL = (db, config) => {
@@ -1617,7 +1836,160 @@ var useDataLoaderCleanupOnly = () => ({
   })
 });
 
-// src/export-tool/ExportStore.ts
+// 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();
+  /**
+   * Add a task to the execution queue
+   * @param task - Function that returns a promise
+   * @returns Promise that resolves when the task completes
+   */
+  enqueue(task) {
+    const promise = this.queue.then(task, task);
+    this.queue = promise.then(
+      () => {
+      },
+      () => {
+      }
+    );
+    return promise;
+  }
+  /**
+   * Reset the queue
+   */
+  reset() {
+    this.queue = Promise.resolve();
+  }
+};
+function createSerialExecutor() {
+  return new SerialExecutor();
+}
+function logSerialExecution(message, data) {
+  if (process.env["DEBUG_SERIAL"]) {
+    console.log(`[SERIAL-HOOK] ${message}`, data || "");
+  }
+}
+
+// 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
+      });
+      if (!args.contextValue) {
+        args.contextValue = {};
+      }
+      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
+          });
+        }
+      };
+    }
+  };
+};
+
+// 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-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();
@@ -1636,22 +2008,23 @@ var ExportStore = class {
   }
   /**
    * Accumulate values into an array with deduplication
-   * First call initializes an array, subsequent calls add to it
-   * Use this when the same export variable is used in multiple array items
+   * 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 (Array.isArray(value)) {
-      value.forEach((item) => {
-        if (item !== null && item !== void 0) {
-          accumulator.add(item);
-        }
-      });
-    } else if (value !== null && value !== void 0) {
-      accumulator.add(value);
+    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);
@@ -1721,72 +2094,15 @@ var ExportStore = class {
   }
 };
 
-// src/export-tool/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);
-        } 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)}`
-          );
-        }
-      }
-      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) {
-        if (Array.isArray(result)) {
-          result.forEach(
-            (value) => exportStore.accumulate(selfExportName, value)
-          );
-        } else {
-          exportStore.set(selfExportName, result);
-        }
-      }
-      if (fieldNode.selectionSet && result !== void 0 && result !== null) {
-        if (Array.isArray(result)) {
-          result.forEach((item) => {
-            if (item && typeof item === "object") {
-              processExports(item, fieldNode.selectionSet, exportStore, true);
-            }
-          });
-        } else if (typeof result === "object") {
-          processExports(result, fieldNode.selectionSet, exportStore, false);
-        }
-      }
-      return result;
-    };
-  };
-}
-
-// src/export-tool/index.ts
-init_utils();
-
-// src/export-tool/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 === "")) {
@@ -1798,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");
@@ -1840,16 +2665,19 @@ function setCustomGraphQLTypes(table, columnTypes) {
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  ExportStore,
   buildSchemaSDLWithDataLoader,
   cleanupDataLoaderContext,
   createDataLoaderContext,
-  createExportMiddleware,
   exportDirectiveTypeDefs,
   makeScalarAcceptExports,
+  serialDirectiveTypeDefs,
   setCustomGraphQL,
   setCustomGraphQLTypes,
   useDataLoaderCleanup,
   useDataLoaderCleanupOnly,
-  useDataLoaderContext
+  useDataLoaderContext,
+  useExportDirective,
+  useSerialDirective
 });
 //# sourceMappingURL=index.cjs.map