@envelop/core 2.4.1 → 2.4.3-alpha-62b6e087.0

package/cjs/plugins/use-masked-errors.js

@@ -65,6 +65,9 @@ const useMaskedErrors = (opts) => {
             : undefined,
         onPluginInit(context) {
             context.registerContextErrorHandler(({ error, setError }) => {
+                if (error instanceof graphql_1.GraphQLError === false && error instanceof Error) {
+                    error = new graphql_1.GraphQLError(error.message, undefined, undefined, undefined, undefined, error);
+                }
                 setError(format(error, message, isDev));
             });
         },

package/esm/plugins/use-masked-errors.js

@@ -60,6 +60,9 @@ export const useMaskedErrors = (opts) => {
             : undefined,
         onPluginInit(context) {
             context.registerContextErrorHandler(({ error, setError }) => {
+                if (error instanceof GraphQLError === false && error instanceof Error) {
+                    error = new GraphQLError(error.message, undefined, undefined, undefined, undefined, error);
+                }
                 setError(format(error, message, isDev));
             });
         },

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "@envelop/core",
-  "version": "2.4.1",
+  "version": "2.4.3-alpha-62b6e087.0",
   "sideEffects": false,
   "peerDependencies": {
     "graphql": "^14.0.0 || ^15.0.0 || ^16.0.0"
   },
   "dependencies": {
-    "@envelop/types": "2.3.0"
+    "@envelop/types": "2.3.1"
   },
   "repository": {
     "type": "git",
@@ -34,7 +34,7 @@
   "exports": {
     ".": {
       "require": {
-        "types": "./typings/index.d.ts",
+        "types": "./typings/index.d.cts",
         "default": "./cjs/index.js"
       },
       "import": {
@@ -48,7 +48,7 @@
     },
     "./*": {
       "require": {
-        "types": "./typings/*.d.ts",
+        "types": "./typings/*.d.cts",
         "default": "./cjs/*.js"
       },
       "import": {

package/typings/create.d.cts

@@ -0,0 +1,6 @@
+import { GetEnvelopedFn, ComposeContext, Plugin } from '@envelop/types';
+import { PluginOrDisabledPlugin } from './enable-if.cjs';
+export declare function envelop<PluginsType extends Plugin<any>[]>(options: {
+    plugins: Array<PluginOrDisabledPlugin>;
+    enableInternalTracing?: boolean;
+}): GetEnvelopedFn<ComposeContext<PluginsType>>;

package/typings/enable-if.d.cts

@@ -0,0 +1,14 @@
+import { Plugin } from '@envelop/types';
+/**
+ * This enum is used only internally in order to create nominal type for the disabled plugin
+ */
+declare enum EnableIfBranded {
+    DisabledPlugin = 0
+}
+export declare type PluginOrDisabledPlugin = Plugin<any> | EnableIfBranded.DisabledPlugin;
+export declare function isPluginEnabled(t: PluginOrDisabledPlugin): t is Plugin;
+/**
+ * Utility function to enable a plugin.
+ */
+export declare function enableIf<PluginContextType = {}>(condition: boolean, plugin: Plugin<PluginContextType> | (() => Plugin<PluginContextType>)): PluginOrDisabledPlugin;
+export {};

package/typings/index.d.cts

@@ -0,0 +1,13 @@
+export * from '@envelop/types';
+export * from './create.cjs';
+export * from './utils.cjs';
+export * from './plugins/use-envelop.cjs';
+export * from './plugins/use-logger.cjs';
+export * from './plugins/use-timing.cjs';
+export * from './plugins/use-schema.cjs';
+export * from './plugins/use-error-handler.cjs';
+export * from './plugins/use-extend-context.cjs';
+export * from './plugins/use-payload-formatter.cjs';
+export * from './plugins/use-masked-errors.cjs';
+export * from './plugins/use-immediate-introspection.cjs';
+export * from './enable-if.cjs';

package/typings/orchestrator.d.cts

@@ -0,0 +1,12 @@
+import { ArbitraryObject, EnvelopContextFnWrapper, GetEnvelopedFn, Plugin, DefaultContext, Maybe } from '@envelop/types';
+import { GraphQLSchema } from 'graphql';
+export declare type EnvelopOrchestrator<InitialContext extends ArbitraryObject = ArbitraryObject, PluginsContext extends ArbitraryObject = ArbitraryObject> = {
+    init: (initialContext?: Maybe<InitialContext>) => void;
+    parse: EnvelopContextFnWrapper<ReturnType<GetEnvelopedFn<PluginsContext>>['parse'], InitialContext>;
+    validate: EnvelopContextFnWrapper<ReturnType<GetEnvelopedFn<PluginsContext>>['validate'], InitialContext>;
+    execute: ReturnType<GetEnvelopedFn<PluginsContext>>['execute'];
+    subscribe: ReturnType<GetEnvelopedFn<PluginsContext>>['subscribe'];
+    contextFactory: EnvelopContextFnWrapper<ReturnType<GetEnvelopedFn<PluginsContext>>['contextFactory'], PluginsContext>;
+    getCurrentSchema: () => Maybe<GraphQLSchema>;
+};
+export declare function createEnvelopOrchestrator<PluginsContext extends DefaultContext>(plugins: Plugin[]): EnvelopOrchestrator<any, PluginsContext>;

package/typings/plugins/use-envelop.d.cts

@@ -0,0 +1,2 @@
+import { GetEnvelopedFn, Plugin } from '@envelop/types';
+export declare const useEnvelop: (envelop: GetEnvelopedFn<any>) => Plugin<any>;

package/typings/plugins/use-error-handler.d.cts

@@ -0,0 +1,4 @@
+import { Plugin, DefaultContext } from '@envelop/types';
+import { GraphQLError } from 'graphql';
+export declare type ErrorHandler = (errors: readonly GraphQLError[], context: Readonly<DefaultContext>) => void;
+export declare const useErrorHandler: <ContextType>(errorHandler: ErrorHandler) => Plugin<ContextType>;

package/typings/plugins/use-extend-context.d.cts

@@ -0,0 +1,5 @@
+import { Plugin } from '@envelop/types';
+export declare type ContextFactoryFn<TResult = unknown, TCurrent = unknown> = (currentContext: TCurrent) => TResult | Promise<TResult>;
+declare type UnwrapAsync<T> = T extends Promise<infer U> ? U : T;
+export declare const useExtendContext: <TContextFactory extends (...args: any[]) => any>(contextFactory: TContextFactory) => Plugin<UnwrapAsync<ReturnType<TContextFactory>>>;
+export {};

package/typings/plugins/use-immediate-introspection.d.cts

@@ -0,0 +1,6 @@
+import type { Plugin } from '@envelop/types';
+/**
+ * In case a GraphQL operation only contains introspection fields the context building can be skipped completely.
+ * With this plugin any further context extensions will be skipped.
+ */
+export declare const useImmediateIntrospection: () => Plugin;

package/typings/plugins/use-logger.d.cts

@@ -0,0 +1,11 @@
+import { Plugin } from '@envelop/types';
+import { envelopIsIntrospectionSymbol } from '../utils.cjs';
+declare type LoggerPluginOptions = {
+    logFn: typeof console.log;
+    skipIntrospection?: boolean;
+};
+declare type InternalPluginContext = {
+    [envelopIsIntrospectionSymbol]?: true;
+};
+export declare const useLogger: (rawOptions?: LoggerPluginOptions) => Plugin<InternalPluginContext>;
+export {};

package/typings/plugins/use-masked-errors.d.cts

@@ -0,0 +1,39 @@
+import { Plugin } from '@envelop/types';
+import { GraphQLError, GraphQLErrorExtensions } from 'graphql';
+export declare const DEFAULT_ERROR_MESSAGE = "Unexpected error.";
+export declare class EnvelopError extends GraphQLError {
+    constructor(message: string, extensions?: GraphQLErrorExtensions);
+}
+export declare type FormatErrorHandler = (error: GraphQLError | unknown, message: string, isDev: boolean) => GraphQLError;
+export declare const formatError: FormatErrorHandler;
+export declare type UseMaskedErrorsOpts = {
+    /** The function used for format/identify errors. */
+    formatError?: FormatErrorHandler;
+    /** The error message that shall be used for masked errors. */
+    errorMessage?: string;
+    /**
+     * Additional information that is forwarded to the `formatError` function.
+     * The default value is `process.env['NODE_ENV'] === 'development'`
+     */
+    isDev?: boolean;
+    /**
+     * Whether parse errors should be processed by this plugin.
+     * In general it is not recommend to set this flag to `true`
+     * as a `parse` error contains useful information for debugging a GraphQL operation.
+     * A `parse` error never contains any sensitive information.
+     * @default false
+     */
+    handleParseErrors?: boolean;
+    /**
+     * Whether validation errors should processed by this plugin.
+     * In general we recommend against setting this flag to `true`
+     * as a `validate` error contains useful information for debugging a GraphQL operation.
+     * A `validate` error contains "did you mean x" suggestions that make it easier
+     * to reverse-introspect a GraphQL schema whose introspection capabilities got disabled.
+     * Instead of disabling introspection and masking validation errors, using persisted operations
+     * is a safer solution for avoiding the execution of unwanted/arbitrary operations.
+     * @default false
+     */
+    handleValidationErrors?: boolean;
+};
+export declare const useMaskedErrors: (opts?: UseMaskedErrorsOpts) => Plugin;

package/typings/plugins/use-payload-formatter.d.cts

@@ -0,0 +1,4 @@
+import { Plugin, TypedExecutionArgs } from '@envelop/types';
+import { ExecutionResult } from 'graphql';
+export declare type FormatterFunction = (result: ExecutionResult<any, any>, args: TypedExecutionArgs<any>) => false | ExecutionResult<any, any>;
+export declare const usePayloadFormatter: (formatter: FormatterFunction) => Plugin;

package/typings/plugins/use-schema.d.cts

@@ -0,0 +1,5 @@
+import { GraphQLSchema } from 'graphql';
+import { DefaultContext, Maybe, Plugin } from '@envelop/types';
+export declare const useSchema: (schema: GraphQLSchema) => Plugin;
+export declare const useLazyLoadedSchema: (schemaLoader: (context: Maybe<DefaultContext>) => GraphQLSchema) => Plugin;
+export declare const useAsyncSchema: (schemaPromise: Promise<GraphQLSchema>) => Plugin;

package/typings/plugins/use-timing.d.cts

@@ -0,0 +1,21 @@
+import { Plugin } from '@envelop/types';
+import { DocumentNode, ExecutionArgs, GraphQLResolveInfo, Source, SubscriptionArgs } from 'graphql';
+import { envelopIsIntrospectionSymbol } from '../utils.cjs';
+export declare type ResultTiming = {
+    ms: number;
+    ns: number;
+};
+export declare type TimingPluginOptions = {
+    skipIntrospection?: boolean;
+    onContextBuildingMeasurement?: (timing: ResultTiming) => void;
+    onExecutionMeasurement?: (args: ExecutionArgs, timing: ResultTiming) => void;
+    onSubscriptionMeasurement?: (args: SubscriptionArgs, timing: ResultTiming) => void;
+    onParsingMeasurement?: (source: Source | string, timing: ResultTiming) => void;
+    onValidationMeasurement?: (document: DocumentNode, timing: ResultTiming) => void;
+    onResolverMeasurement?: (info: GraphQLResolveInfo, timing: ResultTiming) => void;
+};
+declare type InternalPluginContext = {
+    [envelopIsIntrospectionSymbol]?: true;
+};
+export declare const useTiming: (rawOptions?: TimingPluginOptions) => Plugin<InternalPluginContext>;
+export {};

package/typings/traced-orchestrator.d.cts

@@ -0,0 +1,7 @@
+import { ArbitraryObject } from '@envelop/types';
+import { EnvelopOrchestrator } from './orchestrator.cjs';
+declare const tracingSymbol: unique symbol;
+export declare function traceOrchestrator<TInitialContext extends ArbitraryObject, TPluginsContext extends ArbitraryObject>(orchestrator: EnvelopOrchestrator<TInitialContext, TPluginsContext>): EnvelopOrchestrator<TInitialContext & {
+    [tracingSymbol]?: {};
+}, TPluginsContext>;
+export {};

package/typings/traced-schema.d.cts

@@ -0,0 +1,4 @@
+import { GraphQLSchema } from 'graphql';
+export declare const trackedSchemaSymbol: unique symbol;
+export declare const resolversHooksSymbol: unique symbol;
+export declare function prepareTracedSchema(schema: GraphQLSchema | null | undefined): void;

package/typings/utils.d.cts

@@ -0,0 +1,33 @@
+import { ASTNode, DocumentNode, OperationDefinitionNode, Source, ExecutionResult, SubscriptionArgs, ExecutionArgs } from 'graphql';
+import { AsyncIterableIteratorOrValue, ExecuteFunction, SubscribeFunction, PromiseOrValue, DefaultContext, OnExecuteDoneEventPayload, OnExecuteDoneHookResult, OnExecuteDoneHookResultOnNextHook } from '@envelop/types';
+export declare const envelopIsIntrospectionSymbol: unique symbol;
+export declare function isOperationDefinition(def: ASTNode): def is OperationDefinitionNode;
+export declare function isIntrospectionOperation(operation: OperationDefinitionNode): boolean;
+export declare function isIntrospectionDocument(document: DocumentNode): boolean;
+export declare function isIntrospectionOperationString(operation: string | Source): boolean;
+/**
+ * Utility function for making a subscribe function that handles polymorphic arguments.
+ */
+export declare const makeSubscribe: (subscribeFn: (args: SubscriptionArgs) => PromiseOrValue<AsyncIterableIterator<ExecutionResult>>) => SubscribeFunction;
+export declare function mapAsyncIterator<T, O>(source: AsyncIterable<T>, mapper: (input: T) => Promise<O> | O): AsyncGenerator<O>;
+/**
+ * Utility function for making a execute function that handles polymorphic arguments.
+ */
+export declare const makeExecute: (executeFn: (args: ExecutionArgs) => PromiseOrValue<AsyncIterableIteratorOrValue<ExecutionResult>>) => ExecuteFunction;
+/**
+ * Returns true if the provided object implements the AsyncIterator protocol via
+ * implementing a `Symbol.asyncIterator` method.
+ *
+ * Source: https://github.com/graphql/graphql-js/blob/main/src/jsutils/isAsyncIterable.ts
+ */
+export declare function isAsyncIterable<TType>(maybeAsyncIterable: unknown): maybeAsyncIterable is AsyncIterable<TType>;
+/**
+ * A utility function for handling `onExecuteDone` hook result, for simplifying the handling of AsyncIterable returned from `execute`.
+ *
+ * @param payload The payload send to `onExecuteDone` hook function
+ * @param fn The handler to be executed on each result
+ * @returns a subscription for streamed results, or undefined in case of an non-async
+ */
+export declare function handleStreamOrSingleExecutionResult<ContextType = DefaultContext>(payload: OnExecuteDoneEventPayload<ContextType>, fn: OnExecuteDoneHookResultOnNextHook<ContextType>): void | OnExecuteDoneHookResult<ContextType>;
+export declare function finalAsyncIterator<TInput>(source: AsyncIterable<TInput>, onFinal: () => void): AsyncGenerator<TInput>;
+export declare function errorAsyncIterator<TInput>(source: AsyncIterable<TInput>, onError: (err: unknown) => void): AsyncGenerator<TInput>;