@cedarjs/graphql-server 5.0.7-next.338 → 5.0.7

package/dist/cjs/plugins/useRedwoodDirective.js

@@ -0,0 +1,166 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var useRedwoodDirective_exports = {};
+__export(useRedwoodDirective_exports, {
+  DirectiveType: () => DirectiveType,
+  getDirectiveByName: () => getDirectiveByName,
+  hasDirective: () => hasDirective,
+  isPromise: () => isPromise,
+  useRedwoodDirective: () => useRedwoodDirective
+});
+module.exports = __toCommonJS(useRedwoodDirective_exports);
+var import_utils = require("@graphql-tools/utils");
+var import_graphql = require("graphql");
+var DirectiveType = /* @__PURE__ */ ((DirectiveType2) => {
+  DirectiveType2["VALIDATOR"] = "VALIDATOR_DIRECTIVE";
+  DirectiveType2["TRANSFORMER"] = "TRANSFORMER_DIRECTIVE";
+  return DirectiveType2;
+})(DirectiveType || {});
+function hasDirective(info) {
+  try {
+    const { parentType, fieldName, schema } = info;
+    const schemaType = schema.getType(parentType.name);
+    const field = schemaType.getFields()[fieldName];
+    const astNode = field.astNode;
+    return !!astNode?.directives?.length;
+  } catch (error) {
+    console.error(error);
+    return false;
+  }
+}
+function getDirectiveByName(fieldConfig, directiveName) {
+  const associatedDirective = fieldConfig.astNode?.directives?.find(
+    (directive) => directive.name.value === directiveName
+  );
+  return associatedDirective ?? null;
+}
+function isPromise(value) {
+  return typeof value?.then === "function";
+}
+function wrapAffectedResolvers(schema, options) {
+  return (0, import_utils.mapSchema)(schema, {
+    [import_utils.MapperKind.OBJECT_FIELD](fieldConfig, _, __, schema2) {
+      const directiveNode = getDirectiveByName(fieldConfig, options.name);
+      const directive = directiveNode ? schema2.getDirective(directiveNode.name.value) : null;
+      if (directiveNode && directive) {
+        const directiveArgs = (0, import_graphql.getDirectiveValues)(directive, { directives: [directiveNode] }) || {};
+        const originalResolve = fieldConfig.resolve ?? import_graphql.defaultFieldResolver;
+        const originalSubscribe = fieldConfig.subscribe ?? import_graphql.defaultFieldResolver;
+        if (_isValidator(options)) {
+          return {
+            ...fieldConfig,
+            resolve: function useRedwoodDirectiveValidatorResolver(root, args, context, info) {
+              const result = options.onResolvedValue({
+                root,
+                args,
+                context,
+                info,
+                directiveNode,
+                directiveArgs
+              });
+              if (isPromise(result)) {
+                return result.then(
+                  () => originalResolve(root, args, context, info)
+                );
+              }
+              return originalResolve(root, args, context, info);
+            },
+            subscribe: function useRedwoodDirectiveValidatorResolver(root, args, context, info) {
+              const result = options.onResolvedValue({
+                root,
+                args,
+                context,
+                info,
+                directiveNode,
+                directiveArgs
+              });
+              if (isPromise(result)) {
+                return result.then(
+                  () => originalSubscribe(root, args, context, info)
+                );
+              }
+              return originalSubscribe(root, args, context, info);
+            }
+          };
+        }
+        if (_isTransformer(options)) {
+          return {
+            ...fieldConfig,
+            resolve: function useRedwoodDirectiveTransformerResolver(root, args, context, info) {
+              const resolvedValue = originalResolve(root, args, context, info);
+              if (isPromise(resolvedValue)) {
+                return resolvedValue.then(
+                  (resolvedValue2) => options.onResolvedValue({
+                    root,
+                    args,
+                    context,
+                    info,
+                    directiveNode,
+                    directiveArgs,
+                    resolvedValue: resolvedValue2
+                  })
+                );
+              }
+              return options.onResolvedValue({
+                root,
+                args,
+                context,
+                info,
+                directiveNode,
+                directiveArgs,
+                resolvedValue
+              });
+            }
+          };
+        }
+      }
+      return fieldConfig;
+    }
+  });
+}
+const useRedwoodDirective = (options) => {
+  const wasDirectiveApplied = /* @__PURE__ */ Symbol.for(`useRedwoodDirective.${options.name}}`);
+  return {
+    onSchemaChange({ schema, replaceSchema }) {
+      if (schema.extensions?.[wasDirectiveApplied] === true) {
+        return;
+      }
+      const transformedSchema = wrapAffectedResolvers(schema, options);
+      transformedSchema.extensions = {
+        ...schema.extensions,
+        [wasDirectiveApplied]: true
+      };
+      replaceSchema(transformedSchema);
+    }
+  };
+};
+const _isValidator = (options) => {
+  return options.type === "VALIDATOR_DIRECTIVE" /* VALIDATOR */;
+};
+const _isTransformer = (options) => {
+  return options.type === "TRANSFORMER_DIRECTIVE" /* TRANSFORMER */;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DirectiveType,
+  getDirectiveByName,
+  hasDirective,
+  isPromise,
+  useRedwoodDirective
+});

package/dist/{plugins/useCedarError.d.ts → cjs/plugins/useRedwoodError.d.ts}

@@ -2,13 +2,13 @@ import type { Plugin } from 'graphql-yoga';
 import type { Logger } from '@cedarjs/api/logger';
 import type { CedarGraphQLContext } from '../types.js';
 /**
- * Converts CedarErrors to GraphQLErrors
+ * Converts RedwoodErrors to GraphQLErrors
  *
  * This is a workaround for the fact that graphql-yoga doesn't support custom error types.
  *
  * Yoga automatically masks unexpected errors and prevents leaking sensitive information to clients.
  *
- * Since CedarErrors (such as ServiceValidation errors) are expected,
+ * Since RedwoodErrors (such as ServiceValidation errors) are expected,
  * we need to convert them to GraphQLErrors so that they are not masked.
  *
  * See: https://the-guild.dev/graphql/yoga-server/docs/features/error-masking
@@ -16,5 +16,5 @@ import type { CedarGraphQLContext } from '../types.js';
  * @param logger
  * @returns ExecutionResult
  */
-export declare const useCedarError: (logger: Logger) => Plugin<CedarGraphQLContext>;
-//# sourceMappingURL=useCedarError.d.ts.map
+export declare const useRedwoodError: (logger: Logger) => Plugin<CedarGraphQLContext>;
+//# sourceMappingURL=useRedwoodError.d.ts.map

package/dist/cjs/plugins/useRedwoodError.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useRedwoodError.d.ts","sourceRoot":"","sources":["../../../src/plugins/useRedwoodError.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,cAAc,CAAA;AAO1C,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAA;AAEjD,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,aAAa,CAAA;AAEtD;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,eAAe,GAC1B,QAAQ,MAAM,KACb,MAAM,CAAC,mBAAmB,CAsC5B,CAAA"}

package/dist/cjs/plugins/useRedwoodError.js

@@ -0,0 +1,62 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var useRedwoodError_exports = {};
+__export(useRedwoodError_exports, {
+  useRedwoodError: () => useRedwoodError
+});
+module.exports = __toCommonJS(useRedwoodError_exports);
+var import_graphql_yoga = require("graphql-yoga");
+var import_api = require("@cedarjs/api");
+const useRedwoodError = (logger) => {
+  return {
+    async onExecute() {
+      return {
+        onExecuteDone(payload) {
+          return (0, import_graphql_yoga.handleStreamOrSingleExecutionResult)(
+            payload,
+            ({ result, setResult }) => {
+              const errors = result.errors?.map((error) => {
+                if (error.originalError instanceof import_api.RedwoodError) {
+                  logger.debug(
+                    { custom: { name: error.originalError.name } },
+                    "Converting RedwoodError to GraphQLError"
+                  );
+                  return (0, import_graphql_yoga.createGraphQLError)(error.message, {
+                    extensions: error.extensions
+                  });
+                } else {
+                  return error;
+                }
+              });
+              setResult({
+                ...result,
+                errors,
+                extensions: result.extensions || {}
+              });
+            }
+          );
+        }
+      };
+    }
+  };
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  useRedwoodError
+});

package/dist/{plugins/useCedarGlobalContextSetter.d.ts → cjs/plugins/useRedwoodGlobalContextSetter.d.ts}

@@ -5,5 +5,5 @@ import type { CedarGraphQLContext } from '../types.js';
  * the CedarJS global context which can be imported with:
  * `import { context } from '@cedarjs/context'`
  */
-export declare const useCedarGlobalContextSetter: () => Plugin<CedarGraphQLContext>;
-//# sourceMappingURL=useCedarGlobalContextSetter.d.ts.map
+export declare const useRedwoodGlobalContextSetter: () => Plugin<CedarGraphQLContext>;
+//# sourceMappingURL=useRedwoodGlobalContextSetter.d.ts.map

package/dist/cjs/plugins/useRedwoodGlobalContextSetter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useRedwoodGlobalContextSetter.d.ts","sourceRoot":"","sources":["../../../src/plugins/useRedwoodGlobalContextSetter.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,cAAc,CAAA;AAI1C,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,aAAa,CAAA;AAEtD;;;;GAIG;AACH,eAAO,MAAM,6BAA6B,QACpC,MAAM,CAAC,mBAAmB,CAM5B,CAAA"}

package/dist/cjs/plugins/useRedwoodGlobalContextSetter.js

@@ -0,0 +1,35 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var useRedwoodGlobalContextSetter_exports = {};
+__export(useRedwoodGlobalContextSetter_exports, {
+  useRedwoodGlobalContextSetter: () => useRedwoodGlobalContextSetter
+});
+module.exports = __toCommonJS(useRedwoodGlobalContextSetter_exports);
+var import_context = require("@cedarjs/context");
+const useRedwoodGlobalContextSetter = () => ({
+  onContextBuilding() {
+    return ({ context }) => {
+      (0, import_context.setContext)(context);
+    };
+  }
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  useRedwoodGlobalContextSetter
+});

package/dist/{plugins/useCedarLogger.d.ts → cjs/plugins/useRedwoodLogger.d.ts}

@@ -110,6 +110,6 @@ export type LoggerConfig = {
  * @see https://www.envelop.dev/docs/plugins/lifecycle
  * @returns
  */
-export declare const useCedarLogger: (loggerConfig: LoggerConfig) => Plugin<CedarGraphQLContext>;
+export declare const useRedwoodLogger: (loggerConfig: LoggerConfig) => Plugin<CedarGraphQLContext>;
 export {};
-//# sourceMappingURL=useCedarLogger.d.ts.map
+//# sourceMappingURL=useRedwoodLogger.d.ts.map

package/dist/cjs/plugins/useRedwoodLogger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useRedwoodLogger.d.ts","sourceRoot":"","sources":["../../../src/plugins/useRedwoodLogger.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,cAAc,CAAA;AAI1C,OAAO,KAAK,EAAE,MAAM,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAA;AAGlE,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,aAAa,CAAA;AAEtD;;;;;;;;;;;;;GAaG;AACH,KAAK,oBAAoB,GAAG;IAC1B;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,KAAK,CAAC,EAAE,eAAe,GAAG,MAAM,CAAA;IAEhC;;OAEG;IACH,IAAI,CAAC,EAAE,OAAO,CAAA;IAEd;;;;;;;;;;OAUG;IACH,aAAa,CAAC,EAAE,OAAO,CAAA;IAEvB;;;;OAIG;IACH,SAAS,CAAC,EAAE,OAAO,CAAA;IAEnB;;OAEG;IACH,KAAK,CAAC,EAAE,OAAO,CAAA;IAEf;;;;OAIG;IACH,OAAO,CAAC,EAAE,OAAO,CAAA;IAEjB;;;;OAIG;IACH,SAAS,CAAC,EAAE,OAAO,CAAA;IAEnB;;;;;OAKG;IACH,iBAAiB,CAAC,EAAE,MAAM,EAAE,CAAA;CAC7B,CAAA;AAED;;;;;GAKG;AACH,MAAM,MAAM,YAAY,GAAG;IACzB,MAAM,EAAE,MAAM,CAAA;IACd,OAAO,CAAC,EAAE,oBAAoB,CAAA;CAC/B,CAAA;AA+DD;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,gBAAgB,GAC3B,cAAc,YAAY,KACzB,MAAM,CAAC,mBAAmB,CAgH5B,CAAA"}

package/dist/cjs/plugins/useRedwoodLogger.js

@@ -0,0 +1,156 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var useRedwoodLogger_exports = {};
+__export(useRedwoodLogger_exports, {
+  useRedwoodLogger: () => useRedwoodLogger
+});
+module.exports = __toCommonJS(useRedwoodLogger_exports);
+var import_graphql = require("graphql");
+var import_graphql_yoga = require("graphql-yoga");
+var import_uuid = require("uuid");
+var import_errors = require("../errors.js");
+const logResult = (loggerConfig, envelopLogger, operationName) => ({ result }) => {
+  const includeTracing = loggerConfig?.options?.tracing;
+  const includeData = loggerConfig?.options?.data;
+  const options = {};
+  if (result?.errors && result?.errors.length > 0) {
+    result.errors.forEach((error) => {
+      if (error.originalError && (error.originalError instanceof import_errors.AuthenticationError || error.originalError instanceof import_errors.ForbiddenError)) {
+        envelopLogger.warn(
+          error,
+          `'${error?.extensions?.code || "authentication"}' error '${error.message}' occurred in ${operationName}`
+        );
+      } else {
+        envelopLogger.error(
+          error,
+          error?.originalError?.message || error.message || `Error in GraphQL execution: ${operationName}`
+        );
+      }
+    });
+  }
+  if (result?.data) {
+    if (includeData) {
+      options["data"] = result.data;
+    }
+    if (result.extensions?.responseCache) {
+      options["responseCache"] = result.extensions?.responseCache;
+    }
+    if (includeTracing) {
+      options["tracing"] = result.extensions?.envelopTracing;
+    }
+    envelopLogger.debug(
+      {
+        ...options
+      },
+      `GraphQL execution completed: ${operationName}`
+    );
+  }
+};
+const useRedwoodLogger = (loggerConfig) => {
+  const logger = loggerConfig.logger;
+  const level = loggerConfig.options?.level || logger.level || "warn";
+  const childLogger = logger.child({
+    name: "graphql-server"
+  });
+  childLogger.level = level;
+  const includeOperationName = loggerConfig?.options?.operationName;
+  const includeRequestId = loggerConfig?.options?.requestId;
+  const includeUserAgent = loggerConfig?.options?.userAgent;
+  const includeQuery = loggerConfig?.options?.query;
+  const excludeOperations = loggerConfig.options?.excludeOperations;
+  return {
+    onPluginInit(context) {
+      context.registerContextErrorHandler(({ error }) => {
+        if (error) {
+          childLogger.error(`Error building context. ${error}`);
+        }
+      });
+    },
+    onParse({ params }) {
+      const options = params.options;
+      const envelopLogger = childLogger.child({
+        ...options
+      });
+      return ({ result }) => {
+        if (result instanceof Error) {
+          envelopLogger.error(result);
+        }
+      };
+    },
+    onValidate({ params }) {
+      const options = params.options;
+      const envelopLogger = childLogger.child({
+        ...options
+      });
+      return ({ result }) => {
+        result.forEach((item) => {
+          if (item.message) {
+            envelopLogger.error(item.message);
+          }
+        });
+      };
+    },
+    onExecute({ args }) {
+      const options = {};
+      const rootOperation = args.document.definitions.find(
+        (o) => o.kind === import_graphql.Kind.OPERATION_DEFINITION
+      );
+      const operationName = args.operationName || rootOperation.name?.value || "Anonymous Operation";
+      if (excludeOperations?.includes(operationName)) {
+        return;
+      }
+      if (includeOperationName) {
+        options["operationName"] = operationName;
+      }
+      if (includeQuery) {
+        options["query"] = args.variableValues;
+      }
+      if (includeRequestId) {
+        options["requestId"] = // x-request-id is a widely adopted (though informal) HTTP header for
+        // distributed tracing. Load balancers, API gateways, and clients set
+        // it on each request so that all log lines for a single request can
+        // be correlated across services. We check it first so that an
+        // externally assigned ID is preserved end-to-end; if it is absent we
+        // fall back to the Lambda/API-Gateway request ID, and finally
+        // generate a UUID so there is always something to correlate on.
+        args.contextValue.request?.headers.get("x-request-id") || args.contextValue.requestContext?.awsRequestId || args.contextValue.event?.requestContext?.requestId || (0, import_uuid.v4)();
+      }
+      if (includeUserAgent) {
+        options["userAgent"] = args.contextValue.request?.headers.get("user-agent") || args.contextValue.event?.headers["user-agent"];
+      }
+      const envelopLogger = childLogger.child({
+        ...options
+      });
+      envelopLogger.debug(`GraphQL execution started: ${operationName}`);
+      const handleResult = logResult(loggerConfig, envelopLogger, operationName);
+      return {
+        onExecuteDone: (payload) => {
+          (0, import_graphql_yoga.handleStreamOrSingleExecutionResult)(payload, ({ result }) => {
+            handleResult({ result });
+            return void 0;
+          });
+        }
+      };
+    }
+  };
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  useRedwoodLogger
+});

package/dist/{plugins/useCedarOpenTelemetry.d.ts → cjs/plugins/useRedwoodOpenTelemetry.d.ts}

@@ -1,6 +1,6 @@
 import type { Plugin } from '@envelop/core';
 import * as opentelemetry from '@opentelemetry/api';
-import type { CedarOpenTelemetryConfig } from '../types.js';
+import type { RedwoodOpenTelemetryConfig } from '../types.js';
 export declare enum AttributeName {
     EXECUTION_ERROR = "graphql.execute.error",
     EXECUTION_RESULT = "graphql.execute.result",
@@ -17,6 +17,6 @@ declare const tracingSpanSymbol = "OPEN_TELEMETRY_GRAPHQL";
 type PluginContext = {
     [tracingSpanSymbol]: opentelemetry.Span;
 };
-export declare const useCedarOpenTelemetry: (options: CedarOpenTelemetryConfig) => Plugin<PluginContext>;
+export declare const useRedwoodOpenTelemetry: (options: RedwoodOpenTelemetryConfig) => Plugin<PluginContext>;
 export {};
-//# sourceMappingURL=useCedarOpenTelemetry.d.ts.map
+//# sourceMappingURL=useRedwoodOpenTelemetry.d.ts.map

package/dist/cjs/plugins/useRedwoodOpenTelemetry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useRedwoodOpenTelemetry.d.ts","sourceRoot":"","sources":["../../../src/plugins/useRedwoodOpenTelemetry.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAuB,MAAM,eAAe,CAAA;AAKhE,OAAO,KAAK,aAAa,MAAM,oBAAoB,CAAA;AAGnD,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,aAAa,CAAA;AAE7D,oBAAY,aAAa;IACvB,eAAe,0BAA0B;IACzC,gBAAgB,2BAA2B;IAC3C,kBAAkB,+BAA+B;IACjD,mBAAmB,+BAA+B;IAClD,kBAAkB,8BAA8B;IAChD,oBAAoB,gCAAgC;IACpD,aAAa,0BAA0B;IACvC,wBAAwB,kCAAkC;IAC1D,4BAA4B,6BAA6B;IACzD,mBAAmB,8BAA8B;CAClD;AAGD,QAAA,MAAM,iBAAiB,2BAA2B,CAAA;AAElD,KAAK,aAAa,GAAG;IACnB,CAAC,iBAAiB,CAAC,EAAE,aAAa,CAAC,IAAI,CAAA;CACxC,CAAA;AAED,eAAO,MAAM,uBAAuB,GAClC,SAAS,0BAA0B,KAClC,MAAM,CAAC,aAAa,CAgHtB,CAAA"}

package/dist/cjs/plugins/useRedwoodOpenTelemetry.js

@@ -0,0 +1,156 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var useRedwoodOpenTelemetry_exports = {};
+__export(useRedwoodOpenTelemetry_exports, {
+  AttributeName: () => AttributeName,
+  useRedwoodOpenTelemetry: () => useRedwoodOpenTelemetry
+});
+module.exports = __toCommonJS(useRedwoodOpenTelemetry_exports);
+var import_core = require("@envelop/core");
+var import_on_resolve = require("@envelop/on-resolve");
+var import_api = require("@opentelemetry/api");
+var opentelemetry = __toESM(require("@opentelemetry/api"), 1);
+var import_graphql = require("graphql");
+var AttributeName = /* @__PURE__ */ ((AttributeName2) => {
+  AttributeName2["EXECUTION_ERROR"] = "graphql.execute.error";
+  AttributeName2["EXECUTION_RESULT"] = "graphql.execute.result";
+  AttributeName2["RESOLVER_EXCEPTION"] = "graphql.resolver.exception";
+  AttributeName2["RESOLVER_FIELD_NAME"] = "graphql.resolver.fieldName";
+  AttributeName2["RESOLVER_TYPE_NAME"] = "graphql.resolver.typeName";
+  AttributeName2["RESOLVER_RESULT_TYPE"] = "graphql.resolver.resultType";
+  AttributeName2["RESOLVER_ARGS"] = "graphql.resolver.args";
+  AttributeName2["EXECUTION_OPERATION_NAME"] = "graphql.execute.operationName";
+  AttributeName2["EXECUTION_OPERATION_DOCUMENT"] = "graphql.execute.document";
+  AttributeName2["EXECUTION_VARIABLES"] = "graphql.execute.variables";
+  return AttributeName2;
+})(AttributeName || {});
+const tracingSpanSymbol = "OPEN_TELEMETRY_GRAPHQL";
+const useRedwoodOpenTelemetry = (options) => {
+  const spanKind = import_api.SpanKind.SERVER;
+  const spanAdditionalAttributes = {};
+  const tracer = opentelemetry.trace.getTracer("redwoodjs");
+  return {
+    onPluginInit({ addPlugin }) {
+      if (options.resolvers) {
+        addPlugin(
+          (0, import_on_resolve.useOnResolve)(({ info, context, args }) => {
+            if (context && typeof context === "object" && context[tracingSpanSymbol]) {
+              const ctx = opentelemetry.trace.setSpan(
+                opentelemetry.context.active(),
+                context[tracingSpanSymbol]
+              );
+              const { fieldName, returnType, parentType } = info;
+              return tracer.startActiveSpan(
+                `${parentType.name}.${fieldName}`,
+                {
+                  attributes: {
+                    ["graphql.resolver.fieldName" /* RESOLVER_FIELD_NAME */]: fieldName,
+                    ["graphql.resolver.typeName" /* RESOLVER_TYPE_NAME */]: parentType.toString(),
+                    ["graphql.resolver.resultType" /* RESOLVER_RESULT_TYPE */]: returnType.toString(),
+                    ["graphql.resolver.args" /* RESOLVER_ARGS */]: JSON.stringify(args || {})
+                  }
+                },
+                ctx,
+                (resolverSpan) => {
+                  resolverSpan.spanContext();
+                  return ({ result }) => {
+                    if (result instanceof Error) {
+                      resolverSpan.recordException({
+                        name: "graphql.resolver.exception" /* RESOLVER_EXCEPTION */,
+                        message: JSON.stringify(result)
+                      });
+                    }
+                    resolverSpan.end();
+                  };
+                }
+              );
+            }
+            return () => {
+            };
+          })
+        );
+      }
+    },
+    onExecute({ args, extendContext }) {
+      return tracer.startActiveSpan(
+        `${args.operationName || "Anonymous Operation"}`,
+        {
+          kind: spanKind,
+          attributes: {
+            ...spanAdditionalAttributes,
+            ["graphql.execute.operationName" /* EXECUTION_OPERATION_NAME */]: args.operationName ?? void 0,
+            ["graphql.execute.document" /* EXECUTION_OPERATION_DOCUMENT */]: (0, import_graphql.print)(args.document),
+            ...options.variables ? {
+              ["graphql.execute.variables" /* EXECUTION_VARIABLES */]: JSON.stringify(
+                args.variableValues ?? {}
+              )
+            } : {}
+          }
+        },
+        (executionSpan) => {
+          const resultCbs = {
+            onExecuteDone({ result }) {
+              if ((0, import_core.isAsyncIterable)(result)) {
+                executionSpan.end();
+                console.warn(
+                  `Plugin "RedwoodOpenTelemetry" encountered an AsyncIterator which is not supported yet, so tracing data is not available for the operation.`
+                );
+                return;
+              }
+              if (result.data && options.result) {
+                executionSpan.setAttribute(
+                  "graphql.execute.result" /* EXECUTION_RESULT */,
+                  JSON.stringify(result)
+                );
+              }
+              if (result.errors && result.errors.length > 0) {
+                executionSpan.recordException({
+                  name: "graphql.execute.error" /* EXECUTION_ERROR */,
+                  message: JSON.stringify(result.errors)
+                });
+              }
+              executionSpan.end();
+            }
+          };
+          if (options.resolvers) {
+            extendContext({
+              [tracingSpanSymbol]: executionSpan
+            });
+          }
+          return resultCbs;
+        }
+      );
+    }
+  };
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AttributeName,
+  useRedwoodOpenTelemetry
+});

package/dist/{plugins/useCedarPopulateContext.d.ts → cjs/plugins/useRedwoodPopulateContext.d.ts}

@@ -5,5 +5,5 @@ import type { CedarGraphQLContext, GraphQLHandlerOptions } from '../types.js';
  * by populating it with the results of a custom function
  * @returns
  */
-export declare const useCedarPopulateContext: (populateContextBuilder: NonNullable<GraphQLHandlerOptions["context"]>) => Plugin<CedarGraphQLContext>;
-//# sourceMappingURL=useCedarPopulateContext.d.ts.map
+export declare const useRedwoodPopulateContext: (populateContextBuilder: NonNullable<GraphQLHandlerOptions["context"]>) => Plugin<CedarGraphQLContext>;
+//# sourceMappingURL=useRedwoodPopulateContext.d.ts.map

package/dist/cjs/plugins/useRedwoodPopulateContext.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useRedwoodPopulateContext.d.ts","sourceRoot":"","sources":["../../../src/plugins/useRedwoodPopulateContext.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,cAAc,CAAA;AAE1C,OAAO,KAAK,EAAE,mBAAmB,EAAE,qBAAqB,EAAE,MAAM,aAAa,CAAA;AAE7E;;;;GAIG;AACH,eAAO,MAAM,yBAAyB,GACpC,wBAAwB,WAAW,CAAC,qBAAqB,CAAC,SAAS,CAAC,CAAC,KACpE,MAAM,CAAC,mBAAmB,CAW5B,CAAA"}