@theguild/federation-composition 0.9.0 → 0.10.0

package/esm/supergraph/validation/rules/satisfiablity/helpers.js

@@ -0,0 +1,35 @@
+export function occurrences(str, subString) {
+    if (subString.length <= 0) {
+        return str.length + 1;
+    }
+    let n = 0, pos = 0, step = subString.length;
+    while (true) {
+        pos = str.indexOf(subString, pos);
+        if (pos >= 0) {
+            ++n;
+            pos += step;
+        }
+        else
+            break;
+    }
+    return n;
+}
+export function scoreKeyFields(keyFields) {
+    const fields = occurrences(keyFields, ' ') + 1;
+    const innerSelectionSets = occurrences(keyFields, '{') * 3;
+    return fields + innerSelectionSets;
+}
+export function lazy(factory) {
+    let value;
+    return {
+        get() {
+            if (value === undefined) {
+                value = factory();
+            }
+            return value;
+        },
+        invalidate() {
+            value = undefined;
+        },
+    };
+}

package/esm/supergraph/validation/rules/satisfiablity/move-validator.js

@@ -0,0 +1,333 @@
+import { isEntityEdge, isFieldEdge } from './edge';
+import { SatisfiabilityError } from './errors';
+import { concatIfNotExistsFields, concatIfNotExistsString, PathFinder } from './finder';
+export class MoveValidator {
+    supergraph;
+    cache = new Map();
+    logger;
+    pathFinder;
+    constructor(logger, supergraph) {
+        this.supergraph = supergraph;
+        this.logger = logger.create('MoveValidator');
+        this.pathFinder = new PathFinder(this.logger, supergraph, this);
+    }
+    canResolveFields(fields, path, visitedEdges, visitedGraphs, visitedFields) {
+        const cacheKey = JSON.stringify(fields) +
+            ' | ' +
+            visitedGraphs.join(',') +
+            visitedFields.join(',') +
+            ' | ' +
+            visitedEdges
+                .map(e => e.toString())
+                .sort()
+                .join(',');
+        const cached = this.cache.get(cacheKey);
+        if (cached) {
+            return cached;
+        }
+        const requirements = [];
+        for (const field of fields) {
+            requirements.unshift({
+                field,
+                paths: [path.clone()],
+            });
+        }
+        while (requirements.length > 0) {
+            const requirement = requirements.pop();
+            if (!requirement) {
+                break;
+            }
+            const result = this.validateRequirement(requirement, visitedEdges, visitedGraphs, visitedFields);
+            if (result.success === false) {
+                this.cache.set(cacheKey, result);
+                return result;
+            }
+            for (const innerRequirement of result.requirements) {
+                requirements.unshift(innerRequirement);
+            }
+        }
+        this.cache.set(cacheKey, {
+            success: true,
+            errors: undefined,
+        });
+        return {
+            success: true,
+            errors: undefined,
+        };
+    }
+    validateRequirement(requirement, visitedEdges, visitedGraphs, visitedFields) {
+        const nextPaths = [];
+        const errors = [];
+        if ('type' in requirement) {
+            for (const path of requirement.paths) {
+                const directPathsResult = this.pathFinder.findDirectPaths(path, requirement.type.childTypeName, null, visitedEdges);
+                if (directPathsResult.success) {
+                    if (this.logger.isEnabled) {
+                        this.logger.log(() => 'Possible direct paths:');
+                        for (const path of directPathsResult.paths) {
+                            this.logger.log(() => ' ' + path.toString());
+                        }
+                    }
+                    nextPaths.push(...directPathsResult.paths);
+                }
+                else {
+                    errors.push(...directPathsResult.errors);
+                }
+            }
+            for (const path of requirement.paths) {
+                const indirectPathsResult = this.pathFinder.findIndirectPaths(path, requirement.type.childTypeName, null, visitedEdges, visitedGraphs, visitedFields);
+                if (indirectPathsResult.success) {
+                    if (this.logger.isEnabled) {
+                        this.logger.log(() => 'Possible indirect paths:');
+                        for (const path of indirectPathsResult.paths) {
+                            this.logger.log(() => ' ' + path.toString());
+                        }
+                    }
+                    nextPaths.push(...indirectPathsResult.paths);
+                }
+                else {
+                    errors.push(...indirectPathsResult.errors);
+                }
+            }
+            if (nextPaths.length === 0) {
+                if (this.logger.isEnabled) {
+                    this.logger.log(() => 'Could not resolve from:');
+                    for (const path of requirement.paths) {
+                        this.logger.log(() => ' ' + path.toString());
+                    }
+                }
+                return {
+                    success: false,
+                    errors,
+                };
+            }
+            if (!requirement.type.field) {
+                return {
+                    success: true,
+                    requirements: [],
+                };
+            }
+            return {
+                success: true,
+                requirements: [
+                    {
+                        field: requirement.type.field,
+                        paths: nextPaths.slice(),
+                    },
+                ],
+            };
+        }
+        const possibleTypes = this.supergraph.possibleTypesOf(requirement.field.typeName);
+        const needsAbstractMove = !possibleTypes.includes(requirement.field.typeName);
+        if (needsAbstractMove) {
+            const requirements = [];
+            for (const possibleType of possibleTypes) {
+                const abstractMoveRequirement = {
+                    type: {
+                        parentTypeName: requirement.field.typeName,
+                        childTypeName: possibleType,
+                        field: {
+                            ...requirement.field,
+                            typeName: possibleType,
+                        },
+                    },
+                    paths: requirement.paths,
+                };
+                requirements.push(abstractMoveRequirement);
+            }
+            this.logger.log(() => 'Abstract move');
+            return {
+                success: true,
+                requirements,
+            };
+        }
+        for (const path of requirement.paths) {
+            const directPathsResult = this.pathFinder.findDirectPaths(path, requirement.field.typeName, requirement.field.fieldName, visitedEdges);
+            if (directPathsResult.success) {
+                if (this.logger.isEnabled) {
+                    this.logger.log(() => 'Possible direct paths:');
+                    for (const path of directPathsResult.paths) {
+                        this.logger.log(() => ' ' + path.toString());
+                    }
+                }
+                nextPaths.push(...directPathsResult.paths);
+            }
+            else {
+                errors.push(...directPathsResult.errors);
+            }
+        }
+        for (const path of requirement.paths) {
+            const indirectPathsResult = this.pathFinder.findIndirectPaths(path, requirement.field.typeName, requirement.field.fieldName, visitedEdges, visitedGraphs, visitedFields);
+            if (indirectPathsResult.success) {
+                if (this.logger.isEnabled) {
+                    this.logger.log(() => 'Possible indirect paths:');
+                    for (const path of indirectPathsResult.paths) {
+                        this.logger.log(() => ' ' + path.toString());
+                    }
+                }
+                nextPaths.push(...indirectPathsResult.paths);
+            }
+            else {
+                errors.push(...indirectPathsResult.errors);
+            }
+        }
+        if (nextPaths.length === 0) {
+            this.logger.log(() => `Failed to resolve field ${requirement.field.typeName}.${requirement.field.fieldName} from:`);
+            if (this.logger.isEnabled) {
+                for (const path of requirement.paths) {
+                    this.logger.log(() => ` ` + path);
+                }
+            }
+            return {
+                success: false,
+                errors: errors.filter(e => e.isMatchingField(requirement.field.typeName, requirement.field.fieldName)),
+            };
+        }
+        if (!requirement.field.selectionSet || requirement.field.selectionSet.length === 0) {
+            return {
+                success: true,
+                requirements: [],
+            };
+        }
+        return {
+            success: true,
+            requirements: requirement.field.selectionSet.map(field => ({
+                field,
+                paths: nextPaths.slice(),
+            })),
+        };
+    }
+    isExternal(edge) {
+        if (!isFieldEdge(edge)) {
+            return false;
+        }
+        if (edge.move.provided) {
+            return false;
+        }
+        if (!edge.head.typeState) {
+            return false;
+        }
+        if (edge.head.typeState.kind !== 'object') {
+            return false;
+        }
+        const fieldState = edge.head.typeState.fields.get(edge.move.fieldName);
+        if (!fieldState) {
+            return false;
+        }
+        const objectTypeStateInGraph = edge.head.typeState.byGraph.get(edge.head.graphId);
+        if (!objectTypeStateInGraph) {
+            return false;
+        }
+        const fieldStateInGraph = fieldState.byGraph.get(edge.head.graphId);
+        if (!fieldStateInGraph) {
+            return false;
+        }
+        const external = fieldState.byGraph.get(edge.head.graphId)?.external ?? false;
+        if (!external) {
+            return false;
+        }
+        const isFedV1 = fieldStateInGraph.version === 'v1.0';
+        if (isFedV1 && objectTypeStateInGraph.extension && fieldState.usedAsKey) {
+            return false;
+        }
+        if (!fieldStateInGraph.usedAsKey) {
+            return true;
+        }
+        let hasNonExternalFields = false;
+        if (isFedV1) {
+            for (const [fieldName, fieldState] of edge.head.typeState.fields) {
+                if (fieldName === edge.move.fieldName) {
+                    continue;
+                }
+                const fieldStateInGraph = fieldState.byGraph.get(edge.head.graphId);
+                if (!fieldStateInGraph) {
+                    continue;
+                }
+                if (!fieldStateInGraph.external) {
+                    hasNonExternalFields = true;
+                    break;
+                }
+            }
+        }
+        if (hasNonExternalFields) {
+            return false;
+        }
+        if (objectTypeStateInGraph.extension) {
+            return false;
+        }
+        return true;
+    }
+    isOverridden(edge) {
+        if (!isFieldEdge(edge)) {
+            return false;
+        }
+        if (!edge.head.typeState) {
+            return false;
+        }
+        if (!edge.head.typeState || edge.head.typeState.kind !== 'object') {
+            return false;
+        }
+        const fieldState = edge.head.typeState.fields.get(edge.move.fieldName);
+        if (!fieldState) {
+            return false;
+        }
+        if (!fieldState.override) {
+            return false;
+        }
+        const overriddenGraphId = this.supergraph.graphNameToId(fieldState.override);
+        if (!overriddenGraphId) {
+            return false;
+        }
+        return edge.head.graphId === overriddenGraphId;
+    }
+    isEdgeResolvable(edge, path, visitedEdges, visitedGraphs, visitedFields) {
+        this.logger.group(() => 'Checking resolvability of ' + edge);
+        this.logger.log(() => 'Visited graphs: ' + visitedGraphs.join(','));
+        const resolvability = edge.getResolvability(concatIfNotExistsString(visitedGraphs, edge.tail.graphName));
+        if (resolvability) {
+            this.logger.groupEnd(() => resolvability.success
+                ? `Can move to ${edge}`
+                : `Cannot move to ${edge} (already visited: ${resolvability.error.kind})`);
+            return resolvability;
+        }
+        if (isFieldEdge(edge)) {
+            if (this.isOverridden(edge)) {
+                this.logger.groupEnd(() => 'Cannot move to ' + edge + ' because it is overridden');
+                return edge.setResolvable(false, visitedGraphs, SatisfiabilityError.forMissingField(edge.tail.graphName, edge.move.typeName, edge.move.fieldName));
+            }
+            if (edge.move.requires) {
+                this.logger.log(() => 'Detected @requires');
+                const newVisitedGraphs = concatIfNotExistsString(visitedGraphs, edge.tail.graphName);
+                const newVisitedFields = concatIfNotExistsFields(visitedFields, edge.move.requires);
+                this.logger.log(() => 'Visited graphs: ' + newVisitedGraphs.join(','));
+                if (this.canResolveFields(edge.move.requires.fields, path, visitedEdges.concat(edge), newVisitedGraphs, newVisitedFields).success) {
+                    this.logger.groupEnd(() => 'Can move to ' + edge);
+                    return edge.setResolvable(true, newVisitedGraphs);
+                }
+                this.logger.groupEnd(() => 'Cannot move to ' + edge + ' because @require is not resolvable');
+                return {
+                    success: false,
+                    error: SatisfiabilityError.forRequire(edge.head.graphName, edge.move.typeName, edge.move.fieldName),
+                };
+            }
+            else if (this.isExternal(edge)) {
+                this.logger.groupEnd(() => 'Cannot move to ' + edge + ' because it is external and cross-graph');
+                return edge.setResolvable(false, visitedGraphs, SatisfiabilityError.forExternal(edge.head.graphName, edge.move.typeName, edge.move.fieldName));
+            }
+        }
+        else if (isEntityEdge(edge)) {
+            this.logger.log(() => 'Detected @key');
+            const newVisitedGraphs = concatIfNotExistsString(visitedGraphs, edge.tail.graphName);
+            const newVisitedFields = concatIfNotExistsFields(visitedFields, edge.move.keyFields);
+            this.logger.log(() => 'Visited graphs: ' + newVisitedGraphs.join(','));
+            if (this.canResolveFields(edge.move.keyFields.fields, path, visitedEdges.concat(edge), newVisitedGraphs, newVisitedFields).success) {
+                this.logger.groupEnd(() => 'Can move to ' + edge);
+                return edge.setResolvable(true, newVisitedGraphs);
+            }
+            this.logger.groupEnd(() => 'Cannot move to ' + edge + ' because key fields are not resolvable');
+            return edge.setResolvable(false, newVisitedGraphs, SatisfiabilityError.forKey(edge.head.graphName, edge.tail.graphName, edge.head.typeName, edge.move.keyFields.toString()));
+        }
+        this.logger.groupEnd(() => 'Can move to ' + edge);
+        return edge.setResolvable(true, visitedGraphs);
+    }
+}

package/esm/supergraph/validation/rules/satisfiablity/moves.js

@@ -0,0 +1,46 @@
+import { lazy } from './helpers';
+export class FieldMove {
+    typeName;
+    fieldName;
+    requires;
+    provides;
+    provided;
+    _toString = lazy(() => {
+        let str = this.fieldName;
+        if (this.requires) {
+            str += ` @require(${this.requires})`;
+        }
+        if (this.provides) {
+            str += ` @provides(${this.provides})`;
+        }
+        if (this.provided) {
+            str += ' @provided';
+        }
+        return str;
+    });
+    constructor(typeName, fieldName, requires = null, provides = null, provided = false) {
+        this.typeName = typeName;
+        this.fieldName = fieldName;
+        this.requires = requires;
+        this.provides = provides;
+        this.provided = provided;
+    }
+    toString() {
+        return this._toString.get();
+    }
+}
+export class AbstractMove {
+    toString() {
+        return `🔮`;
+    }
+}
+export class EntityMove {
+    keyFields;
+    _toString = lazy(() => `🔑 ${this.keyFields}`);
+    constructor(keyFields) {
+        this.keyFields = keyFields;
+    }
+    toString() {
+        return this._toString.get();
+    }
+}

package/esm/supergraph/validation/rules/satisfiablity/node.js

@@ -0,0 +1,85 @@
+import { lazy } from './helpers';
+export class Node {
+    index;
+    typeName;
+    typeState;
+    graphId;
+    graphName;
+    _toString = lazy(() => `${this.typeName}/${this.graphName}`);
+    isLeaf = false;
+    childrenIndex = new Map();
+    visitedGraphCombos = [];
+    constructor(index, typeName, typeState, graphId, graphName) {
+        this.index = index;
+        this.typeName = typeName;
+        this.typeState = typeState;
+        this.graphId = graphId;
+        this.graphName = graphName;
+        if (this.typeState === undefined) {
+            throw new Error(`Expected typeState to be defined for ${typeName} in subgraph ${graphName}`);
+        }
+        if (this.typeState === null ||
+            this.typeState.kind === 'scalar' ||
+            this.typeState.kind === 'enum') {
+            this.isLeaf = true;
+        }
+    }
+    withoutState() {
+        this.childrenIndex = new Map();
+        this.visitedGraphCombos = [];
+        return this;
+    }
+    addFieldEdge(fieldName, edgeAt) {
+        const id = `field__${fieldName}`;
+        const indexes = this.childrenIndex.get(id);
+        if (indexes) {
+            if (!indexes.includes(edgeAt)) {
+                indexes.push(edgeAt);
+            }
+        }
+        else {
+            this.childrenIndex.set(id, [edgeAt]);
+        }
+    }
+    getFieldEdgeIndexes(fieldName) {
+        return this.childrenIndex.get(`field__${fieldName}`);
+    }
+    addEntityEdge(typeName, edgeAt) {
+        this.pushToChildrenIndex(`entity__${typeName}`, edgeAt);
+    }
+    getEntityEdgeIndexes(typeName) {
+        return this.childrenIndex.get(`entity__${typeName}`);
+    }
+    addAbstractEdge(typeName, edgeAt) {
+        this.pushToChildrenIndex(`abstract__${typeName}`, edgeAt);
+    }
+    getAbstractEdgeIndexes(typeName) {
+        return this.childrenIndex.get(`abstract__${typeName}`);
+    }
+    addCrossGraphEdge(typeName, edgeAt) {
+        this.pushToChildrenIndex(`cross-graph__${typeName}`, edgeAt);
+    }
+    getCrossGraphEdgeIndexes(typeName) {
+        return this.childrenIndex.get(`cross-graph__${typeName}`);
+    }
+    pushToChildrenIndex(id, edgeAt) {
+        const indexes = this.childrenIndex.get(id);
+        if (indexes) {
+            if (!indexes.includes(edgeAt)) {
+                indexes.push(edgeAt);
+            }
+        }
+        else {
+            this.childrenIndex.set(id, [edgeAt]);
+        }
+    }
+    isGraphComboVisited(graphNameProvidesCombos) {
+        return this.visitedGraphCombos.some(visitedGraphs => visitedGraphs.every(g => graphNameProvidesCombos.includes(g)));
+    }
+    setGraphComboAsVisited(graphNames) {
+        this.visitedGraphCombos.push(graphNames);
+    }
+    toString() {
+        return this._toString.get();
+    }
+}

package/esm/supergraph/validation/rules/satisfiablity/operation-path.js

@@ -0,0 +1,66 @@
+import { isFieldEdge } from './edge';
+import { lazy } from './helpers';
+export class OperationPath {
+    _rootNode;
+    _toString = lazy(() => {
+        let str = this._rootNode.toString();
+        for (let i = 0; i < this.previousEdges.length; i++) {
+            const edge = this.previousEdges[i];
+            if (edge) {
+                str += ` -(${edge.move})-> ${edge.tail}`;
+            }
+        }
+        return str;
+    });
+    previousNodes = [];
+    previousEdges = [];
+    previousSteps = [];
+    constructor(_rootNode) {
+        this._rootNode = _rootNode;
+    }
+    move(edge) {
+        this._toString.invalidate();
+        this.advance(edge);
+        return this;
+    }
+    clone() {
+        const newPath = new OperationPath(this._rootNode);
+        newPath.previousNodes = this.previousNodes.slice();
+        newPath.previousEdges = this.previousEdges.slice();
+        newPath.previousSteps = this.previousSteps.slice();
+        return newPath;
+    }
+    depth() {
+        return this.previousEdges.length;
+    }
+    edge() {
+        return this.previousEdges[this.previousEdges.length - 1];
+    }
+    steps() {
+        return this.previousSteps;
+    }
+    tail() {
+        return this.edge()?.tail;
+    }
+    rootNode() {
+        return this._rootNode;
+    }
+    isVisitedEdge(edge) {
+        return this.previousEdges.includes(edge);
+    }
+    toString() {
+        return this._toString.get();
+    }
+    advance(edge) {
+        this.previousEdges.push(edge);
+        this.previousNodes.push(edge.head);
+        this.previousSteps.push(isFieldEdge(edge)
+            ? {
+                typeName: edge.move.typeName,
+                fieldName: edge.move.fieldName,
+            }
+            : {
+                typeName: edge.tail.typeName,
+            });
+    }
+}

package/esm/supergraph/validation/rules/satisfiablity/supergraph.js

@@ -0,0 +1,33 @@
+import { Logger, LoggerContext } from '../../../../utils/logger';
+import { SUPERGRAPH_ID } from './constants';
+import { FieldsResolver } from './fields';
+import { Graph } from './graph';
+import { MoveValidator } from './move-validator';
+import { Walker } from './walker';
+export class Supergraph {
+    supergraph;
+    mergedGraph;
+    fieldsResolver;
+    moveRequirementChecker;
+    logger = new Logger('Supergraph', new LoggerContext());
+    constructor(supergraphState) {
+        this.fieldsResolver = new FieldsResolver(supergraphState);
+        this.supergraph = new Graph(this.logger, SUPERGRAPH_ID, 'supergraph', supergraphState, this.fieldsResolver, true);
+        this.mergedGraph = new Graph(this.logger, SUPERGRAPH_ID, 'merged', supergraphState, this.fieldsResolver);
+        for (const [id, subgraphState] of supergraphState.subgraphs) {
+            this.mergedGraph.addSubgraph(new Graph(this.logger, id, subgraphState.graph.name, supergraphState, this.fieldsResolver, false)
+                .addFromRoots()
+                .addFromEntities()
+                .addUnreachableTypes());
+        }
+        this.mergedGraph.joinSubgraphs();
+        this.supergraph.addFromRoots();
+        this.moveRequirementChecker = new MoveValidator(this.logger, this.mergedGraph);
+    }
+    validate() {
+        return new Walker(this.logger, this.moveRequirementChecker, this.supergraph, this.mergedGraph).walk('dfs');
+    }
+    validateOperation(operation, steps) {
+        return new Walker(this.logger, this.moveRequirementChecker, this.supergraph, this.mergedGraph).walkTrail(operation, steps);
+    }
+}