@theguild/federation-composition 0.9.0 → 0.10.0

package/cjs/supergraph/validation/rules/satisfiablity/finder.js

@@ -0,0 +1,267 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PathFinder = exports.concatIfNotExistsFields = exports.concatIfNotExistsString = void 0;
+const edge_1 = require("./edge");
+const errors_1 = require("./errors");
+function concatIfNotExistsString(list, item) {
+    if (list.includes(item)) {
+        return list;
+    }
+    return list.concat(item);
+}
+exports.concatIfNotExistsString = concatIfNotExistsString;
+function concatIfNotExistsFields(list, item) {
+    if (list.some(f => f.equals(item))) {
+        return list;
+    }
+    return list.concat(item);
+}
+exports.concatIfNotExistsFields = concatIfNotExistsFields;
+class PathFinder {
+    logger;
+    graph;
+    moveValidator;
+    constructor(logger, graph, moveValidator) {
+        this.logger = logger;
+        this.graph = graph;
+        this.moveValidator = moveValidator;
+    }
+    findDirectPaths(path, typeName, fieldName, visitedEdges) {
+        const nextPaths = [];
+        const errors = [];
+        const tail = path.tail() ?? path.rootNode();
+        const isFieldTarget = fieldName !== null;
+        const id = isFieldTarget ? `${typeName}.${fieldName}` : `... on ${typeName}`;
+        this.logger.group(() => 'Direct paths to ' + id + ' from: ' + tail);
+        const edges = isFieldTarget
+            ? this.graph.fieldEdgesOfHead(tail, fieldName)
+            : this.graph.abstractEdgesOfHead(tail);
+        this.logger.log(() => 'Checking ' + edges.length + ' edges');
+        let i = 0;
+        for (const edge of edges) {
+            this.logger.group(() => 'Checking #' + i++ + ' ' + edge);
+            if (edge.isCrossGraphEdge()) {
+                this.logger.groupEnd(() => 'Cross graph edge: ' + edge);
+                continue;
+            }
+            if (visitedEdges.includes(edge)) {
+                this.logger.groupEnd(() => 'Already visited: ' + edge);
+                continue;
+            }
+            if (!isFieldTarget) {
+                if ((0, edge_1.isAbstractEdge)(edge) && edge.tail.typeName === typeName) {
+                    this.logger.groupEnd(() => 'Resolvable: ' + edge);
+                    const newPath = path.clone().move(edge);
+                    nextPaths.push(newPath);
+                    continue;
+                }
+            }
+            if (isFieldTarget &&
+                (0, edge_1.isFieldEdge)(edge) &&
+                edge.move.typeName === typeName &&
+                edge.move.fieldName === fieldName) {
+                const resolvable = this.moveValidator.isEdgeResolvable(edge, path, [], [], []);
+                if (!resolvable.success) {
+                    errors.push(resolvable.error);
+                    this.logger.groupEnd(() => 'Not resolvable: ' + edge);
+                    continue;
+                }
+                this.logger.groupEnd(() => 'Resolvable: ' + edge);
+                const newPath = path.clone().move(edge);
+                nextPaths.push(newPath);
+                continue;
+            }
+            this.logger.groupEnd(() => 'Not matching');
+        }
+        this.logger.groupEnd(() => 'Found ' + nextPaths.length + ' direct paths');
+        if (nextPaths.length === 0) {
+            if (errors.length === 0) {
+                if (isFieldTarget) {
+                    errors.push(errors_1.SatisfiabilityError.forMissingField(tail.graphName, typeName, fieldName));
+                    const typeNodes = this.graph.nodesOf(typeName);
+                    for (const typeNode of typeNodes) {
+                        const edges = this.graph.fieldEdgesOfHead(typeNode, fieldName);
+                        for (const edge of edges) {
+                            if ((0, edge_1.isFieldEdge)(edge) &&
+                                edge.move.typeName === typeName &&
+                                edge.move.fieldName === fieldName &&
+                                !this.moveValidator.isExternal(edge)) {
+                                const typeStateInGraph = edge.head.typeState &&
+                                    edge.head.typeState.kind === 'object' &&
+                                    edge.head.typeState.byGraph.get(edge.head.graphId);
+                                const keys = typeStateInGraph
+                                    ? typeStateInGraph.keys.filter(key => key.resolvable)
+                                    : [];
+                                if (keys.length === 0) {
+                                    errors.push(errors_1.SatisfiabilityError.forNoKey(tail.graphName, edge.tail.graphName, typeName, fieldName));
+                                }
+                            }
+                        }
+                    }
+                }
+                else {
+                    return {
+                        success: true,
+                        errors: undefined,
+                        paths: [],
+                    };
+                }
+            }
+            return {
+                success: false,
+                errors,
+                paths: undefined,
+            };
+        }
+        return {
+            success: true,
+            paths: nextPaths,
+            errors: undefined,
+        };
+    }
+    findIndirectPaths(path, typeName, fieldName, visitedEdges, visitedGraphs, visitedFields) {
+        const errors = [];
+        const tail = path.tail() ?? path.rootNode();
+        const sourceGraphName = tail.graphName;
+        const isFieldTarget = fieldName !== null;
+        const id = isFieldTarget ? `${typeName}.${fieldName}` : `... on ${typeName}`;
+        this.logger.group(() => 'Indirect paths to ' + id + ' from: ' + tail);
+        const queue = [[visitedGraphs, visitedFields, path]];
+        const finalPaths = [];
+        const shortestPathPerGraph = new Map();
+        const edgesToIgnore = visitedEdges.slice();
+        while (queue.length > 0) {
+            const item = queue.pop();
+            if (!item) {
+                throw new Error('Unexpected end of queue');
+            }
+            const [visitedGraphs, visitedFields, path] = item;
+            const tail = path.tail() ?? path.rootNode();
+            const edges = this.graph.crossGraphEdgesOfHead(tail);
+            if (!this.graph.canReachTypeFromType(tail.typeName, typeName)) {
+                this.logger.log(() => 'Cannot reach ' + typeName + ' from ' + tail.typeName);
+                continue;
+            }
+            this.logger.log(() => 'At path: ' + path);
+            this.logger.log(() => 'Checking ' + edges.length + ' edges');
+            let i = 0;
+            for (const edge of edges) {
+                this.logger.group(() => 'Checking #' + i++ + ' ' + edge);
+                this.logger.log(() => 'Visited graphs: ' + visitedGraphs.join(','));
+                if (visitedGraphs.includes(edge.tail.graphName)) {
+                    this.logger.groupEnd(() => 'Ignore: already visited graph');
+                    continue;
+                }
+                if (!edge.isCrossGraphEdge()) {
+                    this.logger.groupEnd(() => 'Not cross-graph edge');
+                    continue;
+                }
+                if (edgesToIgnore.includes(edge)) {
+                    this.logger.groupEnd(() => 'Ignore: already visited edge');
+                    continue;
+                }
+                if (edge.tail.graphName === sourceGraphName && !(0, edge_1.isAbstractEdge)(edge)) {
+                    this.logger.groupEnd(() => 'Ignore: we are back to the same graph');
+                    continue;
+                }
+                if (isFieldTarget && (0, edge_1.isEntityEdge)(edge)) {
+                    if (visitedFields.some(f => f.equals(edge.move.keyFields))) {
+                        this.logger.groupEnd(() => 'Ignore: already visited fields');
+                        continue;
+                    }
+                    const shortestPathToThisGraph = shortestPathPerGraph.get(edge.tail.graphName);
+                    if (shortestPathToThisGraph && shortestPathToThisGraph.depth() <= path.depth()) {
+                        this.logger.groupEnd(() => 'Already found a shorter path to ' + edge.tail);
+                        continue;
+                    }
+                    const resolvable = this.moveValidator.isEdgeResolvable(edge, path, edgesToIgnore.concat(edge), visitedGraphs, visitedFields);
+                    if (!resolvable.success) {
+                        errors.push(resolvable.error);
+                        this.logger.groupEnd(() => 'Not resolvable: ' + resolvable.error);
+                        continue;
+                    }
+                    const newPath = path.clone().move(edge);
+                    this.logger.log(() => 'From indirect path, look for direct paths to ' + id + ' from: ' + edge);
+                    const direct = this.findDirectPaths(newPath, typeName, fieldName, [edge]);
+                    if (direct.success) {
+                        this.logger.groupEnd(() => 'Resolvable: ' + edge + ' with ' + direct.paths.length + ' paths');
+                        finalPaths.push(...direct.paths);
+                        continue;
+                    }
+                    errors.push(...direct.errors);
+                    setShortest(newPath, shortestPathPerGraph);
+                    queue.push([
+                        concatIfNotExistsString(visitedGraphs, edge.tail.graphName),
+                        concatIfNotExistsFields(visitedFields, edge.move.keyFields),
+                        newPath,
+                    ]);
+                    this.logger.log(() => 'Did not find direct paths');
+                    this.logger.groupEnd(() => 'Adding to queue: ' + newPath);
+                }
+                else if (isFieldTarget && (0, edge_1.isFieldEdge)(edge)) {
+                    this.logger.log(() => 'Cross graph field move:' + edge.move);
+                    if (path.isVisitedEdge(edge)) {
+                        this.logger.groupEnd(() => 'Already visited');
+                        continue;
+                    }
+                    if (isFieldTarget && edge.move.requires?.contains(typeName, fieldName)) {
+                        errors.push(errors_1.SatisfiabilityError.forRequire(tail.graphName, typeName, fieldName));
+                        this.logger.groupEnd(() => 'Ignored');
+                        continue;
+                    }
+                    if (edge.move.requires && visitedFields.some(f => f.equals(edge.move.requires))) {
+                        this.logger.groupEnd(() => 'Ignore: already visited fields');
+                        continue;
+                    }
+                    const resolvable = this.moveValidator.isEdgeResolvable(edge, path, visitedEdges.concat(edge), visitedGraphs, edge.move.requires
+                        ? concatIfNotExistsFields(visitedFields, edge.move.requires)
+                        : visitedFields);
+                    if (!resolvable.success) {
+                        errors.push(resolvable.error);
+                        this.logger.groupEnd(() => 'Not resolvable: ' + resolvable.error);
+                        continue;
+                    }
+                    setShortest(path.clone().move(edge), shortestPathPerGraph);
+                    this.logger.groupEnd(() => 'Resolvable: ' + edge);
+                }
+                else if (!isFieldTarget && (0, edge_1.isAbstractEdge)(edge)) {
+                    if (shortestPathPerGraph.has(edge.tail.graphName)) {
+                        this.logger.groupEnd(() => 'Already found a shorter path to ' + edge.tail);
+                        continue;
+                    }
+                    const newPath = path.clone().move(edge);
+                    setShortest(newPath, shortestPathPerGraph);
+                    finalPaths.push(newPath);
+                    this.logger.groupEnd(() => 'Resolvable');
+                }
+                else {
+                    this.logger.groupEnd(() => 'Ignored...');
+                }
+            }
+        }
+        this.logger.groupEnd(() => 'Found ' + finalPaths.length + ' indirect paths');
+        if (finalPaths.length === 0) {
+            return {
+                success: false,
+                errors,
+                paths: undefined,
+            };
+        }
+        return {
+            success: true,
+            paths: finalPaths,
+            errors: undefined,
+        };
+    }
+}
+exports.PathFinder = PathFinder;
+function setShortest(path, shortestPathPerGraph) {
+    const edge = path.edge();
+    if (!edge) {
+        throw new Error('Unexpected end of path');
+    }
+    const shortest = shortestPathPerGraph.get(edge.tail.graphName);
+    if (!shortest || shortest.depth() > path.depth()) {
+        shortestPathPerGraph.set(edge.tail.graphName, path);
+    }
+}