@theguild/federation-composition 0.9.0 → 0.10.0

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

@@ -0,0 +1,671 @@
+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';
+export class Graph {
+    name;
+    supergraphState;
+    fieldsResolver;
+    ignoreInaccessible;
+    _warnedAboutIncorrectEdge = false;
+    nodesByTypeIndex = [];
+    edgesByHeadTypeIndex = [];
+    edgesByTailTypeIndex = [];
+    typeNameToNodeIndexes = new Map();
+    typeChildren = [];
+    typeChildrenCache = new Map();
+    isSubgraph;
+    logger;
+    id;
+    idSymbol;
+    constructor(logger, id, name, supergraphState, fieldsResolver, ignoreInaccessible = false) {
+        this.name = name;
+        this.supergraphState = supergraphState;
+        this.fieldsResolver = fieldsResolver;
+        this.ignoreInaccessible = ignoreInaccessible;
+        this.logger = logger.create('Graph');
+        if (typeof id === 'string') {
+            this.idSymbol = Symbol.for(id);
+            this.id = id;
+            this.isSubgraph = true;
+        }
+        else {
+            this.idSymbol = id;
+            this.id = id.toString();
+            this.isSubgraph = this.idSymbol !== SUPERGRAPH_ID;
+        }
+    }
+    addUnreachableTypes() {
+        if (!this.isSupergraph()) {
+            for (const [typeName, state] of this.supergraphState.objectTypes) {
+                if (state.byGraph.has(this.id)) {
+                    this.createNodesAndEdgesForType(typeName);
+                }
+            }
+            for (const [typeName, state] of this.supergraphState.scalarTypes) {
+                if (state.byGraph.has(this.id)) {
+                    this.createNodeForScalarType(typeName);
+                }
+            }
+            for (const [_, state] of this.supergraphState.enumTypes) {
+                if (state.byGraph.has(this.id)) {
+                    this.createNodeForEnumType(state);
+                }
+            }
+            for (const [_, state] of this.supergraphState.unionTypes) {
+                if (state.byGraph.has(this.id)) {
+                    this.createNodeForUnionType(state);
+                }
+            }
+            for (const [_, state] of this.supergraphState.interfaceTypes) {
+                if (state.byGraph.has(this.id)) {
+                    this.createNodeForInterfaceType(state);
+                }
+            }
+        }
+        return this;
+    }
+    addFromRoots() {
+        for (const typeName of ['Query', 'Mutation', 'Subscription']) {
+            const typeState = this.supergraphState.objectTypes.get(typeName);
+            if (typeState && this.trueOrIfSubgraphThen(() => typeState.byGraph.has(this.id))) {
+                this.createNodesAndEdgesForType(typeState.name);
+            }
+        }
+        return this;
+    }
+    addFromEntities() {
+        for (const typeState of this.supergraphState.objectTypes.values()) {
+            if (typeState?.isEntity && this.trueOrIfSubgraphThen(() => typeState.byGraph.has(this.id))) {
+                this.createNodesAndEdgesForType(typeState.name);
+            }
+        }
+        return this;
+    }
+    addSubgraph(graph) {
+        for (const node of graph.nodesByTypeIndex.flat()) {
+            this.addNode(node.withoutState());
+        }
+        for (const edges of graph.edgesByHeadTypeIndex) {
+            for (const edge of edges) {
+                this.addEdge(edge);
+            }
+        }
+    }
+    connectUnionOrInterface(nodeIndex, sameTypeNameNodeIndexes, edgesToAdd) {
+        for (const headNode of this.nodesByTypeIndex[nodeIndex]) {
+            const edges = this.edgesOfTail(headNode);
+            if (edges.length === 0) {
+                continue;
+            }
+            for (const otherNodeIndex of sameTypeNameNodeIndexes) {
+                if (nodeIndex === otherNodeIndex) {
+                    continue;
+                }
+                for (const tailNode of this.nodesByTypeIndex[otherNodeIndex]) {
+                    if (headNode === tailNode) {
+                        continue;
+                    }
+                    for (const edge of edges) {
+                        edgesToAdd.push(new Edge(edge.head, edge.move, tailNode));
+                    }
+                }
+            }
+        }
+    }
+    connectEntities(nodeIndex, sameTypeNameNodeIndexes, edgesToAdd) {
+        for (const headNode of this.nodesByTypeIndex[nodeIndex]) {
+            for (const otherNodeIndex of sameTypeNameNodeIndexes) {
+                if (nodeIndex === otherNodeIndex) {
+                    continue;
+                }
+                for (const tailNode of this.nodesByTypeIndex[otherNodeIndex]) {
+                    if (!(tailNode.typeState && 'isEntity' in tailNode.typeState && tailNode.typeState.isEntity)) {
+                        continue;
+                    }
+                    const typeStateInGraph = tailNode.typeState.byGraph.get(tailNode.graphId);
+                    const keys = (typeStateInGraph?.keys ?? [])
+                        .slice()
+                        .sort((a, b) => scoreKeyFields(a.fields) - scoreKeyFields(b.fields));
+                    for (const key of keys) {
+                        if (key.resolvable) {
+                            edgesToAdd.push(new Edge(headNode, new EntityMove(this.fieldsResolver.resolve(headNode.typeName, key.fields)), tailNode));
+                        }
+                    }
+                }
+            }
+        }
+    }
+    addProvidedInterfaceFields(head, providedFields, queue) {
+        const abstractIndexes = head.getAbstractEdgeIndexes(head.typeName);
+        if (!abstractIndexes || abstractIndexes.length === 0) {
+            throw new Error('Expected abstract indexes to be defined');
+        }
+        const interfaceFields = [];
+        const fieldsByType = new Map();
+        for (const providedField of providedFields) {
+            if (providedField.typeName === head.typeName) {
+                interfaceFields.push(providedField);
+                continue;
+            }
+            const existing = fieldsByType.get(providedField.typeName);
+            if (existing) {
+                existing.push(providedField);
+            }
+            else {
+                fieldsByType.set(providedField.typeName, [providedField]);
+            }
+        }
+        for (const [typeName, providedFields] of fieldsByType) {
+            let edgeIndex;
+            let edge;
+            for (let i = 0; i < abstractIndexes.length; i++) {
+                const index = abstractIndexes[i];
+                const potentialEdge = this.edgesByHeadTypeIndex[head.index][index];
+                if (!potentialEdge) {
+                    throw new Error('Expected edge to be defined');
+                }
+                if (potentialEdge.tail.typeName === typeName) {
+                    edgeIndex = index;
+                    edge = potentialEdge;
+                    break;
+                }
+            }
+            if (typeof edgeIndex === 'undefined' || !edge) {
+                throw new Error(`Expected an abstract edge matching "${typeName}" to be defined`);
+            }
+            const newTail = this.duplicateNode(edge.tail);
+            const newEdge = new Edge(edge.head, edge.move, newTail);
+            this.replaceEdgeAt(edge.head.index, edge.tail.index, newEdge, edgeIndex);
+            queue.push({
+                head: newTail,
+                providedFields,
+            });
+        }
+        if (!interfaceFields.length) {
+            return;
+        }
+        for (const index of abstractIndexes) {
+            const edge = this.edgesByHeadTypeIndex[head.index][index];
+            if (!edge) {
+                throw new Error('Expected edge to be defined');
+            }
+            assertAbstractEdge(edge);
+            if (edge.isCrossGraphEdge()) {
+                continue;
+            }
+            const newTail = this.duplicateNode(edge.tail);
+            const newEdge = new Edge(edge.head, new AbstractMove(), newTail);
+            this.replaceEdgeAt(edge.head.index, edge.tail.index, newEdge, index);
+            queue.push({
+                head: newTail,
+                providedFields: interfaceFields.map(f => ({
+                    ...f,
+                    typeName: newTail.typeName,
+                })),
+            });
+        }
+    }
+    addProvidedField(head, providedField, queue) {
+        if (providedField.fieldName === '__typename') {
+            return;
+        }
+        const indexes = head.getFieldEdgeIndexes(providedField.fieldName);
+        if (!indexes || indexes.length === 0) {
+            if (head.typeState?.kind === 'object') {
+                throw new Error('Expected indexes to be defined: ' +
+                    providedField.typeName +
+                    '.' +
+                    providedField.fieldName);
+            }
+            else {
+                throw new Error(`Expected ${providedField.typeName}.${providedField.fieldName} to be point to an object type, other kinds are not supported (received: ${head.typeState?.kind})`);
+            }
+        }
+        for (const index of indexes) {
+            const edge = this.edgesByHeadTypeIndex[head.index][index];
+            if (!edge) {
+                throw new Error('Expected edge to be defined');
+            }
+            assertFieldEdge(edge);
+            if (edge.isCrossGraphEdge()) {
+                continue;
+            }
+            const newTail = this.duplicateNode(edge.tail);
+            const newEdge = new Edge(edge.head, new 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({
+                    head: newTail,
+                    providedFields: providedField.selectionSet,
+                });
+            }
+        }
+    }
+    joinSubgraphs() {
+        const edgesToAdd = [];
+        for (let i = 0; i < this.nodesByTypeIndex.length; i++) {
+            const typeNode = this.nodesByTypeIndex[i][0];
+            if (!typeNode.typeState) {
+                continue;
+            }
+            const otherNodesIndexes = this.getIndexesOfType(typeNode.typeName);
+            if (!Array.isArray(otherNodesIndexes)) {
+                continue;
+            }
+            if (typeNode.typeState?.kind === 'object' && typeNode.typeState?.isEntity) {
+                this.connectEntities(i, otherNodesIndexes, edgesToAdd);
+            }
+            else if (typeNode.typeState.kind === 'union' || typeNode.typeState.kind === 'interface') {
+                this.connectUnionOrInterface(i, otherNodesIndexes, edgesToAdd);
+            }
+        }
+        while (edgesToAdd.length > 0) {
+            const edge = edgesToAdd.pop();
+            if (!edge) {
+                throw new Error('Expected edge to be defined');
+            }
+            this.addEdge(edge);
+        }
+        for (let headIndex = 0; headIndex < this.edgesByHeadTypeIndex.length; headIndex++) {
+            const edges = this.edgesByHeadTypeIndex[headIndex];
+            for (let edgeIndex = 0; edgeIndex < edges.length; edgeIndex++) {
+                const edge = edges[edgeIndex];
+                if (edge.isCrossGraphEdge()) {
+                    continue;
+                }
+                if (!(isFieldEdge(edge) && edge.move.provides)) {
+                    continue;
+                }
+                const newTail = this.duplicateNode(edge.tail);
+                const newEdge = new Edge(edge.head, edge.move, newTail);
+                this.replaceEdgeAt(headIndex, edge.tail.index, newEdge, edgeIndex);
+                const queue = [
+                    {
+                        head: newTail,
+                        providedFields: edge.move.provides.fields,
+                    },
+                ];
+                while (queue.length > 0) {
+                    const item = queue.pop();
+                    if (!item) {
+                        throw new Error('Expected item to be defined');
+                    }
+                    const { head, providedFields } = item;
+                    if (head.typeState?.kind === 'interface') {
+                        this.addProvidedInterfaceFields(head, providedFields, queue);
+                        continue;
+                    }
+                    for (const providedField of providedFields) {
+                        this.addProvidedField(head, providedField, queue);
+                    }
+                }
+            }
+        }
+        return this;
+    }
+    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(newNode, edge.move, edge.tail));
+        }
+        return newNode;
+    }
+    replaceEdgeAt(headIndex, tailIndex, newEdge, edgeIndex) {
+        this.edgesByHeadTypeIndex[headIndex][edgeIndex] = newEdge;
+        const newEdgesByTail = [];
+        for (const edge of this.edgesByTailTypeIndex[tailIndex]) {
+            if (edge !== newEdge) {
+                newEdgesByTail.push(edge);
+            }
+        }
+        newEdgesByTail.push(newEdge);
+        this.edgesByTailTypeIndex[tailIndex] = newEdgesByTail;
+    }
+    print(asLink = false) {
+        let str = 'digraph G {';
+        if (this.supergraphState.objectTypes.has('Query')) {
+            str += '\n root -> Query';
+        }
+        if (this.supergraphState.objectTypes.has('Mutation')) {
+            str += '\n root -> Mutation';
+        }
+        if (this.supergraphState.objectTypes.has('Subscription')) {
+            str += '\n root -> Subscription';
+        }
+        for (const edge of this.edgesByHeadTypeIndex.flat()) {
+            if (edge.head.typeName === 'Query') {
+                str += `\n  "Query" -> "${edge.head}";`;
+            }
+            else if (edge.head.typeName === 'Mutation') {
+                str += `\n  "Mutation" -> "${edge.head}";`;
+            }
+            else if (edge.head.typeName === 'Subscription') {
+                str += `\n  "Subscription" -> "${edge.head}";`;
+            }
+            str += `\n  "${edge.head}" -> "${edge.tail}" [label="${edge.move}"];`;
+        }
+        str += '\n}';
+        if (asLink) {
+            return `https://dreampuf.github.io/GraphvizOnline/#${encodeURIComponent(str)}`;
+        }
+        return str;
+    }
+    graphNameToId(graphName) {
+        for (const [id, { graph }] of this.supergraphState.subgraphs) {
+            if (graph.name === graphName) {
+                return id;
+            }
+        }
+    }
+    nodeOf(typeName, failIfMissing = true) {
+        const indexes = this.getIndexesOfType(typeName);
+        if (!Array.isArray(indexes)) {
+            if (failIfMissing) {
+                throw new Error(`Expected TypeNode(${typeName}) to be inserted first in graph ${this.id}`);
+            }
+            return undefined;
+        }
+        if (indexes.length > 1) {
+            throw new Error(`Expected only one node for ${typeName} in graph ${this.id}`);
+        }
+        return this.nodesByTypeIndex[indexes[0]][0];
+    }
+    nodesOf(typeName, failIfMissing = true) {
+        const indexes = this.getIndexesOfType(typeName);
+        if (!Array.isArray(indexes)) {
+            if (failIfMissing) {
+                throw new Error(`Expected TypeNode(${typeName}) to be inserted first in graph ${this.id}`);
+            }
+            return [];
+        }
+        const nodes = [];
+        for (const i of indexes) {
+            for (const node of this.nodesByTypeIndex[i]) {
+                nodes.push(node);
+            }
+        }
+        return nodes;
+    }
+    getSameGraphEdgesOfIndex(head, indexes, kind) {
+        const edges = [];
+        if (!indexes) {
+            return [];
+        }
+        for (const i of indexes) {
+            const edge = this.edgesByHeadTypeIndex[head.index][i];
+            if (!edge) {
+                throw new Error(`Expected edge to be defined at index ${i}`);
+            }
+            if (edge.head.graphName === head.graphName) {
+                edges.push(edge);
+                continue;
+            }
+            if (!this._warnedAboutIncorrectEdge) {
+                console.error(`Expected edge to be in the same graph as head (${kind})` + edge.toString());
+                this._warnedAboutIncorrectEdge = true;
+            }
+        }
+        return edges;
+    }
+    fieldEdgesOfHead(head, fieldName) {
+        return this.getSameGraphEdgesOfIndex(head, head.getFieldEdgeIndexes(fieldName), 'field');
+    }
+    abstractEdgesOfHead(head) {
+        return this.getSameGraphEdgesOfIndex(head, head.getAbstractEdgeIndexes(head.typeName), 'abstract');
+    }
+    entityEdgesOfHead(head) {
+        return this.getSameGraphEdgesOfIndex(head, head.getEntityEdgeIndexes(head.typeName), 'entity');
+    }
+    crossGraphEdgesOfHead(head) {
+        return this.getSameGraphEdgesOfIndex(head, head.getCrossGraphEdgeIndexes(head.typeName), 'cross-graph');
+    }
+    edgesOfHead(head) {
+        return this.edgesByHeadTypeIndex[head.index]?.filter(e => e.head === head) ?? [];
+    }
+    edgesOfTail(tail) {
+        return this.edgesByTailTypeIndex[tail.index]?.filter(e => e.tail === tail) ?? [];
+    }
+    possibleTypesOf(typeName) {
+        if (this.supergraphState.interfaceTypes.has(typeName)) {
+            return Array.from(this.supergraphState.interfaceTypes.get(typeName).implementedBy);
+        }
+        if (this.supergraphState.unionTypes.has(typeName)) {
+            return Array.from(this.supergraphState.unionTypes.get(typeName).members);
+        }
+        return [typeName];
+    }
+    canReachTypeFromType(fromTypeName, toTypeName) {
+        if (fromTypeName === toTypeName) {
+            return true;
+        }
+        const fromTypeIndexes = this.getIndexesOfType(fromTypeName);
+        if (!fromTypeIndexes) {
+            return false;
+        }
+        const visited = new Array(this.typeChildren.length).fill(false);
+        const queue = [];
+        for (const i of fromTypeIndexes) {
+            visited[i] = true;
+        }
+        queue.push(fromTypeName);
+        while (queue.length > 0) {
+            const typeName = queue.shift();
+            if (!typeName) {
+                throw new Error('Unexpected end of queue');
+            }
+            const typeIndexes = this.getIndexesOfType(typeName);
+            if (typeof typeIndexes === 'undefined') {
+                throw new Error(`Could not find an index of type: ${typeName}`);
+            }
+            this.typeChildrenCache.set(`${fromTypeName} -> ${typeName}`, true);
+            if (typeName === toTypeName) {
+                return true;
+            }
+            for (const typeIndex of typeIndexes) {
+                const children = this.typeChildren[typeIndex];
+                for (const childTypeName of children) {
+                    const childTypeIndexes = this.getIndexesOfType(childTypeName);
+                    if (typeof childTypeIndexes === 'undefined') {
+                        throw new Error(`Could not find an index of type: ${typeName}`);
+                    }
+                    for (const childTypeIndex of childTypeIndexes) {
+                        if (!visited[childTypeIndex]) {
+                            visited[childTypeIndex] = true;
+                            this.typeChildrenCache.set(`${fromTypeName} -> ${childTypeName}`, true);
+                            this.typeChildrenCache.set(`${typeName} -> ${childTypeName}`, true);
+                            queue.push(childTypeName);
+                        }
+                    }
+                }
+            }
+        }
+        this.typeChildrenCache.set(`${fromTypeName} -> ${toTypeName}`, false);
+        return false;
+    }
+    createNodesAndEdgesForType(typeName) {
+        if (this.supergraphState.objectTypes.has(typeName)) {
+            return this.createNodesAndEdgesForObjectType(this.supergraphState.objectTypes.get(typeName));
+        }
+        if (specifiedScalarTypes.some(t => t.name === typeName) ||
+            this.supergraphState.scalarTypes.has(typeName)) {
+            return this.createNodeForScalarType(typeName);
+        }
+        if (this.supergraphState.enumTypes.has(typeName)) {
+            return this.createNodeForEnumType(this.supergraphState.enumTypes.get(typeName));
+        }
+        if (this.supergraphState.unionTypes.has(typeName)) {
+            return this.createNodeForUnionType(this.supergraphState.unionTypes.get(typeName));
+        }
+        if (this.supergraphState.interfaceTypes.has(typeName)) {
+            return this.createNodeForInterfaceType(this.supergraphState.interfaceTypes.get(typeName));
+        }
+        throw new Error(`Not implemented path: createNodesAndEdgesForType(${typeName})`);
+    }
+    ensureNonOrSingleNode(typeName) {
+        const indexes = this.typeNameToNodeIndexes.get(typeName);
+        if (!Array.isArray(indexes)) {
+            return;
+        }
+        if (indexes.length > 1) {
+            throw new Error(`Expected only one node for ${typeName} in graph ${this.id}`);
+        }
+        return this.nodesByTypeIndex[indexes[0]][0];
+    }
+    createNodesAndEdgesForObjectType(typeState) {
+        const existing = this.ensureNonOrSingleNode(typeState.name);
+        if (existing) {
+            return existing;
+        }
+        const head = this.createTypeNode(typeState.name, typeState);
+        for (const field of typeState.fields.values()) {
+            if (this.trueOrIfSubgraphThen(() => field.byGraph.has(this.id))) {
+                this.createEdgeForObjectTypeField(head, field);
+            }
+        }
+        return head;
+    }
+    createNodeForScalarType(typeName) {
+        const existing = this.ensureNonOrSingleNode(typeName);
+        if (existing) {
+            return existing;
+        }
+        return this.createTypeNode(typeName, this.supergraphState.scalarTypes.get(typeName) ?? null);
+    }
+    createNodeForEnumType(typeState) {
+        const existing = this.ensureNonOrSingleNode(typeState.name);
+        if (existing) {
+            return existing;
+        }
+        return this.createTypeNode(typeState.name, typeState);
+    }
+    createNodeForUnionType(typeState) {
+        const existing = this.ensureNonOrSingleNode(typeState.name);
+        if (existing) {
+            return existing;
+        }
+        const head = this.createTypeNode(typeState.name, typeState);
+        const members = this.isSupergraph()
+            ? typeState.members
+            : typeState.byGraph.get(this.id)?.members;
+        if (members) {
+            for (const memberTypeName of members) {
+                const tail = this.createNodesAndEdgesForType(memberTypeName);
+                this.addEdge(new Edge(head, new AbstractMove(), tail));
+            }
+        }
+        return head;
+    }
+    createNodeForInterfaceType(typeState) {
+        const existing = this.ensureNonOrSingleNode(typeState.name);
+        if (existing) {
+            return existing;
+        }
+        const head = this.createTypeNode(typeState.name, typeState);
+        const implementedBy = this.isSupergraph()
+            ? typeState.implementedBy
+            : typeState.byGraph.get(this.id)?.implementedBy;
+        if (implementedBy) {
+            for (const memberTypeName of implementedBy) {
+                const tail = this.createNodesAndEdgesForType(memberTypeName);
+                this.addEdge(new Edge(head, new AbstractMove(), tail));
+            }
+        }
+        return head;
+    }
+    createEdgeForObjectTypeField(head, field) {
+        if (this.ignoreInaccessible && field.inaccessible) {
+            return;
+        }
+        if (this.isSupergraph() && field.byGraph.size === 1) {
+            const graphId = Array.from(field.byGraph.keys())[0];
+            const isExternal = field.byGraph.get(graphId)?.external === true;
+            const isFederationV1 = this.supergraphState.subgraphs.get(graphId)?.version === 'v1.0';
+            if (isExternal && isFederationV1) {
+                return;
+            }
+        }
+        const outputTypeName = 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(head, new 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(head, new 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)) {
+            throw new Error(`Node for ${typeName} already exists in subgraph ${this.id}`);
+        }
+        return this.createNode(typeName, typeState, this.id, this.name);
+    }
+    createNode(typeName, typeState, graphId, graphName) {
+        const index = this.nodesByTypeIndex.push([]) - 1;
+        const node = new Node(index, typeName, typeState, graphId, graphName);
+        this.nodesByTypeIndex[node.index].push(node);
+        this.edgesByHeadTypeIndex.push([]);
+        this.edgesByTailTypeIndex.push([]);
+        this.typeChildren.push(new Set());
+        const existing = this.typeNameToNodeIndexes.get(typeName);
+        if (Array.isArray(existing)) {
+            existing.push(index);
+        }
+        else {
+            this.typeNameToNodeIndexes.set(typeName, [index]);
+        }
+        return node;
+    }
+    addNode(node) {
+        const newIndex = this.nodesByTypeIndex.push([]) - 1;
+        node.index = newIndex;
+        this.nodesByTypeIndex[node.index].push(node);
+        this.edgesByHeadTypeIndex.push([]);
+        this.edgesByTailTypeIndex.push([]);
+        this.typeChildren.push(new Set());
+        const existing = this.typeNameToNodeIndexes.get(node.typeName);
+        if (Array.isArray(existing)) {
+            existing.push(newIndex);
+        }
+        else {
+            this.typeNameToNodeIndexes.set(node.typeName, [newIndex]);
+        }
+        return node;
+    }
+    addEdge(edge) {
+        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 (isFieldEdge(edge)) {
+            edge.head.addFieldEdge(edge.move.fieldName, edgeIndex);
+        }
+        else if (isEntityEdge(edge)) {
+            edge.head.addEntityEdge(edge.head.typeName, edgeIndex);
+        }
+        else if (isAbstractEdge(edge)) {
+            edge.head.addAbstractEdge(edge.head.typeName, edgeIndex);
+        }
+        if (edge.isCrossGraphEdge()) {
+            edge.head.addCrossGraphEdge(edge.head.typeName, edgeIndex);
+        }
+        return edge;
+    }
+    getIndexesOfType(typeName) {
+        return this.typeNameToNodeIndexes.get(typeName);
+    }
+    trueOrIfSubgraphThen(conditionFn) {
+        if (this.isSubgraph) {
+            return conditionFn();
+        }
+        return true;
+    }
+    isSupergraph() {
+        return this.isSubgraph === false;
+    }
+}