@graphql-mesh/fusion-federation
Version:
Conversion tool from Federation to Fusion
260 lines (259 loc) • 15 kB
JavaScript
;
Object.defineProperty(exports, "__esModule", { value: true });
exports.convertSupergraphToFusiongraph = void 0;
const graphql_1 = require("graphql");
const utils_1 = require("@graphql-tools/utils");
const schemaBuildOpts = { noLocation: true, assumeValid: true, assumeValidSDL: true };
function convertSupergraphToFusiongraph(federationSupergraph) {
let supergraphSchema;
if ((0, graphql_1.isSchema)(federationSupergraph)) {
supergraphSchema = federationSupergraph;
}
else if ((0, utils_1.isDocumentNode)(federationSupergraph)) {
supergraphSchema = (0, graphql_1.buildASTSchema)(federationSupergraph, schemaBuildOpts);
}
else {
supergraphSchema = (0, graphql_1.buildSchema)(federationSupergraph, schemaBuildOpts);
}
const subgraphLocationMap = new Map();
const joinGraphEnum = supergraphSchema.getType('join__Graph');
if (!(0, graphql_1.isEnumType)(joinGraphEnum)) {
throw new Error('Expected join__Graph to be an enum');
}
for (const joinGraphEnumValue of joinGraphEnum.getValues()) {
const joinGraphDirective = (0, utils_1.getDirective)(supergraphSchema, joinGraphEnumValue, 'join__graph');
if (!joinGraphDirective?.length) {
throw new Error('Expected join__Graph to have a join__graph directive');
}
const { url } = joinGraphDirective[0];
subgraphLocationMap.set(joinGraphEnumValue.value, url);
}
const typeMap = new Map();
const rootTypeMap = (0, utils_1.getRootTypeMap)(supergraphSchema);
const operationByRootType = new Map();
for (const [operationType, rootType] of rootTypeMap) {
operationByRootType.set(rootType.name, operationType);
}
const fusiongraphSchema = (0, utils_1.mapSchema)(supergraphSchema, {
[utils_1.MapperKind.TYPE](type) {
if (type.name.startsWith('link__') || type.name.startsWith('join__')) {
return null;
}
const typeExtensions = (type.extensions ||= {});
const typeDirectiveExtensions = (typeExtensions.directives ||= {});
const joinTypeDirectives = (0, utils_1.getDirective)(supergraphSchema, type, 'join__type');
const sourceDirectivesForFusion = (typeDirectiveExtensions.source ||= []);
const variableDirectivesForFusion = (typeDirectiveExtensions.variable ||= []);
const fieldMap = type.getFields?.();
const combinedVariableValues = new Set();
const resolverDirectives = (typeDirectiveExtensions.resolver ||= []);
for (const joinTypeDirective of joinTypeDirectives || []) {
if (!joinTypeDirective.external) {
sourceDirectivesForFusion.push({
name: type.name,
subgraph: joinTypeDirective.graph,
});
}
if (joinTypeDirective.key) {
const fakeOpForRequiresSelectionSet = (0, graphql_1.parse)(`{ ${joinTypeDirective.key} }`);
const operationAst = (0, graphql_1.getOperationAST)(fakeOpForRequiresSelectionSet, undefined);
if (!operationAst) {
throw new Error(`Expected requires to be a valid selection set for ${type.name}`);
}
for (const selection of operationAst.selectionSet.selections) {
if (selection.kind === graphql_1.Kind.FIELD) {
const selectionName = selection.name.value;
const varName = `${type.name}_key_${selectionName}`;
const selectionFieldObject = fieldMap[selectionName];
if (!selectionFieldObject) {
throw new Error(`Expected field ${selectionName} to exist on type ${type.name}`);
}
let availableSubgraphsForField = [];
const joinFieldDirectives = (0, utils_1.getDirective)(supergraphSchema, selectionFieldObject, 'join__field');
if (joinFieldDirectives?.length) {
availableSubgraphsForField = joinFieldDirectives
.filter(joinFieldDirective => !joinFieldDirective.external)
.map(joinFieldDirective => joinFieldDirective.graph);
}
else {
availableSubgraphsForField = joinTypeDirectives.map(joinTypeDirective => joinTypeDirective.graph);
}
for (const availableSubgraph of availableSubgraphsForField) {
variableDirectivesForFusion.push({
name: varName,
select: (0, graphql_1.print)(selection),
subgraph: availableSubgraph,
type: (0, graphql_1.getNamedType)(fieldMap[selectionName].type).toString(),
});
}
combinedVariableValues.add(`${selectionName}: $${varName}`);
}
}
const mainVariable = {
name: `representations`,
subgraph: joinTypeDirective.graph,
value: `{ __typename: "${type.name}", ${[...combinedVariableValues].join(', ')} }`,
};
variableDirectivesForFusion.push(mainVariable);
resolverDirectives.push({
operation: `query get${type.name}($representations: [_Any!]!) { _entities(representations: $representations) { ... on ${type.name} { ...__export } } }`,
subgraph: joinTypeDirective.graph,
});
}
}
typeMap.set(type.name, type);
return type;
},
[utils_1.MapperKind.FIELD](fieldConfig, fieldName, typeName) {
const type = typeMap.get(typeName);
if (!type) {
throw new Error(`Expected type ${typeName} to exist`);
}
if (!('getFields' in type)) {
throw new Error(`Expected type ${typeName} to be an object type`);
}
const typeFieldMap = type.getFields();
const typeDirectiveExtensions = ((type.extensions ||= {}).directives ||= {});
const typeVariableDirectives = (typeDirectiveExtensions.variable ||= []);
const representationsVariable = typeVariableDirectives.find((directive) => directive.name === 'representations');
const fieldExtensions = (fieldConfig.extensions ||= {});
const fieldDirectiveExtensions = (fieldExtensions.directives ||= {});
const joinFieldDirectives = (0, utils_1.getDirective)(supergraphSchema, fieldConfig, 'join__field');
const sourceDirectivesForFusion = (fieldDirectiveExtensions.source ||= []);
const variableDirectivesForFusion = (fieldDirectiveExtensions.variable ||= []);
// TODO: Pass this to type's representations
const combinedVariableValues = [];
for (const joinFieldDirective of joinFieldDirectives || []) {
if (!joinFieldDirective.external) {
sourceDirectivesForFusion.push({
subgraph: joinFieldDirective.graph,
name: fieldName,
});
}
if (joinFieldDirective.requires) {
const fakeOpForRequiresSelectionSet = (0, graphql_1.parse)(`{ ${joinFieldDirective.requires} }`);
const operationAst = (0, graphql_1.getOperationAST)(fakeOpForRequiresSelectionSet, undefined);
if (!operationAst) {
throw new Error(`Expected requires to be a valid selection set for ${fieldName}`);
}
for (const selection of operationAst.selectionSet.selections) {
if (selection.kind === 'Field') {
const selectionName = selection.name.value;
const varName = `${typeName}_${fieldName}_requires_${selectionName}`;
const selectionFieldObject = typeFieldMap[selectionName];
if (!selectionFieldObject) {
throw new Error(`Expected field ${selectionName} to exist on type ${typeName}`);
}
const joinFieldDirectives = (0, utils_1.getDirective)(supergraphSchema, selectionFieldObject, 'join__field');
for (const joinFieldDirective of joinFieldDirectives || []) {
if (!joinFieldDirective.external) {
variableDirectivesForFusion.push({
name: varName,
select: (0, graphql_1.print)(selection),
subgraph: joinFieldDirective.graph,
type: (0, graphql_1.getNamedType)(typeFieldMap[selectionName].type).toString(),
});
}
}
combinedVariableValues.push(`${selectionName}: $${varName}`);
}
else {
throw new Error(`Kind ${selection.kind} not supported for requires selection set`);
}
}
}
const operationType = operationByRootType.get(type.name);
if (operationType) {
const operationName = operationType === 'query' ? fieldName : `${operationType}${fieldName}`;
const variableDefinitions = [];
const rootFieldArgs = [];
if ('args' in fieldConfig && fieldConfig.args) {
for (const argName in fieldConfig.args) {
const arg = fieldConfig.args[argName];
let variableDefinitionStr = `$${argName}: ${arg.type}`;
if (arg.defaultValue) {
variableDefinitionStr += ` = ${typeof arg.defaultValue === 'string'
? JSON.stringify(arg.defaultValue)
: arg.defaultValue}`;
}
variableDefinitions.push(variableDefinitionStr);
rootFieldArgs.push(`${argName}: $${argName}`);
}
}
const variableDefinitionsString = variableDefinitions.length
? `(${variableDefinitions.join(', ')})`
: '';
const rootFieldArgsString = rootFieldArgs.length ? `(${rootFieldArgs.join(', ')})` : '';
const operationString = `${operationType} ${operationName}${variableDefinitionsString} { ${fieldName}${rootFieldArgsString} }`;
const resolverDirectives = (fieldDirectiveExtensions.resolver ||= []);
// TODO: Later use global resolvers to batch queries for different types
resolverDirectives.push({
subgraph: joinFieldDirective.graph,
operation: operationString,
});
}
}
if (!joinFieldDirectives?.length) {
const typeSourceDirectives = (typeDirectiveExtensions.source ||= []);
for (const typeSourceDirective of typeSourceDirectives) {
sourceDirectivesForFusion.push({
subgraph: typeSourceDirective.subgraph,
name: fieldName,
});
}
}
if (combinedVariableValues.length) {
const existingVariableValuesStr = representationsVariable.value
.substring(1, representationsVariable.value.length - 2)
.trim();
const variableValues = new Set(existingVariableValuesStr.split(',').map((str) => str.trim()));
for (const combinedVariableValue of combinedVariableValues) {
variableValues.add(combinedVariableValue.trim());
}
representationsVariable.value = `{ ${[...variableValues].join(', ')} }`;
}
const seenTypeVariableKeys = new Set();
typeDirectiveExtensions.variable = typeVariableDirectives.filter((variableDirective) => {
const variableKey = variableDirective.name + '_' + variableDirective.subgraph;
if (seenTypeVariableKeys.has(variableKey)) {
return false;
}
seenTypeVariableKeys.add(variableKey);
return true;
});
return fieldConfig;
},
[utils_1.MapperKind.ENUM_VALUE](enumValueConfig, enumValueName) {
const enumValueExtensions = (enumValueConfig.extensions ||= {});
const enumValueDirectiveExtensions = (enumValueExtensions.directives ||= {});
const joinEnumValueDirectives = (0, utils_1.getDirective)(supergraphSchema, enumValueConfig, 'join__enumValue');
const sourceDirectivesForFusion = (enumValueDirectiveExtensions.source ||= []);
for (const joinEnumValueDirective of joinEnumValueDirectives || []) {
sourceDirectivesForFusion.push({
subgraph: joinEnumValueDirective.graph,
name: enumValueName,
});
}
return enumValueConfig;
},
[utils_1.MapperKind.DIRECTIVE](directiveConfig) {
if (directiveConfig.name.startsWith('join__') ||
directiveConfig.name === 'link__' ||
directiveConfig.name === 'link') {
return null;
}
},
});
const fusiongraphSchemaExtensions = (fusiongraphSchema.extensions ||= {});
const fusiongraphDirectiveExtensions = (fusiongraphSchemaExtensions.directives ||= {});
const fusionTransportDefs = (fusiongraphDirectiveExtensions.transport ||= []);
for (const [subgraph, location] of subgraphLocationMap.entries()) {
fusionTransportDefs.push({
subgraph,
kind: 'http',
location,
});
}
return fusiongraphSchema;
}
exports.convertSupergraphToFusiongraph = convertSupergraphToFusiongraph;