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

package/esm/plugins/use-schema.js

@@ -0,0 +1,23 @@
+export const useSchema = (schema) => {
+    return {
+        onPluginInit({ setSchema }) {
+            setSchema(schema);
+        },
+    };
+};
+export const useLazyLoadedSchema = (schemaLoader) => {
+    return {
+        onEnveloped({ setSchema, context }) {
+            setSchema(schemaLoader(context));
+        },
+    };
+};
+export const useAsyncSchema = (schemaPromise) => {
+    return {
+        onPluginInit({ setSchema }) {
+            schemaPromise.then(schemaObj => {
+                setSchema(schemaObj);
+            });
+        },
+    };
+};

package/esm/plugins/use-timing.js

@@ -0,0 +1,134 @@
+import { getOperationAST } from 'graphql';
+import { isIntrospectionOperationString, envelopIsIntrospectionSymbol } from '../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 = 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;
+        },
+    };
+};
+export const useTiming = (rawOptions) => {
+    const options = {
+        ...DEFAULT_OPTIONS,
+        ...(rawOptions || {}),
+    };
+    const result = {};
+    if (options.onContextBuildingMeasurement) {
+        result.onContextBuilding = ({ context }) => {
+            if (context[envelopIsIntrospectionSymbol]) {
+                return;
+            }
+            const contextStartTime = process.hrtime();
+            return () => {
+                options.onContextBuildingMeasurement(deltaFrom(contextStartTime));
+            };
+        };
+    }
+    if (options.onParsingMeasurement) {
+        result.onParse = ({ params, extendContext }) => {
+            if (options.skipIntrospection && isIntrospectionOperationString(params.source)) {
+                extendContext({
+                    [envelopIsIntrospectionSymbol]: true,
+                });
+                return;
+            }
+            const parseStartTime = process.hrtime();
+            return () => {
+                options.onParsingMeasurement(params.source, deltaFrom(parseStartTime));
+            };
+        };
+    }
+    if (options.onValidationMeasurement) {
+        result.onValidate = ({ params, context }) => {
+            if (context[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[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[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[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[envelopIsIntrospectionSymbol]) {
+                    return;
+                }
+                const subscribeStartTime = process.hrtime();
+                return {
+                    onSubscribeResult: () => {
+                        options.onSubscriptionMeasurement && options.onSubscriptionMeasurement(args, deltaFrom(subscribeStartTime));
+                    },
+                };
+            };
+        }
+    }
+    return result;
+};

package/esm/traced-orchestrator.js

@@ -0,0 +1,130 @@
+var _a;
+import { GraphQLSchema } from 'graphql';
+import { isAsyncIterable } from './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');
+export 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 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 (!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 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();
+                }
+            };
+        },
+    };
+}

package/esm/traced-schema.js

@@ -0,0 +1,64 @@
+import { defaultFieldResolver, isIntrospectionType, isObjectType } from 'graphql';
+export const trackedSchemaSymbol = Symbol('TRACKED_SCHEMA');
+export const resolversHooksSymbol = Symbol('RESOLVERS_HOOKS');
+export function prepareTracedSchema(schema) {
+    if (!schema || schema[trackedSchemaSymbol]) {
+        return;
+    }
+    schema[trackedSchemaSymbol] = true;
+    const entries = Object.values(schema.getTypeMap());
+    for (const type of entries) {
+        if (!isIntrospectionType(type) && isObjectType(type)) {
+            const fields = Object.values(type.getFields());
+            for (const field of fields) {
+                let resolverFn = (field.resolve || defaultFieldResolver);
+                field.resolve = async (root, args, context, info) => {
+                    if (context && context[resolversHooksSymbol]) {
+                        const hooks = context[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);
+                    }
+                };
+            }
+        }
+    }
+}

package/esm/utils.js

@@ -0,0 +1,207 @@
+import { Kind, visit, BREAK, } from 'graphql';
+export const envelopIsIntrospectionSymbol = Symbol('ENVELOP_IS_INTROSPECTION');
+export function isOperationDefinition(def) {
+    return def.kind === Kind.OPERATION_DEFINITION;
+}
+export function isIntrospectionOperation(operation) {
+    if (operation.kind === 'OperationDefinition') {
+        let hasIntrospectionField = false;
+        visit(operation, {
+            Field: node => {
+                if (node.name.value === '__schema') {
+                    hasIntrospectionField = true;
+                    return BREAK;
+                }
+            },
+        });
+        return hasIntrospectionField;
+    }
+    return false;
+}
+export function isIntrospectionDocument(document) {
+    const operations = document.definitions.filter(isOperationDefinition);
+    return operations.some(op => isIntrospectionOperation(op));
+}
+export function isIntrospectionOperationString(operation) {
+    return (typeof operation === 'string' ? operation : operation.body).indexOf('__schema') !== -1;
+}
+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.
+ */
+export const makeSubscribe = (subscribeFn) => ((...polyArgs) => subscribeFn(getSubscribeArgs(polyArgs)));
+export 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;
+}
+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.
+ */
+export const makeExecute = (executeFn) => ((...polyArgs) => executeFn(getExecuteArgs(polyArgs)));
+/**
+ * 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
+ */
+export function isAsyncIterable(maybeAsyncIterable) {
+    return (typeof maybeAsyncIterable === 'object' &&
+        maybeAsyncIterable != null &&
+        typeof maybeAsyncIterable[Symbol.asyncIterator] === 'function');
+}
+/**
+ * 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
+ */
+export function handleStreamOrSingleExecutionResult(payload, fn) {
+    if (isAsyncIterable(payload.result)) {
+        return { onNext: fn };
+    }
+    fn({
+        args: payload.args,
+        result: payload.result,
+        setResult: payload.setResult,
+    });
+    return undefined;
+}
+export 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;
+}
+export 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;
+}

package/package.json

@@ -1,16 +1,16 @@
 {
   "name": "@envelop/core",
-  "version": "2.4.0-alpha-db79afa.0",
+  "version": "2.4.0-alpha-05dbec7.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-05dbec7.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"
   }
-}
+}

package/{create.d.ts → typings/create.d.ts}

@@ -1,5 +1,5 @@
 import { GetEnvelopedFn, ComposeContext, Plugin } from '@envelop/types';
-import { PluginOrDisabledPlugin } from './enable-if';
+import { PluginOrDisabledPlugin } from './enable-if.js';
 export declare function envelop<PluginsType extends Plugin<any>[]>(options: {
     plugins: Array<PluginOrDisabledPlugin>;
     enableInternalTracing?: boolean;

package/typings/index.d.ts

@@ -0,0 +1,13 @@
+export * from '@envelop/types';
+export * from './create.js';
+export * from './utils.js';
+export * from './plugins/use-envelop.js';
+export * from './plugins/use-logger.js';
+export * from './plugins/use-timing.js';
+export * from './plugins/use-schema.js';
+export * from './plugins/use-error-handler.js';
+export * from './plugins/use-extend-context.js';
+export * from './plugins/use-payload-formatter.js';
+export * from './plugins/use-masked-errors.js';
+export * from './plugins/use-immediate-introspection.js';
+export * from './enable-if.js';

package/{plugins → typings/plugins}/use-logger.d.ts

@@ -1,5 +1,5 @@
 import { Plugin } from '@envelop/types';
-import { envelopIsIntrospectionSymbol } from '../utils';
+import { envelopIsIntrospectionSymbol } from '../utils.js';
 declare type LoggerPluginOptions = {
     logFn: typeof console.log;
     skipIntrospection?: boolean;