drizzle-graphql-plus 0.8.26 → 0.8.28

package/index.cjs

@@ -22,6 +22,8 @@ var src_exports = {};
 __export(src_exports, {
   buildSchema: () => buildSchema,
   buildSchemaSDL: () => buildSchemaSDL,
+  createExportMiddleware: () => createExportMiddleware,
+  makeScalarAcceptExports: () => makeScalarAcceptExports,
   setCustomGraphQL: () => setCustomGraphQL,
   setCustomGraphQLTypes: () => setCustomGraphQLTypes
 });
@@ -3106,6 +3108,268 @@ var buildSchemaSDL = (db, config) => {
   };
 };
 
+// src/export-tool/ExportStore.ts
+var ExportStore = class {
+  store = /* @__PURE__ */ new Map();
+  pending = /* @__PURE__ */ new Map();
+  /**
+   * Store a value for later retrieval
+   * Resolves any pending promises waiting for this value
+   */
+  set(name, value) {
+    this.store.set(name, value);
+    const callbacks = this.pending.get(name);
+    if (callbacks) {
+      callbacks.forEach((resolve) => resolve(value));
+      this.pending.delete(name);
+    }
+  }
+  /**
+   * Get a value if it exists, otherwise return undefined
+   */
+  get(name) {
+    return this.store.get(name);
+  }
+  /**
+   * Wait for a value to be available
+   * Returns immediately if value already exists
+   * Returns a Promise that resolves when value is set
+   */
+  async waitFor(name, timeout = 5e3) {
+    if (this.store.has(name)) {
+      return this.store.get(name);
+    }
+    return new Promise((resolve, reject) => {
+      if (!this.pending.has(name)) {
+        this.pending.set(name, []);
+      }
+      this.pending.get(name).push(resolve);
+      setTimeout(() => {
+        const callbacks = this.pending.get(name);
+        if (callbacks) {
+          const index = callbacks.indexOf(resolve);
+          if (index > -1) {
+            callbacks.splice(index, 1);
+            reject(new Error(`Timeout waiting for export variable "${name}"`));
+          }
+        }
+      }, timeout);
+    });
+  }
+  /**
+   * Check if a value has been set
+   */
+  has(name) {
+    return this.store.has(name);
+  }
+  /**
+   * Clear all stored values
+   */
+  clear() {
+    this.store.clear();
+    this.pending.clear();
+  }
+  /**
+   * Get all stored values
+   */
+  getAll() {
+    return Object.fromEntries(this.store.entries());
+  }
+};
+
+// src/export-tool/utils.ts
+function isExportVariable(value) {
+  return typeof value === "string" && value.startsWith("$_") && value.length > 2;
+}
+function getVariableName(value) {
+  if (!isExportVariable(value)) {
+    return null;
+  }
+  return value.slice(2);
+}
+async function resolveExportVariables(args, exportStore, timeout) {
+  if (isExportVariable(args)) {
+    const varName = getVariableName(args);
+    return await exportStore.waitFor(varName, timeout);
+  }
+  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);
+        } else if (typeof item === "object" && item !== null) {
+          return await resolveExportVariables(item, exportStore, timeout);
+        }
+        return item;
+      })
+    );
+    return resolved;
+  }
+  if (typeof args === "object" && args !== null) {
+    const resolved = {};
+    for (const [key, value] of Object.entries(args)) {
+      if (isExportVariable(value)) {
+        const varName = getVariableName(value);
+        resolved[key] = await exportStore.waitFor(varName, timeout);
+      } else if (Array.isArray(value)) {
+        resolved[key] = await resolveExportVariables(
+          value,
+          exportStore,
+          timeout
+        );
+      } else if (typeof value === "object" && value !== null) {
+        resolved[key] = await resolveExportVariables(
+          value,
+          exportStore,
+          timeout
+        );
+      } else {
+        resolved[key] = value;
+      }
+    }
+    return resolved;
+  }
+  return args;
+}
+function getExportDirective(fieldNode) {
+  const node = fieldNode;
+  if (!node || !node.directives) {
+    return null;
+  }
+  const exportDirective = node.directives.find(
+    (directive) => directive.name.value === "export"
+  );
+  if (!exportDirective) {
+    return null;
+  }
+  const asArg = exportDirective.arguments?.find(
+    (arg) => arg.name.value === "as"
+  );
+  if (!asArg || asArg.value.kind !== "StringValue") {
+    return null;
+  }
+  return asArg.value.value;
+}
+function hasExportVariables(args) {
+  if (isExportVariable(args)) {
+    return true;
+  }
+  if (Array.isArray(args)) {
+    return args.some((item) => hasExportVariables(item));
+  }
+  if (typeof args === "object" && args !== null) {
+    for (const value of Object.values(args)) {
+      if (hasExportVariables(value)) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+function processExports(result, selectionSet, exportStore) {
+  if (!result || !selectionSet)
+    return;
+  for (const selection of selectionSet.selections) {
+    if (selection.kind !== "Field")
+      continue;
+    const resultKey = selection.alias?.value ?? selection.name.value;
+    if (!(resultKey in result))
+      continue;
+    const value = result[resultKey];
+    const exportName = getExportDirective(selection);
+    if (exportName) {
+      exportStore.set(exportName, value);
+    }
+    if (selection.selectionSet && value !== null && value !== void 0) {
+      if (Array.isArray(value)) {
+        value.forEach((item) => {
+          if (item && typeof item === "object") {
+            processExports(item, selection.selectionSet, exportStore);
+          }
+        });
+      } else if (typeof value === "object") {
+        processExports(value, selection.selectionSet, exportStore);
+      }
+    }
+  }
+}
+
+// src/export-tool/middleware.ts
+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) {
+          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 && result !== null) {
+        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);
+            }
+          });
+        } else if (typeof result === "object") {
+          processExports(result, fieldNode.selectionSet, exportStore);
+        }
+      }
+      return result;
+    };
+  };
+}
+
+// src/export-tool/makeScalarAcceptExports.ts
+var import_graphql11 = require("graphql");
+function makeScalarAcceptExports(originalScalar) {
+  const config = originalScalar.toConfig();
+  return new import_graphql11.GraphQLScalarType({
+    ...config,
+    name: config.name,
+    // Keep original name to override it in schema
+    description: `${config.description} (Wrapped with makeScalarAcceptExports to accept $_ export variables)`,
+    serialize: config.serialize,
+    parseValue(value) {
+      if (typeof value === "string" && (value.startsWith("$_") || value === "")) {
+        return value;
+      }
+      if (config.parseValue) {
+        return config.parseValue(value);
+      }
+      return value;
+    },
+    parseLiteral(ast, variables) {
+      if (ast.kind === import_graphql11.Kind.STRING) {
+        if (ast.value.startsWith("$_") || ast.value === "") {
+          return ast.value;
+        }
+      }
+      if (config.parseLiteral) {
+        return config.parseLiteral(ast, variables);
+      }
+      return void 0;
+    }
+  });
+}
+
 // src/helpers.ts
 var import_drizzle_orm13 = require("drizzle-orm");
 function setCustomGraphQL(table, columnConfig) {
@@ -3137,6 +3401,8 @@ function setCustomGraphQLTypes(table, columnTypes) {
 0 && (module.exports = {
   buildSchema,
   buildSchemaSDL,
+  createExportMiddleware,
+  makeScalarAcceptExports,
   setCustomGraphQL,
   setCustomGraphQLTypes
 });