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

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

@@ -0,0 +1,90 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useMaskedErrors = exports.formatError = exports.EnvelopError = exports.DEFAULT_ERROR_MESSAGE = void 0;
+const graphql_1 = require("graphql");
+const utils_js_1 = require("../utils.js");
+exports.DEFAULT_ERROR_MESSAGE = 'Unexpected error.';
+class EnvelopError extends graphql_1.GraphQLError {
+    constructor(message, extensions) {
+        super(message, undefined, undefined, undefined, undefined, undefined, extensions);
+    }
+}
+exports.EnvelopError = EnvelopError;
+const formatError = (err, message, isDev) => {
+    var _a, _b, _c, _d;
+    if (err instanceof graphql_1.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_1.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_1.GraphQLError(message);
+};
+exports.formatError = formatError;
+const makeHandleResult = (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 : exports.formatError;
+    const message = (opts === null || opts === void 0 ? void 0 : opts.errorMessage) || exports.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((0, exports.formatError)(error, message, isDev));
+            });
+        },
+        onExecute() {
+            return {
+                onExecuteDone(payload) {
+                    return (0, utils_js_1.handleStreamOrSingleExecutionResult)(payload, handleResult);
+                },
+            };
+        },
+        onSubscribe() {
+            return {
+                onSubscribeResult(payload) {
+                    return (0, utils_js_1.handleStreamOrSingleExecutionResult)(payload, handleResult);
+                },
+                onSubscribeError({ error, setError }) {
+                    setError((0, exports.formatError)(error, message, isDev));
+                },
+            };
+        },
+    };
+};
+exports.useMaskedErrors = useMaskedErrors;

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

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.usePayloadFormatter = void 0;
+const utils_js_1 = require("../utils.js");
+const makeHandleResult = (formatter) => ({ args, result, setResult, }) => {
+    const modified = formatter(result, args);
+    if (modified !== false) {
+        setResult(modified);
+    }
+};
+const usePayloadFormatter = (formatter) => ({
+    onExecute() {
+        const handleResult = makeHandleResult(formatter);
+        return {
+            onExecuteDone(payload) {
+                return (0, utils_js_1.handleStreamOrSingleExecutionResult)(payload, handleResult);
+            },
+        };
+    },
+});
+exports.usePayloadFormatter = usePayloadFormatter;

package/cjs/plugins/use-schema.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useAsyncSchema = exports.useLazyLoadedSchema = exports.useSchema = void 0;
+const useSchema = (schema) => {
+    return {
+        onPluginInit({ setSchema }) {
+            setSchema(schema);
+        },
+    };
+};
+exports.useSchema = useSchema;
+const useLazyLoadedSchema = (schemaLoader) => {
+    return {
+        onEnveloped({ setSchema, context }) {
+            setSchema(schemaLoader(context));
+        },
+    };
+};
+exports.useLazyLoadedSchema = useLazyLoadedSchema;
+const useAsyncSchema = (schemaPromise) => {
+    return {
+        onPluginInit({ setSchema }) {
+            schemaPromise.then(schemaObj => {
+                setSchema(schemaObj);
+            });
+        },
+    };
+};
+exports.useAsyncSchema = useAsyncSchema;

package/cjs/plugins/use-timing.js

@@ -0,0 +1,138 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useTiming = void 0;
+const graphql_1 = require("graphql");
+const utils_js_1 = require("../utils.js");
+const HR_TO_NS = 1e9;
+const NS_TO_MS = 1e6;
+const DEFAULT_OPTIONS = {
+    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 = (0, graphql_1.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,
+        ...(rawOptions || {}),
+    };
+    const result = {};
+    if (options.onContextBuildingMeasurement) {
+        result.onContextBuilding = ({ context }) => {
+            if (context[utils_js_1.envelopIsIntrospectionSymbol]) {
+                return;
+            }
+            const contextStartTime = process.hrtime();
+            return () => {
+                options.onContextBuildingMeasurement(deltaFrom(contextStartTime));
+            };
+        };
+    }
+    if (options.onParsingMeasurement) {
+        result.onParse = ({ params, extendContext }) => {
+            if (options.skipIntrospection && (0, utils_js_1.isIntrospectionOperationString)(params.source)) {
+                extendContext({
+                    [utils_js_1.envelopIsIntrospectionSymbol]: true,
+                });
+                return;
+            }
+            const parseStartTime = process.hrtime();
+            return () => {
+                options.onParsingMeasurement(params.source, deltaFrom(parseStartTime));
+            };
+        };
+    }
+    if (options.onValidationMeasurement) {
+        result.onValidate = ({ params, context }) => {
+            if (context[utils_js_1.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[utils_js_1.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[utils_js_1.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[utils_js_1.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[utils_js_1.envelopIsIntrospectionSymbol]) {
+                    return;
+                }
+                const subscribeStartTime = process.hrtime();
+                return {
+                    onSubscribeResult: () => {
+                        options.onSubscriptionMeasurement && options.onSubscriptionMeasurement(args, deltaFrom(subscribeStartTime));
+                    },
+                };
+            };
+        }
+    }
+    return result;
+};
+exports.useTiming = useTiming;

package/cjs/traced-orchestrator.js

@@ -0,0 +1,134 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.traceOrchestrator = void 0;
+const graphql_1 = require("graphql");
+const utils_js_1 = require("./utils.js");
+const getTimestamp = typeof globalThis !== 'undefined' && ((_a = globalThis === null || globalThis === void 0 ? void 0 : globalThis.performance) === null || _a === void 0 ? void 0 : _a.now) ? () => globalThis.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_1.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 (!(0, utils_js_1.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_1.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();
+                }
+            };
+        },
+    };
+}
+exports.traceOrchestrator = traceOrchestrator;

package/cjs/traced-schema.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.prepareTracedSchema = exports.resolversHooksSymbol = exports.trackedSchemaSymbol = void 0;
+const graphql_1 = require("graphql");
+exports.trackedSchemaSymbol = Symbol('TRACKED_SCHEMA');
+exports.resolversHooksSymbol = Symbol('RESOLVERS_HOOKS');
+function prepareTracedSchema(schema) {
+    if (!schema || schema[exports.trackedSchemaSymbol]) {
+        return;
+    }
+    schema[exports.trackedSchemaSymbol] = true;
+    const entries = Object.values(schema.getTypeMap());
+    for (const type of entries) {
+        if (!(0, graphql_1.isIntrospectionType)(type) && (0, graphql_1.isObjectType)(type)) {
+            const fields = Object.values(type.getFields());
+            for (const field of fields) {
+                let resolverFn = (field.resolve || graphql_1.defaultFieldResolver);
+                field.resolve = async (root, args, context, info) => {
+                    if (context && context[exports.resolversHooksSymbol]) {
+                        const hooks = context[exports.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);
+                    }
+                };
+            }
+        }
+    }
+}
+exports.prepareTracedSchema = prepareTracedSchema;