@envelop/core 2.4.0-alpha-db79afa.0 → 2.4.0-alpha-05dbec7.0

package/esm/orchestrator.js

@@ -0,0 +1,447 @@
+import { execute, parse, specifiedRules, subscribe, validate, } from 'graphql';
+import { prepareTracedSchema, resolversHooksSymbol } from './traced-schema.js';
+import { errorAsyncIterator, finalAsyncIterator, makeExecute, makeSubscribe, mapAsyncIterator, isAsyncIterable, } from './utils.js';
+export 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 = 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;
+        }
+        : () => parse;
+    const customValidate = beforeCallbacks.validate.length
+        ? initialContext => (schema, documentAST, rules, typeInfo, validationOptions) => {
+            let actualRules = rules ? [...rules] : undefined;
+            let validateFn = 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 = [...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;
+        }
+        : () => 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 = 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(subscribe);
+    const useCustomExecute = beforeCallbacks.execute.length || onResolversHandlers.length;
+    const customExecute = useCustomExecute
+        ? makeExecute(async (args) => {
+            let executeFn = 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(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,
+    };
+}

package/esm/plugins/use-envelop.js

@@ -0,0 +1,9 @@
+export const useEnvelop = (envelop) => {
+    return {
+        onPluginInit({ addPlugin }) {
+            for (const plugin of envelop._plugins) {
+                addPlugin(plugin);
+            }
+        },
+    };
+};

package/esm/plugins/use-error-handler.js

@@ -0,0 +1,17 @@
+import { handleStreamOrSingleExecutionResult } from '../utils.js';
+const makeHandleResult = (errorHandler) => ({ result, args }) => {
+    var _a;
+    if ((_a = result.errors) === null || _a === void 0 ? void 0 : _a.length) {
+        errorHandler(result.errors, args);
+    }
+};
+export const useErrorHandler = (errorHandler) => ({
+    onExecute() {
+        const handleResult = makeHandleResult(errorHandler);
+        return {
+            onExecuteDone(payload) {
+                return handleStreamOrSingleExecutionResult(payload, handleResult);
+            },
+        };
+    },
+});

package/esm/plugins/use-extend-context.js

@@ -0,0 +1,5 @@
+export const useExtendContext = (contextFactory) => ({
+    async onContextBuilding({ context, extendContext }) {
+        extendContext((await contextFactory(context)));
+    },
+});

package/esm/plugins/use-immediate-introspection.js

@@ -0,0 +1,46 @@
+import { BREAK } from 'graphql';
+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 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.
+ */
+export 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();
+            }
+        },
+    };
+};

package/esm/plugins/use-logger.js

@@ -0,0 +1,41 @@
+import { envelopIsIntrospectionSymbol, isIntrospectionOperationString } from '../utils.js';
+const DEFAULT_OPTIONS = {
+    logFn: console.log,
+};
+export 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 });
+                },
+            };
+        },
+    };
+};

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

@@ -0,0 +1,84 @@
+import { GraphQLError } from 'graphql';
+import { handleStreamOrSingleExecutionResult } from '../utils.js';
+export const DEFAULT_ERROR_MESSAGE = 'Unexpected error.';
+export class EnvelopError extends GraphQLError {
+    constructor(message, extensions) {
+        super(message, undefined, undefined, undefined, undefined, undefined, extensions);
+    }
+}
+export const formatError = (err, message, isDev) => {
+    var _a, _b, _c, _d;
+    if (err instanceof GraphQLError) {
+        if (
+        /** execution error */
+        (err.originalError && err.originalError instanceof EnvelopError === false) ||
+            /** validate and parse errors */
+            (err.originalError === undefined && err instanceof EnvelopError === false)) {
+            return new 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 GraphQLError(message);
+};
+const makeHandleResult = (format, message, isDev) => ({ result, setResult }) => {
+    if (result.errors != null) {
+        setResult({ ...result, errors: result.errors.map(error => format(error, message, isDev)) });
+    }
+};
+export 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(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));
+                },
+            };
+        },
+    };
+};

package/esm/plugins/use-payload-formatter.js

@@ -0,0 +1,17 @@
+import { handleStreamOrSingleExecutionResult } from '../utils.js';
+const makeHandleResult = (formatter) => ({ args, result, setResult, }) => {
+    const modified = formatter(result, args);
+    if (modified !== false) {
+        setResult(modified);
+    }
+};
+export const usePayloadFormatter = (formatter) => ({
+    onExecute() {
+        const handleResult = makeHandleResult(formatter);
+        return {
+            onExecuteDone(payload) {
+                return handleStreamOrSingleExecutionResult(payload, handleResult);
+            },
+        };
+    },
+});