@envelop/core 2.5.1-alpha-20220824165935-4720f031 → 2.6.0

package/cjs/create.js

@@ -3,15 +3,13 @@ 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);
-    const orchestrator = (0, orchestrator_js_1.createEnvelopOrchestrator)({
-        plugins,
-        parse: options.parse,
-        execute: options.execute,
-        validate: options.validate,
-        subscribe: options.subscribe,
-    });
+    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);

package/cjs/index.js

@@ -1,16 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.resolversHooksSymbol = void 0;
 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);
-var orchestrator_js_1 = require("./orchestrator.js");
-Object.defineProperty(exports, "resolversHooksSymbol", { enumerable: true, get: function () { return orchestrator_js_1.resolversHooksSymbol; } });

package/cjs/orchestrator.js

@@ -1,9 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createEnvelopOrchestrator = exports.resolversHooksSymbol = void 0;
+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");
-exports.resolversHooksSymbol = Symbol('RESOLVERS_HOOKS');
-function createEnvelopOrchestrator({ plugins, parse, execute, subscribe, validate, }) {
+function createEnvelopOrchestrator(plugins) {
     let schema = null;
     let initDone = false;
     const onResolversHandlers = [];
@@ -17,7 +18,7 @@ function createEnvelopOrchestrator({ plugins, parse, execute, subscribe, validat
     // here not to call the same plugin that initiated the schema switch.
     const replaceSchema = (newSchema, ignorePluginIndex = -1) => {
         if (onResolversHandlers.length) {
-            // prepareTracedSchema(newSchema);
+            (0, traced_schema_js_1.prepareTracedSchema)(newSchema);
         }
         schema = newSchema;
         if (initDone) {
@@ -81,7 +82,7 @@ function createEnvelopOrchestrator({ plugins, parse, execute, subscribe, validat
     const customParse = beforeCallbacks.parse.length
         ? initialContext => (source, parseOptions) => {
             let result = null;
-            let parseFn = parse;
+            let parseFn = graphql_1.parse;
             const context = initialContext;
             const afterCalls = [];
             for (const onParse of beforeCallbacks.parse) {
@@ -129,11 +130,11 @@ function createEnvelopOrchestrator({ plugins, parse, execute, subscribe, validat
             }
             return result;
         }
-        : () => parse;
+        : () => graphql_1.parse;
     const customValidate = beforeCallbacks.validate.length
         ? initialContext => (schema, documentAST, rules, typeInfo, validationOptions) => {
             let actualRules = rules ? [...rules] : undefined;
-            let validateFn = validate;
+            let validateFn = graphql_1.validate;
             let result = null;
             const context = initialContext;
             const afterCalls = [];
@@ -153,10 +154,7 @@ function createEnvelopOrchestrator({ plugins, parse, execute, subscribe, validat
                     validateFn,
                     addValidationRule: rule => {
                         if (!actualRules) {
-                            // Ideally we should provide default validation rules here.
-                            // eslint-disable-next-line no-console
-                            console.warn('No default validation rules provided.');
-                            actualRules = [];
+                            actualRules = [...graphql_1.specifiedRules];
                         }
                         actualRules.push(rule);
                     },
@@ -172,9 +170,6 @@ function createEnvelopOrchestrator({ plugins, parse, execute, subscribe, validat
             if (!result) {
                 result = validateFn(schema, documentAST, actualRules, typeInfo, validationOptions);
             }
-            if (!result) {
-                return;
-            }
             const valid = result.length === 0;
             for (const afterCb of afterCalls) {
                 afterCb({
@@ -191,7 +186,7 @@ function createEnvelopOrchestrator({ plugins, parse, execute, subscribe, validat
             }
             return result;
         }
-        : () => validate;
+        : () => graphql_1.validate;
     const customContextFactory = beforeCallbacks.context
         .length
         ? initialContext => async (orchestratorCtx) => {
@@ -245,7 +240,7 @@ function createEnvelopOrchestrator({ plugins, parse, execute, subscribe, validat
     const useCustomSubscribe = beforeCallbacks.subscribe.length || onResolversHandlers.length;
     const customSubscribe = useCustomSubscribe
         ? (0, utils_js_1.makeSubscribe)(async (args) => {
-            let subscribeFn = subscribe;
+            let subscribeFn = graphql_1.subscribe;
             const afterCalls = [];
             const subscribeErrorHandlers = [];
             let context = args.contextValue || {};
@@ -277,7 +272,7 @@ function createEnvelopOrchestrator({ plugins, parse, execute, subscribe, validat
                 }
             }
             if (onResolversHandlers.length) {
-                context[exports.resolversHooksSymbol] = onResolversHandlers;
+                context[traced_schema_js_1.resolversHooksSymbol] = onResolversHandlers;
             }
             if (result === undefined) {
                 result = await subscribeFn({
@@ -287,9 +282,6 @@ function createEnvelopOrchestrator({ plugins, parse, execute, subscribe, validat
                     // Can be removed once we drop support for GraphQL.js 15
                 });
             }
-            if (!result) {
-                return;
-            }
             const onNextHandler = [];
             const onEndHandler = [];
             for (const afterCb of afterCalls) {
@@ -344,11 +336,11 @@ function createEnvelopOrchestrator({ plugins, parse, execute, subscribe, validat
             }
             return result;
         })
-        : (0, utils_js_1.makeSubscribe)(subscribe);
+        : (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 = execute;
+            let executeFn = graphql_1.execute;
             let result;
             const afterCalls = [];
             let context = args.contextValue || {};
@@ -382,7 +374,7 @@ function createEnvelopOrchestrator({ plugins, parse, execute, subscribe, validat
                 }
             }
             if (onResolversHandlers.length) {
-                context[exports.resolversHooksSymbol] = onResolversHandlers;
+                context[traced_schema_js_1.resolversHooksSymbol] = onResolversHandlers;
             }
             if (result === undefined) {
                 result = (await executeFn({
@@ -432,7 +424,7 @@ function createEnvelopOrchestrator({ plugins, parse, execute, subscribe, validat
             }
             return result;
         })
-        : (0, utils_js_1.makeExecute)(execute);
+        : (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.

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-masked-errors.js

@@ -0,0 +1,93 @@
+"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 }) => {
+                if (error instanceof graphql_1.GraphQLError === false && error instanceof Error) {
+                    error = new graphql_1.GraphQLError(error.message, undefined, undefined, undefined, undefined, error);
+                }
+                setError(format(error, message, isDev));
+            });
+        },
+        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(format(error, message, isDev));
+                },
+            };
+        },
+    };
+};
+exports.useMaskedErrors = useMaskedErrors;

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,136 @@
+"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;