@graphql-mesh/transport-thrift/cjs/execution.js

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.getThriftExecutor = getThriftExecutor;
const string_interpolation_1 = require("@graphql-mesh/string-interpolation");
const utils_1 = require("@graphql-mesh/utils");
const utils_2 = require("@graphql-tools/utils");
const client_js_1 = require("./client.js");
function getThriftExecutor(subgraph) {
    const schemaDefDirectives = (0, utils_2.getDirectiveExtensions)(subgraph);
    const transportDirectives = schemaDefDirectives?.transport;
    if (!transportDirectives?.length)
        throw new Error('No @transport directive found on schema definition');
    const graphqlAnnotations = transportDirectives[0];
    const client = (0, client_js_1.createGraphQLThriftClient)(graphqlAnnotations);
    let headers;
    if (typeof graphqlAnnotations.headers === 'string') {
        headers = JSON.parse(graphqlAnnotations.headers);
    }
    if (Array.isArray(graphqlAnnotations.headers)) {
        headers = Object.fromEntries(graphqlAnnotations.headers);
    }
    const headersFactory = (0, string_interpolation_1.getInterpolatedHeadersFactory)(headers);
    const rootTypeMap = (0, utils_2.getRootTypeMap)(subgraph);
    const fieldTypeMapDirectivesByField = new Map();
    return async function thriftExecutor(executionRequest) {
        const operationsAndFragments = (0, utils_1.getOperationsAndFragments)(executionRequest.document);
        const operationName = executionRequest.operationName || Object.keys(operationsAndFragments.operations)[0];
        const operationAst = operationsAndFragments.operations[operationName];
        const rootType = rootTypeMap.get(operationAst.operation);
        if (!rootType) {
            throw new Error(`No root type found for operation type ${operationAst.operation}`);
        }
        const rootFieldMap = rootType.getFields();
        const rootFieldsWithArgs = (0, utils_1.getRootFieldsWithArgs)(subgraph, executionRequest);
        const requestPromises = [];
        const root = {};
        const errors = [];
        for (const [fieldName, args] of rootFieldsWithArgs) {
            if (fieldName === '__typename') {
                root[fieldName] = rootType.name;
                continue;
            }
            const field = rootFieldMap[fieldName];
            if (!field) {
                throw new Error(`No root field found for field ${fieldName}`);
            }
            let fieldTypeMapDirectives = fieldTypeMapDirectivesByField.get(fieldName);
            if (fieldTypeMapDirectives == null) {
                fieldTypeMapDirectives = (0, utils_2.getDirectiveExtensions)(field)?.fieldTypeMap || [];
                fieldTypeMapDirectivesByField.set(fieldName, fieldTypeMapDirectives);
            }
            fieldTypeMapDirectives?.forEach(fieldTypeMapDirective => {
                requestPromises.push(client
                    .doRequest(fieldName, args, fieldTypeMapDirective?.fieldTypeMap, {
                    headers: headersFactory({
                        root,
                        args,
                        context: executionRequest.context,
                        env: globalThis.process?.env,
                    }),
                })
                    .then(result => {
                    root[fieldName] = result;
                })
                    .catch(err => {
                    errors.push(err);
                }));
            });
        }
        await Promise.all(requestPromises);
        const projectedData = (0, utils_1.projectResultBySelectionSet)({
            result: root,
            selectionSet: operationAst.selectionSet,
            fragments: operationsAndFragments.fragments,
        });
        return {
            data: projectedData,
            errors: errors.length ? errors : undefined,
        };
    };
}