grafast/dist/execute.js

Cutting edge GraphQL planning and execution engine

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.withGrafastArgs = withGrafastArgs;
exports.execute = execute;
const eventemitter3_1 = require("eventemitter3");
const constants_ts_1 = require("./constants.js");
const middleware_ts_1 = require("./middleware.js");
const prepare_ts_1 = require("./prepare.js");
const utils_ts_1 = require("./utils.js");
/**
 * Used by `execute` and `subscribe`.
 * @internal
 */
function withGrafastArgs(inArgs) {
    const args = {
        ...inArgs,
    };
    const options = args.resolvedPreset?.grafast;
    const explain = options?.explain;
    const shouldExplain = !!explain;
    let unlisten = null;
    if (shouldExplain) {
        const eventEmitter = new eventemitter3_1.EventEmitter();
        const explainOperations = [];
        args[constants_ts_1.$$eventEmitter] = eventEmitter;
        args[constants_ts_1.$$extensions] = {
            explain: {
                operations: explainOperations,
            },
        };
        const handleExplainOperation = ({ operation, }) => {
            if (explain === true || (explain && explain.includes(operation.type))) {
                explainOperations.push(operation);
            }
        };
        eventEmitter.on("explainOperation", handleExplainOperation);
        unlisten = () => {
            eventEmitter.removeListener("explainOperation", handleExplainOperation);
        };
    }
    // TODO: inline this into args
    const operationOptions = {
        explain: options?.explain,
        timeouts: options?.timeouts,
        maxPlanningDepth: options?.maxPlanningDepth,
        // TODO: Delete this
        outputDataAsString: args.outputDataAsString,
    };
    const executionResult = (0, prepare_ts_1.grafastPrepare)(args, operationOptions);
    if (unlisten !== null) {
        Promise.resolve(executionResult).then(unlisten, unlisten);
    }
    // Convert from PromiseOrDirect to PromiseOrValue
    if ((0, utils_ts_1.isPromiseLike)(executionResult)) {
        return Promise.resolve(executionResult);
    }
    else {
        return executionResult;
    }
}
function execute(args, legacyResolvedPreset, legacyOutputDataAsString) {
    // TODO: remove legacy compatibility
    if (legacyResolvedPreset !== undefined) {
        args.resolvedPreset = legacyResolvedPreset;
    }
    if (legacyOutputDataAsString !== undefined) {
        args.outputDataAsString = legacyOutputDataAsString;
    }
    const { resolvedPreset } = args;
    const middleware = args.middleware === undefined && resolvedPreset != null
        ? (0, middleware_ts_1.getGrafastMiddleware)(resolvedPreset)
        : (args.middleware ?? null);
    if (args.middleware === undefined) {
        args.middleware = middleware;
    }
    if (middleware !== null) {
        return middleware.run("execute", { args }, executeMiddlewareCallback);
    }
    else {
        return withGrafastArgs(args);
    }
}
const executeMiddlewareCallback = (event) => withGrafastArgs(event.args);
//# sourceMappingURL=execute.js.map