@terra-graph/core 1.0.0-rc.4

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

@@ -0,0 +1,397 @@
+import { DirectedGraph } from 'graphology';
+import { GraphologyAdapter } from '../../Adapters/GraphologyAdapter.js';
+import { GraphResolver } from '../../GraphResolver.js';
+import { TG_SCHEMA_VERSION, asEdgeId, asNodeId, } from '../../TgGraph.js';
+import { RemoveLeafChain } from './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: asNodeId(id),
+    label: id,
+    terraform: {
+        kind,
+        address: id,
+        resource,
+        name: id,
+    },
+});
+const buildEdge = (id, from, to) => ({
+    id: asEdgeId(id),
+    from: asNodeId(from),
+    to: asNodeId(to),
+    attributes: {},
+});
+const applyRule = (graph) => {
+    const adapter = new GraphologyAdapter(new DirectedGraph());
+    const resolver = new GraphResolver(adapter);
+    return resolver.resolve({
+        graph,
+        phases: [[new 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: 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(asNodeId('data'))).toBeUndefined();
+        expect(result.getNodeAttributes(asNodeId('rolePolicy'))).toBeUndefined();
+        expect(result.getNodeAttributes(asNodeId('attachment'))).toBeUndefined();
+        expect(result.getNodeAttributes(asNodeId('role'))).toBeUndefined();
+    });
+    it('shoud remove the full chain when an attachment is a leaf', () => {
+        const result = applyRule({
+            schemaVersion: 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(asNodeId('data'))).toBeUndefined();
+        expect(result.getNodeAttributes(asNodeId('policy'))).toBeUndefined();
+        expect(result.getNodeAttributes(asNodeId('role'))).toBeUndefined();
+        expect(result.getNodeAttributes(asNodeId('attachment'))).toBeUndefined();
+    });
+    it('shoud remove an orphaned data.aws_iam_policy_document leaf node', () => {
+        const result = applyRule({
+            schemaVersion: TG_SCHEMA_VERSION,
+            description: {},
+            nodes: {
+                data: buildNode('data', 'data', 'aws_iam_policy_document'),
+            },
+            edges: [],
+        });
+        expect(result.getNodeAttributes(asNodeId('data'))).toBeUndefined();
+    });
+    it('shoud remove an orphaned data.aws_iam_policy leaf node', () => {
+        const result = applyRule({
+            schemaVersion: TG_SCHEMA_VERSION,
+            description: {},
+            nodes: {
+                data: buildNode('data', 'data', 'aws_iam_policy'),
+            },
+            edges: [],
+        });
+        expect(result.getNodeAttributes(asNodeId('data'))).toBeUndefined();
+    });
+    it('shoud preserve shared IAM nodes that still lead to non-IAM resources', () => {
+        const result = applyRule({
+            schemaVersion: 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(asNodeId('deadAttachment'))).toBeUndefined();
+        expect(result.getNodeAttributes(asNodeId('deadRole'))).toBeUndefined();
+        expect(result.getNodeAttributes(asNodeId('policy'))).toBeDefined();
+        expect(result.getNodeAttributes(asNodeId('liveAttachment'))).toBeDefined();
+        expect(result.getNodeAttributes(asNodeId('liveRole'))).toBeDefined();
+        expect(result.getNodeAttributes(asNodeId('lambda'))).toBeDefined();
+    });
+    it('shoud stop chain removal at non-IAM boundaries', () => {
+        const result = applyRule({
+            schemaVersion: 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(asNodeId('attachment'))).toBeUndefined();
+        expect(result.getNodeAttributes(asNodeId('lambda'))).toBeDefined();
+    });
+    it('shoud iteratively prune newly orphaned predecessors to a fixpoint', () => {
+        const result = applyRule({
+            schemaVersion: 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(asNodeId('data'))).toBeUndefined();
+        expect(result.getNodeAttributes(asNodeId('policyA'))).toBeUndefined();
+        expect(result.getNodeAttributes(asNodeId('policyB'))).toBeUndefined();
+        expect(result.getNodeAttributes(asNodeId('attachment'))).toBeUndefined();
+        expect(result.getNodeAttributes(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: TG_SCHEMA_VERSION,
+            description: {},
+            nodes: {
+                [nodeA.id]: nodeA,
+                [nodeB.id]: nodeB,
+            },
+            edges: [buildEdge('edge-a-b', 'node-a', 'node-b')],
+        };
+        const adapter = new GraphologyAdapter(new DirectedGraph()).withTgGraph(graph);
+        const node = adapter.getNodeAttributes(asNodeId('node-a'));
+        if (!node) {
+            throw new Error('Missing node attributes for node-a');
+        }
+        const rule = new RemoveLeafChain({
+            node: { nodeId: { eq: 'node-a' } },
+        });
+        rule.match(asNodeId('node-a'), node, adapter);
+        const result = rule.apply(asNodeId('node-a'), node, adapter);
+        expect(result.getNodeAttributes(asNodeId('node-a'))).toBeDefined();
+        expect(result.getNodeAttributes(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: 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(new DirectedGraph()).withTgGraph(graph);
+        const node = adapter.getNodeAttributes(asNodeId('node-b'));
+        if (!node) {
+            throw new Error('Missing node attributes for node-b');
+        }
+        const rule = new RemoveLeafChain({
+            node: { nodeId: { in: ['node-a', 'node-b'] } },
+        });
+        rule.match(asNodeId('node-b'), node, adapter);
+        const result = rule.apply(asNodeId('node-b'), node, adapter);
+        expect(result.getNodeAttributes(asNodeId('node-b'))).toBeUndefined();
+        expect(result.getNodeAttributes(asNodeId('node-a'))).toBeDefined();
+        expect(result.getNodeAttributes(asNodeId('node-c'))).toBeDefined();
+    });
+    it('shoud only apply once per rule instance', () => {
+        const node = buildNode('leaf', 'resource', 'aws_iam_role');
+        const graph = {
+            schemaVersion: TG_SCHEMA_VERSION,
+            description: {},
+            nodes: {
+                [node.id]: node,
+            },
+            edges: [],
+        };
+        const adapter = new GraphologyAdapter(new DirectedGraph()).withTgGraph(graph);
+        const nodeAttributes = adapter.getNodeAttributes(asNodeId('leaf'));
+        if (!nodeAttributes) {
+            throw new Error('Missing node attributes for leaf');
+        }
+        const rule = new RemoveLeafChain({ node: { any: true } });
+        rule.match(asNodeId('leaf'), nodeAttributes, adapter);
+        const first = rule.apply(asNodeId('leaf'), nodeAttributes, adapter);
+        const second = rule.apply(asNodeId('leaf'), nodeAttributes, first);
+        expect(first.getNodeAttributes(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: TG_SCHEMA_VERSION,
+            description: {},
+            nodes: {
+                [emptyNode.id]: emptyNode,
+            },
+            edges: [],
+        };
+        const adapter = new GraphologyAdapter(new DirectedGraph()).withTgGraph(graph);
+        const nodeAttributes = adapter.getNodeAttributes(asNodeId(''));
+        if (!nodeAttributes) {
+            throw new Error('Missing node attributes for empty id');
+        }
+        const rule = new RemoveLeafChain({ node: { any: true } });
+        rule.match(asNodeId(''), nodeAttributes, adapter);
+        const result = rule.apply(asNodeId(''), nodeAttributes, adapter);
+        expect(result.getNodeAttributes(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: 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(new DirectedGraph()).withTgGraph(graph);
+        const nodeAttributes = adapter.getNodeAttributes(asNodeId('node-b'));
+        if (!nodeAttributes) {
+            throw new Error('Missing node attributes for node-b');
+        }
+        const rule = new RemoveLeafChain({ node: { any: true } });
+        rule.match(asNodeId('node-b'), nodeAttributes, adapter);
+        const result = rule.apply(asNodeId('node-b'), nodeAttributes, adapter);
+        expect(result.getNodeAttributes(asNodeId('node-a'))).toBeUndefined();
+        expect(result.getNodeAttributes(asNodeId('node-b'))).toBeUndefined();
+        expect(result.getNodeAttributes(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({
+            node: { attr: { key: 'label', eq: 'node-a' } },
+        });
+        rule.match(asNodeId('node-a'), nodeAttributes, adapter);
+        rule.apply(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({
+            node: { attr: { key: 'label', eq: 'node-a' } },
+        });
+        rule.match(asNodeId('node-a'), nodeAttributes, adapter);
+        rule.apply(asNodeId('node-a'), nodeAttributes, adapter);
+        expect(adapter.removed).toBe(false);
+    });
+});

package/dist/esm/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/esm/Graph/Rules/Node/RemoveNode.js

@@ -0,0 +1,10 @@
+import { NodeRule } from '../Rule.js';
+export class RemoveNode extends NodeRule {
+    apply(nodeId, node, graph) {
+        if (!this.wasMatched(nodeId)) {
+            return graph;
+        }
+        return graph.removeNode(nodeId);
+    }
+}
+NodeRule.register(RemoveNode);

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

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

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

@@ -0,0 +1,31 @@
+import { mock } from 'jest-mock-extended';
+import { asNodeId } from '../../TgGraph.js';
+import { RemoveNode } from './RemoveNode.js';
+describe('RemoveNode.apply', () => {
+    it('shoud remove node when the query matches', () => {
+        const hook = new RemoveNode({
+            node: { attr: { key: 'label', eq: 'node-1' } },
+        });
+        const graph = mock();
+        const nextGraph = mock();
+        graph.removeNode.mockReturnValue(nextGraph);
+        const nodeId = 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({
+            node: { attr: { key: 'label', eq: 'node-1' } },
+        });
+        const graph = mock();
+        const nodeId = 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/esm/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/esm/Graph/Rules/Node/RemoveNodeAndReconnectEdges.js

@@ -0,0 +1,34 @@
+import { edgeIdFrom } from '../../TgGraph.js';
+import { NodeRule } from '../Rule.js';
+export class RemoveNodeAndReconnectEdges extends 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 = 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 = edgeIdFrom(sourceId, targetId, `redirect:${inEdgeId}:${outEdgeId}`);
+                    updated = updated.setEdge(edgeId, sourceId, targetId, {});
+                }
+            }
+        }
+        return updated.removeNode(nodeId);
+    }
+}
+NodeRule.register(RemoveNodeAndReconnectEdges);

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

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

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

@@ -0,0 +1,111 @@
+import { DirectedGraph } from 'graphology';
+import { GraphologyAdapter } from '../../Adapters/GraphologyAdapter.js';
+import { TG_SCHEMA_VERSION, asEdgeId, asNodeId, } from '../../TgGraph.js';
+import { RemoveNodeAndReconnectEdges } from './RemoveNodeAndReconnectEdges.js';
+describe('RemoveNodeAndReconnectEdges.apply', () => {
+    it('shoud reconnect predecessors to successors and remove the node', () => {
+        const nodeA = asNodeId('node-a');
+        const nodeB = asNodeId('node-b');
+        const nodeC = asNodeId('node-c');
+        const nodeD = asNodeId('node-d');
+        const tg = {
+            schemaVersion: 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: asEdgeId('edge-a-b'), from: nodeA, to: nodeB, attributes: {} },
+                { id: asEdgeId('edge-c-b'), from: nodeC, to: nodeB, attributes: {} },
+                { id: asEdgeId('edge-b-d'), from: nodeB, to: nodeD, attributes: {} },
+            ],
+        };
+        const adapter = new GraphologyAdapter(new DirectedGraph()).withTgGraph(tg);
+        const node = adapter.getNodeAttributes(nodeB);
+        if (!node) {
+            throw new Error('Missing node attributes for node-b');
+        }
+        const hook = new 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 = asNodeId('node-a');
+        const nodeB = asNodeId('node-b');
+        const nodeC = asNodeId('node-c');
+        const tg = {
+            schemaVersion: TG_SCHEMA_VERSION,
+            description: {},
+            nodes: {
+                [nodeA]: { id: nodeA, label: 'A' },
+                [nodeB]: { id: nodeB, label: 'B' },
+                [nodeC]: { id: nodeC, label: 'C' },
+            },
+            edges: [
+                { id: asEdgeId('edge-a-b'), from: nodeA, to: nodeB, attributes: {} },
+                { id: asEdgeId('edge-b-c'), from: nodeB, to: nodeC, attributes: {} },
+            ],
+        };
+        const adapter = new GraphologyAdapter(new DirectedGraph()).withTgGraph(tg);
+        const node = adapter.getNodeAttributes(nodeA);
+        if (!node) {
+            throw new Error('Missing node attributes for node-a');
+        }
+        const hook = new 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 = asNodeId('node-a');
+        const nodeB = asNodeId('node-b');
+        const nodeC = asNodeId('node-c');
+        const nodeD = asNodeId('node-d');
+        const tg = {
+            schemaVersion: 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: asEdgeId('edge-a-b'), from: nodeA, to: nodeB, attributes: {} },
+                { id: asEdgeId('edge-b-c'), from: nodeB, to: nodeC, attributes: {} },
+                { id: asEdgeId('edge-b-d'), from: nodeB, to: nodeD, attributes: {} },
+            ],
+        };
+        const adapter = new GraphologyAdapter(new DirectedGraph()).withTgGraph(tg);
+        const node = adapter.getNodeAttributes(nodeB);
+        if (!node) {
+            throw new Error('Missing node attributes for node-b');
+        }
+        const hook = new 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/esm/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/esm/Graph/Rules/Node/index.js

@@ -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/esm/Graph/Rules/Rule.d.ts

@@ -0,0 +1,40 @@
+import { NodeQuery } from '../Operations/Matchers/NodeQuery/NodeQuery.js';
+import { AdapterOperations } from '../Operations/Operations.js';
+import { NodeId, TgNodeAttributes } from '../TgGraph.js';
+import { EdgeRuleConfig, NodeRuleConfig, RuleConfig, SerializedRule } from './RuleConfig.js';
+type RuleClass<TConfig extends RuleConfig> = new (config: TConfig, ...args: unknown[]) => BaseRule<TConfig>;
+export type EdgeRuleMatcher = {
+    from: NodeQuery;
+    to: NodeQuery;
+};
+export declare abstract class BaseRule<TConfig extends RuleConfig = RuleConfig> {
+    protected readonly config: TConfig;
+    private static registry;
+    private lastMatch;
+    private lastMatchNodeId?;
+    protected abstract get query(): unknown;
+    static register<TConfig extends RuleConfig>(ruleClass: RuleClass<TConfig>): void;
+    static fromSerialized(rule: SerializedRule): BaseRule;
+    constructor(config: TConfig);
+    describe(_nodeName: NodeId, _node: TgNodeAttributes): string;
+    match(nodeId: NodeId, node: TgNodeAttributes, graph: AdapterOperations): boolean;
+    protected abstract matches(nodeId: NodeId, node: TgNodeAttributes, graph: AdapterOperations): boolean;
+    supports(_adapter: AdapterOperations): boolean;
+    abstract apply(nodeId: NodeId, node: TgNodeAttributes, graph: AdapterOperations): AdapterOperations;
+    serialize(): SerializedRule;
+    protected getId(): string;
+    protected wasMatched(_nodeId: NodeId): boolean;
+}
+export declare abstract class NodeRule extends BaseRule<NodeRuleConfig> {
+    private readonly queryValue;
+    constructor(config: NodeRuleConfig);
+    protected get query(): NodeQuery;
+    protected matches(nodeId: NodeId, node: TgNodeAttributes, graph: AdapterOperations): boolean;
+}
+export declare abstract class EdgeRule extends BaseRule<EdgeRuleConfig> {
+    private readonly queryValue;
+    constructor(config: EdgeRuleConfig);
+    protected get query(): EdgeRuleMatcher;
+    protected matches(nodeId: NodeId, node: TgNodeAttributes, graph: AdapterOperations): boolean;
+}
+export {};