drizzle-graphql-plus 0.8.26 → 0.8.29

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
 });
@@ -2257,10 +2259,12 @@ var customScalars = /* @__PURE__ */ new Set();
 var enumDefinitions = /* @__PURE__ */ new Map();
 var requiredFieldFilters = /* @__PURE__ */ new Set();
 var foreignKeyTypes = /* @__PURE__ */ new Map();
-var columnToSDL = (column, columnName, tableName, forceNullable = false) => {
+var columnToSDL = (column, columnName, tableName, forceNullable = false, isPrimaryKey = false) => {
   let baseType;
   if (column.customGraphqlType) {
     baseType = column.customGraphqlType;
+  } else if (isPrimaryKey) {
+    baseType = "ID";
   } else {
     const foreignKeyType = foreignKeyTypes.get(`${tableName}.${columnName}`);
     if (foreignKeyType) {
@@ -2392,11 +2396,16 @@ var generateTypeDefs = (tables, relations) => {
           continue;
         const referencedCustomType = referencedColumn.customGraphqlType;
         const foreignKeyHasCustomType = !!foreignKeyColumn.customGraphqlType;
-        if (referencedCustomType && !foreignKeyHasCustomType) {
-          foreignKeyTypes.set(
-            `${tableName}.${foreignKeyPropertyName}`,
-            referencedCustomType
-          );
+        const referencedIsPrimaryKey = referencedColumn.primary || false;
+        if (!foreignKeyHasCustomType) {
+          if (referencedCustomType) {
+            foreignKeyTypes.set(
+              `${tableName}.${foreignKeyPropertyName}`,
+              referencedCustomType
+            );
+          } else if (referencedIsPrimaryKey) {
+            foreignKeyTypes.set(`${tableName}.${foreignKeyPropertyName}`, "ID");
+          }
         }
       }
     }
@@ -2405,11 +2414,13 @@ var generateTypeDefs = (tables, relations) => {
     const typeName = capitalize(tableName);
     const fields = [];
     for (const [columnName, column] of Object.entries(tableInfo.columns)) {
+      const isPrimaryKey = column.primary || false;
       const typeStr = columnToSDL(
         column,
         columnName,
         tableName,
-        false
+        false,
+        isPrimaryKey
       );
       const description = column.customGraphqlDescription;
       if (description) {
@@ -2441,11 +2452,13 @@ ${fields.join("\n")}
 }`);
     const insertFields = [];
     for (const [columnName, column] of Object.entries(tableInfo.columns)) {
+      const isPrimaryKey = column.primary || false;
       const typeStr = columnToSDL(
         column,
         columnName,
         tableName,
-        false
+        false,
+        isPrimaryKey
       );
       const nullableType = typeStr.endsWith("!") ? typeStr.slice(0, -1) : typeStr;
       insertFields.push(`  ${columnName}: ${nullableType}`);
@@ -2459,11 +2472,13 @@ ${insertFields.join("\n")}
     }
     const updateFields = [];
     for (const [columnName, column] of Object.entries(tableInfo.columns)) {
+      const isPrimaryKey = column.primary || false;
       const typeStr = columnToSDL(
         column,
         columnName,
         tableName,
-        true
+        true,
+        isPrimaryKey
       );
       updateFields.push(`  ${columnName}: ${typeStr}`);
     }
@@ -2474,11 +2489,13 @@ ${updateFields.join("\n")}
     );
     const whereFields = [];
     for (const [columnName, column] of Object.entries(tableInfo.columns)) {
+      const isPrimaryKey = column.primary || false;
       const typeStr = columnToSDL(
         column,
         columnName,
         tableName,
-        true
+        true,
+        isPrimaryKey
       );
       const normalizedType = typeStr.replace(/[^a-zA-Z0-9]/g, "");
       const filterTypeName = `${normalizedType}FieldFilter`;
@@ -3106,6 +3123,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 +3416,8 @@ function setCustomGraphQLTypes(table, columnTypes) {
 0 && (module.exports = {
   buildSchema,
   buildSchemaSDL,
+  createExportMiddleware,
+  makeScalarAcceptExports,
   setCustomGraphQL,
   setCustomGraphQLTypes
 });