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

package/cjs/create.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.envelop = void 0;
+const enable_if_js_1 = require("./enable-if.js");
+const orchestrator_js_1 = require("./orchestrator.js");
+const traced_orchestrator_js_1 = require("./traced-orchestrator.js");
+function envelop(options) {
+    const plugins = options.plugins.filter(enable_if_js_1.isPluginEnabled);
+    let orchestrator = (0, orchestrator_js_1.createEnvelopOrchestrator)(plugins);
+    if (options.enableInternalTracing) {
+        orchestrator = (0, traced_orchestrator_js_1.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;
+}
+exports.envelop = envelop;

package/cjs/enable-if.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.enableIf = exports.isPluginEnabled = void 0;
+/**
+ * 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;
+}
+exports.isPluginEnabled = isPluginEnabled;
+/**
+ * Utility function to enable a plugin.
+ */
+function enableIf(condition, plugin) {
+    if (condition) {
+        return typeof plugin === 'function' ? plugin() : plugin;
+    }
+    return EnableIfBranded.DisabledPlugin;
+}
+exports.enableIf = enableIf;

package/cjs/index.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("@envelop/types"), exports);
+tslib_1.__exportStar(require("./create.js"), exports);
+tslib_1.__exportStar(require("./utils.js"), exports);
+tslib_1.__exportStar(require("./plugins/use-envelop.js"), exports);
+tslib_1.__exportStar(require("./plugins/use-logger.js"), exports);
+tslib_1.__exportStar(require("./plugins/use-timing.js"), exports);
+tslib_1.__exportStar(require("./plugins/use-schema.js"), exports);
+tslib_1.__exportStar(require("./plugins/use-error-handler.js"), exports);
+tslib_1.__exportStar(require("./plugins/use-extend-context.js"), exports);
+tslib_1.__exportStar(require("./plugins/use-payload-formatter.js"), exports);
+tslib_1.__exportStar(require("./plugins/use-masked-errors.js"), exports);
+tslib_1.__exportStar(require("./plugins/use-immediate-introspection.js"), exports);
+tslib_1.__exportStar(require("./enable-if.js"), exports);

package/cjs/orchestrator.js

@@ -0,0 +1,451 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createEnvelopOrchestrator = void 0;
+const graphql_1 = require("graphql");
+const traced_schema_js_1 = require("./traced-schema.js");
+const utils_js_1 = require("./utils.js");
+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) {
+            (0, traced_schema_js_1.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_1.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_1.parse;
+    const customValidate = beforeCallbacks.validate.length
+        ? initialContext => (schema, documentAST, rules, typeInfo, validationOptions) => {
+            let actualRules = rules ? [...rules] : undefined;
+            let validateFn = graphql_1.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_1.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_1.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
+        ? (0, utils_js_1.makeSubscribe)(async (args) => {
+            let subscribeFn = graphql_1.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[traced_schema_js_1.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 && (0, utils_js_1.isAsyncIterable)(result)) {
+                result = (0, utils_js_1.mapAsyncIterator)(result, async (result) => {
+                    for (const onNext of onNextHandler) {
+                        await onNext({
+                            args: args,
+                            result,
+                            setResult: newResult => (result = newResult),
+                        });
+                    }
+                    return result;
+                });
+            }
+            if (onEndHandler.length && (0, utils_js_1.isAsyncIterable)(result)) {
+                result = (0, utils_js_1.finalAsyncIterator)(result, () => {
+                    for (const onEnd of onEndHandler) {
+                        onEnd();
+                    }
+                });
+            }
+            if (subscribeErrorHandlers.length && (0, utils_js_1.isAsyncIterable)(result)) {
+                result = (0, utils_js_1.errorAsyncIterator)(result, err => {
+                    let error = err;
+                    for (const handler of subscribeErrorHandlers) {
+                        handler({
+                            error,
+                            setError: err => {
+                                error = err;
+                            },
+                        });
+                    }
+                    throw error;
+                });
+            }
+            return result;
+        })
+        : (0, utils_js_1.makeSubscribe)(graphql_1.subscribe);
+    const useCustomExecute = beforeCallbacks.execute.length || onResolversHandlers.length;
+    const customExecute = useCustomExecute
+        ? (0, utils_js_1.makeExecute)(async (args) => {
+            let executeFn = graphql_1.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[traced_schema_js_1.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 && (0, utils_js_1.isAsyncIterable)(result)) {
+                result = (0, utils_js_1.mapAsyncIterator)(result, async (result) => {
+                    for (const onNext of onNextHandler) {
+                        await onNext({
+                            args: args,
+                            result,
+                            setResult: newResult => {
+                                result = newResult;
+                            },
+                        });
+                    }
+                    return result;
+                });
+            }
+            if (onEndHandler.length && (0, utils_js_1.isAsyncIterable)(result)) {
+                result = (0, utils_js_1.finalAsyncIterator)(result, () => {
+                    for (const onEnd of onEndHandler) {
+                        onEnd();
+                    }
+                });
+            }
+            return result;
+        })
+        : (0, utils_js_1.makeExecute)(graphql_1.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,
+    };
+}
+exports.createEnvelopOrchestrator = createEnvelopOrchestrator;

package/cjs/package.json

@@ -0,0 +1 @@
+{"type":"commonjs"}

package/cjs/plugins/use-envelop.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useEnvelop = void 0;
+const useEnvelop = (envelop) => {
+    return {
+        onPluginInit({ addPlugin }) {
+            for (const plugin of envelop._plugins) {
+                addPlugin(plugin);
+            }
+        },
+    };
+};
+exports.useEnvelop = useEnvelop;

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

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useErrorHandler = void 0;
+const utils_js_1 = require("../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);
+    }
+};
+const useErrorHandler = (errorHandler) => ({
+    onExecute() {
+        const handleResult = makeHandleResult(errorHandler);
+        return {
+            onExecuteDone(payload) {
+                return (0, utils_js_1.handleStreamOrSingleExecutionResult)(payload, handleResult);
+            },
+        };
+    },
+});
+exports.useErrorHandler = useErrorHandler;

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

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useExtendContext = void 0;
+const useExtendContext = (contextFactory) => ({
+    async onContextBuilding({ context, extendContext }) {
+        extendContext((await contextFactory(context)));
+    },
+});
+exports.useExtendContext = useExtendContext;

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

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useImmediateIntrospection = void 0;
+const graphql_1 = require("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 graphql_1.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();
+            }
+        },
+    };
+};
+exports.useImmediateIntrospection = useImmediateIntrospection;

package/cjs/plugins/use-logger.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useLogger = void 0;
+const utils_js_1 = require("../utils.js");
+const DEFAULT_OPTIONS = {
+    logFn: console.log,
+};
+const useLogger = (rawOptions = DEFAULT_OPTIONS) => {
+    const options = {
+        DEFAULT_OPTIONS,
+        ...rawOptions,
+    };
+    return {
+        onParse({ extendContext, params }) {
+            if (options.skipIntrospection && (0, utils_js_1.isIntrospectionOperationString)(params.source)) {
+                extendContext({
+                    [utils_js_1.envelopIsIntrospectionSymbol]: true,
+                });
+            }
+        },
+        onExecute({ args }) {
+            if (args.contextValue[utils_js_1.envelopIsIntrospectionSymbol]) {
+                return;
+            }
+            options.logFn('execute-start', { args });
+            return {
+                onExecuteDone: ({ result }) => {
+                    options.logFn('execute-end', { args, result });
+                },
+            };
+        },
+        onSubscribe({ args }) {
+            if (args.contextValue[utils_js_1.envelopIsIntrospectionSymbol]) {
+                return;
+            }
+            options.logFn('subscribe-start', { args });
+            return {
+                onSubscribeResult: ({ result }) => {
+                    options.logFn('subscribe-end', { args, result });
+                },
+            };
+        },
+    };
+};
+exports.useLogger = useLogger;