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

package/cjs/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/esm/create.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.envelop = void 0;
+const enable_if_js_1 = require("./enable-if.js");
+const orchestrator_js_1 = require("./orchestrator.js");
+const traced_orchestrator_js_1 = require("./traced-orchestrator.js");
+function envelop(options) {
+    const plugins = options.plugins.filter(enable_if_js_1.isPluginEnabled);
+    let orchestrator = (0, orchestrator_js_1.createEnvelopOrchestrator)(plugins);
+    if (options.enableInternalTracing) {
+        orchestrator = (0, traced_orchestrator_js_1.traceOrchestrator)(orchestrator);
+    }
+    const getEnveloped = (initialContext = {}) => {
+        const typedOrchestrator = orchestrator;
+        typedOrchestrator.init(initialContext);
+        return {
+            parse: typedOrchestrator.parse(initialContext),
+            validate: typedOrchestrator.validate(initialContext),
+            contextFactory: typedOrchestrator.contextFactory(initialContext),
+            execute: typedOrchestrator.execute,
+            subscribe: typedOrchestrator.subscribe,
+            schema: typedOrchestrator.getCurrentSchema(),
+        };
+    };
+    getEnveloped._plugins = plugins;
+    return getEnveloped;
+}
+exports.envelop = envelop;

package/esm/enable-if.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.enableIf = exports.isPluginEnabled = void 0;
+/**
+ * This enum is used only internally in order to create nominal type for the disabled plugin
+ */
+var EnableIfBranded;
+(function (EnableIfBranded) {
+    EnableIfBranded[EnableIfBranded["DisabledPlugin"] = 0] = "DisabledPlugin";
+})(EnableIfBranded || (EnableIfBranded = {}));
+function isPluginEnabled(t) {
+    return t !== EnableIfBranded.DisabledPlugin && t !== null;
+}
+exports.isPluginEnabled = isPluginEnabled;
+/**
+ * Utility function to enable a plugin.
+ */
+function enableIf(condition, plugin) {
+    if (condition) {
+        return typeof plugin === 'function' ? plugin() : plugin;
+    }
+    return EnableIfBranded.DisabledPlugin;
+}
+exports.enableIf = enableIf;

package/esm/index.js

@@ -0,0 +1,29 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("@envelop/types"), exports);
+__exportStar(require("./create.js"), exports);
+__exportStar(require("./utils.js"), exports);
+__exportStar(require("./plugins/use-envelop.js"), exports);
+__exportStar(require("./plugins/use-logger.js"), exports);
+__exportStar(require("./plugins/use-timing.js"), exports);
+__exportStar(require("./plugins/use-schema.js"), exports);
+__exportStar(require("./plugins/use-error-handler.js"), exports);
+__exportStar(require("./plugins/use-extend-context.js"), exports);
+__exportStar(require("./plugins/use-payload-formatter.js"), exports);
+__exportStar(require("./plugins/use-masked-errors.js"), exports);
+__exportStar(require("./plugins/use-immediate-introspection.js"), exports);
+__exportStar(require("./enable-if.js"), exports);