@theguild/federation-composition 0.10.0 → 0.10.1-alpha-20240313122455-e8bf68a

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

@@ -1,10 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Edge = exports.assertFieldEdge = exports.isFieldEdge = exports.assertAbstractEdge = exports.isAbstractEdge = exports.assertEntityEdge = exports.isEntityEdge = void 0;
-const helpers_1 = require("./helpers");
-const moves_1 = require("./moves");
+const helpers_js_1 = require("./helpers.js");
+const moves_js_1 = require("./moves.js");
 function isEntityEdge(edge) {
-    return edge.move instanceof moves_1.EntityMove;
+    return edge.move instanceof moves_js_1.EntityMove;
 }
 exports.isEntityEdge = isEntityEdge;
 function assertEntityEdge(edge) {
@@ -14,7 +14,7 @@ function assertEntityEdge(edge) {
 }
 exports.assertEntityEdge = assertEntityEdge;
 function isAbstractEdge(edge) {
-    return edge.move instanceof moves_1.AbstractMove;
+    return edge.move instanceof moves_js_1.AbstractMove;
 }
 exports.isAbstractEdge = isAbstractEdge;
 function assertAbstractEdge(edge) {
@@ -24,7 +24,7 @@ function assertAbstractEdge(edge) {
 }
 exports.assertAbstractEdge = assertAbstractEdge;
 function isFieldEdge(edge) {
-    return edge.move instanceof moves_1.FieldMove;
+    return edge.move instanceof moves_js_1.FieldMove;
 }
 exports.isFieldEdge = isFieldEdge;
 function assertFieldEdge(edge) {
@@ -38,7 +38,7 @@ class Edge {
     move;
     tail;
     resolvable = [];
-    _toString = (0, helpers_1.lazy)(() => `${this.head} -(${this.move})-> ${this.tail}`);
+    _toString = (0, helpers_js_1.lazy)(() => `${this.head} -(${this.move})-> ${this.tail}`);
     constructor(head, move, tail) {
         this.head = head;
         this.move = move;

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

@@ -2,8 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FieldsResolver = exports.Fields = void 0;
 const graphql_1 = require("graphql");
-const helpers_1 = require("../../../../subgraph/helpers");
-const state_1 = require("../../../../utils/state");
+const helpers_js_1 = require("../../../../subgraph/helpers.js");
+const state_js_1 = require("../../../../utils/state.js");
 class Fields {
     typeName;
     source;
@@ -68,7 +68,7 @@ class FieldsResolver {
         if (!typeState) {
             throw new Error(`Expected an object type when resolving keyFields of ${typeName}`);
         }
-        const selectionSetNode = (0, helpers_1.parseFields)(keyFields);
+        const selectionSetNode = (0, helpers_js_1.parseFields)(keyFields);
         if (!selectionSetNode) {
             throw new Error(`Expected a selection set when resolving keyFields of ${typeName}`);
         }
@@ -92,7 +92,7 @@ class FieldsResolver {
             throw new Error(`Type "${typeName.toString()}" does not have field "${fieldNode.name.value}".`);
         }
         if (fieldNode.selectionSet) {
-            const outputType = (0, state_1.stripTypeModifiers)(typeState.fields.get(fieldNode.name.value).type);
+            const outputType = (0, state_js_1.stripTypeModifiers)(typeState.fields.get(fieldNode.name.value).type);
             fields.push({
                 fieldName: fieldNode.name.value,
                 typeName,

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

@@ -1,8 +1,8 @@
 "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");
+const edge_js_1 = require("./edge.js");
+const errors_js_1 = require("./errors.js");
 function concatIfNotExistsString(list, item) {
     if (list.includes(item)) {
         return list;
@@ -49,7 +49,7 @@ class PathFinder {
                 continue;
             }
             if (!isFieldTarget) {
-                if ((0, edge_1.isAbstractEdge)(edge) && edge.tail.typeName === typeName) {
+                if ((0, edge_js_1.isAbstractEdge)(edge) && edge.tail.typeName === typeName) {
                     this.logger.groupEnd(() => 'Resolvable: ' + edge);
                     const newPath = path.clone().move(edge);
                     nextPaths.push(newPath);
@@ -57,7 +57,7 @@ class PathFinder {
                 }
             }
             if (isFieldTarget &&
-                (0, edge_1.isFieldEdge)(edge) &&
+                (0, edge_js_1.isFieldEdge)(edge) &&
                 edge.move.typeName === typeName &&
                 edge.move.fieldName === fieldName) {
                 const resolvable = this.moveValidator.isEdgeResolvable(edge, path, [], [], []);
@@ -77,12 +77,12 @@ class PathFinder {
         if (nextPaths.length === 0) {
             if (errors.length === 0) {
                 if (isFieldTarget) {
-                    errors.push(errors_1.SatisfiabilityError.forMissingField(tail.graphName, typeName, fieldName));
+                    errors.push(errors_js_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) &&
+                            if ((0, edge_js_1.isFieldEdge)(edge) &&
                                 edge.move.typeName === typeName &&
                                 edge.move.fieldName === fieldName &&
                                 !this.moveValidator.isExternal(edge)) {
@@ -93,7 +93,7 @@ class PathFinder {
                                     ? typeStateInGraph.keys.filter(key => key.resolvable)
                                     : [];
                                 if (keys.length === 0) {
-                                    errors.push(errors_1.SatisfiabilityError.forNoKey(tail.graphName, edge.tail.graphName, typeName, fieldName));
+                                    errors.push(errors_js_1.SatisfiabilityError.forNoKey(tail.graphName, edge.tail.graphName, typeName, fieldName));
                                 }
                             }
                         }
@@ -160,11 +160,11 @@ class PathFinder {
                     this.logger.groupEnd(() => 'Ignore: already visited edge');
                     continue;
                 }
-                if (edge.tail.graphName === sourceGraphName && !(0, edge_1.isAbstractEdge)(edge)) {
+                if (edge.tail.graphName === sourceGraphName && !(0, edge_js_1.isAbstractEdge)(edge)) {
                     this.logger.groupEnd(() => 'Ignore: we are back to the same graph');
                     continue;
                 }
-                if (isFieldTarget && (0, edge_1.isEntityEdge)(edge)) {
+                if (isFieldTarget && (0, edge_js_1.isEntityEdge)(edge)) {
                     if (visitedFields.some(f => f.equals(edge.move.keyFields))) {
                         this.logger.groupEnd(() => 'Ignore: already visited fields');
                         continue;
@@ -198,14 +198,14 @@ class PathFinder {
                     this.logger.log(() => 'Did not find direct paths');
                     this.logger.groupEnd(() => 'Adding to queue: ' + newPath);
                 }
-                else if (isFieldTarget && (0, edge_1.isFieldEdge)(edge)) {
+                else if (isFieldTarget && (0, edge_js_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));
+                        errors.push(errors_js_1.SatisfiabilityError.forRequire(tail.graphName, typeName, fieldName));
                         this.logger.groupEnd(() => 'Ignored');
                         continue;
                     }
@@ -224,7 +224,7 @@ class PathFinder {
                     setShortest(path.clone().move(edge), shortestPathPerGraph);
                     this.logger.groupEnd(() => 'Resolvable: ' + edge);
                 }
-                else if (!isFieldTarget && (0, edge_1.isAbstractEdge)(edge)) {
+                else if (!isFieldTarget && (0, edge_js_1.isAbstractEdge)(edge)) {
                     if (shortestPathPerGraph.has(edge.tail.graphName)) {
                         this.logger.groupEnd(() => 'Already found a shorter path to ' + edge.tail);
                         continue;

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

@@ -2,12 +2,12 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Graph = void 0;
 const graphql_1 = require("graphql");
-const state_1 = require("../../../../utils/state");
-const constants_1 = require("./constants");
-const edge_1 = require("./edge");
-const helpers_1 = require("./helpers");
-const moves_1 = require("./moves");
-const node_1 = require("./node");
+const state_js_1 = require("../../../../utils/state.js");
+const constants_js_1 = require("./constants.js");
+const edge_js_1 = require("./edge.js");
+const helpers_js_1 = require("./helpers.js");
+const moves_js_1 = require("./moves.js");
+const node_js_1 = require("./node.js");
 class Graph {
     name;
     supergraphState;
@@ -38,7 +38,7 @@ class Graph {
         else {
             this.idSymbol = id;
             this.id = id.toString();
-            this.isSubgraph = this.idSymbol !== constants_1.SUPERGRAPH_ID;
+            this.isSubgraph = this.idSymbol !== constants_js_1.SUPERGRAPH_ID;
         }
     }
     addUnreachableTypes() {
@@ -113,7 +113,7 @@ class Graph {
                         continue;
                     }
                     for (const edge of edges) {
-                        edgesToAdd.push(new edge_1.Edge(edge.head, edge.move, tailNode));
+                        edgesToAdd.push(new edge_js_1.Edge(edge.head, edge.move, tailNode));
                     }
                 }
             }
@@ -132,10 +132,10 @@ class Graph {
                     const typeStateInGraph = tailNode.typeState.byGraph.get(tailNode.graphId);
                     const keys = (typeStateInGraph?.keys ?? [])
                         .slice()
-                        .sort((a, b) => (0, helpers_1.scoreKeyFields)(a.fields) - (0, helpers_1.scoreKeyFields)(b.fields));
+                        .sort((a, b) => (0, helpers_js_1.scoreKeyFields)(a.fields) - (0, helpers_js_1.scoreKeyFields)(b.fields));
                     for (const key of keys) {
                         if (key.resolvable) {
-                            edgesToAdd.push(new edge_1.Edge(headNode, new moves_1.EntityMove(this.fieldsResolver.resolve(headNode.typeName, key.fields)), tailNode));
+                            edgesToAdd.push(new edge_js_1.Edge(headNode, new moves_js_1.EntityMove(this.fieldsResolver.resolve(headNode.typeName, key.fields)), tailNode));
                         }
                     }
                 }
@@ -181,7 +181,7 @@ class Graph {
                 throw new Error(`Expected an abstract edge matching "${typeName}" to be defined`);
             }
             const newTail = this.duplicateNode(edge.tail);
-            const newEdge = new edge_1.Edge(edge.head, edge.move, newTail);
+            const newEdge = new edge_js_1.Edge(edge.head, edge.move, newTail);
             this.replaceEdgeAt(edge.head.index, edge.tail.index, newEdge, edgeIndex);
             queue.push({
                 head: newTail,
@@ -196,12 +196,12 @@ class Graph {
             if (!edge) {
                 throw new Error('Expected edge to be defined');
             }
-            (0, edge_1.assertAbstractEdge)(edge);
+            (0, edge_js_1.assertAbstractEdge)(edge);
             if (edge.isCrossGraphEdge()) {
                 continue;
             }
             const newTail = this.duplicateNode(edge.tail);
-            const newEdge = new edge_1.Edge(edge.head, new moves_1.AbstractMove(), newTail);
+            const newEdge = new edge_js_1.Edge(edge.head, new moves_js_1.AbstractMove(), newTail);
             this.replaceEdgeAt(edge.head.index, edge.tail.index, newEdge, index);
             queue.push({
                 head: newTail,
@@ -233,12 +233,12 @@ class Graph {
             if (!edge) {
                 throw new Error('Expected edge to be defined');
             }
-            (0, edge_1.assertFieldEdge)(edge);
+            (0, edge_js_1.assertFieldEdge)(edge);
             if (edge.isCrossGraphEdge()) {
                 continue;
             }
             const newTail = this.duplicateNode(edge.tail);
-            const newEdge = new edge_1.Edge(edge.head, new moves_1.FieldMove(edge.move.typeName, edge.move.fieldName, edge.move.requires, edge.move.provides, true), newTail);
+            const newEdge = new edge_js_1.Edge(edge.head, new moves_js_1.FieldMove(edge.move.typeName, edge.move.fieldName, edge.move.requires, edge.move.provides, true), newTail);
             this.replaceEdgeAt(edge.head.index, edge.tail.index, newEdge, index);
             if (providedField.selectionSet) {
                 queue.push({
@@ -280,11 +280,11 @@ class Graph {
                 if (edge.isCrossGraphEdge()) {
                     continue;
                 }
-                if (!((0, edge_1.isFieldEdge)(edge) && edge.move.provides)) {
+                if (!((0, edge_js_1.isFieldEdge)(edge) && edge.move.provides)) {
                     continue;
                 }
                 const newTail = this.duplicateNode(edge.tail);
-                const newEdge = new edge_1.Edge(edge.head, edge.move, newTail);
+                const newEdge = new edge_js_1.Edge(edge.head, edge.move, newTail);
                 this.replaceEdgeAt(headIndex, edge.tail.index, newEdge, edgeIndex);
                 const queue = [
                     {
@@ -313,7 +313,7 @@ class Graph {
     duplicateNode(originalNode) {
         const newNode = this.createNode(originalNode.typeName, originalNode.typeState, originalNode.graphId, originalNode.graphName);
         for (const edge of this.edgesOfHead(originalNode)) {
-            this.addEdge(new edge_1.Edge(newNode, edge.move, edge.tail));
+            this.addEdge(new edge_js_1.Edge(newNode, edge.move, edge.tail));
         }
         return newNode;
     }
@@ -557,7 +557,7 @@ class Graph {
         if (members) {
             for (const memberTypeName of members) {
                 const tail = this.createNodesAndEdgesForType(memberTypeName);
-                this.addEdge(new edge_1.Edge(head, new moves_1.AbstractMove(), tail));
+                this.addEdge(new edge_js_1.Edge(head, new moves_js_1.AbstractMove(), tail));
             }
         }
         return head;
@@ -574,7 +574,7 @@ class Graph {
         if (implementedBy) {
             for (const memberTypeName of implementedBy) {
                 const tail = this.createNodesAndEdgesForType(memberTypeName);
-                this.addEdge(new edge_1.Edge(head, new moves_1.AbstractMove(), tail));
+                this.addEdge(new edge_js_1.Edge(head, new moves_js_1.AbstractMove(), tail));
             }
         }
         return head;
@@ -591,17 +591,17 @@ class Graph {
                 return;
             }
         }
-        const outputTypeName = (0, state_1.stripTypeModifiers)(field.type);
+        const outputTypeName = (0, state_js_1.stripTypeModifiers)(field.type);
         const tail = this.createNodesAndEdgesForType(outputTypeName);
         if (!tail) {
             throw new Error(`Failed to create Node for ${outputTypeName} in subgraph ${this.id}`);
         }
         if (this.isSupergraph()) {
-            return this.addEdge(new edge_1.Edge(head, new moves_1.FieldMove(head.typeName, field.name), tail));
+            return this.addEdge(new edge_js_1.Edge(head, new moves_js_1.FieldMove(head.typeName, field.name), tail));
         }
         const requires = field.byGraph.get(head.graphId)?.requires;
         const provides = field.byGraph.get(head.graphId)?.provides;
-        return this.addEdge(new edge_1.Edge(head, new moves_1.FieldMove(head.typeName, field.name, requires ? this.fieldsResolver.resolve(head.typeName, requires) : null, provides ? this.fieldsResolver.resolve(outputTypeName, provides) : null), tail));
+        return this.addEdge(new edge_js_1.Edge(head, new moves_js_1.FieldMove(head.typeName, field.name, requires ? this.fieldsResolver.resolve(head.typeName, requires) : null, provides ? this.fieldsResolver.resolve(outputTypeName, provides) : null), tail));
     }
     createTypeNode(typeName, typeState) {
         if (this.typeNameToNodeIndexes.has(typeName)) {
@@ -611,7 +611,7 @@ class Graph {
     }
     createNode(typeName, typeState, graphId, graphName) {
         const index = this.nodesByTypeIndex.push([]) - 1;
-        const node = new node_1.Node(index, typeName, typeState, graphId, graphName);
+        const node = new node_js_1.Node(index, typeName, typeState, graphId, graphName);
         this.nodesByTypeIndex[node.index].push(node);
         this.edgesByHeadTypeIndex.push([]);
         this.edgesByTailTypeIndex.push([]);
@@ -645,13 +645,13 @@ class Graph {
         const edgeIndex = this.edgesByHeadTypeIndex[edge.head.index].push(edge) - 1;
         this.edgesByTailTypeIndex[edge.tail.index].push(edge);
         this.typeChildren[edge.head.index].add(edge.tail.typeName);
-        if ((0, edge_1.isFieldEdge)(edge)) {
+        if ((0, edge_js_1.isFieldEdge)(edge)) {
             edge.head.addFieldEdge(edge.move.fieldName, edgeIndex);
         }
-        else if ((0, edge_1.isEntityEdge)(edge)) {
+        else if ((0, edge_js_1.isEntityEdge)(edge)) {
             edge.head.addEntityEdge(edge.head.typeName, edgeIndex);
         }
-        else if ((0, edge_1.isAbstractEdge)(edge)) {
+        else if ((0, edge_js_1.isAbstractEdge)(edge)) {
             edge.head.addAbstractEdge(edge.head.typeName, edgeIndex);
         }
         if (edge.isCrossGraphEdge()) {

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

@@ -1,9 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MoveValidator = void 0;
-const edge_1 = require("./edge");
-const errors_1 = require("./errors");
-const finder_1 = require("./finder");
+const edge_js_1 = require("./edge.js");
+const errors_js_1 = require("./errors.js");
+const finder_js_1 = require("./finder.js");
 class MoveValidator {
     supergraph;
     cache = new Map();
@@ -12,7 +12,7 @@ class MoveValidator {
     constructor(logger, supergraph) {
         this.supergraph = supergraph;
         this.logger = logger.create('MoveValidator');
-        this.pathFinder = new finder_1.PathFinder(this.logger, supergraph, this);
+        this.pathFinder = new finder_js_1.PathFinder(this.logger, supergraph, this);
     }
     canResolveFields(fields, path, visitedEdges, visitedGraphs, visitedFields) {
         const cacheKey = JSON.stringify(fields) +
@@ -201,7 +201,7 @@ class MoveValidator {
         };
     }
     isExternal(edge) {
-        if (!(0, edge_1.isFieldEdge)(edge)) {
+        if (!(0, edge_js_1.isFieldEdge)(edge)) {
             return false;
         }
         if (edge.move.provided) {
@@ -261,7 +261,7 @@ class MoveValidator {
         return true;
     }
     isOverridden(edge) {
-        if (!(0, edge_1.isFieldEdge)(edge)) {
+        if (!(0, edge_js_1.isFieldEdge)(edge)) {
             return false;
         }
         if (!edge.head.typeState) {
@@ -286,22 +286,22 @@ class MoveValidator {
     isEdgeResolvable(edge, path, visitedEdges, visitedGraphs, visitedFields) {
         this.logger.group(() => 'Checking resolvability of ' + edge);
         this.logger.log(() => 'Visited graphs: ' + visitedGraphs.join(','));
-        const resolvability = edge.getResolvability((0, finder_1.concatIfNotExistsString)(visitedGraphs, edge.tail.graphName));
+        const resolvability = edge.getResolvability((0, finder_js_1.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 ((0, edge_1.isFieldEdge)(edge)) {
+        if ((0, edge_js_1.isFieldEdge)(edge)) {
             if (this.isOverridden(edge)) {
                 this.logger.groupEnd(() => 'Cannot move to ' + edge + ' because it is overridden');
-                return edge.setResolvable(false, visitedGraphs, errors_1.SatisfiabilityError.forMissingField(edge.tail.graphName, edge.move.typeName, edge.move.fieldName));
+                return edge.setResolvable(false, visitedGraphs, errors_js_1.SatisfiabilityError.forMissingField(edge.tail.graphName, edge.move.typeName, edge.move.fieldName));
             }
             if (edge.move.requires) {
                 this.logger.log(() => 'Detected @requires');
-                const newVisitedGraphs = (0, finder_1.concatIfNotExistsString)(visitedGraphs, edge.tail.graphName);
-                const newVisitedFields = (0, finder_1.concatIfNotExistsFields)(visitedFields, edge.move.requires);
+                const newVisitedGraphs = (0, finder_js_1.concatIfNotExistsString)(visitedGraphs, edge.tail.graphName);
+                const newVisitedFields = (0, finder_js_1.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);
@@ -310,25 +310,25 @@ class MoveValidator {
                 this.logger.groupEnd(() => 'Cannot move to ' + edge + ' because @require is not resolvable');
                 return {
                     success: false,
-                    error: errors_1.SatisfiabilityError.forRequire(edge.head.graphName, edge.move.typeName, edge.move.fieldName),
+                    error: errors_js_1.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, errors_1.SatisfiabilityError.forExternal(edge.head.graphName, edge.move.typeName, edge.move.fieldName));
+                return edge.setResolvable(false, visitedGraphs, errors_js_1.SatisfiabilityError.forExternal(edge.head.graphName, edge.move.typeName, edge.move.fieldName));
             }
         }
-        else if ((0, edge_1.isEntityEdge)(edge)) {
+        else if ((0, edge_js_1.isEntityEdge)(edge)) {
             this.logger.log(() => 'Detected @key');
-            const newVisitedGraphs = (0, finder_1.concatIfNotExistsString)(visitedGraphs, edge.tail.graphName);
-            const newVisitedFields = (0, finder_1.concatIfNotExistsFields)(visitedFields, edge.move.keyFields);
+            const newVisitedGraphs = (0, finder_js_1.concatIfNotExistsString)(visitedGraphs, edge.tail.graphName);
+            const newVisitedFields = (0, finder_js_1.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, errors_1.SatisfiabilityError.forKey(edge.head.graphName, edge.tail.graphName, edge.head.typeName, edge.move.keyFields.toString()));
+            return edge.setResolvable(false, newVisitedGraphs, errors_js_1.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/cjs/supergraph/validation/rules/satisfiablity/moves.js

@@ -1,14 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.EntityMove = exports.AbstractMove = exports.FieldMove = void 0;
-const helpers_1 = require("./helpers");
+const helpers_js_1 = require("./helpers.js");
 class FieldMove {
     typeName;
     fieldName;
     requires;
     provides;
     provided;
-    _toString = (0, helpers_1.lazy)(() => {
+    _toString = (0, helpers_js_1.lazy)(() => {
         let str = this.fieldName;
         if (this.requires) {
             str += ` @require(${this.requires})`;
@@ -41,7 +41,7 @@ class AbstractMove {
 exports.AbstractMove = AbstractMove;
 class EntityMove {
     keyFields;
-    _toString = (0, helpers_1.lazy)(() => `🔑 ${this.keyFields}`);
+    _toString = (0, helpers_js_1.lazy)(() => `🔑 ${this.keyFields}`);
     constructor(keyFields) {
         this.keyFields = keyFields;
     }

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

@@ -1,14 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Node = void 0;
-const helpers_1 = require("./helpers");
+const helpers_js_1 = require("./helpers.js");
 class Node {
     index;
     typeName;
     typeState;
     graphId;
     graphName;
-    _toString = (0, helpers_1.lazy)(() => `${this.typeName}/${this.graphName}`);
+    _toString = (0, helpers_js_1.lazy)(() => `${this.typeName}/${this.graphName}`);
     isLeaf = false;
     childrenIndex = new Map();
     visitedGraphCombos = [];

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

@@ -1,11 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.OperationPath = void 0;
-const edge_1 = require("./edge");
-const helpers_1 = require("./helpers");
+const edge_js_1 = require("./edge.js");
+const helpers_js_1 = require("./helpers.js");
 class OperationPath {
     _rootNode;
-    _toString = (0, helpers_1.lazy)(() => {
+    _toString = (0, helpers_js_1.lazy)(() => {
         let str = this._rootNode.toString();
         for (let i = 0; i < this.previousEdges.length; i++) {
             const edge = this.previousEdges[i];
@@ -57,7 +57,7 @@ class OperationPath {
     advance(edge) {
         this.previousEdges.push(edge);
         this.previousNodes.push(edge.head);
-        this.previousSteps.push((0, edge_1.isFieldEdge)(edge)
+        this.previousSteps.push((0, edge_js_1.isFieldEdge)(edge)
             ? {
                 typeName: edge.move.typeName,
                 fieldName: edge.move.fieldName,

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

@@ -1,37 +1,37 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Supergraph = void 0;
-const logger_1 = require("../../../../utils/logger");
-const constants_1 = require("./constants");
-const fields_1 = require("./fields");
-const graph_1 = require("./graph");
-const move_validator_1 = require("./move-validator");
-const walker_1 = require("./walker");
+const logger_js_1 = require("../../../../utils/logger.js");
+const constants_js_1 = require("./constants.js");
+const fields_js_1 = require("./fields.js");
+const graph_js_1 = require("./graph.js");
+const move_validator_js_1 = require("./move-validator.js");
+const walker_js_1 = require("./walker.js");
 class Supergraph {
     supergraph;
     mergedGraph;
     fieldsResolver;
     moveRequirementChecker;
-    logger = new logger_1.Logger('Supergraph', new logger_1.LoggerContext());
+    logger = new logger_js_1.Logger('Supergraph', new logger_js_1.LoggerContext());
     constructor(supergraphState) {
-        this.fieldsResolver = new fields_1.FieldsResolver(supergraphState);
-        this.supergraph = new graph_1.Graph(this.logger, constants_1.SUPERGRAPH_ID, 'supergraph', supergraphState, this.fieldsResolver, true);
-        this.mergedGraph = new graph_1.Graph(this.logger, constants_1.SUPERGRAPH_ID, 'merged', supergraphState, this.fieldsResolver);
+        this.fieldsResolver = new fields_js_1.FieldsResolver(supergraphState);
+        this.supergraph = new graph_js_1.Graph(this.logger, constants_js_1.SUPERGRAPH_ID, 'supergraph', supergraphState, this.fieldsResolver, true);
+        this.mergedGraph = new graph_js_1.Graph(this.logger, constants_js_1.SUPERGRAPH_ID, 'merged', supergraphState, this.fieldsResolver);
         for (const [id, subgraphState] of supergraphState.subgraphs) {
-            this.mergedGraph.addSubgraph(new graph_1.Graph(this.logger, id, subgraphState.graph.name, supergraphState, this.fieldsResolver, false)
+            this.mergedGraph.addSubgraph(new graph_js_1.Graph(this.logger, id, subgraphState.graph.name, supergraphState, this.fieldsResolver, false)
                 .addFromRoots()
                 .addFromEntities()
                 .addUnreachableTypes());
         }
         this.mergedGraph.joinSubgraphs();
         this.supergraph.addFromRoots();
-        this.moveRequirementChecker = new move_validator_1.MoveValidator(this.logger, this.mergedGraph);
+        this.moveRequirementChecker = new move_validator_js_1.MoveValidator(this.logger, this.mergedGraph);
     }
     validate() {
-        return new walker_1.Walker(this.logger, this.moveRequirementChecker, this.supergraph, this.mergedGraph).walk('dfs');
+        return new walker_js_1.Walker(this.logger, this.moveRequirementChecker, this.supergraph, this.mergedGraph).walk('dfs');
     }
     validateOperation(operation, steps) {
-        return new walker_1.Walker(this.logger, this.moveRequirementChecker, this.supergraph, this.mergedGraph).walkTrail(operation, steps);
+        return new walker_js_1.Walker(this.logger, this.moveRequirementChecker, this.supergraph, this.mergedGraph).walkTrail(operation, steps);
     }
 }
 exports.Supergraph = Supergraph;

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

@@ -2,9 +2,9 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Walker = exports.WalkTracker = void 0;
 const graphql_1 = require("graphql");
-const edge_1 = require("./edge");
-const finder_1 = require("./finder");
-const operation_path_1 = require("./operation-path");
+const edge_js_1 = require("./edge.js");
+const finder_js_1 = require("./finder.js");
+const operation_path_js_1 = require("./operation-path.js");
 class WalkTracker {
     superPath;
     paths;
@@ -14,7 +14,7 @@ class WalkTracker {
         this.paths = paths;
     }
     move(edge) {
-        if ((0, edge_1.isFieldEdge)(edge) || (0, edge_1.isAbstractEdge)(edge)) {
+        if ((0, edge_js_1.isFieldEdge)(edge) || (0, edge_js_1.isAbstractEdge)(edge)) {
             return new WalkTracker(this.superPath.clone().move(edge), []);
         }
         throw new Error('Expected edge to be FieldMove or AbstractMove');
@@ -31,7 +31,7 @@ class WalkTracker {
     }
     givesEmptyResult() {
         const lastEdge = this.superPath.edge();
-        return (this.paths.length === 0 && this.errors.length === 0 && !!lastEdge && (0, edge_1.isAbstractEdge)(lastEdge));
+        return (this.paths.length === 0 && this.errors.length === 0 && !!lastEdge && (0, edge_js_1.isAbstractEdge)(lastEdge));
     }
     isEdgeVisited(edge) {
         return this.superPath.isVisitedEdge(edge);
@@ -65,7 +65,7 @@ class Walker {
         this.supergraph = supergraph;
         this.mergedGraph = mergedGraph;
         this.logger = logger.create('Walker');
-        this.pathFinder = new finder_1.PathFinder(this.logger, this.mergedGraph, this.moveChecker);
+        this.pathFinder = new finder_js_1.PathFinder(this.logger, this.mergedGraph, this.moveChecker);
     }
     walkTrail(operationType, steps) {
         if (steps.length === 0) {
@@ -79,7 +79,7 @@ class Walker {
         if (!rootNode) {
             throw new Error(`Expected root node for operation type ${operationType}`);
         }
-        let state = new WalkTracker(new operation_path_1.OperationPath(rootNode), this.mergedGraph.nodesOf(rootNode.typeName, false).map(n => new operation_path_1.OperationPath(n)));
+        let state = new WalkTracker(new operation_path_js_1.OperationPath(rootNode), this.mergedGraph.nodesOf(rootNode.typeName, false).map(n => new operation_path_js_1.OperationPath(n)));
         for (const step of steps) {
             const stepId = 'fieldName' in step && step.fieldName
                 ? `${step.typeName}.${step.fieldName}`
@@ -87,7 +87,7 @@ class Walker {
             const isFieldStep = 'fieldName' in step;
             const isEdgeIgnored = (edge) => {
                 if (isFieldStep) {
-                    return !(0, edge_1.isFieldEdge)(edge) || edge.move.fieldName !== step.fieldName;
+                    return !(0, edge_js_1.isFieldEdge)(edge) || edge.move.fieldName !== step.fieldName;
                 }
                 return true;
             };
@@ -142,7 +142,7 @@ class Walker {
             const edge = p.edge();
             const tail = p.tail() ?? p.rootNode();
             const tailGraphName = tail.graphName;
-            if (edge && (0, edge_1.isFieldEdge)(edge) && edge.move.provides) {
+            if (edge && (0, edge_js_1.isFieldEdge)(edge) && edge.move.provides) {
                 return `${tailGraphName}#provides`;
             }
             return tailGraphName;
@@ -162,12 +162,12 @@ class Walker {
                 this.logger.groupEnd(() => 'Edge already visited: ' + superEdge);
                 continue;
             }
-            if (!((0, edge_1.isFieldEdge)(superEdge) || (0, edge_1.isAbstractEdge)(superEdge))) {
+            if (!((0, edge_js_1.isFieldEdge)(superEdge) || (0, edge_js_1.isAbstractEdge)(superEdge))) {
                 throw new Error('Expected edge to have a FieldMove or AbstractMove');
             }
             const nextState = state.move(superEdge);
             const shortestPathPerTail = new Map();
-            const isFieldMove = (0, edge_1.isFieldEdge)(superEdge);
+            const isFieldMove = (0, edge_js_1.isFieldEdge)(superEdge);
             const id = isFieldMove
                 ? `${superEdge.move.typeName}.${superEdge.move.fieldName}`
                 : `... on ${superEdge.tail.typeName}`;
@@ -215,7 +215,7 @@ class Walker {
             .map(name => this.supergraph.nodeOf(name, false))
             .filter((node) => !!node);
         for (const rootNode of rootNodes) {
-            this._dfs(rootNode, new WalkTracker(new operation_path_1.OperationPath(rootNode), this.mergedGraph.nodesOf(rootNode.typeName, false).map(n => new operation_path_1.OperationPath(n))), unreachable);
+            this._dfs(rootNode, new WalkTracker(new operation_path_js_1.OperationPath(rootNode), this.mergedGraph.nodesOf(rootNode.typeName, false).map(n => new operation_path_js_1.OperationPath(n))), unreachable);
         }
         return unreachable;
     }
@@ -255,7 +255,7 @@ class Walker {
             .map(name => this.supergraph.nodeOf(name, false))
             .filter((node) => !!node);
         for (const rootNode of rootNodes) {
-            queue.push(new WalkTracker(new operation_path_1.OperationPath(rootNode), this.mergedGraph.nodesOf(rootNode.typeName, false).map(n => new operation_path_1.OperationPath(n))));
+            queue.push(new WalkTracker(new operation_path_js_1.OperationPath(rootNode), this.mergedGraph.nodesOf(rootNode.typeName, false).map(n => new operation_path_js_1.OperationPath(n))));
         }
         while (queue.length > 0) {
             const state = queue.pop();

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

@@ -1,5 +1,5 @@
-import { lazy } from './helpers';
-import { AbstractMove, EntityMove, FieldMove } from './moves';
+import { lazy } from './helpers.js';
+import { AbstractMove, EntityMove, FieldMove } from './moves.js';
 export function isEntityEdge(edge) {
     return edge.move instanceof EntityMove;
 }

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

@@ -1,6 +1,6 @@
 import { Kind } from 'graphql';
-import { parseFields } from '../../../../subgraph/helpers';
-import { stripTypeModifiers } from '../../../../utils/state';
+import { parseFields } from '../../../../subgraph/helpers.js';
+import { stripTypeModifiers } from '../../../../utils/state.js';
 export class Fields {
     typeName;
     source;

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

@@ -1,5 +1,5 @@
-import { isAbstractEdge, isEntityEdge, isFieldEdge } from './edge';
-import { SatisfiabilityError } from './errors';
+import { isAbstractEdge, isEntityEdge, isFieldEdge } from './edge.js';
+import { SatisfiabilityError } from './errors.js';
 export function concatIfNotExistsString(list, item) {
     if (list.includes(item)) {
         return list;

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

@@ -1,10 +1,10 @@
 import { specifiedScalarTypes } from 'graphql';
-import { stripTypeModifiers } from '../../../../utils/state';
-import { SUPERGRAPH_ID } from './constants';
-import { assertAbstractEdge, assertFieldEdge, Edge, isAbstractEdge, isEntityEdge, isFieldEdge, } from './edge';
-import { scoreKeyFields } from './helpers';
-import { AbstractMove, EntityMove, FieldMove } from './moves';
-import { Node } from './node';
+import { stripTypeModifiers } from '../../../../utils/state.js';
+import { SUPERGRAPH_ID } from './constants.js';
+import { assertAbstractEdge, assertFieldEdge, Edge, isAbstractEdge, isEntityEdge, isFieldEdge, } from './edge.js';
+import { scoreKeyFields } from './helpers.js';
+import { AbstractMove, EntityMove, FieldMove } from './moves.js';
+import { Node } from './node.js';
 export class Graph {
     name;
     supergraphState;

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

@@ -1,6 +1,6 @@
-import { isEntityEdge, isFieldEdge } from './edge';
-import { SatisfiabilityError } from './errors';
-import { concatIfNotExistsFields, concatIfNotExistsString, PathFinder } from './finder';
+import { isEntityEdge, isFieldEdge } from './edge.js';
+import { SatisfiabilityError } from './errors.js';
+import { concatIfNotExistsFields, concatIfNotExistsString, PathFinder } from './finder.js';
 export class MoveValidator {
     supergraph;
     cache = new Map();

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

@@ -1,4 +1,4 @@
-import { lazy } from './helpers';
+import { lazy } from './helpers.js';
 export class FieldMove {
     typeName;
     fieldName;

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

@@ -1,4 +1,4 @@
-import { lazy } from './helpers';
+import { lazy } from './helpers.js';
 export class Node {
     index;
     typeName;

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

@@ -1,5 +1,5 @@
-import { isFieldEdge } from './edge';
-import { lazy } from './helpers';
+import { isFieldEdge } from './edge.js';
+import { lazy } from './helpers.js';
 export class OperationPath {
     _rootNode;
     _toString = lazy(() => {

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

@@ -1,9 +1,9 @@
-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';
+import { Logger, LoggerContext } from '../../../../utils/logger.js';
+import { SUPERGRAPH_ID } from './constants.js';
+import { FieldsResolver } from './fields.js';
+import { Graph } from './graph.js';
+import { MoveValidator } from './move-validator.js';
+import { Walker } from './walker.js';
 export class Supergraph {
     supergraph;
     mergedGraph;

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

@@ -1,7 +1,7 @@
 import { OperationTypeNode } from 'graphql';
-import { isAbstractEdge, isFieldEdge } from './edge';
-import { PathFinder } from './finder';
-import { OperationPath } from './operation-path';
+import { isAbstractEdge, isFieldEdge } from './edge.js';
+import { PathFinder } from './finder.js';
+import { OperationPath } from './operation-path.js';
 export class WalkTracker {
     superPath;
     paths;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@theguild/federation-composition",
-  "version": "0.10.0",
+  "version": "0.10.1-alpha-20240313122455-e8bf68a",
   "description": "Open Source Composition library for Apollo Federation",
   "peerDependencies": {
     "graphql": "^16.0.0"

package/typings/supergraph/validation/rules/satisfiablity/edge.d.cts

@@ -1,6 +1,6 @@
-import { SatisfiabilityError } from './errors';
-import { AbstractMove, EntityMove, FieldMove, Move } from './moves';
-import { Node } from './node';
+import { SatisfiabilityError } from './errors.cjs';
+import { AbstractMove, EntityMove, FieldMove, Move } from './moves.cjs';
+import { Node } from './node.cjs';
 type EdgeResolvabilityResult = {
     success: true;
     error: undefined;

package/typings/supergraph/validation/rules/satisfiablity/edge.d.ts

@@ -1,6 +1,6 @@
-import { SatisfiabilityError } from './errors';
-import { AbstractMove, EntityMove, FieldMove, Move } from './moves';
-import { Node } from './node';
+import { SatisfiabilityError } from './errors.js';
+import { AbstractMove, EntityMove, FieldMove, Move } from './moves.js';
+import { Node } from './node.js';
 type EdgeResolvabilityResult = {
     success: true;
     error: undefined;

package/typings/supergraph/validation/rules/satisfiablity/fields.d.cts

@@ -1,4 +1,4 @@
-import { SupergraphState } from '../../../state';
+import { SupergraphState } from '../../../state.cjs';
 export type Field = {
     typeName: string;
     fieldName: string;

package/typings/supergraph/validation/rules/satisfiablity/fields.d.ts

@@ -1,4 +1,4 @@
-import { SupergraphState } from '../../../state';
+import { SupergraphState } from '../../../state.js';
 export type Field = {
     typeName: string;
     fieldName: string;

package/typings/supergraph/validation/rules/satisfiablity/finder.d.cts

@@ -1,10 +1,10 @@
-import type { Logger } from '../../../../utils/logger';
-import { Edge } from './edge';
-import { SatisfiabilityError } from './errors';
-import { Fields } from './fields';
-import type { Graph } from './graph';
-import type { MoveValidator } from './move-validator';
-import type { OperationPath } from './operation-path';
+import type { Logger } from '../../../../utils/logger.cjs';
+import { Edge } from './edge.cjs';
+import { SatisfiabilityError } from './errors.cjs';
+import { Fields } from './fields.cjs';
+import type { Graph } from './graph.cjs';
+import type { MoveValidator } from './move-validator.cjs';
+import type { OperationPath } from './operation-path.cjs';
 export declare function concatIfNotExistsString(list: string[], item: string): string[];
 export declare function concatIfNotExistsFields(list: Fields[], item: Fields): Fields[];
 type PathFinderResult = {

package/typings/supergraph/validation/rules/satisfiablity/finder.d.ts

@@ -1,10 +1,10 @@
-import type { Logger } from '../../../../utils/logger';
-import { Edge } from './edge';
-import { SatisfiabilityError } from './errors';
-import { Fields } from './fields';
-import type { Graph } from './graph';
-import type { MoveValidator } from './move-validator';
-import type { OperationPath } from './operation-path';
+import type { Logger } from '../../../../utils/logger.js';
+import { Edge } from './edge.js';
+import { SatisfiabilityError } from './errors.js';
+import { Fields } from './fields.js';
+import type { Graph } from './graph.js';
+import type { MoveValidator } from './move-validator.js';
+import type { OperationPath } from './operation-path.js';
 export declare function concatIfNotExistsString(list: string[], item: string): string[];
 export declare function concatIfNotExistsFields(list: Fields[], item: Fields): Fields[];
 type PathFinderResult = {

package/typings/supergraph/validation/rules/satisfiablity/graph.d.cts

@@ -1,8 +1,8 @@
-import type { Logger } from '../../../../utils/logger';
-import type { SupergraphState } from '../../../state';
-import { Edge } from './edge';
-import type { FieldsResolver } from './fields';
-import { Node } from './node';
+import type { Logger } from '../../../../utils/logger.cjs';
+import type { SupergraphState } from '../../../state.cjs';
+import { Edge } from './edge.cjs';
+import type { FieldsResolver } from './fields.cjs';
+import { Node } from './node.cjs';
 export declare class Graph {
     name: string;
     private supergraphState;
@@ -37,11 +37,11 @@ export declare class Graph {
     nodesOf(typeName: string, failIfMissing?: boolean): Node[];
     private getSameGraphEdgesOfIndex;
     fieldEdgesOfHead(head: Node, fieldName: string): Edge[];
-    abstractEdgesOfHead(head: Node): Edge<import("./moves").Move>[];
-    entityEdgesOfHead(head: Node): Edge<import("./moves").Move>[];
-    crossGraphEdgesOfHead(head: Node): Edge<import("./moves").Move>[];
-    edgesOfHead(head: Node): Edge<import("./moves").Move>[];
-    edgesOfTail(tail: Node): Edge<import("./moves").Move>[];
+    abstractEdgesOfHead(head: Node): Edge<import("./moves.js").Move>[];
+    entityEdgesOfHead(head: Node): Edge<import("./moves.js").Move>[];
+    crossGraphEdgesOfHead(head: Node): Edge<import("./moves.js").Move>[];
+    edgesOfHead(head: Node): Edge<import("./moves.js").Move>[];
+    edgesOfTail(tail: Node): Edge<import("./moves.js").Move>[];
     possibleTypesOf(typeName: string): string[];
     canReachTypeFromType(fromTypeName: string, toTypeName: string): boolean;
     private createNodesAndEdgesForType;

package/typings/supergraph/validation/rules/satisfiablity/graph.d.ts

@@ -1,8 +1,8 @@
-import type { Logger } from '../../../../utils/logger';
-import type { SupergraphState } from '../../../state';
-import { Edge } from './edge';
-import type { FieldsResolver } from './fields';
-import { Node } from './node';
+import type { Logger } from '../../../../utils/logger.js';
+import type { SupergraphState } from '../../../state.js';
+import { Edge } from './edge.js';
+import type { FieldsResolver } from './fields.js';
+import { Node } from './node.js';
 export declare class Graph {
     name: string;
     private supergraphState;
@@ -37,11 +37,11 @@ export declare class Graph {
     nodesOf(typeName: string, failIfMissing?: boolean): Node[];
     private getSameGraphEdgesOfIndex;
     fieldEdgesOfHead(head: Node, fieldName: string): Edge[];
-    abstractEdgesOfHead(head: Node): Edge<import("./moves").Move>[];
-    entityEdgesOfHead(head: Node): Edge<import("./moves").Move>[];
-    crossGraphEdgesOfHead(head: Node): Edge<import("./moves").Move>[];
-    edgesOfHead(head: Node): Edge<import("./moves").Move>[];
-    edgesOfTail(tail: Node): Edge<import("./moves").Move>[];
+    abstractEdgesOfHead(head: Node): Edge<import("./moves.js").Move>[];
+    entityEdgesOfHead(head: Node): Edge<import("./moves.js").Move>[];
+    crossGraphEdgesOfHead(head: Node): Edge<import("./moves.js").Move>[];
+    edgesOfHead(head: Node): Edge<import("./moves.js").Move>[];
+    edgesOfTail(tail: Node): Edge<import("./moves.js").Move>[];
     possibleTypesOf(typeName: string): string[];
     canReachTypeFromType(fromTypeName: string, toTypeName: string): boolean;
     private createNodesAndEdgesForType;

package/typings/supergraph/validation/rules/satisfiablity/move-validator.d.cts

@@ -1,9 +1,9 @@
-import type { Logger } from '../../../../utils/logger';
-import { Edge } from './edge';
-import { SatisfiabilityError } from './errors';
-import type { Fields } from './fields';
-import type { Graph } from './graph';
-import { OperationPath } from './operation-path';
+import type { Logger } from '../../../../utils/logger.cjs';
+import { Edge } from './edge.cjs';
+import { SatisfiabilityError } from './errors.cjs';
+import type { Fields } from './fields.cjs';
+import type { Graph } from './graph.cjs';
+import { OperationPath } from './operation-path.cjs';
 export declare class MoveValidator {
     private supergraph;
     private cache;

package/typings/supergraph/validation/rules/satisfiablity/move-validator.d.ts

@@ -1,9 +1,9 @@
-import type { Logger } from '../../../../utils/logger';
-import { Edge } from './edge';
-import { SatisfiabilityError } from './errors';
-import type { Fields } from './fields';
-import type { Graph } from './graph';
-import { OperationPath } from './operation-path';
+import type { Logger } from '../../../../utils/logger.js';
+import { Edge } from './edge.js';
+import { SatisfiabilityError } from './errors.js';
+import type { Fields } from './fields.js';
+import type { Graph } from './graph.js';
+import { OperationPath } from './operation-path.js';
 export declare class MoveValidator {
     private supergraph;
     private cache;

package/typings/supergraph/validation/rules/satisfiablity/moves.d.cts

@@ -1,4 +1,4 @@
-import type { Fields } from './fields';
+import type { Fields } from './fields.cjs';
 export interface Move {
     toString(): string;
 }

package/typings/supergraph/validation/rules/satisfiablity/moves.d.ts

@@ -1,4 +1,4 @@
-import type { Fields } from './fields';
+import type { Fields } from './fields.js';
 export interface Move {
     toString(): string;
 }

package/typings/supergraph/validation/rules/satisfiablity/node.d.cts

@@ -1,8 +1,8 @@
-import type { EnumTypeState } from '../../../composition/enum-type';
-import type { InterfaceTypeState } from '../../../composition/interface-type';
-import type { ObjectTypeState } from '../../../composition/object-type';
-import type { ScalarTypeState } from '../../../composition/scalar-type';
-import type { UnionTypeState } from '../../../composition/union-type';
+import type { EnumTypeState } from '../../../composition/enum-type.cjs';
+import type { InterfaceTypeState } from '../../../composition/interface-type.cjs';
+import type { ObjectTypeState } from '../../../composition/object-type.cjs';
+import type { ScalarTypeState } from '../../../composition/scalar-type.cjs';
+import type { UnionTypeState } from '../../../composition/union-type.cjs';
 export declare class Node {
     index: number;
     typeName: string;

package/typings/supergraph/validation/rules/satisfiablity/node.d.ts

@@ -1,8 +1,8 @@
-import type { EnumTypeState } from '../../../composition/enum-type';
-import type { InterfaceTypeState } from '../../../composition/interface-type';
-import type { ObjectTypeState } from '../../../composition/object-type';
-import type { ScalarTypeState } from '../../../composition/scalar-type';
-import type { UnionTypeState } from '../../../composition/union-type';
+import type { EnumTypeState } from '../../../composition/enum-type.js';
+import type { InterfaceTypeState } from '../../../composition/interface-type.js';
+import type { ObjectTypeState } from '../../../composition/object-type.js';
+import type { ScalarTypeState } from '../../../composition/scalar-type.js';
+import type { UnionTypeState } from '../../../composition/union-type.js';
 export declare class Node {
     index: number;
     typeName: string;

package/typings/supergraph/validation/rules/satisfiablity/operation-path.d.cts

@@ -1,5 +1,5 @@
-import { type Edge } from './edge';
-import type { Node } from './node';
+import { type Edge } from './edge.cjs';
+import type { Node } from './node.cjs';
 export type Step = FieldStep | AbstractStep;
 export type FieldStep = {
     fieldName: string;

package/typings/supergraph/validation/rules/satisfiablity/operation-path.d.ts

@@ -1,5 +1,5 @@
-import { type Edge } from './edge';
-import type { Node } from './node';
+import { type Edge } from './edge.js';
+import type { Node } from './node.js';
 export type Step = FieldStep | AbstractStep;
 export type FieldStep = {
     fieldName: string;

package/typings/supergraph/validation/rules/satisfiablity/supergraph.d.cts

@@ -1,6 +1,6 @@
 import { OperationTypeNode } from 'graphql';
-import type { SupergraphState } from '../../../state';
-import { Step } from './operation-path';
+import type { SupergraphState } from '../../../state.cjs';
+import { Step } from './operation-path.cjs';
 export declare class Supergraph {
     private supergraph;
     private mergedGraph;
@@ -8,7 +8,7 @@ export declare class Supergraph {
     private moveRequirementChecker;
     private logger;
     constructor(supergraphState: SupergraphState);
-    validate(): import("./walker").WalkTracker[];
-    validateOperation(operation: OperationTypeNode, steps: Step[]): import("./walker").WalkTracker;
+    validate(): import("./walker.js").WalkTracker[];
+    validateOperation(operation: OperationTypeNode, steps: Step[]): import("./walker.js").WalkTracker;
 }
 //# sourceMappingURL=supergraph.d.ts.map

package/typings/supergraph/validation/rules/satisfiablity/supergraph.d.ts

@@ -1,6 +1,6 @@
 import { OperationTypeNode } from 'graphql';
-import type { SupergraphState } from '../../../state';
-import { Step } from './operation-path';
+import type { SupergraphState } from '../../../state.js';
+import { Step } from './operation-path.js';
 export declare class Supergraph {
     private supergraph;
     private mergedGraph;
@@ -8,7 +8,7 @@ export declare class Supergraph {
     private moveRequirementChecker;
     private logger;
     constructor(supergraphState: SupergraphState);
-    validate(): import("./walker").WalkTracker[];
-    validateOperation(operation: OperationTypeNode, steps: Step[]): import("./walker").WalkTracker;
+    validate(): import("./walker.js").WalkTracker[];
+    validateOperation(operation: OperationTypeNode, steps: Step[]): import("./walker.js").WalkTracker;
 }
 //# sourceMappingURL=supergraph.d.ts.map

package/typings/supergraph/validation/rules/satisfiablity/walker.d.cts

@@ -1,10 +1,10 @@
 import { OperationTypeNode } from 'graphql';
-import type { Logger } from '../../../../utils/logger';
-import { type Edge } from './edge';
-import { SatisfiabilityError } from './errors';
-import type { Graph } from './graph';
-import type { MoveValidator } from './move-validator';
-import { OperationPath, type Step } from './operation-path';
+import type { Logger } from '../../../../utils/logger.cjs';
+import { type Edge } from './edge.cjs';
+import { SatisfiabilityError } from './errors.cjs';
+import type { Graph } from './graph.cjs';
+import type { MoveValidator } from './move-validator.cjs';
+import { OperationPath, type Step } from './operation-path.cjs';
 export declare class WalkTracker {
     superPath: OperationPath;
     paths: OperationPath[];

package/typings/supergraph/validation/rules/satisfiablity/walker.d.ts

@@ -1,10 +1,10 @@
 import { OperationTypeNode } from 'graphql';
-import type { Logger } from '../../../../utils/logger';
-import { type Edge } from './edge';
-import { SatisfiabilityError } from './errors';
-import type { Graph } from './graph';
-import type { MoveValidator } from './move-validator';
-import { OperationPath, type Step } from './operation-path';
+import type { Logger } from '../../../../utils/logger.js';
+import { type Edge } from './edge.js';
+import { SatisfiabilityError } from './errors.js';
+import type { Graph } from './graph.js';
+import type { MoveValidator } from './move-validator.js';
+import { OperationPath, type Step } from './operation-path.js';
 export declare class WalkTracker {
     superPath: OperationPath;
     paths: OperationPath[];