@omnigraph/thrift
Version:
410 lines (409 loc) • 17.6 kB
JavaScript
;
Object.defineProperty(exports, "__esModule", { value: true });
exports.fieldTypeMapDirective = exports.FieldTypeMapScalar = void 0;
exports.loadNonExecutableGraphQLSchemaFromIDL = loadNonExecutableGraphQLSchemaFromIDL;
exports.loadNonExecutableGraphQLSchemaFromThriftDocument = loadNonExecutableGraphQLSchemaFromThriftDocument;
const graphql_1 = require("graphql");
const graphql_scalars_1 = require("graphql-scalars");
const thrift_parser_1 = require("@creditkarma/thrift-parser");
const thrift_server_core_1 = require("@creditkarma/thrift-server-core");
const cross_helpers_1 = require("@graphql-mesh/cross-helpers");
const utils_1 = require("@graphql-mesh/utils");
const fetch_1 = require("@whatwg-node/fetch");
exports.FieldTypeMapScalar = new graphql_1.GraphQLScalarType({ name: 'FieldTypeMap' });
exports.fieldTypeMapDirective = new graphql_1.GraphQLDirective({
name: 'fieldTypeMap',
locations: [graphql_1.DirectiveLocation.FIELD_DEFINITION],
args: {
subgraph: {
type: graphql_1.GraphQLString,
},
fieldTypeMap: {
type: exports.FieldTypeMapScalar,
},
},
});
async function loadNonExecutableGraphQLSchemaFromIDL({ subgraphName, source, endpoint, operationHeaders = {}, serviceName, baseDir = process.cwd(), schemaHeaders = {}, fetchFn = fetch_1.fetch, logger = new utils_1.DefaultLogger('Thrift'), importFn = utils_1.defaultImportFn, }) {
const namespaceASTMap = {};
await parseWithIncludes({
idlFilePath: source,
includesMap: namespaceASTMap,
baseDir,
schemaHeaders,
fetchFn,
logger,
importFn,
});
const baseNamespace = cross_helpers_1.path.basename(source, '.thrift');
return loadNonExecutableGraphQLSchemaFromThriftDocument({
subgraphName,
baseNamespace,
namespaceASTMap,
location: endpoint,
headers: operationHeaders,
serviceName,
});
}
async function parseWithIncludes({ idlFilePath, includesMap, baseDir, schemaHeaders, fetchFn, logger, importFn, }) {
const rawThrift = await (0, utils_1.readFileOrUrl)(idlFilePath, {
allowUnknownExtensions: true,
cwd: baseDir,
headers: schemaHeaders,
fetch: fetchFn,
logger,
importFn,
});
const parseResult = (0, thrift_parser_1.parse)(rawThrift, { organize: false });
const idlNamespace = cross_helpers_1.path.basename(idlFilePath).split('.')[0];
if (parseResult.type === thrift_parser_1.SyntaxType.ThriftErrors) {
if (parseResult.errors.length === 1) {
throw parseResult.errors[0];
}
throw new AggregateError(parseResult.errors);
}
includesMap[idlNamespace] = parseResult;
const includes = parseResult.body.filter((statement) => statement.type === thrift_parser_1.SyntaxType.IncludeDefinition);
await Promise.all(includes.map(async (include) => {
const absoluteIdlFilePath = cross_helpers_1.path.isAbsolute(idlFilePath)
? idlFilePath
: cross_helpers_1.path.resolve(baseDir, idlFilePath);
const includePath = cross_helpers_1.path.resolve(cross_helpers_1.path.dirname(absoluteIdlFilePath), include.path.value);
await parseWithIncludes({
idlFilePath: includePath,
includesMap,
baseDir,
schemaHeaders,
fetchFn,
logger,
importFn,
});
}));
return includesMap;
}
function loadNonExecutableGraphQLSchemaFromThriftDocument({ subgraphName, baseNamespace, namespaceASTMap, location, headers = {}, serviceName, }) {
const enumTypeMap = new Map();
const outputTypeMap = new Map();
const inputTypeMap = new Map();
const rootFields = {};
const annotations = {};
const methodAnnotations = {};
const methodNames = [];
const methodParameters = {};
const topTypeMap = {};
let currentId = 0;
for (const namespace of Object.keys(namespaceASTMap).reverse()) {
const thriftAST = namespaceASTMap[namespace];
for (const statement of thriftAST.body) {
let typeName = 'name' in statement ? statement.name.value : undefined;
if (namespace !== baseNamespace) {
typeName = `${namespace}_${typeName}`;
}
switch (statement.type) {
case thrift_parser_1.SyntaxType.EnumDefinition:
enumTypeMap.set(typeName, new graphql_1.GraphQLEnumType({
name: typeName,
description: processComments(statement.comments),
values: statement.members.reduce((prev, curr) => ({
...prev,
[curr.name.value]: {
description: processComments(curr.comments),
value: curr.name.value,
},
}), {}),
}));
break;
case thrift_parser_1.SyntaxType.StructDefinition: {
const description = processComments(statement.comments);
const structTypeVal = {
id: currentId++,
name: typeName,
type: thrift_server_core_1.TType.STRUCT,
fields: {},
};
topTypeMap[typeName] = structTypeVal;
const structFieldTypeMap = structTypeVal.fields;
const fields = [];
for (const field of statement.fields) {
fields.push({ field, description: processComments(field.comments) });
const { typeVal } = getGraphQLFunctionType({
functionType: field.fieldType,
id: field.fieldID?.value,
enumTypeMap,
inputTypeMap,
outputTypeMap,
topTypeMap,
});
structFieldTypeMap[field.name.value] = typeVal;
}
const getFieldsMap = (typeKind) => Object.fromEntries(fields.map(entry => {
const { field: { fieldType, fieldID, name, requiredness }, } = entry;
if (!entry.type) {
entry.type = getGraphQLFunctionType({
functionType: fieldType,
id: fieldID?.value,
enumTypeMap,
inputTypeMap,
outputTypeMap,
topTypeMap,
});
}
const { [typeKind]: type } = entry.type;
return [
name.value,
{
type: requiredness === 'required' ? new graphql_1.GraphQLNonNull(type) : type,
description,
},
];
}));
// We use fields thunk to avoid circular dependency in case of recursive types
outputTypeMap.set(typeName, new graphql_1.GraphQLObjectType({
name: typeName,
description,
fields: () => getFieldsMap('outputType'),
}));
inputTypeMap.set(typeName, new graphql_1.GraphQLInputObjectType({
name: typeName + 'Input',
description,
fields: () => getFieldsMap('inputType'),
}));
break;
}
case thrift_parser_1.SyntaxType.ServiceDefinition:
for (const fnIndex in statement.functions) {
const fn = statement.functions[fnIndex];
const fnName = fn.name.value;
const description = processComments(fn.comments);
const { outputType: returnType } = getGraphQLFunctionType({
functionType: fn.returnType,
id: Number(fnIndex) + 1,
enumTypeMap,
inputTypeMap,
outputTypeMap,
topTypeMap,
});
const args = {};
const fieldTypeMap = {};
for (const field of fn.fields) {
const fieldName = field.name.value;
const fieldDescription = processComments(field.comments);
let { inputType: fieldType, typeVal } = getGraphQLFunctionType({
functionType: field.fieldType,
id: field.fieldID?.value,
enumTypeMap,
inputTypeMap,
outputTypeMap,
topTypeMap,
});
if (field.requiredness === 'required') {
fieldType = new graphql_1.GraphQLNonNull(fieldType);
}
args[fieldName] = {
type: fieldType,
description: fieldDescription,
};
fieldTypeMap[fieldName] = typeVal;
}
rootFields[fnName] = {
type: returnType,
description,
args,
extensions: {
directives: {
fieldTypeMap: {
subgraph: subgraphName,
fieldTypeMap,
},
},
},
};
methodNames.push(fnName);
methodAnnotations[fnName] = { annotations: {}, fieldAnnotations: {} };
methodParameters[fnName] = fn.fields.length + 1;
}
break;
case thrift_parser_1.SyntaxType.TypedefDefinition: {
const { inputType, outputType } = getGraphQLFunctionType({
id: currentId++,
functionType: statement.definitionType,
enumTypeMap,
inputTypeMap,
outputTypeMap,
topTypeMap,
});
inputTypeMap.set(typeName, inputType);
outputTypeMap.set(typeName, outputType);
break;
}
}
}
}
const queryObjectType = new graphql_1.GraphQLObjectType({
name: 'Query',
fields: rootFields,
});
const graphQLThriftAnnotations = {
subgraph: subgraphName,
kind: 'thrift',
location,
headers,
options: {
clientAnnotations: {
serviceName,
annotations,
methodNames,
methodAnnotations,
methodParameters,
},
topTypeMap,
},
};
const schema = new graphql_1.GraphQLSchema({
query: queryObjectType,
directives: [exports.fieldTypeMapDirective],
extensions: {
directives: {
transport: graphQLThriftAnnotations,
},
},
});
return schema;
}
function processComments(comments) {
return comments.map(comment => comment.value).join('\n');
}
function getGraphQLFunctionType({ functionType, id, enumTypeMap, inputTypeMap, outputTypeMap, topTypeMap, }) {
let inputType;
let outputType;
let typeVal;
switch (functionType.type) {
case thrift_parser_1.SyntaxType.BinaryKeyword:
case thrift_parser_1.SyntaxType.StringKeyword:
inputType = graphql_1.GraphQLString;
outputType = graphql_1.GraphQLString;
break;
case thrift_parser_1.SyntaxType.DoubleKeyword:
inputType = graphql_1.GraphQLFloat;
outputType = graphql_1.GraphQLFloat;
typeVal = typeVal || { type: thrift_server_core_1.TType.DOUBLE };
break;
case thrift_parser_1.SyntaxType.VoidKeyword:
typeVal = typeVal || { type: thrift_server_core_1.TType.VOID };
inputType = graphql_scalars_1.GraphQLVoid;
outputType = graphql_scalars_1.GraphQLVoid;
break;
case thrift_parser_1.SyntaxType.BoolKeyword:
typeVal = typeVal || { type: thrift_server_core_1.TType.BOOL };
inputType = graphql_1.GraphQLBoolean;
outputType = graphql_1.GraphQLBoolean;
break;
case thrift_parser_1.SyntaxType.I8Keyword:
inputType = graphql_1.GraphQLInt;
outputType = graphql_1.GraphQLInt;
typeVal = typeVal || { type: thrift_server_core_1.TType.I08 };
break;
case thrift_parser_1.SyntaxType.I16Keyword:
inputType = graphql_1.GraphQLInt;
outputType = graphql_1.GraphQLInt;
typeVal = typeVal || { type: thrift_server_core_1.TType.I16 };
break;
case thrift_parser_1.SyntaxType.I32Keyword:
inputType = graphql_1.GraphQLInt;
outputType = graphql_1.GraphQLInt;
typeVal = typeVal || { type: thrift_server_core_1.TType.I32 };
break;
case thrift_parser_1.SyntaxType.ByteKeyword:
inputType = graphql_scalars_1.GraphQLByte;
outputType = graphql_scalars_1.GraphQLByte;
typeVal = typeVal || { type: thrift_server_core_1.TType.BYTE };
break;
case thrift_parser_1.SyntaxType.I64Keyword:
inputType = graphql_scalars_1.GraphQLBigInt;
outputType = graphql_scalars_1.GraphQLBigInt;
typeVal = typeVal || { type: thrift_server_core_1.TType.I64 };
break;
case thrift_parser_1.SyntaxType.ListType: {
const ofTypeList = getGraphQLFunctionType({
functionType: functionType.valueType,
id,
enumTypeMap,
inputTypeMap,
outputTypeMap,
topTypeMap,
});
inputType = new graphql_1.GraphQLList(ofTypeList.inputType);
outputType = new graphql_1.GraphQLList(ofTypeList.outputType);
typeVal = typeVal || { type: thrift_server_core_1.TType.LIST, elementType: ofTypeList.typeVal };
break;
}
case thrift_parser_1.SyntaxType.SetType: {
const ofSetType = getGraphQLFunctionType({
functionType: functionType.valueType,
id,
enumTypeMap,
inputTypeMap,
outputTypeMap,
topTypeMap,
});
inputType = new graphql_1.GraphQLList(ofSetType.inputType);
outputType = new graphql_1.GraphQLList(ofSetType.outputType);
typeVal = typeVal || { type: thrift_server_core_1.TType.SET, elementType: ofSetType.typeVal };
break;
}
case thrift_parser_1.SyntaxType.MapType: {
inputType = graphql_scalars_1.GraphQLJSON;
outputType = graphql_scalars_1.GraphQLJSON;
const ofTypeKey = getGraphQLFunctionType({
functionType: functionType.keyType,
id,
enumTypeMap,
inputTypeMap,
outputTypeMap,
topTypeMap,
});
const ofTypeValue = getGraphQLFunctionType({
functionType: functionType.valueType,
id,
enumTypeMap,
inputTypeMap,
outputTypeMap,
topTypeMap,
});
typeVal = typeVal || {
type: thrift_server_core_1.TType.MAP,
keyType: ofTypeKey.typeVal,
valType: ofTypeValue.typeVal,
};
break;
}
case thrift_parser_1.SyntaxType.Identifier: {
const typeName = functionType.value.replace('.', '_');
if (enumTypeMap.has(typeName)) {
const enumType = enumTypeMap.get(typeName);
inputType = enumType;
outputType = enumType;
}
if (inputTypeMap.has(typeName)) {
inputType = inputTypeMap.get(typeName);
}
if (outputTypeMap.has(typeName)) {
outputType = outputTypeMap.get(typeName);
}
typeVal = {
name: typeName,
type: 'ref',
};
break;
}
default:
throw new Error(`Unknown function type: ${functionType}!`);
}
return {
inputType: inputType,
outputType: outputType,
typeVal: {
...typeVal,
id,
},
};
}