@cedarjs/graphql-server 0.6.1-next.0 → 0.7.0

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 = 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/cjs/plugins/useRedwoodError.d.ts

@@ -0,0 +1,20 @@
+import type { Plugin } from 'graphql-yoga';
+import type { Logger } from '@cedarjs/api/logger';
+import type { RedwoodGraphQLContext } from '../types.js';
+/**
+ * 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 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
+ *
+ * @param logger
+ * @returns ExecutionResult
+ */
+export declare const useRedwoodError: (logger: Logger) => Plugin<RedwoodGraphQLContext>;
+//# 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,qBAAqB,EAAE,MAAM,aAAa,CAAA;AAExD;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,eAAe,WAClB,MAAM,KACb,MAAM,CAAC,qBAAqB,CAyC9B,CAAA"}

package/dist/cjs/plugins/useRedwoodError.js

@@ -0,0 +1,63 @@
+"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 && 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,
+                    originalError: error
+                  });
+                } 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/cjs/plugins/useRedwoodGlobalContextSetter.d.ts

@@ -0,0 +1,9 @@
+import type { Plugin } from 'graphql-yoga';
+import type { RedwoodGraphQLContext } from '../types.js';
+/**
+ * This Envelop plugin waits until the GraphQL context is done building and sets
+ * the CedarJS global context which can be imported with:
+ * `import { context } from '@cedarjs/context'`
+ */
+export declare const useRedwoodGlobalContextSetter: () => Plugin<RedwoodGraphQLContext>;
+//# 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,qBAAqB,EAAE,MAAM,aAAa,CAAA;AAExD;;;;GAIG;AACH,eAAO,MAAM,6BAA6B,QACpC,MAAM,CAAC,qBAAqB,CAM9B,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/cjs/plugins/useRedwoodLogger.d.ts

@@ -0,0 +1,115 @@
+import type { Plugin } from 'graphql-yoga';
+import type { Logger, LevelWithSilent } from '@cedarjs/api/logger';
+import type { RedwoodGraphQLContext } from '../types.js';
+/**
+ * Options for request and response information to include in the log statements
+ * output by UseRedwoodLogger around the execution event
+ *
+ * @param level - Sets log level specific to GraphQL log output. Defaults to current logger level.
+ * @param data - Include response data sent to client.
+ * @param operationName - Include operation name.
+ * @param requestId - Include the event's requestId, or if none, generate a uuid as an identifier.
+ * @param query - Include the query. This is the query or mutation (with fields) made in the request.
+ * @param tracing - Include the tracing and timing information.
+ * @param userAgent - Include the browser (or client's) user agent.
+ * @param excludeOperations - Exclude the specified operations from being logged.
+ *
+ */
+type GraphQLLoggerOptions = {
+    /**
+     * Sets log level for GraphQL logging.
+     * This level setting can be different from the one used in api side logging.
+     * Defaults to the same level as the logger unless set here.
+     *
+     * Available log levels:
+     *
+     * - 'fatal'
+     * - 'error'
+     * - 'warn'
+     * - 'info'
+     * - 'debug'
+     * - 'trace'
+     * - 'silent'
+     *
+     * The logging level is a __minimum__ level. For instance if `logger.level` is `'info'` then all `'fatal'`, `'error'`, `'warn'`,
+     * and `'info'` logs will be enabled.
+     *
+     * You can pass `'silent'` to disable logging.
+     *
+     * @default level of the logger set in LoggerConfig
+     *
+     */
+    level?: LevelWithSilent | string;
+    /**
+     * @description Include response data sent to client.
+     */
+    data?: boolean;
+    /**
+     * @description Include operation name.
+     *
+     * The operation name is a meaningful and explicit name for your operation. It is only required in multi-operation documents,
+     * but its use is encouraged because it is very helpful for debugging and server-side logging.
+     * When something goes wrong (you see errors either in your network logs, or in the logs of your GraphQL server)
+     * it is easier to identify a query in your codebase by name instead of trying to decipher the contents.
+     * Think of this just like a function name in your favorite programming language.
+     *
+     * @see https://graphql.org/learn/queries/#operation-name
+     */
+    operationName?: boolean;
+    /**
+     * @description Include the event's requestId, or if none, generate a uuid as an identifier.
+     *
+     * The requestId can be helpful when contacting your deployment provider to resolve issues when encountering errors or unexpected behavior.
+     */
+    requestId?: boolean;
+    /**
+     * @description Include the query. This is the query or mutation (with fields) made in the request.
+     */
+    query?: boolean;
+    /**
+     * @description Include the tracing and timing information.
+     *
+     * This will log various performance timings within the GraphQL event lifecycle (parsing, validating, executing, etc).
+     */
+    tracing?: boolean;
+    /**
+     * @description Include the browser (or client's) user agent.
+     *
+     * This can be helpful to know what type of client made the request to resolve issues when encountering errors or unexpected behavior.
+     */
+    userAgent?: boolean;
+    /**
+     * @description Exclude operation from the log output.
+     *
+     * This is useful when you want to filter out certain operations from the log output.
+     * For example `IntrospectionQuery` from GraphQL playground.
+     */
+    excludeOperations?: string[];
+};
+/**
+ * Configure the logger used by the GraphQL server.
+ *
+ * @param logger your logger
+ * @param options the GraphQLLoggerOptions such as tracing, operationName, etc
+ */
+export type LoggerConfig = {
+    logger: Logger;
+    options?: GraphQLLoggerOptions;
+};
+/**
+ * This plugin logs every time an operation is being executed and
+ * when the execution of the operation is done.
+ *
+ * It adds information using a child logger from the context
+ * such as the operation name, request id, errors, and header info
+ * to help trace and diagnose issues.
+ *
+ * Tracing and timing information can be enabled via the
+ * GraphQLHandlerOptions traction option.
+ *
+ * @see https://www.envelop.dev/docs/plugins/lifecycle
+ * @returns
+ */
+export declare const useRedwoodLogger: (loggerConfig: LoggerConfig) => Plugin<RedwoodGraphQLContext>;
+export {};
+//# 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,qBAAqB,EAAE,MAAM,aAAa,CAAA;AAExD;;;;;;;;;;;;;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,iBACb,YAAY,KACzB,MAAM,CAAC,qBAAqB,CAsG9B,CAAA"}

package/dist/cjs/plugins/useRedwoodLogger.js

@@ -0,0 +1,149 @@
+"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"] = args.contextValue.requestContext?.awsRequestId || args.contextValue.event?.requestContext?.requestId || (0, import_uuid.v4)();
+      }
+      if (includeUserAgent) {
+        options["userAgent"] = 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/cjs/plugins/useRedwoodOpenTelemetry.d.ts

@@ -0,0 +1,22 @@
+import type { Plugin } from '@envelop/core';
+import * as opentelemetry from '@opentelemetry/api';
+import type { RedwoodOpenTelemetryConfig } from '../types.js';
+export declare enum AttributeName {
+    EXECUTION_ERROR = "graphql.execute.error",
+    EXECUTION_RESULT = "graphql.execute.result",
+    RESOLVER_EXCEPTION = "graphql.resolver.exception",
+    RESOLVER_FIELD_NAME = "graphql.resolver.fieldName",
+    RESOLVER_TYPE_NAME = "graphql.resolver.typeName",
+    RESOLVER_RESULT_TYPE = "graphql.resolver.resultType",
+    RESOLVER_ARGS = "graphql.resolver.args",
+    EXECUTION_OPERATION_NAME = "graphql.execute.operationName",
+    EXECUTION_OPERATION_DOCUMENT = "graphql.execute.document",
+    EXECUTION_VARIABLES = "graphql.execute.variables"
+}
+declare const tracingSpanSymbol = "OPEN_TELEMETRY_GRAPHQL";
+type PluginContext = {
+    [tracingSpanSymbol]: opentelemetry.Span;
+};
+export declare const useRedwoodOpenTelemetry: (options: RedwoodOpenTelemetryConfig) => Plugin<PluginContext>;
+export {};
+//# 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,YACzB,0BAA0B,KAClC,MAAM,CAAC,aAAa,CAgHtB,CAAA"}