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

package/esm/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/esm/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/esm/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/esm/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/esm/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;

package/esm/utils.js

@@ -0,0 +1,221 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.errorAsyncIterator = exports.finalAsyncIterator = exports.handleStreamOrSingleExecutionResult = exports.isAsyncIterable = exports.makeExecute = exports.mapAsyncIterator = exports.makeSubscribe = exports.isIntrospectionOperationString = exports.isIntrospectionDocument = exports.isIntrospectionOperation = exports.isOperationDefinition = exports.envelopIsIntrospectionSymbol = void 0;
+const graphql_1 = require("graphql");
+exports.envelopIsIntrospectionSymbol = Symbol('ENVELOP_IS_INTROSPECTION');
+function isOperationDefinition(def) {
+    return def.kind === graphql_1.Kind.OPERATION_DEFINITION;
+}
+exports.isOperationDefinition = isOperationDefinition;
+function isIntrospectionOperation(operation) {
+    if (operation.kind === 'OperationDefinition') {
+        let hasIntrospectionField = false;
+        (0, graphql_1.visit)(operation, {
+            Field: node => {
+                if (node.name.value === '__schema') {
+                    hasIntrospectionField = true;
+                    return graphql_1.BREAK;
+                }
+            },
+        });
+        return hasIntrospectionField;
+    }
+    return false;
+}
+exports.isIntrospectionOperation = isIntrospectionOperation;
+function isIntrospectionDocument(document) {
+    const operations = document.definitions.filter(isOperationDefinition);
+    return operations.some(op => isIntrospectionOperation(op));
+}
+exports.isIntrospectionDocument = isIntrospectionDocument;
+function isIntrospectionOperationString(operation) {
+    return (typeof operation === 'string' ? operation : operation.body).indexOf('__schema') !== -1;
+}
+exports.isIntrospectionOperationString = isIntrospectionOperationString;
+function getSubscribeArgs(args) {
+    return args.length === 1
+        ? args[0]
+        : {
+            schema: args[0],
+            document: args[1],
+            rootValue: args[2],
+            contextValue: args[3],
+            variableValues: args[4],
+            operationName: args[5],
+            fieldResolver: args[6],
+            subscribeFieldResolver: args[7],
+        };
+}
+/**
+ * Utility function for making a subscribe function that handles polymorphic arguments.
+ */
+const makeSubscribe = (subscribeFn) => ((...polyArgs) => subscribeFn(getSubscribeArgs(polyArgs)));
+exports.makeSubscribe = makeSubscribe;
+function mapAsyncIterator(source, mapper) {
+    const iterator = source[Symbol.asyncIterator]();
+    async function mapResult(result) {
+        var _a;
+        if (result.done) {
+            return result;
+        }
+        try {
+            return { value: await mapper(result.value), done: false };
+        }
+        catch (error) {
+            try {
+                await ((_a = iterator.return) === null || _a === void 0 ? void 0 : _a.call(iterator));
+            }
+            catch (_error) {
+                /* ignore error */
+            }
+            throw error;
+        }
+    }
+    const stream = {
+        [Symbol.asyncIterator]() {
+            return stream;
+        },
+        async next() {
+            return await mapResult(await iterator.next());
+        },
+        async return() {
+            var _a;
+            const promise = (_a = iterator.return) === null || _a === void 0 ? void 0 : _a.call(iterator);
+            return promise ? await mapResult(await promise) : { value: undefined, done: true };
+        },
+        async throw(error) {
+            var _a;
+            const promise = (_a = iterator.throw) === null || _a === void 0 ? void 0 : _a.call(iterator);
+            if (promise) {
+                return await mapResult(await promise);
+            }
+            // if the source has no throw method we just re-throw error
+            // usually throw is not called anyways
+            throw error;
+        },
+    };
+    return stream;
+}
+exports.mapAsyncIterator = mapAsyncIterator;
+function getExecuteArgs(args) {
+    return args.length === 1
+        ? args[0]
+        : {
+            schema: args[0],
+            document: args[1],
+            rootValue: args[2],
+            contextValue: args[3],
+            variableValues: args[4],
+            operationName: args[5],
+            fieldResolver: args[6],
+            typeResolver: args[7],
+        };
+}
+/**
+ * Utility function for making a execute function that handles polymorphic arguments.
+ */
+const makeExecute = (executeFn) => ((...polyArgs) => executeFn(getExecuteArgs(polyArgs)));
+exports.makeExecute = makeExecute;
+/**
+ * Returns true if the provided object implements the AsyncIterator protocol via
+ * implementing a `Symbol.asyncIterator` method.
+ *
+ * Source: https://github.com/graphql/graphql-js/blob/main/src/jsutils/isAsyncIterable.ts
+ */
+function isAsyncIterable(maybeAsyncIterable) {
+    return (typeof maybeAsyncIterable === 'object' &&
+        maybeAsyncIterable != null &&
+        typeof maybeAsyncIterable[Symbol.asyncIterator] === 'function');
+}
+exports.isAsyncIterable = isAsyncIterable;
+/**
+ * A utility function for handling `onExecuteDone` hook result, for simplifying the handling of AsyncIterable returned from `execute`.
+ *
+ * @param payload The payload send to `onExecuteDone` hook function
+ * @param fn The handler to be executed on each result
+ * @returns a subscription for streamed results, or undefined in case of an non-async
+ */
+function handleStreamOrSingleExecutionResult(payload, fn) {
+    if (isAsyncIterable(payload.result)) {
+        return { onNext: fn };
+    }
+    fn({
+        args: payload.args,
+        result: payload.result,
+        setResult: payload.setResult,
+    });
+    return undefined;
+}
+exports.handleStreamOrSingleExecutionResult = handleStreamOrSingleExecutionResult;
+function finalAsyncIterator(source, onFinal) {
+    const iterator = source[Symbol.asyncIterator]();
+    let isDone = false;
+    const stream = {
+        [Symbol.asyncIterator]() {
+            return stream;
+        },
+        async next() {
+            const result = await iterator.next();
+            if (result.done && isDone === false) {
+                isDone = true;
+                onFinal();
+            }
+            return result;
+        },
+        async return() {
+            var _a;
+            const promise = (_a = iterator.return) === null || _a === void 0 ? void 0 : _a.call(iterator);
+            if (isDone === false) {
+                isDone = true;
+                onFinal();
+            }
+            return promise ? await promise : { done: true, value: undefined };
+        },
+        async throw(error) {
+            var _a;
+            const promise = (_a = iterator.throw) === null || _a === void 0 ? void 0 : _a.call(iterator);
+            if (promise) {
+                return await promise;
+            }
+            // if the source has no throw method we just re-throw error
+            // usually throw is not called anyways
+            throw error;
+        },
+    };
+    return stream;
+}
+exports.finalAsyncIterator = finalAsyncIterator;
+function errorAsyncIterator(source, onError) {
+    const iterator = source[Symbol.asyncIterator]();
+    const stream = {
+        [Symbol.asyncIterator]() {
+            return stream;
+        },
+        async next() {
+            try {
+                return await iterator.next();
+            }
+            catch (error) {
+                onError(error);
+                return { done: true, value: undefined };
+            }
+        },
+        async return() {
+            var _a;
+            const promise = (_a = iterator.return) === null || _a === void 0 ? void 0 : _a.call(iterator);
+            return promise ? await promise : { done: true, value: undefined };
+        },
+        async throw(error) {
+            var _a;
+            const promise = (_a = iterator.throw) === null || _a === void 0 ? void 0 : _a.call(iterator);
+            if (promise) {
+                return await promise;
+            }
+            // if the source has no throw method we just re-throw error
+            // usually throw is not called anyways
+            throw error;
+        },
+    };
+    return stream;
+}
+exports.errorAsyncIterator = errorAsyncIterator;

package/package.json

@@ -1,16 +1,16 @@
 {
   "name": "@envelop/core",
-  "version": "2.4.0-alpha-c0cc559.0",
+  "version": "2.4.0-alpha-e9434aa.0",
   "sideEffects": false,
   "peerDependencies": {
     "graphql": "^14.0.0 || ^15.0.0 || ^16.0.0"
   },
   "dependencies": {
-    "@envelop/types": "2.2.0"
+    "@envelop/types": "2.3.0-alpha-e9434aa.0"
   },
   "repository": {
     "type": "git",
-    "url": "https://github.com/dotansimha/envelop.git",
+    "url": "https://github.com/n1ru4l/envelop.git",
     "directory": "packages/core"
   },
   "keywords": [
@@ -24,21 +24,42 @@
   ],
   "author": "Dotan Simha <dotansimha@gmail.com>",
   "license": "MIT",
-  "main": "index.js",
-  "module": "index.mjs",
-  "typings": "index.d.ts",
+  "main": "cjs/index.js",
+  "module": "esm/index.js",
+  "typings": "typings/index.d.ts",
   "typescript": {
-    "definition": "index.d.ts"
+    "definition": "typings/index.d.ts"
   },
+  "type": "module",
   "exports": {
     ".": {
-      "require": "./index.js",
-      "import": "./index.mjs"
+      "require": {
+        "types": "./typings/index.d.ts",
+        "default": "./cjs/index.js"
+      },
+      "import": {
+        "types": "./typings/index.d.ts",
+        "default": "./esm/index.js"
+      },
+      "default": {
+        "types": "./typings/index.d.ts",
+        "default": "./esm/index.js"
+      }
     },
     "./*": {
-      "require": "./*.js",
-      "import": "./*.mjs"
+      "require": {
+        "types": "./typings/*.d.ts",
+        "default": "./cjs/*.js"
+      },
+      "import": {
+        "types": "./typings/*.d.ts",
+        "default": "./esm/*.js"
+      },
+      "default": {
+        "types": "./typings/*.d.ts",
+        "default": "./esm/*.js"
+      }
     },
     "./package.json": "./package.json"
   }
-}
+}