@wundergraph/composition 0.46.0 → 0.46.1

package/dist/resolvability-graph/graph.js

@@ -2,25 +2,26 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Graph = void 0;
 const graph_nodes_1 = require("./graph-nodes");
-const utils_1 = require("./utils");
-const string_constants_1 = require("../utils/string-constants");
+const utils_1 = require("./utils/utils");
 const utils_2 = require("../utils/utils");
+const string_constants_1 = require("./constants/string-constants");
+const entity_walker_1 = require("./walker/entity-walker/entity-walker");
+const root_field_walker_1 = require("./walker/root-field-walkers/root-field-walker");
 class Graph {
     edgeId = -1;
-    entityDataNodes = new Map();
-    entityNodeNamesBySharedFieldPath = new Map();
+    entityDataNodeByTypeName = new Map();
     nodeByNodeName = new Map();
     nodesByTypeName = new Map();
-    rootNodeByRootTypeName = new Map();
+    resolvedRootFieldNodeNames = new Set();
+    rootNodeByTypeName = new Map();
     subgraphName = string_constants_1.NOT_APPLICABLE;
-    resolvableFieldNamesByRelativeFieldPathByEntityNodeName = new Map();
-    nodeResolutionDataByFieldPath = new Map();
-    unresolvableFieldPaths = new Set();
-    failureResultByEntityNodeName = new Map();
+    resDataByNodeName = new Map();
+    resDataByRelativePathByEntity = new Map();
+    visitedEntitiesByOriginEntity = new Map();
     walkerIndex = -1;
     constructor() { }
     getRootNode(typeName) {
-        return (0, utils_2.getValueOrDefault)(this.rootNodeByRootTypeName, typeName, () => new graph_nodes_1.RootNode(typeName));
+        return (0, utils_2.getValueOrDefault)(this.rootNodeByTypeName, typeName, () => new graph_nodes_1.RootNode(typeName));
     }
     addOrUpdateNode(typeName, options) {
         const nodeName = `${this.subgraphName}.${typeName}`;
@@ -40,7 +41,7 @@ class Graph {
     addEdge(headNode, tailNode, fieldName, isAbstractEdge = false) {
         if (headNode.isRootNode) {
             const edge = new graph_nodes_1.Edge(this.getNextEdgeId(), tailNode, fieldName);
-            (0, utils_2.getValueOrDefault)(headNode.headToShareableTailEdges, fieldName, () => []).push(edge);
+            (0, utils_2.getValueOrDefault)(headNode.headToSharedTailEdges, fieldName, () => []).push(edge);
             return edge;
         }
         const headGraphNode = headNode;
@@ -49,17 +50,20 @@ class Graph {
         return headToTailEdge;
     }
     addEntityDataNode(typeName) {
-        const node = this.entityDataNodes.get(typeName);
+        const node = this.entityDataNodeByTypeName.get(typeName);
         if (node) {
             return node;
         }
         const newNode = new graph_nodes_1.EntityDataNode(typeName);
-        this.entityDataNodes.set(typeName, newNode);
+        this.entityDataNodeByTypeName.set(typeName, newNode);
         return newNode;
     }
     getNextEdgeId() {
         return (this.edgeId += 1);
     }
+    getNextWalkerIndex() {
+        return (this.walkerIndex += 1);
+    }
     setNodeInaccessible(typeName) {
         const nodes = this.nodesByTypeName.get(typeName);
         if (!nodes) {
@@ -69,12 +73,12 @@ class Graph {
             node.isInaccessible = true;
         }
     }
-    initializeNode(typeName, fieldDataByFieldName) {
-        const entityDataNode = this.entityDataNodes.get(typeName);
+    initializeNode(typeName, fieldDataByName) {
+        const entityDataNode = this.entityDataNodeByTypeName.get(typeName);
         if (string_constants_1.ROOT_TYPE_NAMES.has(typeName)) {
             const rootNode = this.getRootNode(typeName);
-            rootNode.removeInaccessibleEdges(fieldDataByFieldName);
-            rootNode.fieldDataByFieldName = fieldDataByFieldName;
+            rootNode.removeInaccessibleEdges(fieldDataByName);
+            rootNode.fieldDataByName = fieldDataByName;
             return;
         }
         const nodes = this.nodesByTypeName.get(typeName);
@@ -82,7 +86,7 @@ class Graph {
             return;
         }
         for (const node of nodes) {
-            node.fieldDataByFieldName = fieldDataByFieldName;
+            node.fieldDataByName = fieldDataByName;
             node.handleInaccessibleEdges();
             node.isLeaf = false;
             if (!entityDataNode) {
@@ -91,7 +95,7 @@ class Graph {
             node.hasEntitySiblings = true;
             for (const fieldSet of node.satisfiedFieldSets) {
                 const subgraphNames = entityDataNode.targetSubgraphNamesByFieldSet.get(fieldSet);
-                for (const subgraphName of subgraphNames || []) {
+                for (const subgraphName of subgraphNames ?? []) {
                     // A subgraph should not jump to itself
                     if (subgraphName === node.subgraphName) {
                         continue;
@@ -107,300 +111,294 @@ class Graph {
     setSubgraphName(subgraphName) {
         this.subgraphName = subgraphName;
     }
-    validateEntities(entityNodeNamesBySharedFieldPath, rootFieldData) {
-        const nestedEntityNodeNamesBySharedFieldPathByParentNodeName = new Map();
-        for (const [sharedFieldPath, entityNodeNames] of entityNodeNamesBySharedFieldPath) {
-            const isFieldShared = entityNodeNames.size > 1;
-            let failureResult;
-            /* In the event of a shared entity field, the validation changes slightly.
-             * The fields are linked through a mutual entity ancestor, and may/may not have additional routing through a key.
-             * In this case, the following must occur:
-             * 1. sharedResolvableFieldNamesByRelativeFieldPath will be created and passed to ensure the resolvability of
-             * paths are assessed collectively, rather than by a single instance of the shared fields
-             * */
-            const sharedResolvableFieldNamesByRelativeFieldPath = isFieldShared
-                ? new Map()
-                : undefined;
-            /*
-             * 2. unresolvableSharedFieldPaths is used to determine whether there are still unresolvable paths even after
-             * all shared fields have been analysed.
-             * */
-            const unresolvableSharedFieldPaths = new Set();
-            /*
-             * 3. nestedEntityNodeNamesBySharedFieldPath should be a reference to the same set, to ensure nested shared fields
-             * are analysed as shared fields when moving deeper.
-             * */
-            const sharedNestedEntityNodeNamesBySharedFieldPath = new Map();
-            for (const entityNodeName of entityNodeNames) {
-                const entityNode = this.nodeByNodeName.get(entityNodeName);
-                if (!entityNode) {
-                    throw new Error(`Fatal: Could not find entity node for "${entityNodeName}".`);
-                }
-                const resolvableFieldNamesByRelativeFieldPath = this.resolvableFieldNamesByRelativeFieldPathByEntityNodeName.get(entityNodeName);
-                if (resolvableFieldNamesByRelativeFieldPath) {
-                    // If at least one of the referenced entities is always fully resolvable, the path is resolvable.
-                    const entityFailureResult = this.failureResultByEntityNodeName.get(entityNodeName);
-                    if (!entityFailureResult) {
-                        failureResult = undefined;
-                        break;
-                    }
-                    // If the path is shared, it must be assessed collectively
-                    if (!isFieldShared) {
-                        return entityFailureResult;
-                    }
-                }
-                const interSubgraphNodes = this.nodesByTypeName.get(entityNode.typeName) || [];
-                const nestedEntityNodeNamesBySharedFieldPath = (0, utils_2.getValueOrDefault)(nestedEntityNodeNamesBySharedFieldPathByParentNodeName, entityNodeName, () => (isFieldShared ? sharedNestedEntityNodeNamesBySharedFieldPath : new Map()));
-                const walker = new Walker({
-                    interSubgraphNodes,
-                    entityNodeNamesBySharedFieldPath: nestedEntityNodeNamesBySharedFieldPath,
-                    originNode: entityNode,
-                    resolvableFieldNamesByRelativeFieldPathByEntityNodeName: this.resolvableFieldNamesByRelativeFieldPathByEntityNodeName,
-                    walkerIndex: (this.walkerIndex += 1),
-                    sharedResolvableFieldNamesByRelativeFieldPath,
-                    unresolvableSharedFieldPaths,
-                });
-                walker.visitEntityNode(entityNode);
-                if (walker.unresolvableFieldPaths.size > 0) {
-                    if (isFieldShared && unresolvableSharedFieldPaths.size < 1) {
-                        failureResult = undefined;
-                        break;
-                    }
-                    failureResult = {
-                        entityAncestorData: {
-                            fieldSetsByTargetSubgraphName: (0, utils_2.getOrThrowError)(this.entityDataNodes, entityNode.typeName, 'entityDataNodes').fieldSetsByTargetSubgraphName,
-                            subgraphName: entityNode.subgraphName,
-                            typeName: entityNode.typeName,
-                        },
-                        nodeName: entityNodeName,
-                        parentFieldPathForEntityReference: [sharedFieldPath],
-                        success: false,
-                        typeName: entityNode.typeName,
-                        unresolvableFieldPaths: isFieldShared ? unresolvableSharedFieldPaths : walker.unresolvableFieldPaths,
-                    };
-                    this.failureResultByEntityNodeName.set(entityNodeName, failureResult);
-                    continue;
-                }
-                // In a shared path, only a single instance need succeed
-                failureResult = undefined;
-                break;
+    visitEntity({ encounteredEntityNodeNames, entityNodeName, relativeOriginPaths, resDataByRelativeOriginPath, subgraphNameByUnresolvablePath, visitedEntities, }) {
+        const entityNode = this.nodeByNodeName.get(entityNodeName);
+        if (!entityNode) {
+            throw new Error(`Fatal: Could not find entity node for "${entityNodeName}".`);
+        }
+        visitedEntities.add(entityNodeName);
+        const interSubgraphNodes = this.nodesByTypeName.get(entityNode.typeName);
+        if (!interSubgraphNodes?.length) {
+            throw new Error(`Fatal: Could not find any nodes for "${entityNodeName}".`);
+        }
+        const walker = new entity_walker_1.EntityWalker({
+            encounteredEntityNodeNames,
+            index: this.getNextWalkerIndex(),
+            relativeOriginPaths,
+            resDataByNodeName: this.resDataByNodeName,
+            resDataByRelativeOriginPath,
+            subgraphNameByUnresolvablePath,
+            visitedEntities,
+        });
+        const accessibleEntityNodeNames = entityNode.getAllAccessibleEntityNodeNames();
+        for (const siblingEntityNode of interSubgraphNodes) {
+            if (siblingEntityNode.nodeName !== entityNode.nodeName &&
+                !accessibleEntityNodeNames.has(siblingEntityNode.nodeName)) {
+                continue;
             }
-            if (failureResult) {
-                if (isFieldShared && sharedResolvableFieldNamesByRelativeFieldPath) {
-                    this.resolvableFieldNamesByRelativeFieldPathByEntityNodeName.set(failureResult.nodeName, sharedResolvableFieldNamesByRelativeFieldPath);
-                }
-                return failureResult;
+            const { areDescendantsResolved } = walker.visitEntityDescendantConcreteNode({
+                node: siblingEntityNode,
+                selectionPath: '',
+            });
+            // All fields and descendent fields are resolved; nothing more to do for this entity.
+            if (areDescendantsResolved) {
+                return;
             }
         }
-        if (nestedEntityNodeNamesBySharedFieldPathByParentNodeName.size > 0) {
-            for (const [parentNodeName, fieldPathsByNestedNodeName,] of nestedEntityNodeNamesBySharedFieldPathByParentNodeName) {
-                const result = this.validateEntities(fieldPathsByNestedNodeName, rootFieldData);
-                if (result.success) {
-                    continue;
-                }
-                for (const [sharedFieldPath, entityNodeNames] of entityNodeNamesBySharedFieldPath) {
-                    if (!entityNodeNames.has(parentNodeName)) {
-                        continue;
-                    }
-                    result.parentFieldPathForEntityReference.push(sharedFieldPath);
-                    break;
-                }
-                return result;
-            }
+        // Because of shared entity descendant paths, we can only assess the errors after checking all nested entities.
+        for (const [nestedEntityNodeName, selectionPath] of walker.selectionPathByEntityNodeName) {
+            /* Short circuiting on failures here can cause false positives.
+             * For example, an Object that is an entity at least one graph and defines at least one unique (nested) field.
+             * If that Object has no accessible keys but is accessible through an ancestor, short-circuiting here would
+             * produce an error before that shared path has been visited.
+             */
+            this.visitEntity({
+                encounteredEntityNodeNames,
+                entityNodeName: nestedEntityNodeName,
+                relativeOriginPaths: (0, utils_1.getMultipliedRelativeOriginPaths)({
+                    relativeOriginPaths,
+                    selectionPath: selectionPath,
+                }),
+                resDataByRelativeOriginPath,
+                subgraphNameByUnresolvablePath,
+                visitedEntities,
+            });
         }
-        return { success: true };
     }
     validate() {
-        const errors = [];
-        for (const rootNode of this.rootNodeByRootTypeName.values()) {
-            shareableRootFieldLoop: for (const [rootFieldName, shareableRootFieldEdges,] of rootNode.headToShareableTailEdges) {
-                for (const rootFieldEdge of shareableRootFieldEdges) {
-                    if (rootFieldEdge.isInaccessible) {
-                        continue shareableRootFieldLoop;
+        for (const rootNode of this.rootNodeByTypeName.values()) {
+            for (const [rootFieldName, sharedRootFieldEdges] of rootNode.headToSharedTailEdges) {
+                const isSharedRootField = sharedRootFieldEdges.length > 1;
+                if (!isSharedRootField) {
+                    const namedTypeNodeName = sharedRootFieldEdges[0].node.nodeName;
+                    if (this.resolvedRootFieldNodeNames.has(namedTypeNodeName)) {
+                        continue;
                     }
-                    this.walkerIndex += 1;
-                    this.visitEdge(rootFieldEdge, `${rootNode.typeName.toLowerCase()}`);
+                    this.resolvedRootFieldNodeNames.add(namedTypeNodeName);
                 }
-                const fieldData = (0, utils_2.getOrThrowError)(rootNode.fieldDataByFieldName, rootFieldName, 'fieldDataByFieldName');
-                const rootFieldData = (0, utils_1.newRootFieldData)(rootNode.typeName, rootFieldName, fieldData.subgraphNames);
-                if (this.unresolvableFieldPaths.size > 0) {
-                    (0, utils_1.generateResolvabilityErrors)({
-                        unresolvableFieldPaths: this.unresolvableFieldPaths,
-                        nodeResolutionDataByFieldPath: this.nodeResolutionDataByFieldPath,
-                        rootFieldData,
-                        errors,
-                    });
+                const rootFieldWalker = new root_field_walker_1.RootFieldWalker({
+                    index: this.getNextWalkerIndex(),
+                    nodeResolutionDataByNodeName: this.resDataByNodeName,
+                });
+                if (rootFieldWalker.visitRootFieldEdges({
+                    edges: sharedRootFieldEdges,
+                    rootTypeName: rootNode.typeName.toLowerCase(),
+                }).areDescendantsResolved) {
+                    continue;
                 }
-                if (this.entityNodeNamesBySharedFieldPath.size > 0) {
-                    const result = this.validateEntities(this.entityNodeNamesBySharedFieldPath, rootFieldData);
-                    if (!result.success) {
-                        this.generateEntityResolvabilityErrors(result, rootFieldData, errors);
-                    }
+                const involvesEntities = isSharedRootField
+                    ? rootFieldWalker.entityNodeNamesByPath.size > 0
+                    : rootFieldWalker.pathsByEntityNodeName.size > 0;
+                if (rootFieldWalker.unresolvablePaths.size < 1 && !involvesEntities) {
+                    continue;
                 }
-                if (errors.length > 0) {
-                    return errors;
+                const fieldData = (0, utils_2.getOrThrowError)(rootNode.fieldDataByName, rootFieldName, 'fieldDataByName');
+                const rootFieldData = (0, utils_1.newRootFieldData)(rootNode.typeName, rootFieldName, fieldData.subgraphNames);
+                // If there are no nested entities, then the unresolvable fields must be impossible to resolve.
+                if (!involvesEntities) {
+                    return {
+                        errors: (0, utils_1.generateRootResolvabilityErrors)({
+                            unresolvablePaths: rootFieldWalker.unresolvablePaths,
+                            resDataByPath: rootFieldWalker.resDataByPath,
+                            rootFieldData,
+                        }),
+                        success: false,
+                    };
+                }
+                const result = this.validateEntities({ isSharedRootField, rootFieldData, walker: rootFieldWalker });
+                if (!result.success) {
+                    return result;
                 }
-                this.entityNodeNamesBySharedFieldPath = new Map();
             }
         }
-        return [];
+        return {
+            success: true,
+        };
     }
-    // Returns true if the edge is visited and false otherwise (e.g., inaccessible)
-    visitEdge(edge, fieldPath) {
-        if (edge.isInaccessible || edge.node.isInaccessible) {
-            return false;
-        }
-        if (!(0, utils_2.add)(edge.visitedIndices, this.walkerIndex) || edge.node.isLeaf) {
-            return true;
-        }
-        if (edge.node.isAbstract) {
-            this.validateAbstractNode(edge.node, `${fieldPath}.${edge.edgeName}`);
-        }
-        else {
-            this.validateConcreteNode(edge.node, `${fieldPath}.${edge.edgeName}`);
-        }
-        return true;
-    }
-    validateConcreteNode(node, fieldPath) {
-        if (node.headToTailEdges.size < 1) {
-            return;
-        }
-        if (node.hasEntitySiblings) {
-            (0, utils_2.getValueOrDefault)(this.entityNodeNamesBySharedFieldPath, fieldPath, () => new Set()).add(node.nodeName);
-            return;
-        }
-        const resolvedFieldNames = (0, utils_2.getValueOrDefault)(this.nodeResolutionDataByFieldPath, fieldPath, () => new utils_1.NodeResolutionData(node.typeName, node.fieldDataByFieldName));
-        for (const [fieldName, edge] of node.headToTailEdges) {
-            // Returns true if the edge was visited
-            if (this.visitEdge(edge, fieldPath)) {
-                resolvedFieldNames.add(fieldName);
+    consolidateUnresolvableRootWithEntityPaths({ pathFromRoot, resDataByRelativeOriginPath, subgraphNameByUnresolvablePath, walker, }) {
+        for (const unresolvableRootPath of walker.unresolvablePaths) {
+            if (!unresolvableRootPath.startsWith(pathFromRoot)) {
+                continue;
             }
-        }
-        if (resolvedFieldNames.isResolved) {
-            this.unresolvableFieldPaths.delete(fieldPath);
-        }
-        else {
-            this.unresolvableFieldPaths.add(fieldPath);
-        }
-    }
-    validateAbstractNode(node, fieldPath) {
-        if (node.headToTailEdges.size < 1) {
-            return;
-        }
-        for (const edge of node.headToTailEdges.values()) {
-            this.visitEdge(edge, fieldPath);
+            const relativePath = unresolvableRootPath.slice(pathFromRoot.length);
+            const rootResData = (0, utils_2.getOrThrowError)(walker.resDataByPath, unresolvableRootPath, `rootFieldWalker.unresolvablePaths`);
+            const entityResData = resDataByRelativeOriginPath.get(relativePath);
+            if (!entityResData) {
+                continue;
+            }
+            rootResData.addData(entityResData);
+            entityResData.addData(rootResData);
+            if (!rootResData.isResolved()) {
+                // Delete the root path so that the error only propagates once through the entity.
+                walker.unresolvablePaths.delete(unresolvableRootPath);
+                continue;
+            }
+            walker.unresolvablePaths.delete(unresolvableRootPath);
+            subgraphNameByUnresolvablePath.delete(relativePath);
         }
     }
-    generateEntityResolvabilityErrors(result, rootFieldData, errors) {
-        const nodeResolutionDataByFieldPath = (0, utils_2.getOrThrowError)(this.resolvableFieldNamesByRelativeFieldPathByEntityNodeName, result.nodeName, 'resolvableFieldNamesByRelativeFieldPathByEntityNodeName');
-        let pathFromRoot = '';
-        // Reconstruct the path
-        for (const fieldPath of result.parentFieldPathForEntityReference) {
-            pathFromRoot = fieldPath + pathFromRoot;
+    consolidateUnresolvableEntityWithRootPaths({ pathFromRoot, resDataByRelativeOriginPath, subgraphNameByUnresolvablePath, walker, }) {
+        for (const unresolvableEntityPath of subgraphNameByUnresolvablePath.keys()) {
+            const entityResData = (0, utils_2.getOrThrowError)(resDataByRelativeOriginPath, unresolvableEntityPath, `resDataByRelativeOriginPath`);
+            const fullPath = `${pathFromRoot}${unresolvableEntityPath}`;
+            const rootResData = (0, utils_2.getOrThrowError)(walker.resDataByPath, fullPath, `rootFieldWalker.resDataByPath`);
+            entityResData.addData(rootResData);
+            rootResData.addData(entityResData);
+            if (!entityResData.isResolved()) {
+                continue;
+            }
+            subgraphNameByUnresolvablePath.delete(unresolvableEntityPath);
         }
-        (0, utils_1.generateResolvabilityErrors)({
-            unresolvableFieldPaths: result.unresolvableFieldPaths,
-            nodeResolutionDataByFieldPath,
-            rootFieldData: rootFieldData,
-            errors,
-            pathFromRoot,
-            entityAncestorData: result.entityAncestorData,
-        });
     }
-}
-exports.Graph = Graph;
-class Walker {
-    entityNodeNamesBySharedFieldPath;
-    interSubgraphNodes;
-    originNode;
-    resolvableFieldNamesByRelativeFieldPath;
-    resolvableFieldNamesByRelativeFieldPathByEntityNodeName;
-    unresolvableFieldPaths = new Set();
-    unresolvableSharedFieldPaths;
-    walkerIndex;
-    sharedResolvableFieldNamesByRelativeFieldPath;
-    constructor({ entityNodeNamesBySharedFieldPath, interSubgraphNodes, originNode, resolvableFieldNamesByRelativeFieldPathByEntityNodeName, unresolvableSharedFieldPaths, walkerIndex, sharedResolvableFieldNamesByRelativeFieldPath, }) {
-        this.entityNodeNamesBySharedFieldPath = entityNodeNamesBySharedFieldPath;
-        this.interSubgraphNodes = interSubgraphNodes;
-        this.originNode = originNode;
-        this.resolvableFieldNamesByRelativeFieldPathByEntityNodeName =
-            resolvableFieldNamesByRelativeFieldPathByEntityNodeName;
-        this.resolvableFieldNamesByRelativeFieldPath = (0, utils_2.getValueOrDefault)(this.resolvableFieldNamesByRelativeFieldPathByEntityNodeName, originNode.nodeName, () => new Map());
-        this.unresolvableSharedFieldPaths = unresolvableSharedFieldPaths;
-        this.walkerIndex = walkerIndex;
-        this.sharedResolvableFieldNamesByRelativeFieldPath = sharedResolvableFieldNamesByRelativeFieldPath;
+    validateSharedRootFieldEntities({ rootFieldData, walker }) {
+        for (const [pathFromRoot, entityNodeNames] of walker.entityNodeNamesByPath) {
+            const subgraphNameByUnresolvablePath = new Map();
+            // Shared fields are unique contexts, so the resolution data cannot be reused.
+            const resDataByRelativeOriginPath = new Map();
+            /* The entity nodes are connected through the root (and not necessarily through a key), so all origins must be
+             * explored before an error can be propagated with certainty.
+             * */
+            for (const entityNodeName of entityNodeNames) {
+                this.visitEntity({
+                    encounteredEntityNodeNames: new Set(),
+                    entityNodeName,
+                    resDataByRelativeOriginPath: resDataByRelativeOriginPath,
+                    subgraphNameByUnresolvablePath,
+                    visitedEntities: new Set(),
+                });
+            }
+            /* There might be root errors that rely on entity data propagation.
+             * Always propagate entity resolution data to the root data before moving on.
+             * */
+            this.consolidateUnresolvableRootWithEntityPaths({
+                pathFromRoot,
+                resDataByRelativeOriginPath,
+                subgraphNameByUnresolvablePath,
+                walker,
+            });
+            if (subgraphNameByUnresolvablePath.size < 1) {
+                continue;
+            }
+            this.consolidateUnresolvableEntityWithRootPaths({
+                pathFromRoot,
+                resDataByRelativeOriginPath,
+                subgraphNameByUnresolvablePath,
+                walker,
+            });
+            const errors = new Array();
+            if (subgraphNameByUnresolvablePath.size > 0) {
+                errors.push(...this.getSharedEntityResolvabilityErrors({
+                    entityNodeNames,
+                    resDataByPath: resDataByRelativeOriginPath,
+                    pathFromRoot,
+                    rootFieldData,
+                    subgraphNameByUnresolvablePath,
+                }));
+            }
+            if (walker.unresolvablePaths.size > 0) {
+                errors.push(...(0, utils_1.generateRootResolvabilityErrors)({
+                    unresolvablePaths: walker.unresolvablePaths,
+                    resDataByPath: walker.resDataByPath,
+                    rootFieldData,
+                }));
+            }
+            if (errors.length < 1) {
+                continue;
+            }
+            return {
+                errors,
+                success: false,
+            };
+        }
+        if (walker.unresolvablePaths.size > 0) {
+            return {
+                errors: (0, utils_1.generateRootResolvabilityErrors)({
+                    resDataByPath: walker.resDataByPath,
+                    rootFieldData,
+                    unresolvablePaths: walker.unresolvablePaths,
+                }),
+                success: false,
+            };
+        }
+        return {
+            success: true,
+        };
     }
-    visitEntityNode(node) {
-        this.validateEntityRelatedConcreteNode(node, '');
-        const accessibleEntityNodeNames = node.getAllAccessibleEntityNodeNames();
-        for (const sibling of this.interSubgraphNodes) {
-            if (this.unresolvableFieldPaths.size < 0) {
-                return;
+    validateRootFieldEntities({ rootFieldData, walker }) {
+        for (const [entityNodeName, entityPaths] of walker.pathsByEntityNodeName) {
+            const subgraphNameByUnresolvablePath = new Map();
+            if (this.resDataByNodeName.has(entityNodeName)) {
+                continue;
             }
-            if (!accessibleEntityNodeNames.has(sibling.nodeName)) {
+            const resDataByRelativeOriginPath = (0, utils_2.getValueOrDefault)(this.resDataByRelativePathByEntity, entityNodeName, () => new Map());
+            this.visitEntity({
+                encounteredEntityNodeNames: new Set(),
+                entityNodeName,
+                resDataByRelativeOriginPath: resDataByRelativeOriginPath,
+                subgraphNameByUnresolvablePath,
+                visitedEntities: (0, utils_2.getValueOrDefault)(this.visitedEntitiesByOriginEntity, entityNodeName, () => new Set()),
+            });
+            if (subgraphNameByUnresolvablePath.size < 1) {
                 continue;
             }
-            this.validateEntityRelatedConcreteNode(sibling, '');
-        }
+            return {
+                errors: this.getEntityResolvabilityErrors({
+                    entityNodeName,
+                    // Propagate errors for the first encounter only.
+                    pathFromRoot: (0, utils_2.getFirstEntry)(entityPaths) ?? '',
+                    rootFieldData,
+                    subgraphNameByUnresolvablePath,
+                }),
+                success: false,
+            };
+        }
+        return {
+            success: true,
+        };
     }
-    // Returns true if the edge is visited and false if it's inaccessible
-    visitEntityRelatedEdge(edge, fieldPath) {
-        if (edge.isInaccessible || edge.node.isInaccessible) {
-            return false;
-        }
-        if (!(0, utils_2.add)(edge.visitedIndices, this.walkerIndex) || edge.node.isLeaf) {
-            return true;
-        }
-        if (edge.node.hasEntitySiblings) {
-            (0, utils_2.getValueOrDefault)(this.entityNodeNamesBySharedFieldPath, `${fieldPath}.${edge.edgeName}`, () => new Set()).add(edge.node.nodeName);
-            return true;
-        }
-        if (edge.node.isAbstract) {
-            this.validateEntityRelatedAbstractNode(edge.node, `${fieldPath}.${edge.edgeName}`);
+    validateEntities(params) {
+        if (params.isSharedRootField) {
+            return this.validateSharedRootFieldEntities(params);
         }
-        else {
-            this.validateEntityRelatedConcreteNode(edge.node, `${fieldPath}.${edge.edgeName}`);
-        }
-        return true;
+        return this.validateRootFieldEntities(params);
     }
-    validateEntityRelatedConcreteNode(node, fieldPath) {
-        if (node.headToTailEdges.size < 1) {
-            return;
-        }
-        const originResolvedFieldNames = (0, utils_2.getValueOrDefault)(this.resolvableFieldNamesByRelativeFieldPath, fieldPath, () => new utils_1.NodeResolutionData(node.typeName, node.fieldDataByFieldName));
-        const sharedResolvedFieldNames = this.sharedResolvableFieldNamesByRelativeFieldPath
-            ? (0, utils_2.getValueOrDefault)(this.sharedResolvableFieldNamesByRelativeFieldPath, fieldPath, () => new utils_1.NodeResolutionData(node.typeName, node.fieldDataByFieldName))
-            : undefined;
-        for (const [fieldName, edge] of node.headToTailEdges) {
-            // Returns true if the edge is visited
-            if (this.visitEntityRelatedEdge(edge, fieldPath)) {
-                originResolvedFieldNames.add(fieldName);
-                sharedResolvedFieldNames?.add(fieldName);
-            }
-        }
-        if (originResolvedFieldNames.isResolved) {
-            this.unresolvableFieldPaths.delete(fieldPath);
-        }
-        else {
-            this.unresolvableFieldPaths.add(fieldPath);
-        }
-        if (!sharedResolvedFieldNames) {
-            return;
-        }
-        if (sharedResolvedFieldNames.isResolved) {
-            this.unresolvableSharedFieldPaths.delete(fieldPath);
-        }
-        else {
-            this.unresolvableSharedFieldPaths.add(fieldPath);
-        }
+    getEntityResolvabilityErrors({ entityNodeName, pathFromRoot, rootFieldData, subgraphNameByUnresolvablePath, }) {
+        const nodeResolutionDataByFieldPath = (0, utils_2.getOrThrowError)(this.resDataByRelativePathByEntity, entityNodeName, 'resDataByRelativePathByEntity');
+        const entityTypeName = entityNodeName.split(string_constants_1.LITERAL_PERIOD)[1];
+        const { fieldSetsByTargetSubgraphName } = (0, utils_2.getOrThrowError)(this.entityDataNodeByTypeName, entityTypeName, 'entityDataNodeByTypeName');
+        return (0, utils_1.generateEntityResolvabilityErrors)({
+            entityAncestorData: {
+                fieldSetsByTargetSubgraphName,
+                subgraphName: '',
+                typeName: entityTypeName,
+            },
+            pathFromRoot,
+            resDataByPath: nodeResolutionDataByFieldPath,
+            rootFieldData: rootFieldData,
+            subgraphNameByUnresolvablePath,
+        });
     }
-    validateEntityRelatedAbstractNode(node, fieldPath) {
-        if (node.headToTailEdges.size < 1) {
-            return;
-        }
-        for (const edge of node.headToTailEdges.values()) {
-            this.visitEntityRelatedEdge(edge, fieldPath);
-        }
+    getSharedEntityResolvabilityErrors({ entityNodeNames, pathFromRoot, rootFieldData, resDataByPath, subgraphNameByUnresolvablePath, }) {
+        let entityTypeName = undefined;
+        const subgraphNames = new Array();
+        for (const entityNodeName of entityNodeNames) {
+            const segments = entityNodeName.split(string_constants_1.LITERAL_PERIOD);
+            entityTypeName ??= segments[1];
+            subgraphNames.push(segments[0]);
+        }
+        const { fieldSetsByTargetSubgraphName } = (0, utils_2.getOrThrowError)(this.entityDataNodeByTypeName, entityTypeName, 'entityDataNodeByTypeName');
+        return (0, utils_1.generateSharedEntityResolvabilityErrors)({
+            entityAncestors: {
+                fieldSetsByTargetSubgraphName,
+                subgraphNames,
+                typeName: entityTypeName,
+            },
+            pathFromRoot,
+            resDataByPath,
+            rootFieldData: rootFieldData,
+            subgraphNameByUnresolvablePath,
+        });
     }
 }
+exports.Graph = Graph;
 //# sourceMappingURL=graph.js.map