@theguild/federation-composition 0.0.0-alpha-20230916192321-bb37b43

package/cjs/supergraph/composition/common.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.convertToConst = void 0;
+function convertToConst(nodes) {
+    return nodes;
+}
+exports.convertToConst = convertToConst;

package/cjs/supergraph/composition/directive.js

@@ -0,0 +1,93 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.directiveBuilder = void 0;
+const ast_js_1 = require("./ast.js");
+const common_js_1 = require("./common.js");
+function directiveBuilder() {
+    return {
+        visitSubgraphState(graph, state, directiveName, directive) {
+            if (!directive.composed) {
+                return;
+            }
+            const directiveState = getOrCreateDirective(state, directiveName);
+            for (const location of directive.locations) {
+                directiveState.locations.add(location);
+            }
+            if (directive.repeatable) {
+                directiveState.repeatable = true;
+            }
+            for (const arg of directive.args.values()) {
+                const argState = getOrCreateArg(directiveState, arg.name, arg.type);
+                arg.tags.forEach(tag => argState.tags.add(tag));
+                if (arg.type.endsWith('!')) {
+                    argState.type = arg.type;
+                }
+                arg.ast.directives.forEach(directive => {
+                    argState.ast.directives.push(directive);
+                });
+                if (arg.inaccessible) {
+                    argState.inaccessible = true;
+                }
+                argState.byGraph.set(graph.id, {
+                    type: arg.type,
+                    defaultValue: arg.defaultValue,
+                });
+            }
+            directiveState.byGraph.set(graph.id, {
+                locations: directive.locations,
+                repeatable: directive.repeatable,
+            });
+        },
+        composeSupergraphNode(directive) {
+            return (0, ast_js_1.createDirectiveNode)({
+                name: directive.name,
+                locations: Array.from(directive.locations),
+                repeatable: directive.repeatable,
+                arguments: Array.from(directive.args.values()).map(arg => ({
+                    name: arg.name,
+                    type: arg.type,
+                    tags: Array.from(arg.tags),
+                    inaccessible: arg.inaccessible,
+                    defaultValue: arg.defaultValue,
+                    ast: {
+                        directives: (0, common_js_1.convertToConst)(arg.ast.directives),
+                    },
+                })),
+            });
+        },
+    };
+}
+exports.directiveBuilder = directiveBuilder;
+function getOrCreateDirective(state, directiveName) {
+    const existing = state.get(directiveName);
+    if (existing) {
+        return existing;
+    }
+    const def = {
+        name: directiveName,
+        locations: new Set(),
+        byGraph: new Map(),
+        args: new Map(),
+        repeatable: false,
+    };
+    state.set(directiveName, def);
+    return def;
+}
+function getOrCreateArg(directiveState, argName, argType) {
+    const existing = directiveState.args.get(argName);
+    if (existing) {
+        return existing;
+    }
+    const def = {
+        name: argName,
+        type: argType,
+        inaccessible: false,
+        tags: new Set(),
+        byGraph: new Map(),
+        ast: {
+            directives: [],
+        },
+    };
+    directiveState.args.set(argName, def);
+    return def;
+}

package/cjs/supergraph/composition/enum-type.js

@@ -0,0 +1,132 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.enumTypeBuilder = void 0;
+const ast_js_1 = require("./ast.js");
+function enumTypeBuilder() {
+    return {
+        visitSubgraphState(graph, state, typeName, type) {
+            const enumTypeState = getOrCreateEnumType(state, typeName);
+            type.tags.forEach(tag => enumTypeState.tags.add(tag));
+            if (type.inaccessible) {
+                enumTypeState.inaccessible = true;
+            }
+            if (type.isDefinition) {
+                enumTypeState.hasDefinition = true;
+            }
+            if (type.description && !enumTypeState.description) {
+                enumTypeState.description = type.description;
+            }
+            if (type.referencedByInputType) {
+                enumTypeState.referencedByInputType = true;
+                type.inputTypeReferences.forEach(ref => {
+                    enumTypeState.inputTypeReferences.add(ref);
+                });
+            }
+            if (type.referencedByOutputType) {
+                enumTypeState.referencedByOutputType = true;
+                type.outputTypeReferences.forEach(ref => {
+                    enumTypeState.outputTypeReferences.add(ref);
+                });
+            }
+            enumTypeState.byGraph.set(graph.id, {
+                inaccessible: type.inaccessible,
+            });
+            for (const value of type.values.values()) {
+                const valueState = getOrCreateEnumValue(enumTypeState, value.name);
+                value.tags.forEach(tag => valueState.tags.add(tag));
+                if (value.inaccessible) {
+                    valueState.inaccessible = true;
+                }
+                if (value.deprecated && !valueState.deprecated) {
+                    valueState.deprecated = value.deprecated;
+                }
+                if (value.description && !valueState.description) {
+                    valueState.description = value.description;
+                }
+                valueState.byGraph.set(graph.id, {
+                    inaccessible: value.inaccessible,
+                });
+            }
+        },
+        composeSupergraphNode(enumType) {
+            const mergeMethod = decideOnEnumMergeStrategy(enumType.referencedByInputType, enumType.referencedByOutputType);
+            const values = mergeMethod === 'intersection'
+                ? intersectionOfEnumValues(enumType)
+                : Array.from(enumType.values);
+            return (0, ast_js_1.createEnumTypeNode)({
+                name: enumType.name,
+                values: values.map(([_, value]) => ({
+                    name: value.name,
+                    join: {
+                        enumValue: Array.from(value.byGraph.keys()).map(graph => ({
+                            graph: graph.toUpperCase(),
+                        })),
+                    },
+                    tags: Array.from(value.tags),
+                    inaccessible: value.inaccessible,
+                    description: value.description,
+                    deprecated: value.deprecated,
+                })),
+                tags: Array.from(enumType.tags),
+                inaccessible: enumType.inaccessible,
+                description: enumType.description,
+                join: {
+                    type: Array.from(enumType.byGraph.keys()).map(graphName => ({
+                        graph: graphName.toUpperCase(),
+                    })),
+                },
+            });
+        },
+    };
+}
+exports.enumTypeBuilder = enumTypeBuilder;
+function decideOnEnumMergeStrategy(referencedByInputType, referencedByOutputType) {
+    if (referencedByInputType === referencedByOutputType) {
+        return 'equal';
+    }
+    if (referencedByInputType) {
+        return 'intersection';
+    }
+    if (referencedByOutputType) {
+        return 'union';
+    }
+    return 'equal';
+}
+function intersectionOfEnumValues(enumType) {
+    const numberOfGraphs = enumType.byGraph.size;
+    return Array.from(enumType.values).filter(([_, value]) => value.byGraph.size === numberOfGraphs);
+}
+function getOrCreateEnumType(state, typeName) {
+    const existing = state.get(typeName);
+    if (existing) {
+        return existing;
+    }
+    const def = {
+        name: typeName,
+        values: new Map(),
+        tags: new Set(),
+        hasDefinition: false,
+        inaccessible: false,
+        referencedByInputType: false,
+        referencedByOutputType: false,
+        inputTypeReferences: new Set(),
+        outputTypeReferences: new Set(),
+        byGraph: new Map(),
+    };
+    state.set(typeName, def);
+    return def;
+}
+function getOrCreateEnumValue(enumTypeState, enumValueName) {
+    const existing = enumTypeState.values.get(enumValueName);
+    if (existing) {
+        return existing;
+    }
+    const def = {
+        name: enumValueName,
+        tags: new Set(),
+        inaccessible: false,
+        byGraph: new Map(),
+    };
+    enumTypeState.values.set(enumValueName, def);
+    return def;
+}

package/cjs/supergraph/composition/input-object-type.js

@@ -0,0 +1,119 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.inputObjectTypeBuilder = void 0;
+const ast_js_1 = require("./ast.js");
+function inputObjectTypeBuilder() {
+    return {
+        visitSubgraphState(graph, state, typeName, type) {
+            const inputObjectTypeState = getOrCreateInputObjectType(state, typeName);
+            type.tags.forEach(tag => inputObjectTypeState.tags.add(tag));
+            if (type.inaccessible) {
+                inputObjectTypeState.inaccessible = true;
+            }
+            const isDefinition = type.isDefinition && !type.extension;
+            if (type.description && !inputObjectTypeState.description) {
+                inputObjectTypeState.description = type.description;
+            }
+            if (type.isDefinition) {
+                inputObjectTypeState.hasDefinition = true;
+            }
+            inputObjectTypeState.byGraph.set(graph.id, {
+                inaccessible: type.inaccessible,
+            });
+            for (const field of type.fields.values()) {
+                const fieldState = getOrCreateField(inputObjectTypeState, field.name, field.type);
+                field.tags.forEach(tag => fieldState.tags.add(tag));
+                if (field.type.endsWith('!') && !fieldState.type.endsWith('!')) {
+                    fieldState.type = field.type;
+                }
+                if (field.inaccessible) {
+                    fieldState.inaccessible = true;
+                }
+                if (field.description && !fieldState.description) {
+                    fieldState.description = field.description;
+                }
+                if (field.deprecated && !fieldState.deprecated) {
+                    fieldState.deprecated = field.deprecated;
+                }
+                if (typeof field.defaultValue === 'string') {
+                    fieldState.defaultValue = field.defaultValue;
+                }
+                fieldState.byGraph.set(graph.id, {
+                    type: field.type,
+                    inaccessible: field.inaccessible,
+                    defaultValue: field.defaultValue,
+                });
+            }
+        },
+        composeSupergraphNode(inputObjectType) {
+            return (0, ast_js_1.createInputObjectTypeNode)({
+                name: inputObjectType.name,
+                tags: Array.from(inputObjectType.tags),
+                inaccessible: inputObjectType.inaccessible,
+                description: inputObjectType.description,
+                fields: Array.from(inputObjectType.fields.values())
+                    .filter(field => {
+                    if (field.byGraph.size !== inputObjectType.byGraph.size) {
+                        return false;
+                    }
+                    return true;
+                })
+                    .map(field => {
+                    const hasDifferentType = Array.from(field.byGraph.values()).some(f => f.type !== field.type);
+                    return {
+                        name: field.name,
+                        type: field.type,
+                        tags: Array.from(field.tags),
+                        inaccessible: field.inaccessible,
+                        defaultValue: field.defaultValue,
+                        description: field.description,
+                        deprecated: field.deprecated,
+                        join: {
+                            field: hasDifferentType
+                                ? Array.from(field.byGraph).map(([graph, fieldByGraph]) => ({
+                                    graph,
+                                    type: fieldByGraph.type,
+                                }))
+                                : [],
+                        },
+                    };
+                }),
+                join: {
+                    type: Array.from(inputObjectType.byGraph.keys()).map(graph => ({ graph })),
+                },
+            });
+        },
+    };
+}
+exports.inputObjectTypeBuilder = inputObjectTypeBuilder;
+function getOrCreateInputObjectType(state, typeName) {
+    const existing = state.get(typeName);
+    if (existing) {
+        return existing;
+    }
+    const def = {
+        name: typeName,
+        tags: new Set(),
+        hasDefinition: false,
+        inaccessible: false,
+        byGraph: new Map(),
+        fields: new Map(),
+    };
+    state.set(typeName, def);
+    return def;
+}
+function getOrCreateField(objectTypeState, fieldName, fieldType) {
+    const existing = objectTypeState.fields.get(fieldName);
+    if (existing) {
+        return existing;
+    }
+    const def = {
+        name: fieldName,
+        type: fieldType,
+        tags: new Set(),
+        inaccessible: false,
+        byGraph: new Map(),
+    };
+    objectTypeState.fields.set(fieldName, def);
+    return def;
+}

package/cjs/supergraph/composition/interface-type.js

@@ -0,0 +1,226 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.interfaceTypeBuilder = void 0;
+const ast_js_1 = require("./ast.js");
+const common_js_1 = require("./common.js");
+function interfaceTypeBuilder() {
+    return {
+        visitSubgraphState(graph, state, typeName, type) {
+            const interfaceTypeState = getOrCreateInterfaceType(state, typeName);
+            type.tags.forEach(tag => interfaceTypeState.tags.add(tag));
+            if (type.inaccessible) {
+                interfaceTypeState.inaccessible = true;
+            }
+            if (type.isDefinition) {
+                interfaceTypeState.hasDefinition = true;
+            }
+            if (type.description && !interfaceTypeState.description) {
+                interfaceTypeState.description = type.description;
+            }
+            type.ast.directives.forEach(directive => {
+                interfaceTypeState.ast.directives.push(directive);
+            });
+            type.interfaces.forEach(interfaceName => interfaceTypeState.interfaces.add(interfaceName));
+            type.implementedBy.forEach(objectTypeName => interfaceTypeState.implementedBy.add(objectTypeName));
+            interfaceTypeState.byGraph.set(graph.id, {
+                extension: type.extension,
+                keys: type.keys,
+                interfaces: type.interfaces,
+                implementedBy: type.implementedBy,
+            });
+            for (const field of type.fields.values()) {
+                const fieldState = getOrCreateInterfaceField(interfaceTypeState, field.name, field.type);
+                field.tags.forEach(tag => fieldState.tags.add(tag));
+                if (!field.type.endsWith('!') && fieldState.type.endsWith('!')) {
+                    fieldState.type = field.type;
+                }
+                if (field.inaccessible) {
+                    fieldState.inaccessible = true;
+                }
+                if (field.deprecated && !fieldState.deprecated) {
+                    fieldState.deprecated = field.deprecated;
+                }
+                if (field.description && !fieldState.description) {
+                    fieldState.description = field.description;
+                }
+                field.ast.directives.forEach(directive => {
+                    fieldState.ast.directives.push(directive);
+                });
+                fieldState.byGraph.set(graph.id, {
+                    type: field.type,
+                    override: field.override,
+                    provides: field.provides,
+                    requires: field.requires,
+                });
+                for (const arg of field.args.values()) {
+                    const argState = getOrCreateArg(fieldState, arg.name, arg.type);
+                    arg.tags.forEach(tag => argState.tags.add(tag));
+                    if (arg.type.endsWith('!')) {
+                        argState.type = arg.type;
+                    }
+                    if (arg.deprecated && !argState.deprecated) {
+                        argState.deprecated = arg.deprecated;
+                    }
+                    if (arg.description && !argState.description) {
+                        argState.description = arg.description;
+                    }
+                    if (typeof arg.defaultValue === 'string') {
+                        argState.defaultValue = arg.defaultValue;
+                    }
+                    arg.ast.directives.forEach(directive => {
+                        argState.ast.directives.push(directive);
+                    });
+                    argState.byGraph.set(graph.id, {
+                        type: arg.type,
+                        defaultValue: arg.defaultValue,
+                    });
+                }
+            }
+        },
+        composeSupergraphNode(interfaceType, graphs) {
+            return (0, ast_js_1.createInterfaceTypeNode)({
+                name: interfaceType.name,
+                fields: Array.from(interfaceType.fields.values()).map(field => {
+                    return {
+                        name: field.name,
+                        type: field.type,
+                        inaccessible: field.inaccessible,
+                        tags: Array.from(field.tags),
+                        deprecated: field.deprecated,
+                        description: field.description,
+                        ast: {
+                            directives: (0, common_js_1.convertToConst)(field.ast.directives),
+                        },
+                        arguments: Array.from(field.args.values())
+                            .filter(arg => {
+                            if (arg.byGraph.size !== field.byGraph.size) {
+                                return false;
+                            }
+                            return true;
+                        })
+                            .map(arg => {
+                            return {
+                                name: arg.name,
+                                type: arg.type,
+                                tags: Array.from(arg.tags),
+                                defaultValue: arg.defaultValue,
+                                deprecated: arg.deprecated,
+                                description: arg.description,
+                                ast: {
+                                    directives: (0, common_js_1.convertToConst)(arg.ast.directives),
+                                },
+                            };
+                        }),
+                        join: {
+                            field: field.byGraph.size === interfaceType.byGraph.size
+                                ? []
+                                : Array.from(field.byGraph.entries()).map(([graphName, meta]) => ({
+                                    graph: graphName.toUpperCase(),
+                                    type: meta.type === field.type ? undefined : meta.type,
+                                    override: meta.override ?? undefined,
+                                    provides: meta.provides ?? undefined,
+                                    requires: meta.requires ?? undefined,
+                                })),
+                        },
+                    };
+                }),
+                tags: Array.from(interfaceType.tags),
+                inaccessible: interfaceType.inaccessible,
+                description: interfaceType.description,
+                interfaces: Array.from(interfaceType.interfaces),
+                ast: {
+                    directives: (0, common_js_1.convertToConst)(interfaceType.ast.directives),
+                },
+                join: {
+                    type: Array.from(interfaceType.byGraph)
+                        .map(([graphId, meta]) => {
+                        if (meta.keys.length && graphs.get(graphId).version !== 'v1.0') {
+                            return meta.keys.map(key => ({
+                                graph: graphId,
+                                key: key.fields,
+                                extension: meta.extension,
+                            }));
+                        }
+                        return [
+                            {
+                                graph: graphId,
+                            },
+                        ];
+                    })
+                        .flat(1),
+                    implements: interfaceType.interfaces.size > 0
+                        ? Array.from(interfaceType.byGraph.entries())
+                            .map(([graphId, meta]) => {
+                            if (meta.interfaces.size) {
+                                return Array.from(meta.interfaces).map(iface => ({
+                                    graph: graphId,
+                                    interface: iface,
+                                }));
+                            }
+                            return [];
+                        })
+                            .flat(1)
+                        : [],
+                },
+            });
+        },
+    };
+}
+exports.interfaceTypeBuilder = interfaceTypeBuilder;
+function getOrCreateInterfaceType(state, typeName) {
+    const existing = state.get(typeName);
+    if (existing) {
+        return existing;
+    }
+    const def = {
+        name: typeName,
+        tags: new Set(),
+        inaccessible: false,
+        hasDefinition: false,
+        byGraph: new Map(),
+        fields: new Map(),
+        interfaces: new Set(),
+        implementedBy: new Set(),
+        ast: {
+            directives: [],
+        },
+    };
+    state.set(typeName, def);
+    return def;
+}
+function getOrCreateInterfaceField(interfaceTypeState, fieldName, fieldType) {
+    const existing = interfaceTypeState.fields.get(fieldName);
+    if (existing) {
+        return existing;
+    }
+    const def = {
+        name: fieldName,
+        type: fieldType,
+        tags: new Set(),
+        inaccessible: false,
+        byGraph: new Map(),
+        args: new Map(),
+        ast: {
+            directives: [],
+        },
+    };
+    interfaceTypeState.fields.set(fieldName, def);
+    return def;
+}
+function getOrCreateArg(fieldState, argName, argType) {
+    const existing = fieldState.args.get(argName);
+    if (existing) {
+        return existing;
+    }
+    const def = {
+        name: argName,
+        type: argType,
+        tags: new Set(),
+        byGraph: new Map(),
+        ast: {
+            directives: [],
+        },
+    };
+    fieldState.args.set(argName, def);
+    return def;
+}