@envelop/core 2.4.0-alpha-aca44e1.0 → 2.4.0-alpha-e9434aa.0

package/index.js

@@ -1,1359 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, '__esModule', { value: true });
-
-const types = require('@envelop/types');
-const graphql = require('graphql');
-
-/**
- * This enum is used only internally in order to create nominal type for the disabled plugin
- */
-var EnableIfBranded;
-(function (EnableIfBranded) {
-    EnableIfBranded[EnableIfBranded["DisabledPlugin"] = 0] = "DisabledPlugin";
-})(EnableIfBranded || (EnableIfBranded = {}));
-function isPluginEnabled(t) {
-    return t !== EnableIfBranded.DisabledPlugin && t !== null;
-}
-/**
- * Utility function to enable a plugin.
- */
-function enableIf(condition, plugin) {
-    if (condition) {
-        return typeof plugin === 'function' ? plugin() : plugin;
-    }
-    else {
-        return EnableIfBranded.DisabledPlugin;
-    }
-}
-
-const trackedSchemaSymbol = Symbol('TRACKED_SCHEMA');
-const resolversHooksSymbol = Symbol('RESOLVERS_HOOKS');
-function prepareTracedSchema(schema) {
-    if (!schema || schema[trackedSchemaSymbol]) {
-        return;
-    }
-    schema[trackedSchemaSymbol] = true;
-    const entries = Object.values(schema.getTypeMap());
-    for (const type of entries) {
-        if (!graphql.isIntrospectionType(type) && graphql.isObjectType(type)) {
-            const fields = Object.values(type.getFields());
-            for (const field of fields) {
-                let resolverFn = (field.resolve || graphql.defaultFieldResolver);
-                field.resolve = async (root, args, context, info) => {
-                    if (context && context[resolversHooksSymbol]) {
-                        const hooks = context[resolversHooksSymbol];
-                        const afterCalls = [];
-                        for (const hook of hooks) {
-                            const afterFn = await hook({
-                                root,
-                                args,
-                                context,
-                                info,
-                                resolverFn,
-                                replaceResolverFn: newFn => {
-                                    resolverFn = newFn;
-                                },
-                            });
-                            afterFn && afterCalls.push(afterFn);
-                        }
-                        try {
-                            let result = await resolverFn(root, args, context, info);
-                            for (const afterFn of afterCalls) {
-                                afterFn({
-                                    result,
-                                    setResult: newResult => {
-                                        result = newResult;
-                                    },
-                                });
-                            }
-                            return result;
-                        }
-                        catch (e) {
-                            let resultErr = e;
-                            for (const afterFn of afterCalls) {
-                                afterFn({
-                                    result: resultErr,
-                                    setResult: newResult => {
-                                        resultErr = newResult;
-                                    },
-                                });
-                            }
-                            throw resultErr;
-                        }
-                    }
-                    else {
-                        return resolverFn(root, args, context, info);
-                    }
-                };
-            }
-        }
-    }
-}
-
-const envelopIsIntrospectionSymbol = Symbol('ENVELOP_IS_INTROSPECTION');
-function isOperationDefinition(def) {
-    return def.kind === graphql.Kind.OPERATION_DEFINITION;
-}
-function isIntrospectionOperation(operation) {
-    if (operation.kind === 'OperationDefinition') {
-        let hasIntrospectionField = false;
-        graphql.visit(operation, {
-            Field: node => {
-                if (node.name.value === '__schema') {
-                    hasIntrospectionField = true;
-                    return graphql.BREAK;
-                }
-            },
-        });
-        return hasIntrospectionField;
-    }
-    return false;
-}
-function isIntrospectionDocument(document) {
-    const operations = document.definitions.filter(isOperationDefinition);
-    return operations.some(op => isIntrospectionOperation(op));
-}
-function isIntrospectionOperationString(operation) {
-    return (typeof operation === 'string' ? operation : operation.body).indexOf('__schema') !== -1;
-}
-function getSubscribeArgs(args) {
-    return args.length === 1
-        ? args[0]
-        : {
-            schema: args[0],
-            document: args[1],
-            rootValue: args[2],
-            contextValue: args[3],
-            variableValues: args[4],
-            operationName: args[5],
-            fieldResolver: args[6],
-            subscribeFieldResolver: args[7],
-        };
-}
-/**
- * Utility function for making a subscribe function that handles polymorphic arguments.
- */
-const makeSubscribe = (subscribeFn) => ((...polyArgs) => subscribeFn(getSubscribeArgs(polyArgs)));
-function mapAsyncIterator(source, mapper) {
-    const iterator = source[Symbol.asyncIterator]();
-    async function mapResult(result) {
-        var _a;
-        if (result.done) {
-            return result;
-        }
-        try {
-            return { value: await mapper(result.value), done: false };
-        }
-        catch (error) {
-            try {
-                await ((_a = iterator.return) === null || _a === void 0 ? void 0 : _a.call(iterator));
-            }
-            catch (_error) {
-                /* ignore error */
-            }
-            throw error;
-        }
-    }
-    const stream = {
-        [Symbol.asyncIterator]() {
-            return stream;
-        },
-        async next() {
-            return await mapResult(await iterator.next());
-        },
-        async return() {
-            var _a;
-            const promise = (_a = iterator.return) === null || _a === void 0 ? void 0 : _a.call(iterator);
-            return promise ? await mapResult(await promise) : { value: undefined, done: true };
-        },
-        async throw(error) {
-            var _a;
-            const promise = (_a = iterator.throw) === null || _a === void 0 ? void 0 : _a.call(iterator);
-            if (promise) {
-                return await mapResult(await promise);
-            }
-            // if the source has no throw method we just re-throw error
-            // usually throw is not called anyways
-            throw error;
-        },
-    };
-    return stream;
-}
-function getExecuteArgs(args) {
-    return args.length === 1
-        ? args[0]
-        : {
-            schema: args[0],
-            document: args[1],
-            rootValue: args[2],
-            contextValue: args[3],
-            variableValues: args[4],
-            operationName: args[5],
-            fieldResolver: args[6],
-            typeResolver: args[7],
-        };
-}
-/**
- * Utility function for making a execute function that handles polymorphic arguments.
- */
-const makeExecute = (executeFn) => ((...polyArgs) => executeFn(getExecuteArgs(polyArgs)));
-/**
- * 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
- */
-function isAsyncIterable(maybeAsyncIterable) {
-    return (typeof maybeAsyncIterable === 'object' &&
-        maybeAsyncIterable != null &&
-        typeof maybeAsyncIterable[Symbol.asyncIterator] === 'function');
-}
-/**
- * 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
- */
-function handleStreamOrSingleExecutionResult(payload, fn) {
-    if (isAsyncIterable(payload.result)) {
-        return { onNext: fn };
-    }
-    else {
-        fn({
-            args: payload.args,
-            result: payload.result,
-            setResult: payload.setResult,
-        });
-        return undefined;
-    }
-}
-function finalAsyncIterator(source, onFinal) {
-    const iterator = source[Symbol.asyncIterator]();
-    let isDone = false;
-    const stream = {
-        [Symbol.asyncIterator]() {
-            return stream;
-        },
-        async next() {
-            const result = await iterator.next();
-            if (result.done && isDone === false) {
-                isDone = true;
-                onFinal();
-            }
-            return result;
-        },
-        async return() {
-            var _a;
-            const promise = (_a = iterator.return) === null || _a === void 0 ? void 0 : _a.call(iterator);
-            if (isDone === false) {
-                isDone = true;
-                onFinal();
-            }
-            return promise ? await promise : { done: true, value: undefined };
-        },
-        async throw(error) {
-            var _a;
-            const promise = (_a = iterator.throw) === null || _a === void 0 ? void 0 : _a.call(iterator);
-            if (promise) {
-                return await promise;
-            }
-            // if the source has no throw method we just re-throw error
-            // usually throw is not called anyways
-            throw error;
-        },
-    };
-    return stream;
-}
-function errorAsyncIterator(source, onError) {
-    const iterator = source[Symbol.asyncIterator]();
-    const stream = {
-        [Symbol.asyncIterator]() {
-            return stream;
-        },
-        async next() {
-            try {
-                return await iterator.next();
-            }
-            catch (error) {
-                onError(error);
-                return { done: true, value: undefined };
-            }
-        },
-        async return() {
-            var _a;
-            const promise = (_a = iterator.return) === null || _a === void 0 ? void 0 : _a.call(iterator);
-            return promise ? await promise : { done: true, value: undefined };
-        },
-        async throw(error) {
-            var _a;
-            const promise = (_a = iterator.throw) === null || _a === void 0 ? void 0 : _a.call(iterator);
-            if (promise) {
-                return await promise;
-            }
-            // if the source has no throw method we just re-throw error
-            // usually throw is not called anyways
-            throw error;
-        },
-    };
-    return stream;
-}
-function getInMemoryLRUCache({ max = 1000, onDelete = () => { }, } = {}) {
-    let storage = {};
-    let keys = [];
-    return {
-        get(key) {
-            return storage[key];
-        },
-        set(key, value) {
-            queueMicrotask(() => {
-                if (storage[key] != null) {
-                    if (keys.indexOf(key)) {
-                        keys.splice(keys.indexOf(key), 1);
-                    }
-                }
-                keys.push(key);
-                storage[key] = value;
-                while (keys.length > max) {
-                    const key = keys.shift();
-                    if (key != null) {
-                        onDelete(key, storage[key]);
-                        delete storage[key];
-                    }
-                }
-            });
-        },
-        delete(key) {
-            queueMicrotask(() => {
-                if (storage[key] != null) {
-                    keys.splice(keys.indexOf(key), 1);
-                    onDelete(key, storage[key]);
-                    delete storage[key];
-                }
-            });
-        },
-        clear() {
-            queueMicrotask(() => {
-                storage = {};
-                keys = [];
-            });
-        },
-    };
-}
-// eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
-function isSourceObject(maybeSource) {
-    return maybeSource != null && maybeSource.body != null;
-}
-
-function createEnvelopOrchestrator(plugins) {
-    let schema = null;
-    let initDone = false;
-    const onResolversHandlers = [];
-    for (const plugin of plugins) {
-        if (plugin.onResolverCalled) {
-            onResolversHandlers.push(plugin.onResolverCalled);
-        }
-    }
-    // Define the initial method for replacing the GraphQL schema, this is needed in order
-    // to allow setting the schema from the onPluginInit callback. We also need to make sure
-    // here not to call the same plugin that initiated the schema switch.
-    const replaceSchema = (newSchema, ignorePluginIndex = -1) => {
-        if (onResolversHandlers.length) {
-            prepareTracedSchema(newSchema);
-        }
-        schema = newSchema;
-        if (initDone) {
-            for (const [i, plugin] of plugins.entries()) {
-                if (i !== ignorePluginIndex) {
-                    plugin.onSchemaChange &&
-                        plugin.onSchemaChange({
-                            schema,
-                            replaceSchema: schemaToSet => {
-                                replaceSchema(schemaToSet, i);
-                            },
-                        });
-                }
-            }
-        }
-    };
-    const contextErrorHandlers = [];
-    // Iterate all plugins and trigger onPluginInit
-    for (const [i, plugin] of plugins.entries()) {
-        plugin.onPluginInit &&
-            plugin.onPluginInit({
-                plugins,
-                addPlugin: newPlugin => {
-                    plugins.push(newPlugin);
-                },
-                setSchema: modifiedSchema => replaceSchema(modifiedSchema, i),
-                registerContextErrorHandler: handler => contextErrorHandlers.push(handler),
-            });
-    }
-    // A set of before callbacks defined here in order to allow it to be used later
-    const beforeCallbacks = {
-        init: [],
-        parse: [],
-        validate: [],
-        subscribe: [],
-        execute: [],
-        context: [],
-    };
-    for (const { onContextBuilding, onExecute, onParse, onSubscribe, onValidate, onEnveloped } of plugins) {
-        onEnveloped && beforeCallbacks.init.push(onEnveloped);
-        onContextBuilding && beforeCallbacks.context.push(onContextBuilding);
-        onExecute && beforeCallbacks.execute.push(onExecute);
-        onParse && beforeCallbacks.parse.push(onParse);
-        onSubscribe && beforeCallbacks.subscribe.push(onSubscribe);
-        onValidate && beforeCallbacks.validate.push(onValidate);
-    }
-    const init = initialContext => {
-        for (const [i, onEnveloped] of beforeCallbacks.init.entries()) {
-            onEnveloped({
-                context: initialContext,
-                extendContext: extension => {
-                    if (!initialContext) {
-                        return;
-                    }
-                    Object.assign(initialContext, extension);
-                },
-                setSchema: modifiedSchema => replaceSchema(modifiedSchema, i),
-            });
-        }
-    };
-    const customParse = beforeCallbacks.parse.length
-        ? initialContext => (source, parseOptions) => {
-            let result = null;
-            let parseFn = graphql.parse;
-            const context = initialContext;
-            const afterCalls = [];
-            for (const onParse of beforeCallbacks.parse) {
-                const afterFn = onParse({
-                    context,
-                    extendContext: extension => {
-                        Object.assign(context, extension);
-                    },
-                    params: { source, options: parseOptions },
-                    parseFn,
-                    setParseFn: newFn => {
-                        parseFn = newFn;
-                    },
-                    setParsedDocument: newDoc => {
-                        result = newDoc;
-                    },
-                });
-                afterFn && afterCalls.push(afterFn);
-            }
-            if (result === null) {
-                try {
-                    result = parseFn(source, parseOptions);
-                }
-                catch (e) {
-                    result = e;
-                }
-            }
-            for (const afterCb of afterCalls) {
-                afterCb({
-                    context,
-                    extendContext: extension => {
-                        Object.assign(context, extension);
-                    },
-                    replaceParseResult: newResult => {
-                        result = newResult;
-                    },
-                    result,
-                });
-            }
-            if (result === null) {
-                throw new Error(`Failed to parse document.`);
-            }
-            if (result instanceof Error) {
-                throw result;
-            }
-            return result;
-        }
-        : () => graphql.parse;
-    const customValidate = beforeCallbacks.validate.length
-        ? initialContext => (schema, documentAST, rules, typeInfo, validationOptions) => {
-            let actualRules = rules ? [...rules] : undefined;
-            let validateFn = graphql.validate;
-            let result = null;
-            const context = initialContext;
-            const afterCalls = [];
-            for (const onValidate of beforeCallbacks.validate) {
-                const afterFn = onValidate({
-                    context,
-                    extendContext: extension => {
-                        Object.assign(context, extension);
-                    },
-                    params: {
-                        schema,
-                        documentAST,
-                        rules: actualRules,
-                        typeInfo,
-                        options: validationOptions,
-                    },
-                    validateFn,
-                    addValidationRule: rule => {
-                        if (!actualRules) {
-                            actualRules = [...graphql.specifiedRules];
-                        }
-                        actualRules.push(rule);
-                    },
-                    setValidationFn: newFn => {
-                        validateFn = newFn;
-                    },
-                    setResult: newResults => {
-                        result = newResults;
-                    },
-                });
-                afterFn && afterCalls.push(afterFn);
-            }
-            if (!result) {
-                result = validateFn(schema, documentAST, actualRules, typeInfo, validationOptions);
-            }
-            const valid = result.length === 0;
-            for (const afterCb of afterCalls) {
-                afterCb({
-                    valid,
-                    result,
-                    context,
-                    extendContext: extension => {
-                        Object.assign(context, extension);
-                    },
-                    setResult: newResult => {
-                        result = newResult;
-                    },
-                });
-            }
-            return result;
-        }
-        : () => graphql.validate;
-    const customContextFactory = beforeCallbacks.context.length
-        ? initialContext => async (orchestratorCtx) => {
-            const afterCalls = [];
-            // In order to have access to the "last working" context object we keep this outside of the try block:
-            let context = orchestratorCtx ? { ...initialContext, ...orchestratorCtx } : initialContext;
-            try {
-                let isBreakingContextBuilding = false;
-                for (const onContext of beforeCallbacks.context) {
-                    const afterHookResult = await onContext({
-                        context,
-                        extendContext: extension => {
-                            context = { ...context, ...extension };
-                        },
-                        breakContextBuilding: () => {
-                            isBreakingContextBuilding = true;
-                        },
-                    });
-                    if (typeof afterHookResult === 'function') {
-                        afterCalls.push(afterHookResult);
-                    }
-                    if (isBreakingContextBuilding === true) {
-                        break;
-                    }
-                }
-                for (const afterCb of afterCalls) {
-                    afterCb({
-                        context,
-                        extendContext: extension => {
-                            context = { ...context, ...extension };
-                        },
-                    });
-                }
-                return context;
-            }
-            catch (err) {
-                let error = err;
-                for (const errorCb of contextErrorHandlers) {
-                    errorCb({
-                        context,
-                        error,
-                        setError: err => {
-                            error = err;
-                        },
-                    });
-                }
-                throw error;
-            }
-        }
-        : initialContext => orchestratorCtx => orchestratorCtx ? { ...initialContext, ...orchestratorCtx } : initialContext;
-    const useCustomSubscribe = beforeCallbacks.subscribe.length || onResolversHandlers.length;
-    const customSubscribe = useCustomSubscribe
-        ? makeSubscribe(async (args) => {
-            let subscribeFn = graphql.subscribe;
-            const afterCalls = [];
-            const subscribeErrorHandlers = [];
-            let context = args.contextValue || {};
-            let result;
-            for (const onSubscribe of beforeCallbacks.subscribe) {
-                const after = await onSubscribe({
-                    subscribeFn,
-                    setSubscribeFn: newSubscribeFn => {
-                        subscribeFn = newSubscribeFn;
-                    },
-                    extendContext: extension => {
-                        context = { ...context, ...extension };
-                    },
-                    args: args,
-                    setResultAndStopExecution: stopResult => {
-                        result = stopResult;
-                    },
-                });
-                if (after) {
-                    if (after.onSubscribeResult) {
-                        afterCalls.push(after.onSubscribeResult);
-                    }
-                    if (after.onSubscribeError) {
-                        subscribeErrorHandlers.push(after.onSubscribeError);
-                    }
-                }
-                if (result !== undefined) {
-                    break;
-                }
-            }
-            if (onResolversHandlers.length) {
-                context[resolversHooksSymbol] = onResolversHandlers;
-            }
-            if (result === undefined) {
-                result = await subscribeFn({
-                    ...args,
-                    contextValue: context,
-                    // Casted for GraphQL.js 15 compatibility
-                    // Can be removed once we drop support for GraphQL.js 15
-                });
-            }
-            const onNextHandler = [];
-            const onEndHandler = [];
-            for (const afterCb of afterCalls) {
-                const hookResult = afterCb({
-                    args: args,
-                    result,
-                    setResult: newResult => {
-                        result = newResult;
-                    },
-                });
-                if (hookResult) {
-                    if (hookResult.onNext) {
-                        onNextHandler.push(hookResult.onNext);
-                    }
-                    if (hookResult.onEnd) {
-                        onEndHandler.push(hookResult.onEnd);
-                    }
-                }
-            }
-            if (onNextHandler.length && isAsyncIterable(result)) {
-                result = mapAsyncIterator(result, async (result) => {
-                    for (const onNext of onNextHandler) {
-                        await onNext({
-                            args: args,
-                            result,
-                            setResult: newResult => (result = newResult),
-                        });
-                    }
-                    return result;
-                });
-            }
-            if (onEndHandler.length && isAsyncIterable(result)) {
-                result = finalAsyncIterator(result, () => {
-                    for (const onEnd of onEndHandler) {
-                        onEnd();
-                    }
-                });
-            }
-            if (subscribeErrorHandlers.length && isAsyncIterable(result)) {
-                result = errorAsyncIterator(result, err => {
-                    let error = err;
-                    for (const handler of subscribeErrorHandlers) {
-                        handler({
-                            error,
-                            setError: err => {
-                                error = err;
-                            },
-                        });
-                    }
-                    throw error;
-                });
-            }
-            return result;
-        })
-        : makeSubscribe(graphql.subscribe);
-    const useCustomExecute = beforeCallbacks.execute.length || onResolversHandlers.length;
-    const customExecute = useCustomExecute
-        ? makeExecute(async (args) => {
-            let executeFn = graphql.execute;
-            let result;
-            const afterCalls = [];
-            let context = args.contextValue || {};
-            for (const onExecute of beforeCallbacks.execute) {
-                const after = await onExecute({
-                    executeFn,
-                    setExecuteFn: newExecuteFn => {
-                        executeFn = newExecuteFn;
-                    },
-                    setResultAndStopExecution: stopResult => {
-                        result = stopResult;
-                    },
-                    extendContext: extension => {
-                        if (typeof extension === 'object') {
-                            context = {
-                                ...(context || {}),
-                                ...extension,
-                            };
-                        }
-                        else {
-                            throw new Error(`Invalid context extension provided! Expected "object", got: "${JSON.stringify(extension)}" (${typeof extension})`);
-                        }
-                    },
-                    args: args,
-                });
-                if (after === null || after === void 0 ? void 0 : after.onExecuteDone) {
-                    afterCalls.push(after.onExecuteDone);
-                }
-                if (result !== undefined) {
-                    break;
-                }
-            }
-            if (onResolversHandlers.length) {
-                context[resolversHooksSymbol] = onResolversHandlers;
-            }
-            if (result === undefined) {
-                result = (await executeFn({
-                    ...args,
-                    contextValue: context,
-                }));
-            }
-            const onNextHandler = [];
-            const onEndHandler = [];
-            for (const afterCb of afterCalls) {
-                const hookResult = await afterCb({
-                    args: args,
-                    result,
-                    setResult: newResult => {
-                        result = newResult;
-                    },
-                });
-                if (hookResult) {
-                    if (hookResult.onNext) {
-                        onNextHandler.push(hookResult.onNext);
-                    }
-                    if (hookResult.onEnd) {
-                        onEndHandler.push(hookResult.onEnd);
-                    }
-                }
-            }
-            if (onNextHandler.length && isAsyncIterable(result)) {
-                result = mapAsyncIterator(result, async (result) => {
-                    for (const onNext of onNextHandler) {
-                        await onNext({
-                            args: args,
-                            result,
-                            setResult: newResult => {
-                                result = newResult;
-                            },
-                        });
-                    }
-                    return result;
-                });
-            }
-            if (onEndHandler.length && isAsyncIterable(result)) {
-                result = finalAsyncIterator(result, () => {
-                    for (const onEnd of onEndHandler) {
-                        onEnd();
-                    }
-                });
-            }
-            return result;
-        })
-        : makeExecute(graphql.execute);
-    initDone = true;
-    // This is done in order to trigger the first schema available, to allow plugins that needs the schema
-    // eagerly to have it.
-    if (schema) {
-        for (const [i, plugin] of plugins.entries()) {
-            plugin.onSchemaChange &&
-                plugin.onSchemaChange({
-                    schema,
-                    replaceSchema: modifiedSchema => replaceSchema(modifiedSchema, i),
-                });
-        }
-    }
-    return {
-        getCurrentSchema() {
-            return schema;
-        },
-        init,
-        parse: customParse,
-        validate: customValidate,
-        execute: customExecute,
-        subscribe: customSubscribe,
-        contextFactory: customContextFactory,
-    };
-}
-
-const getTimestamp = typeof performance !== 'undefined' && performance.now ? () => performance.now() : () => Date.now();
-const measure = () => {
-    const start = getTimestamp();
-    return () => {
-        const end = getTimestamp();
-        return end - start;
-    };
-};
-const tracingSymbol = Symbol('envelopTracing');
-function traceOrchestrator(orchestrator) {
-    const createTracer = (name, ctx) => {
-        const end = measure();
-        return () => {
-            ctx[tracingSymbol][name] = end();
-        };
-    };
-    return {
-        ...orchestrator,
-        init: (ctx = {}) => {
-            ctx[tracingSymbol] = ctx[tracingSymbol] || {};
-            const done = createTracer('init', ctx || {});
-            try {
-                return orchestrator.init(ctx);
-            }
-            finally {
-                done();
-            }
-        },
-        parse: (ctx = {}) => {
-            ctx[tracingSymbol] = ctx[tracingSymbol] || {};
-            const actualFn = orchestrator.parse(ctx);
-            return (...args) => {
-                const done = createTracer('parse', ctx);
-                try {
-                    return actualFn(...args);
-                }
-                finally {
-                    done();
-                }
-            };
-        },
-        validate: (ctx = {}) => {
-            ctx[tracingSymbol] = ctx[tracingSymbol] || {};
-            const actualFn = orchestrator.validate(ctx);
-            return (...args) => {
-                const done = createTracer('validate', ctx);
-                try {
-                    return actualFn(...args);
-                }
-                finally {
-                    done();
-                }
-            };
-        },
-        execute: async (argsOrSchema, document, rootValue, contextValue, variableValues, operationName, fieldResolver, typeResolver) => {
-            const args = argsOrSchema instanceof graphql.GraphQLSchema
-                ? {
-                    schema: argsOrSchema,
-                    document: document,
-                    rootValue,
-                    contextValue,
-                    variableValues,
-                    operationName,
-                    fieldResolver,
-                    typeResolver,
-                }
-                : argsOrSchema;
-            // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-            // @ts-ignore GraphQL.js types contextValue as unknown
-            const done = createTracer('execute', args.contextValue || {});
-            try {
-                const result = await orchestrator.execute(args);
-                done();
-                if (!isAsyncIterable(result)) {
-                    result.extensions = result.extensions || {};
-                    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-                    // @ts-ignore GraphQL.js types contextValue as unknown
-                    result.extensions.envelopTracing = args.contextValue[tracingSymbol];
-                }
-                else {
-                    // eslint-disable-next-line no-console
-                    console.warn(`"traceOrchestrator" encountered a AsyncIterator which is not supported yet, so tracing data is not available for the operation.`);
-                }
-                return result;
-            }
-            catch (e) {
-                done();
-                throw e;
-            }
-        },
-        subscribe: async (argsOrSchema, document, rootValue, contextValue, variableValues, operationName, fieldResolver, subscribeFieldResolver) => {
-            const args = argsOrSchema instanceof graphql.GraphQLSchema
-                ? {
-                    schema: argsOrSchema,
-                    document: document,
-                    rootValue,
-                    contextValue,
-                    variableValues,
-                    operationName,
-                    fieldResolver,
-                    subscribeFieldResolver,
-                }
-                : argsOrSchema;
-            // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-            // @ts-ignore GraphQL.js types contextValue as unknown
-            const done = createTracer('subscribe', args.contextValue || {});
-            try {
-                return await orchestrator.subscribe(args);
-            }
-            finally {
-                done();
-            }
-        },
-        contextFactory: (ctx = {}) => {
-            const actualFn = orchestrator.contextFactory(ctx);
-            return async (childCtx) => {
-                const done = createTracer('contextFactory', ctx);
-                try {
-                    return await actualFn(childCtx);
-                }
-                finally {
-                    done();
-                }
-            };
-        },
-    };
-}
-
-function envelop(options) {
-    const plugins = options.plugins.filter(isPluginEnabled);
-    let orchestrator = createEnvelopOrchestrator(plugins);
-    if (options.enableInternalTracing) {
-        orchestrator = traceOrchestrator(orchestrator);
-    }
-    const getEnveloped = (initialContext = {}) => {
-        const typedOrchestrator = orchestrator;
-        typedOrchestrator.init(initialContext);
-        return {
-            parse: typedOrchestrator.parse(initialContext),
-            validate: typedOrchestrator.validate(initialContext),
-            contextFactory: typedOrchestrator.contextFactory(initialContext),
-            execute: typedOrchestrator.execute,
-            subscribe: typedOrchestrator.subscribe,
-            schema: typedOrchestrator.getCurrentSchema(),
-        };
-    };
-    getEnveloped._plugins = plugins;
-    return getEnveloped;
-}
-
-const useEnvelop = (envelop) => {
-    return {
-        onPluginInit({ addPlugin }) {
-            for (const plugin of envelop._plugins) {
-                addPlugin(plugin);
-            }
-        },
-    };
-};
-
-const DEFAULT_OPTIONS = {
-    logFn: console.log,
-};
-const useLogger = (rawOptions = DEFAULT_OPTIONS) => {
-    const options = {
-        DEFAULT_OPTIONS,
-        ...rawOptions,
-    };
-    return {
-        onParse({ extendContext, params }) {
-            if (options.skipIntrospection && isIntrospectionOperationString(params.source)) {
-                extendContext({
-                    [envelopIsIntrospectionSymbol]: true,
-                });
-            }
-        },
-        onExecute({ args }) {
-            if (args.contextValue[envelopIsIntrospectionSymbol]) {
-                return;
-            }
-            options.logFn('execute-start', { args });
-            return {
-                onExecuteDone: ({ result }) => {
-                    options.logFn('execute-end', { args, result });
-                },
-            };
-        },
-        onSubscribe({ args }) {
-            if (args.contextValue[envelopIsIntrospectionSymbol]) {
-                return;
-            }
-            options.logFn('subscribe-start', { args });
-            return {
-                onSubscribeResult: ({ result }) => {
-                    options.logFn('subscribe-end', { args, result });
-                },
-            };
-        },
-    };
-};
-
-const HR_TO_NS = 1e9;
-const NS_TO_MS = 1e6;
-const DEFAULT_OPTIONS$1 = {
-    onExecutionMeasurement: (args, timing) => console.log(`Operation execution "${args.operationName}" done in ${timing.ms}ms`),
-    onSubscriptionMeasurement: (args, timing) => console.log(`Operation subscription "${args.operationName}" done in ${timing.ms}ms`),
-    onParsingMeasurement: (source, timing) => console.log(`Parsing "${source}" done in ${timing.ms}ms`),
-    onValidationMeasurement: (document, timing) => { var _a, _b; return console.log(`Validation "${((_b = (_a = graphql.getOperationAST(document)) === null || _a === void 0 ? void 0 : _a.name) === null || _b === void 0 ? void 0 : _b.value) || '-'}" done in ${timing.ms}ms`); },
-    onResolverMeasurement: (info, timing) => console.log(`\tResolver of "${info.parentType.toString()}.${info.fieldName}" done in ${timing.ms}ms`),
-    onContextBuildingMeasurement: (timing) => console.log(`Context building done in ${timing.ms}ms`),
-};
-const deltaFrom = (hrtime) => {
-    const delta = process.hrtime(hrtime);
-    const ns = delta[0] * HR_TO_NS + delta[1];
-    return {
-        ns,
-        get ms() {
-            return ns / NS_TO_MS;
-        },
-    };
-};
-const useTiming = (rawOptions) => {
-    const options = {
-        ...DEFAULT_OPTIONS$1,
-        ...(rawOptions || {}),
-    };
-    const result = {};
-    if (options.onContextBuildingMeasurement) {
-        result.onContextBuilding = ({ context }) => {
-            if (context[envelopIsIntrospectionSymbol]) {
-                return;
-            }
-            const contextStartTime = process.hrtime();
-            return () => {
-                options.onContextBuildingMeasurement(deltaFrom(contextStartTime));
-            };
-        };
-    }
-    if (options.onParsingMeasurement) {
-        result.onParse = ({ params, extendContext }) => {
-            if (options.skipIntrospection && isIntrospectionOperationString(params.source)) {
-                extendContext({
-                    [envelopIsIntrospectionSymbol]: true,
-                });
-                return;
-            }
-            const parseStartTime = process.hrtime();
-            return () => {
-                options.onParsingMeasurement(params.source, deltaFrom(parseStartTime));
-            };
-        };
-    }
-    if (options.onValidationMeasurement) {
-        result.onValidate = ({ params, context }) => {
-            if (context[envelopIsIntrospectionSymbol]) {
-                return;
-            }
-            const validateStartTime = process.hrtime();
-            return () => {
-                options.onValidationMeasurement(params.documentAST, deltaFrom(validateStartTime));
-            };
-        };
-    }
-    if (options.onExecutionMeasurement) {
-        if (options.onResolverMeasurement) {
-            result.onExecute = ({ args }) => {
-                if (args.contextValue[envelopIsIntrospectionSymbol]) {
-                    return;
-                }
-                const executeStartTime = process.hrtime();
-                return {
-                    onExecuteDone: () => {
-                        options.onExecutionMeasurement(args, deltaFrom(executeStartTime));
-                    },
-                };
-            };
-            result.onResolverCalled = ({ info }) => {
-                const resolverStartTime = process.hrtime();
-                return () => {
-                    options.onResolverMeasurement(info, deltaFrom(resolverStartTime));
-                };
-            };
-        }
-        else {
-            result.onExecute = ({ args }) => {
-                if (args.contextValue[envelopIsIntrospectionSymbol]) {
-                    return;
-                }
-                const executeStartTime = process.hrtime();
-                return {
-                    onExecuteDone: () => {
-                        options.onExecutionMeasurement(args, deltaFrom(executeStartTime));
-                    },
-                };
-            };
-        }
-    }
-    if (options.onSubscriptionMeasurement) {
-        if (options.onResolverMeasurement) {
-            result.onSubscribe = ({ args }) => {
-                if (args.contextValue[envelopIsIntrospectionSymbol]) {
-                    return;
-                }
-                const subscribeStartTime = process.hrtime();
-                return {
-                    onSubscribeResult: () => {
-                        options.onSubscriptionMeasurement && options.onSubscriptionMeasurement(args, deltaFrom(subscribeStartTime));
-                    },
-                };
-            };
-            result.onResolverCalled = ({ info }) => {
-                const resolverStartTime = process.hrtime();
-                return () => {
-                    options.onResolverMeasurement && options.onResolverMeasurement(info, deltaFrom(resolverStartTime));
-                };
-            };
-        }
-        else {
-            result.onSubscribe = ({ args }) => {
-                if (args.contextValue[envelopIsIntrospectionSymbol]) {
-                    return;
-                }
-                const subscribeStartTime = process.hrtime();
-                return {
-                    onSubscribeResult: () => {
-                        options.onSubscriptionMeasurement && options.onSubscriptionMeasurement(args, deltaFrom(subscribeStartTime));
-                    },
-                };
-            };
-        }
-    }
-    return result;
-};
-
-const useSchema = (schema) => {
-    return {
-        onPluginInit({ setSchema }) {
-            setSchema(schema);
-        },
-    };
-};
-const useLazyLoadedSchema = (schemaLoader) => {
-    return {
-        onEnveloped({ setSchema, context }) {
-            setSchema(schemaLoader(context));
-        },
-    };
-};
-const useAsyncSchema = (schemaPromise) => {
-    return {
-        onPluginInit({ setSchema }) {
-            schemaPromise.then(schemaObj => {
-                setSchema(schemaObj);
-            });
-        },
-    };
-};
-
-const makeHandleResult = (errorHandler) => ({ result, args }) => {
-    var _a;
-    if ((_a = result.errors) === null || _a === void 0 ? void 0 : _a.length) {
-        errorHandler(result.errors, args);
-    }
-};
-const useErrorHandler = (errorHandler) => ({
-    onExecute() {
-        const handleResult = makeHandleResult(errorHandler);
-        return {
-            onExecuteDone(payload) {
-                return handleStreamOrSingleExecutionResult(payload, handleResult);
-            },
-        };
-    },
-});
-
-const useExtendContext = (contextFactory) => ({
-    async onContextBuilding({ context, extendContext }) {
-        extendContext((await contextFactory(context)));
-    },
-});
-
-const makeHandleResult$1 = (formatter) => ({ args, result, setResult, }) => {
-    const modified = formatter(result, args);
-    if (modified !== false) {
-        setResult(modified);
-    }
-};
-const usePayloadFormatter = (formatter) => ({
-    onExecute() {
-        const handleResult = makeHandleResult$1(formatter);
-        return {
-            onExecuteDone(payload) {
-                return handleStreamOrSingleExecutionResult(payload, handleResult);
-            },
-        };
-    },
-});
-
-const DEFAULT_ERROR_MESSAGE = 'Unexpected error.';
-class EnvelopError extends graphql.GraphQLError {
-    constructor(message, extensions) {
-        super(message, undefined, undefined, undefined, undefined, undefined, extensions);
-    }
-}
-const formatError = (err, message, isDev) => {
-    var _a, _b, _c, _d;
-    if (err instanceof graphql.GraphQLError) {
-        if (
-        /** execution error */
-        (err.originalError && err.originalError instanceof EnvelopError === false) ||
-            /** validate and parse errors */
-            (err.originalError === undefined && err instanceof EnvelopError === false)) {
-            return new graphql.GraphQLError(message, err.nodes, err.source, err.positions, err.path, undefined, isDev
-                ? {
-                    originalError: {
-                        message: (_b = (_a = err.originalError) === null || _a === void 0 ? void 0 : _a.message) !== null && _b !== void 0 ? _b : err.message,
-                        stack: (_d = (_c = err.originalError) === null || _c === void 0 ? void 0 : _c.stack) !== null && _d !== void 0 ? _d : err.stack,
-                    },
-                }
-                : undefined);
-        }
-        return err;
-    }
-    return new graphql.GraphQLError(message);
-};
-const makeHandleResult$2 = (format, message, isDev) => ({ result, setResult }) => {
-    if (result.errors != null) {
-        setResult({ ...result, errors: result.errors.map(error => format(error, message, isDev)) });
-    }
-};
-const useMaskedErrors = (opts) => {
-    var _a, _b;
-    const format = (_a = opts === null || opts === void 0 ? void 0 : opts.formatError) !== null && _a !== void 0 ? _a : formatError;
-    const message = (opts === null || opts === void 0 ? void 0 : opts.errorMessage) || DEFAULT_ERROR_MESSAGE;
-    // eslint-disable-next-line dot-notation
-    const isDev = (_b = opts === null || opts === void 0 ? void 0 : opts.isDev) !== null && _b !== void 0 ? _b : (typeof process !== 'undefined' ? process.env['NODE_ENV'] === 'development' : false);
-    const handleResult = makeHandleResult$2(format, message, isDev);
-    return {
-        onParse: (opts === null || opts === void 0 ? void 0 : opts.handleParseErrors) === true
-            ? function onParse() {
-                return function onParseEnd({ result, replaceParseResult }) {
-                    if (result instanceof Error) {
-                        replaceParseResult(format(result, message, isDev));
-                    }
-                };
-            }
-            : undefined,
-        onValidate: (opts === null || opts === void 0 ? void 0 : opts.handleValidationErrors) === true
-            ? function onValidate() {
-                return function onValidateEnd({ valid, result, setResult }) {
-                    if (valid === false) {
-                        setResult(result.map(error => format(error, message, isDev)));
-                    }
-                };
-            }
-            : undefined,
-        onPluginInit(context) {
-            context.registerContextErrorHandler(({ error, setError }) => {
-                setError(formatError(error, message, isDev));
-            });
-        },
-        onExecute() {
-            return {
-                onExecuteDone(payload) {
-                    return handleStreamOrSingleExecutionResult(payload, handleResult);
-                },
-            };
-        },
-        onSubscribe() {
-            return {
-                onSubscribeResult(payload) {
-                    return handleStreamOrSingleExecutionResult(payload, handleResult);
-                },
-                onSubscribeError({ error, setError }) {
-                    setError(formatError(error, message, isDev));
-                },
-            };
-        },
-    };
-};
-
-const OnNonIntrospectionFieldReachedValidationRule = (onNonIntrospectionField) => ctx => {
-    const rootQueryType = ctx.getSchema().getQueryType();
-    const rootMutationType = ctx.getSchema().getMutationType();
-    const rootSubscriptionType = ctx.getSchema().getSubscriptionType();
-    return {
-        Field(field) {
-            const parentType = ctx.getParentType();
-            const isQuery = parentType === rootQueryType;
-            const isMutation = parentType === rootMutationType;
-            const isSubscription = parentType === rootSubscriptionType;
-            if ((isQuery && !field.name.value.startsWith('__')) || isMutation || isSubscription) {
-                onNonIntrospectionField();
-                return graphql.BREAK;
-            }
-            return undefined;
-        },
-    };
-};
-const fastIntroSpectionSymbol = Symbol('fastIntrospection');
-/**
- * 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.
- */
-const useImmediateIntrospection = () => {
-    return {
-        onValidate({ addValidationRule }) {
-            let isIntrospectionOnly = true;
-            addValidationRule(OnNonIntrospectionFieldReachedValidationRule(() => {
-                isIntrospectionOnly = false;
-            }));
-            return function afterValidate({ extendContext }) {
-                if (isIntrospectionOnly) {
-                    extendContext({ [fastIntroSpectionSymbol]: true });
-                }
-            };
-        },
-        onContextBuilding({ context, breakContextBuilding }) {
-            if (context[fastIntroSpectionSymbol]) {
-                // hijack and skip all other context related stuff.
-                // We dont need a context!
-                breakContextBuilding();
-            }
-        },
-    };
-};
-
-Object.keys(types).forEach(function (k) {
-    if (k !== 'default') Object.defineProperty(exports, k, {
-        enumerable: true,
-        get: function () {
-            return types[k];
-        }
-    });
-});
-exports.DEFAULT_ERROR_MESSAGE = DEFAULT_ERROR_MESSAGE;
-exports.EnvelopError = EnvelopError;
-exports.enableIf = enableIf;
-exports.envelop = envelop;
-exports.envelopIsIntrospectionSymbol = envelopIsIntrospectionSymbol;
-exports.errorAsyncIterator = errorAsyncIterator;
-exports.finalAsyncIterator = finalAsyncIterator;
-exports.formatError = formatError;
-exports.getInMemoryLRUCache = getInMemoryLRUCache;
-exports.handleStreamOrSingleExecutionResult = handleStreamOrSingleExecutionResult;
-exports.isAsyncIterable = isAsyncIterable;
-exports.isIntrospectionDocument = isIntrospectionDocument;
-exports.isIntrospectionOperation = isIntrospectionOperation;
-exports.isIntrospectionOperationString = isIntrospectionOperationString;
-exports.isOperationDefinition = isOperationDefinition;
-exports.isPluginEnabled = isPluginEnabled;
-exports.isSourceObject = isSourceObject;
-exports.makeExecute = makeExecute;
-exports.makeSubscribe = makeSubscribe;
-exports.mapAsyncIterator = mapAsyncIterator;
-exports.useAsyncSchema = useAsyncSchema;
-exports.useEnvelop = useEnvelop;
-exports.useErrorHandler = useErrorHandler;
-exports.useExtendContext = useExtendContext;
-exports.useImmediateIntrospection = useImmediateIntrospection;
-exports.useLazyLoadedSchema = useLazyLoadedSchema;
-exports.useLogger = useLogger;
-exports.useMaskedErrors = useMaskedErrors;
-exports.usePayloadFormatter = usePayloadFormatter;
-exports.useSchema = useSchema;
-exports.useTiming = useTiming;