@graphql-mesh/transport-thrift
Version:
106 lines (105 loc) • 4.78 kB
JavaScript
;
Object.defineProperty(exports, "__esModule", { value: true });
exports.getThriftExecutor = void 0;
const graphql_1 = require("graphql");
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 getDirectiveAnnotations(directableObj) {
const directiveAnnotations = [];
if (directableObj.astNode?.directives?.length) {
directableObj.astNode.directives.forEach(directive => {
directiveAnnotations.push({
name: directive.name.value,
args: directive.arguments
? Object.fromEntries(directive.arguments.map(arg => [arg.name.value, (0, graphql_1.valueFromASTUntyped)(arg.value)]))
: {},
});
});
}
if (directableObj.extensions?.directives) {
for (const directiveName in directableObj.extensions.directives) {
const directiveObjs = directableObj.extensions.directives[directiveName];
if (Array.isArray(directiveObjs)) {
directiveObjs.forEach(directiveObj => {
directiveAnnotations.push({
name: directiveName,
args: directiveObj,
});
});
}
else {
directiveAnnotations.push({
name: directiveName,
args: directiveObjs,
});
}
}
}
return directiveAnnotations;
}
function getThriftExecutor(subgraph) {
const schemaDefDirectives = getDirectiveAnnotations(subgraph);
const graphqlAnnotations = schemaDefDirectives.find(directive => directive.name === 'transport')
?.args;
if (!graphqlAnnotations)
throw new Error('No @transport directive found on schema definition');
const client = (0, client_js_1.createGraphQLThriftClient)(graphqlAnnotations);
const headersFactory = (0, string_interpolation_1.getInterpolatedHeadersFactory)(graphqlAnnotations.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) {
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 = getDirectiveAnnotations(field).filter(directive => directive.name === 'fieldTypeMap');
fieldTypeMapDirectivesByField.set(fieldName, fieldTypeMapDirectives || []);
}
fieldTypeMapDirectives?.forEach(fieldTypeMap => {
requestPromises.push(client
.doRequest(fieldName, args, fieldTypeMap.args, {
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,
};
};
}
exports.getThriftExecutor = getThriftExecutor;