@terra-graph/core 1.0.0-rc.4

package/dist/cjs/Graph/Rules/Node/RemoveLeafChain.test.js

@@ -0,0 +1,399 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const graphology_1 = require("graphology");
+const GraphologyAdapter_js_1 = require("../../Adapters/GraphologyAdapter.js");
+const GraphResolver_js_1 = require("../../GraphResolver.js");
+const TgGraph_js_1 = require("../../TgGraph.js");
+const RemoveLeafChain_js_1 = require("./RemoveLeafChain.js");
+const IAM_ORPHAN_SCOPE = {
+    or: [
+        {
+            and: [
+                { attr: { key: 'terraform.kind', eq: 'resource' } },
+                {
+                    attr: {
+                        key: 'terraform.resource',
+                        in: [
+                            'aws_iam_role',
+                            'aws_iam_role_policy_attachment',
+                            'aws_iam_policy_attachment',
+                            'aws_iam_policy',
+                            'aws_iam_role_policy',
+                        ],
+                    },
+                },
+            ],
+        },
+        {
+            and: [
+                { attr: { key: 'terraform.kind', eq: 'data' } },
+                {
+                    attr: {
+                        key: 'terraform.resource',
+                        in: ['aws_iam_policy_document', 'aws_iam_policy'],
+                    },
+                },
+            ],
+        },
+    ],
+};
+const buildNode = (id, kind, resource) => ({
+    id: (0, TgGraph_js_1.asNodeId)(id),
+    label: id,
+    terraform: {
+        kind,
+        address: id,
+        resource,
+        name: id,
+    },
+});
+const buildEdge = (id, from, to) => ({
+    id: (0, TgGraph_js_1.asEdgeId)(id),
+    from: (0, TgGraph_js_1.asNodeId)(from),
+    to: (0, TgGraph_js_1.asNodeId)(to),
+    attributes: {},
+});
+const applyRule = (graph) => {
+    const adapter = new GraphologyAdapter_js_1.GraphologyAdapter(new graphology_1.DirectedGraph());
+    const resolver = new GraphResolver_js_1.GraphResolver(adapter);
+    return resolver.resolve({
+        graph,
+        phases: [[new RemoveLeafChain_js_1.RemoveLeafChain({ node: IAM_ORPHAN_SCOPE })]],
+    });
+};
+describe('RemoveLeafChain.apply', () => {
+    it('shoud remove the full chain when an aws_iam_role is a leaf', () => {
+        const result = applyRule({
+            schemaVersion: TgGraph_js_1.TG_SCHEMA_VERSION,
+            description: {},
+            nodes: {
+                data: buildNode('data', 'data', 'aws_iam_policy_document'),
+                rolePolicy: buildNode('rolePolicy', 'resource', 'aws_iam_role_policy'),
+                attachment: buildNode('attachment', 'resource', 'aws_iam_role_policy_attachment'),
+                role: buildNode('role', 'resource', 'aws_iam_role'),
+            },
+            edges: [
+                buildEdge('data-rolePolicy', 'data', 'rolePolicy'),
+                buildEdge('rolePolicy-attachment', 'rolePolicy', 'attachment'),
+                buildEdge('attachment-role', 'attachment', 'role'),
+            ],
+        });
+        expect(result.getNodeAttributes((0, TgGraph_js_1.asNodeId)('data'))).toBeUndefined();
+        expect(result.getNodeAttributes((0, TgGraph_js_1.asNodeId)('rolePolicy'))).toBeUndefined();
+        expect(result.getNodeAttributes((0, TgGraph_js_1.asNodeId)('attachment'))).toBeUndefined();
+        expect(result.getNodeAttributes((0, TgGraph_js_1.asNodeId)('role'))).toBeUndefined();
+    });
+    it('shoud remove the full chain when an attachment is a leaf', () => {
+        const result = applyRule({
+            schemaVersion: TgGraph_js_1.TG_SCHEMA_VERSION,
+            description: {},
+            nodes: {
+                data: buildNode('data', 'data', 'aws_iam_policy_document'),
+                policy: buildNode('policy', 'resource', 'aws_iam_policy'),
+                role: buildNode('role', 'resource', 'aws_iam_role'),
+                attachment: buildNode('attachment', 'resource', 'aws_iam_policy_attachment'),
+            },
+            edges: [
+                buildEdge('data-policy', 'data', 'policy'),
+                buildEdge('policy-attachment', 'policy', 'attachment'),
+                buildEdge('role-attachment', 'role', 'attachment'),
+            ],
+        });
+        expect(result.getNodeAttributes((0, TgGraph_js_1.asNodeId)('data'))).toBeUndefined();
+        expect(result.getNodeAttributes((0, TgGraph_js_1.asNodeId)('policy'))).toBeUndefined();
+        expect(result.getNodeAttributes((0, TgGraph_js_1.asNodeId)('role'))).toBeUndefined();
+        expect(result.getNodeAttributes((0, TgGraph_js_1.asNodeId)('attachment'))).toBeUndefined();
+    });
+    it('shoud remove an orphaned data.aws_iam_policy_document leaf node', () => {
+        const result = applyRule({
+            schemaVersion: TgGraph_js_1.TG_SCHEMA_VERSION,
+            description: {},
+            nodes: {
+                data: buildNode('data', 'data', 'aws_iam_policy_document'),
+            },
+            edges: [],
+        });
+        expect(result.getNodeAttributes((0, TgGraph_js_1.asNodeId)('data'))).toBeUndefined();
+    });
+    it('shoud remove an orphaned data.aws_iam_policy leaf node', () => {
+        const result = applyRule({
+            schemaVersion: TgGraph_js_1.TG_SCHEMA_VERSION,
+            description: {},
+            nodes: {
+                data: buildNode('data', 'data', 'aws_iam_policy'),
+            },
+            edges: [],
+        });
+        expect(result.getNodeAttributes((0, TgGraph_js_1.asNodeId)('data'))).toBeUndefined();
+    });
+    it('shoud preserve shared IAM nodes that still lead to non-IAM resources', () => {
+        const result = applyRule({
+            schemaVersion: TgGraph_js_1.TG_SCHEMA_VERSION,
+            description: {},
+            nodes: {
+                policy: buildNode('policy', 'resource', 'aws_iam_policy'),
+                deadAttachment: buildNode('deadAttachment', 'resource', 'aws_iam_policy_attachment'),
+                deadRole: buildNode('deadRole', 'resource', 'aws_iam_role'),
+                liveAttachment: buildNode('liveAttachment', 'resource', 'aws_iam_policy_attachment'),
+                liveRole: buildNode('liveRole', 'resource', 'aws_iam_role'),
+                lambda: buildNode('lambda', 'resource', 'aws_lambda_function'),
+            },
+            edges: [
+                buildEdge('policy-deadAttachment', 'policy', 'deadAttachment'),
+                buildEdge('deadAttachment-deadRole', 'deadAttachment', 'deadRole'),
+                buildEdge('policy-liveAttachment', 'policy', 'liveAttachment'),
+                buildEdge('liveAttachment-liveRole', 'liveAttachment', 'liveRole'),
+                buildEdge('liveRole-lambda', 'liveRole', 'lambda'),
+            ],
+        });
+        expect(result.getNodeAttributes((0, TgGraph_js_1.asNodeId)('deadAttachment'))).toBeUndefined();
+        expect(result.getNodeAttributes((0, TgGraph_js_1.asNodeId)('deadRole'))).toBeUndefined();
+        expect(result.getNodeAttributes((0, TgGraph_js_1.asNodeId)('policy'))).toBeDefined();
+        expect(result.getNodeAttributes((0, TgGraph_js_1.asNodeId)('liveAttachment'))).toBeDefined();
+        expect(result.getNodeAttributes((0, TgGraph_js_1.asNodeId)('liveRole'))).toBeDefined();
+        expect(result.getNodeAttributes((0, TgGraph_js_1.asNodeId)('lambda'))).toBeDefined();
+    });
+    it('shoud stop chain removal at non-IAM boundaries', () => {
+        const result = applyRule({
+            schemaVersion: TgGraph_js_1.TG_SCHEMA_VERSION,
+            description: {},
+            nodes: {
+                lambda: buildNode('lambda', 'resource', 'aws_lambda_function'),
+                attachment: buildNode('attachment', 'resource', 'aws_iam_policy_attachment'),
+            },
+            edges: [buildEdge('lambda-attachment', 'lambda', 'attachment')],
+        });
+        expect(result.getNodeAttributes((0, TgGraph_js_1.asNodeId)('attachment'))).toBeUndefined();
+        expect(result.getNodeAttributes((0, TgGraph_js_1.asNodeId)('lambda'))).toBeDefined();
+    });
+    it('shoud iteratively prune newly orphaned predecessors to a fixpoint', () => {
+        const result = applyRule({
+            schemaVersion: TgGraph_js_1.TG_SCHEMA_VERSION,
+            description: {},
+            nodes: {
+                data: buildNode('data', 'data', 'aws_iam_policy_document'),
+                policyA: buildNode('policyA', 'resource', 'aws_iam_policy'),
+                policyB: buildNode('policyB', 'resource', 'aws_iam_policy'),
+                attachment: buildNode('attachment', 'resource', 'aws_iam_policy_attachment'),
+                role: buildNode('role', 'resource', 'aws_iam_role'),
+            },
+            edges: [
+                buildEdge('data-policyA', 'data', 'policyA'),
+                buildEdge('data-policyB', 'data', 'policyB'),
+                buildEdge('policyA-attachment', 'policyA', 'attachment'),
+                buildEdge('policyB-attachment', 'policyB', 'attachment'),
+                buildEdge('attachment-role', 'attachment', 'role'),
+            ],
+        });
+        expect(result.getNodeAttributes((0, TgGraph_js_1.asNodeId)('data'))).toBeUndefined();
+        expect(result.getNodeAttributes((0, TgGraph_js_1.asNodeId)('policyA'))).toBeUndefined();
+        expect(result.getNodeAttributes((0, TgGraph_js_1.asNodeId)('policyB'))).toBeUndefined();
+        expect(result.getNodeAttributes((0, TgGraph_js_1.asNodeId)('attachment'))).toBeUndefined();
+        expect(result.getNodeAttributes((0, TgGraph_js_1.asNodeId)('role'))).toBeUndefined();
+    });
+});
+describe('RemoveLeafChain.apply (direct)', () => {
+    it('shoud skip scoped nodes that are not leaf nodes', () => {
+        const nodeA = buildNode('node-a', 'resource', 'aws_iam_role');
+        const nodeB = buildNode('node-b', 'resource', 'aws_lambda_function');
+        const graph = {
+            schemaVersion: TgGraph_js_1.TG_SCHEMA_VERSION,
+            description: {},
+            nodes: {
+                [nodeA.id]: nodeA,
+                [nodeB.id]: nodeB,
+            },
+            edges: [buildEdge('edge-a-b', 'node-a', 'node-b')],
+        };
+        const adapter = new GraphologyAdapter_js_1.GraphologyAdapter(new graphology_1.DirectedGraph()).withTgGraph(graph);
+        const node = adapter.getNodeAttributes((0, TgGraph_js_1.asNodeId)('node-a'));
+        if (!node) {
+            throw new Error('Missing node attributes for node-a');
+        }
+        const rule = new RemoveLeafChain_js_1.RemoveLeafChain({
+            node: { nodeId: { eq: 'node-a' } },
+        });
+        rule.match((0, TgGraph_js_1.asNodeId)('node-a'), node, adapter);
+        const result = rule.apply((0, TgGraph_js_1.asNodeId)('node-a'), node, adapter);
+        expect(result.getNodeAttributes((0, TgGraph_js_1.asNodeId)('node-a'))).toBeDefined();
+        expect(result.getNodeAttributes((0, TgGraph_js_1.asNodeId)('node-b'))).toBeDefined();
+    });
+    it('shoud avoid removing predecessors when not all successors are removable', () => {
+        const nodeA = buildNode('node-a', 'resource', 'aws_iam_role');
+        const nodeB = buildNode('node-b', 'resource', 'aws_iam_policy');
+        const nodeC = buildNode('node-c', 'resource', 'aws_lambda_function');
+        const graph = {
+            schemaVersion: TgGraph_js_1.TG_SCHEMA_VERSION,
+            description: {},
+            nodes: {
+                [nodeA.id]: nodeA,
+                [nodeB.id]: nodeB,
+                [nodeC.id]: nodeC,
+            },
+            edges: [
+                buildEdge('edge-a-b', 'node-a', 'node-b'),
+                buildEdge('edge-a-c', 'node-a', 'node-c'),
+            ],
+        };
+        const adapter = new GraphologyAdapter_js_1.GraphologyAdapter(new graphology_1.DirectedGraph()).withTgGraph(graph);
+        const node = adapter.getNodeAttributes((0, TgGraph_js_1.asNodeId)('node-b'));
+        if (!node) {
+            throw new Error('Missing node attributes for node-b');
+        }
+        const rule = new RemoveLeafChain_js_1.RemoveLeafChain({
+            node: { nodeId: { in: ['node-a', 'node-b'] } },
+        });
+        rule.match((0, TgGraph_js_1.asNodeId)('node-b'), node, adapter);
+        const result = rule.apply((0, TgGraph_js_1.asNodeId)('node-b'), node, adapter);
+        expect(result.getNodeAttributes((0, TgGraph_js_1.asNodeId)('node-b'))).toBeUndefined();
+        expect(result.getNodeAttributes((0, TgGraph_js_1.asNodeId)('node-a'))).toBeDefined();
+        expect(result.getNodeAttributes((0, TgGraph_js_1.asNodeId)('node-c'))).toBeDefined();
+    });
+    it('shoud only apply once per rule instance', () => {
+        const node = buildNode('leaf', 'resource', 'aws_iam_role');
+        const graph = {
+            schemaVersion: TgGraph_js_1.TG_SCHEMA_VERSION,
+            description: {},
+            nodes: {
+                [node.id]: node,
+            },
+            edges: [],
+        };
+        const adapter = new GraphologyAdapter_js_1.GraphologyAdapter(new graphology_1.DirectedGraph()).withTgGraph(graph);
+        const nodeAttributes = adapter.getNodeAttributes((0, TgGraph_js_1.asNodeId)('leaf'));
+        if (!nodeAttributes) {
+            throw new Error('Missing node attributes for leaf');
+        }
+        const rule = new RemoveLeafChain_js_1.RemoveLeafChain({ node: { any: true } });
+        rule.match((0, TgGraph_js_1.asNodeId)('leaf'), nodeAttributes, adapter);
+        const first = rule.apply((0, TgGraph_js_1.asNodeId)('leaf'), nodeAttributes, adapter);
+        const second = rule.apply((0, TgGraph_js_1.asNodeId)('leaf'), nodeAttributes, first);
+        expect(first.getNodeAttributes((0, TgGraph_js_1.asNodeId)('leaf'))).toBeUndefined();
+        expect(second).toBe(first);
+    });
+    it('shoud skip falsy node ids when collecting removable nodes', () => {
+        const emptyNode = buildNode('', 'resource', 'aws_iam_role');
+        const graph = {
+            schemaVersion: TgGraph_js_1.TG_SCHEMA_VERSION,
+            description: {},
+            nodes: {
+                [emptyNode.id]: emptyNode,
+            },
+            edges: [],
+        };
+        const adapter = new GraphologyAdapter_js_1.GraphologyAdapter(new graphology_1.DirectedGraph()).withTgGraph(graph);
+        const nodeAttributes = adapter.getNodeAttributes((0, TgGraph_js_1.asNodeId)(''));
+        if (!nodeAttributes) {
+            throw new Error('Missing node attributes for empty id');
+        }
+        const rule = new RemoveLeafChain_js_1.RemoveLeafChain({ node: { any: true } });
+        rule.match((0, TgGraph_js_1.asNodeId)(''), nodeAttributes, adapter);
+        const result = rule.apply((0, TgGraph_js_1.asNodeId)(''), nodeAttributes, adapter);
+        expect(result.getNodeAttributes((0, TgGraph_js_1.asNodeId)(''))).toBeDefined();
+    });
+    it('shoud handle duplicate queue entries when removing leaf chains', () => {
+        const nodeA = buildNode('node-a', 'resource', 'aws_iam_role');
+        const nodeB = buildNode('node-b', 'resource', 'aws_iam_policy');
+        const nodeC = buildNode('node-c', 'resource', 'aws_iam_policy');
+        const graph = {
+            schemaVersion: TgGraph_js_1.TG_SCHEMA_VERSION,
+            description: {},
+            nodes: {
+                [nodeA.id]: nodeA,
+                [nodeB.id]: nodeB,
+                [nodeC.id]: nodeC,
+            },
+            edges: [
+                buildEdge('edge-a-b', 'node-a', 'node-b'),
+                buildEdge('edge-a-c', 'node-a', 'node-c'),
+            ],
+        };
+        const adapter = new GraphologyAdapter_js_1.GraphologyAdapter(new graphology_1.DirectedGraph()).withTgGraph(graph);
+        const nodeAttributes = adapter.getNodeAttributes((0, TgGraph_js_1.asNodeId)('node-b'));
+        if (!nodeAttributes) {
+            throw new Error('Missing node attributes for node-b');
+        }
+        const rule = new RemoveLeafChain_js_1.RemoveLeafChain({ node: { any: true } });
+        rule.match((0, TgGraph_js_1.asNodeId)('node-b'), nodeAttributes, adapter);
+        const result = rule.apply((0, TgGraph_js_1.asNodeId)('node-b'), nodeAttributes, adapter);
+        expect(result.getNodeAttributes((0, TgGraph_js_1.asNodeId)('node-a'))).toBeUndefined();
+        expect(result.getNodeAttributes((0, TgGraph_js_1.asNodeId)('node-b'))).toBeUndefined();
+        expect(result.getNodeAttributes((0, TgGraph_js_1.asNodeId)('node-c'))).toBeUndefined();
+    });
+    it('shoud skip removals when nodes disappear after collection', () => {
+        const nodeA = buildNode('node-a', 'resource', 'aws_iam_role');
+        const nodeAttributes = nodeA;
+        class FlakyRemovalAdapter {
+            removed = false;
+            callCount = 0;
+            nodeIds() {
+                return [nodeA.id];
+            }
+            outEdges() {
+                return [];
+            }
+            predecessors() {
+                return [];
+            }
+            edgeTarget() {
+                return nodeA.id;
+            }
+            getNodeAttributes() {
+                this.callCount += 1;
+                if (this.callCount > 2) {
+                    return undefined;
+                }
+                return nodeAttributes;
+            }
+            removeNode() {
+                this.removed = true;
+                return this;
+            }
+        }
+        const adapter = new FlakyRemovalAdapter();
+        const rule = new RemoveLeafChain_js_1.RemoveLeafChain({
+            node: { attr: { key: 'label', eq: 'node-a' } },
+        });
+        rule.match((0, TgGraph_js_1.asNodeId)('node-a'), nodeAttributes, adapter);
+        rule.apply((0, TgGraph_js_1.asNodeId)('node-a'), nodeAttributes, adapter);
+        expect(adapter.removed).toBe(false);
+    });
+    it('shoud skip nodes that fall out of scope during processing', () => {
+        const nodeA = buildNode('node-a', 'resource', 'aws_iam_role');
+        const nodeAttributes = nodeA;
+        class FlakyScopeAdapter {
+            removed = false;
+            callCount = 0;
+            nodeIds() {
+                return [nodeA.id];
+            }
+            outEdges() {
+                return [];
+            }
+            predecessors() {
+                return [];
+            }
+            edgeTarget() {
+                return nodeA.id;
+            }
+            getNodeAttributes() {
+                this.callCount += 1;
+                if (this.callCount > 1) {
+                    return undefined;
+                }
+                return nodeAttributes;
+            }
+            removeNode() {
+                this.removed = true;
+                return this;
+            }
+        }
+        const adapter = new FlakyScopeAdapter();
+        const rule = new RemoveLeafChain_js_1.RemoveLeafChain({
+            node: { attr: { key: 'label', eq: 'node-a' } },
+        });
+        rule.match((0, TgGraph_js_1.asNodeId)('node-a'), nodeAttributes, adapter);
+        rule.apply((0, TgGraph_js_1.asNodeId)('node-a'), nodeAttributes, adapter);
+        expect(adapter.removed).toBe(false);
+    });
+});

package/dist/cjs/Graph/Rules/Node/RemoveNode.d.ts

@@ -0,0 +1,6 @@
+import { AdapterOperations } from '../../Operations/Operations.js';
+import { NodeId, TgNodeAttributes } from '../../TgGraph.js';
+import { NodeRule } from '../Rule.js';
+export declare class RemoveNode extends NodeRule {
+    apply(nodeId: NodeId, node: TgNodeAttributes, graph: AdapterOperations): AdapterOperations;
+}

package/dist/cjs/Graph/Rules/Node/RemoveNode.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RemoveNode = void 0;
+const Rule_js_1 = require("../Rule.js");
+class RemoveNode extends Rule_js_1.NodeRule {
+    apply(nodeId, node, graph) {
+        if (!this.wasMatched(nodeId)) {
+            return graph;
+        }
+        return graph.removeNode(nodeId);
+    }
+}
+exports.RemoveNode = RemoveNode;
+Rule_js_1.NodeRule.register(RemoveNode);

package/dist/cjs/Graph/Rules/Node/RemoveNode.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/cjs/Graph/Rules/Node/RemoveNode.test.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const jest_mock_extended_1 = require("jest-mock-extended");
+const TgGraph_js_1 = require("../../TgGraph.js");
+const RemoveNode_js_1 = require("./RemoveNode.js");
+describe('RemoveNode.apply', () => {
+    it('shoud remove node when the query matches', () => {
+        const hook = new RemoveNode_js_1.RemoveNode({
+            node: { attr: { key: 'label', eq: 'node-1' } },
+        });
+        const graph = (0, jest_mock_extended_1.mock)();
+        const nextGraph = (0, jest_mock_extended_1.mock)();
+        graph.removeNode.mockReturnValue(nextGraph);
+        const nodeId = (0, TgGraph_js_1.asNodeId)('node-1');
+        const node = { label: 'node-1' };
+        hook.match(nodeId, node, graph);
+        const result = hook.apply(nodeId, node, graph);
+        expect(graph.removeNode).toHaveBeenCalledWith(nodeId);
+        expect(result).toBe(nextGraph);
+    });
+    it('shoud keep graph unchanged when the query does not match', () => {
+        const hook = new RemoveNode_js_1.RemoveNode({
+            node: { attr: { key: 'label', eq: 'node-1' } },
+        });
+        const graph = (0, jest_mock_extended_1.mock)();
+        const nodeId = (0, TgGraph_js_1.asNodeId)('node-1');
+        const node = { label: 'other' };
+        hook.match(nodeId, node, graph);
+        const result = hook.apply(nodeId, node, graph);
+        expect(graph.removeNode).not.toHaveBeenCalled();
+        expect(result).toBe(graph);
+    });
+});

package/dist/cjs/Graph/Rules/Node/RemoveNodeAndReconnectEdges.d.ts

@@ -0,0 +1,6 @@
+import { AdapterOperations } from '../../Operations/Operations.js';
+import { NodeId, TgNodeAttributes } from '../../TgGraph.js';
+import { NodeRule } from '../Rule.js';
+export declare class RemoveNodeAndReconnectEdges extends NodeRule {
+    apply(nodeId: NodeId, node: TgNodeAttributes, graph: AdapterOperations): AdapterOperations;
+}

package/dist/cjs/Graph/Rules/Node/RemoveNodeAndReconnectEdges.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RemoveNodeAndReconnectEdges = void 0;
+const TgGraph_js_1 = require("../../TgGraph.js");
+const Rule_js_1 = require("../Rule.js");
+class RemoveNodeAndReconnectEdges extends Rule_js_1.NodeRule {
+    apply(nodeId, node, graph) {
+        if (!this.wasMatched(nodeId)) {
+            return graph;
+        }
+        const inEdges = graph.inEdges(nodeId);
+        const outEdges = graph.outEdges(nodeId);
+        let updated = graph;
+        if (outEdges.length > inEdges.length) {
+            for (const inEdgeId of inEdges) {
+                const sourceId = updated.edgeSource(inEdgeId);
+                for (const outEdgeId of outEdges) {
+                    const targetId = updated.edgeTarget(outEdgeId);
+                    const edgeId = (0, TgGraph_js_1.edgeIdFrom)(sourceId, targetId, `redirect:${inEdgeId}:${outEdgeId}`);
+                    updated = updated.setEdge(edgeId, sourceId, targetId, {});
+                }
+            }
+        }
+        else {
+            for (const outEdgeId of outEdges) {
+                const targetId = updated.edgeTarget(outEdgeId);
+                for (const inEdgeId of inEdges) {
+                    const sourceId = updated.edgeSource(inEdgeId);
+                    const edgeId = (0, TgGraph_js_1.edgeIdFrom)(sourceId, targetId, `redirect:${inEdgeId}:${outEdgeId}`);
+                    updated = updated.setEdge(edgeId, sourceId, targetId, {});
+                }
+            }
+        }
+        return updated.removeNode(nodeId);
+    }
+}
+exports.RemoveNodeAndReconnectEdges = RemoveNodeAndReconnectEdges;
+Rule_js_1.NodeRule.register(RemoveNodeAndReconnectEdges);

package/dist/cjs/Graph/Rules/Node/RemoveNodeAndReconnectEdges.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/cjs/Graph/Rules/Node/RemoveNodeAndReconnectEdges.test.js

@@ -0,0 +1,113 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const graphology_1 = require("graphology");
+const GraphologyAdapter_js_1 = require("../../Adapters/GraphologyAdapter.js");
+const TgGraph_js_1 = require("../../TgGraph.js");
+const RemoveNodeAndReconnectEdges_js_1 = require("./RemoveNodeAndReconnectEdges.js");
+describe('RemoveNodeAndReconnectEdges.apply', () => {
+    it('shoud reconnect predecessors to successors and remove the node', () => {
+        const nodeA = (0, TgGraph_js_1.asNodeId)('node-a');
+        const nodeB = (0, TgGraph_js_1.asNodeId)('node-b');
+        const nodeC = (0, TgGraph_js_1.asNodeId)('node-c');
+        const nodeD = (0, TgGraph_js_1.asNodeId)('node-d');
+        const tg = {
+            schemaVersion: TgGraph_js_1.TG_SCHEMA_VERSION,
+            description: {},
+            nodes: {
+                [nodeA]: { id: nodeA, label: 'A' },
+                [nodeB]: { id: nodeB, label: 'B' },
+                [nodeC]: { id: nodeC, label: 'C' },
+                [nodeD]: { id: nodeD, label: 'D' },
+            },
+            edges: [
+                { id: (0, TgGraph_js_1.asEdgeId)('edge-a-b'), from: nodeA, to: nodeB, attributes: {} },
+                { id: (0, TgGraph_js_1.asEdgeId)('edge-c-b'), from: nodeC, to: nodeB, attributes: {} },
+                { id: (0, TgGraph_js_1.asEdgeId)('edge-b-d'), from: nodeB, to: nodeD, attributes: {} },
+            ],
+        };
+        const adapter = new GraphologyAdapter_js_1.GraphologyAdapter(new graphology_1.DirectedGraph()).withTgGraph(tg);
+        const node = adapter.getNodeAttributes(nodeB);
+        if (!node) {
+            throw new Error('Missing node attributes for node-b');
+        }
+        const hook = new RemoveNodeAndReconnectEdges_js_1.RemoveNodeAndReconnectEdges({
+            node: { nodeId: { eq: 'node-b' } },
+        });
+        hook.match(nodeB, node, adapter);
+        const result = hook.apply(nodeB, node, adapter);
+        expect(result.getNodeAttributes(nodeB)).toBeUndefined();
+        expect(result.edgesBetween(nodeA, nodeD)).toHaveLength(1);
+        expect(result.edgesBetween(nodeC, nodeD)).toHaveLength(1);
+        for (const edgeId of result.outEdges(nodeA)) {
+            expect(result.edgeTarget(edgeId)).not.toBe(nodeB);
+        }
+        for (const edgeId of result.outEdges(nodeC)) {
+            expect(result.edgeTarget(edgeId)).not.toBe(nodeB);
+        }
+    });
+    it('shoud keep graph unchanged when the query does not match', () => {
+        const nodeA = (0, TgGraph_js_1.asNodeId)('node-a');
+        const nodeB = (0, TgGraph_js_1.asNodeId)('node-b');
+        const nodeC = (0, TgGraph_js_1.asNodeId)('node-c');
+        const tg = {
+            schemaVersion: TgGraph_js_1.TG_SCHEMA_VERSION,
+            description: {},
+            nodes: {
+                [nodeA]: { id: nodeA, label: 'A' },
+                [nodeB]: { id: nodeB, label: 'B' },
+                [nodeC]: { id: nodeC, label: 'C' },
+            },
+            edges: [
+                { id: (0, TgGraph_js_1.asEdgeId)('edge-a-b'), from: nodeA, to: nodeB, attributes: {} },
+                { id: (0, TgGraph_js_1.asEdgeId)('edge-b-c'), from: nodeB, to: nodeC, attributes: {} },
+            ],
+        };
+        const adapter = new GraphologyAdapter_js_1.GraphologyAdapter(new graphology_1.DirectedGraph()).withTgGraph(tg);
+        const node = adapter.getNodeAttributes(nodeA);
+        if (!node) {
+            throw new Error('Missing node attributes for node-a');
+        }
+        const hook = new RemoveNodeAndReconnectEdges_js_1.RemoveNodeAndReconnectEdges({
+            node: { nodeId: { eq: 'node-b' } },
+        });
+        hook.match(nodeA, node, adapter);
+        const result = hook.apply(nodeA, node, adapter);
+        expect(result.getNodeAttributes(nodeB)).toBeDefined();
+        expect(result.edgesBetween(nodeA, nodeB)).toHaveLength(1);
+        expect(result.edgesBetween(nodeB, nodeC)).toHaveLength(1);
+    });
+    it('shoud reconnect edges when there are more outgoing edges than incoming edges', () => {
+        const nodeA = (0, TgGraph_js_1.asNodeId)('node-a');
+        const nodeB = (0, TgGraph_js_1.asNodeId)('node-b');
+        const nodeC = (0, TgGraph_js_1.asNodeId)('node-c');
+        const nodeD = (0, TgGraph_js_1.asNodeId)('node-d');
+        const tg = {
+            schemaVersion: TgGraph_js_1.TG_SCHEMA_VERSION,
+            description: {},
+            nodes: {
+                [nodeA]: { id: nodeA, label: 'A' },
+                [nodeB]: { id: nodeB, label: 'B' },
+                [nodeC]: { id: nodeC, label: 'C' },
+                [nodeD]: { id: nodeD, label: 'D' },
+            },
+            edges: [
+                { id: (0, TgGraph_js_1.asEdgeId)('edge-a-b'), from: nodeA, to: nodeB, attributes: {} },
+                { id: (0, TgGraph_js_1.asEdgeId)('edge-b-c'), from: nodeB, to: nodeC, attributes: {} },
+                { id: (0, TgGraph_js_1.asEdgeId)('edge-b-d'), from: nodeB, to: nodeD, attributes: {} },
+            ],
+        };
+        const adapter = new GraphologyAdapter_js_1.GraphologyAdapter(new graphology_1.DirectedGraph()).withTgGraph(tg);
+        const node = adapter.getNodeAttributes(nodeB);
+        if (!node) {
+            throw new Error('Missing node attributes for node-b');
+        }
+        const hook = new RemoveNodeAndReconnectEdges_js_1.RemoveNodeAndReconnectEdges({
+            node: { nodeId: { eq: 'node-b' } },
+        });
+        hook.match(nodeB, node, adapter);
+        const result = hook.apply(nodeB, node, adapter);
+        expect(result.getNodeAttributes(nodeB)).toBeUndefined();
+        expect(result.edgesBetween(nodeA, nodeC)).toHaveLength(1);
+        expect(result.edgesBetween(nodeA, nodeD)).toHaveLength(1);
+    });
+});

package/dist/cjs/Graph/Rules/Node/index.d.ts

@@ -0,0 +1,6 @@
+export * from './ConvertNodeToEdge.js';
+export * from './NodeDotProperties.js';
+export * from './NodeProperties.js';
+export * from './RemoveLeafChain.js';
+export * from './RemoveNode.js';
+export * from './RemoveNodeAndReconnectEdges.js';

package/dist/cjs/Graph/Rules/Node/index.js

@@ -0,0 +1,22 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./ConvertNodeToEdge.js"), exports);
+__exportStar(require("./NodeDotProperties.js"), exports);
+__exportStar(require("./NodeProperties.js"), exports);
+__exportStar(require("./RemoveLeafChain.js"), exports);
+__exportStar(require("./RemoveNode.js"), exports);
+__exportStar(require("./RemoveNodeAndReconnectEdges.js"), exports);