drizzle-graphql-plus 0.8.37 → 0.8.38

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/utils.ts
 var utils_exports = {};
 __export(utils_exports, {
   extractExportDirectives: () => extractExportDirectives,
@@ -50,24 +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;
       })
@@ -79,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;
@@ -186,7 +183,7 @@ function processExports(result, selectionSet, exportStore, isArrayItem = false)
   }
 }
 var init_utils = __esm({
-  "src/export-tool/utils.ts"() {
+  "src/export-directive/utils.ts"() {
     "use strict";
   }
 });
@@ -194,12 +191,18 @@ var init_utils = __esm({
 // src/index.ts
 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,
   setCustomGraphQL: () => setCustomGraphQL,
   setCustomGraphQLTypes: () => setCustomGraphQLTypes,
   useDataLoaderCleanup: () => useDataLoaderCleanup,
@@ -912,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
+              );
             }
           }
         }
@@ -948,11 +963,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 +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);
       }
     }
@@ -975,7 +997,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 +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
     );
   }
@@ -1523,9 +1553,12 @@ var generateMutations = (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_schema2 = require("@graphql-tools/schema");
 var buildSchemaSDL = (db, config) => {
@@ -1617,7 +1650,185 @@ 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();
@@ -1636,22 +1847,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,7 +1933,7 @@ var ExportStore = class {
   }
 };
 
-// src/export-tool/middleware.ts
+// src/export-directive/middleware.ts
 init_utils();
 function createExportMiddleware() {
   return (next) => {
@@ -1733,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)}`
           );
         }
       }
@@ -1750,11 +1957,13 @@ function createExportMiddleware() {
       if (!fieldNode)
         return result;
       const selfExportName = getExportDirective(fieldNode);
-      if (selfExportName && result !== void 0) {
+      if (selfExportName && result !== void 0 && result !== null) {
         if (Array.isArray(result)) {
-          result.forEach(
-            (value) => exportStore.accumulate(selfExportName, value)
-          );
+          result.forEach((value) => {
+            if (value !== void 0 && value !== null) {
+              exportStore.accumulate(selfExportName, value);
+            }
+          });
         } else {
           exportStore.set(selfExportName, result);
         }
@@ -1774,11 +1983,17 @@ function createExportMiddleware() {
     };
   };
 }
+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
+// src/export-directive/makeScalarAcceptExports.ts
 var import_graphql5 = require("graphql");
 function makeScalarAcceptExports(originalScalar) {
   const config = originalScalar.toConfig();
@@ -1840,12 +2055,18 @@ 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,
   setCustomGraphQL,
   setCustomGraphQLTypes,
   useDataLoaderCleanup,