@terra-graph/core 1.0.0-rc.4

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

@@ -0,0 +1,369 @@
+import { DirectedGraph } from 'graphology';
+import { GraphologyAdapter } from '../../Adapters/GraphologyAdapter.js';
+import { TG_SCHEMA_VERSION, tgNodeIdFrom } from '../../TgGraph.js';
+import { NodeProperties } from './NodeProperties.js';
+describe('NodeProperties.constructor', () => {
+    it('shoud require options', () => {
+        expect(() => new NodeProperties({
+            node: { nodeId: { eq: 'node-a' } },
+        })).toThrow(`Rule 'NodeProperties' requires options in config`);
+    });
+});
+describe('NodeProperties.apply', () => {
+    it('shoud set nested properties using references from node attributes', () => {
+        const nodeId = tgNodeIdFrom('resource', 'module.identity.aws_iam_role.api');
+        const tg = {
+            schemaVersion: TG_SCHEMA_VERSION,
+            description: {},
+            nodes: {
+                [nodeId]: {
+                    id: nodeId,
+                    terraform: {
+                        kind: 'resource',
+                        address: 'module.identity.aws_iam_role.api',
+                        resource: 'aws_iam_role',
+                        name: 'api',
+                        moduleAddress: 'module.identity',
+                    },
+                    hints: {
+                        label: {},
+                    },
+                },
+            },
+            edges: [],
+        };
+        const adapter = new GraphologyAdapter(new DirectedGraph()).withTgGraph(tg);
+        const node = adapter.getNodeAttributes(nodeId);
+        if (!node) {
+            throw new Error('Missing node attributes for module role');
+        }
+        const hook = new NodeProperties({
+            node: { nodeId: { eq: String(nodeId) } },
+            options: {
+                hints: {
+                    label: {
+                        end: { from: 'terraform.name' },
+                    },
+                },
+            },
+        });
+        hook.match(nodeId, node, adapter);
+        const result = hook.apply(nodeId, node, adapter);
+        expect(result.getNodeAttributes(nodeId)).toEqual({
+            ...node,
+            hints: {
+                label: {
+                    end: 'api',
+                },
+            },
+        });
+    });
+    it('shoud keep graph unchanged when the rule does not match', () => {
+        const nodeId = tgNodeIdFrom('resource', 'aws_iam_role.api');
+        const tg = {
+            schemaVersion: TG_SCHEMA_VERSION,
+            description: {},
+            nodes: {
+                [nodeId]: {
+                    id: nodeId,
+                    terraform: {
+                        kind: 'resource',
+                        address: 'aws_iam_role.api',
+                        resource: 'aws_iam_role',
+                        name: 'api',
+                    },
+                },
+            },
+            edges: [],
+        };
+        const adapter = new GraphologyAdapter(new DirectedGraph()).withTgGraph(tg);
+        const node = adapter.getNodeAttributes(nodeId);
+        if (!node) {
+            throw new Error('Missing node attributes for role');
+        }
+        const hook = new NodeProperties({
+            node: { nodeId: { eq: 'different-node' } },
+            options: {
+                hints: {
+                    label: {
+                        end: { from: 'terraform.name' },
+                    },
+                },
+            },
+        });
+        hook.match(nodeId, node, adapter);
+        const result = hook.apply(nodeId, node, adapter);
+        expect(result.getNodeAttributes(nodeId)).toEqual(node);
+    });
+    it('shoud resolve nodeId references', () => {
+        const nodeId = tgNodeIdFrom('resource', 'aws_iam_role.api');
+        const tg = {
+            schemaVersion: TG_SCHEMA_VERSION,
+            description: {},
+            nodes: {
+                [nodeId]: {
+                    id: nodeId,
+                    label: 'role',
+                    terraform: {
+                        kind: 'resource',
+                        address: 'aws_iam_role.api',
+                        resource: 'aws_iam_role',
+                        name: 'api',
+                    },
+                },
+            },
+            edges: [],
+        };
+        const adapter = new GraphologyAdapter(new DirectedGraph()).withTgGraph(tg);
+        const node = adapter.getNodeAttributes(nodeId);
+        if (!node) {
+            throw new Error('Missing node attributes for role');
+        }
+        const hook = new NodeProperties({
+            node: { nodeId: { eq: String(nodeId) } },
+            options: {
+                hints: {
+                    label: {
+                        end: { from: 'nodeId' },
+                    },
+                },
+            },
+        });
+        hook.match(nodeId, node, adapter);
+        const result = hook.apply(nodeId, node, adapter);
+        expect(result.getNodeAttributes(nodeId)).toEqual({
+            ...node,
+            hints: {
+                label: {
+                    end: String(nodeId),
+                },
+            },
+        });
+    });
+    it('shoud resolve arrays of option values', () => {
+        const nodeId = tgNodeIdFrom('resource', 'aws_iam_role.api');
+        const tg = {
+            schemaVersion: TG_SCHEMA_VERSION,
+            description: {},
+            nodes: {
+                [nodeId]: {
+                    id: nodeId,
+                    label: 'role',
+                    terraform: {
+                        kind: 'resource',
+                        address: 'aws_iam_role.api',
+                        resource: 'aws_iam_role',
+                        name: 'api',
+                    },
+                },
+            },
+            edges: [],
+        };
+        const adapter = new GraphologyAdapter(new DirectedGraph()).withTgGraph(tg);
+        const node = adapter.getNodeAttributes(nodeId);
+        if (!node) {
+            throw new Error('Missing node attributes for role');
+        }
+        const hook = new NodeProperties({
+            node: { nodeId: { eq: String(nodeId) } },
+            options: {
+                tags: [{ from: 'terraform.resource' }, 'static'],
+            },
+        });
+        hook.match(nodeId, node, adapter);
+        const result = hook.apply(nodeId, node, adapter);
+        expect(result.getNodeAttributes(nodeId)).toEqual({
+            ...node,
+            tags: ['aws_iam_role', 'static'],
+        });
+    });
+    it('shoud keep graph unchanged when resolved options are undefined', () => {
+        const nodeId = tgNodeIdFrom('resource', 'aws_iam_role.api');
+        const tg = {
+            schemaVersion: TG_SCHEMA_VERSION,
+            description: {},
+            nodes: {
+                [nodeId]: {
+                    id: nodeId,
+                    label: 'role',
+                    terraform: {
+                        kind: 'resource',
+                        address: 'aws_iam_role.api',
+                        resource: 'aws_iam_role',
+                        name: 'api',
+                    },
+                },
+            },
+            edges: [],
+        };
+        const adapter = new GraphologyAdapter(new DirectedGraph()).withTgGraph(tg);
+        const node = adapter.getNodeAttributes(nodeId);
+        if (!node) {
+            throw new Error('Missing node attributes for role');
+        }
+        const hook = new NodeProperties({
+            node: { nodeId: { eq: String(nodeId) } },
+            options: { from: 'terraform.missing' },
+        });
+        hook.match(nodeId, node, adapter);
+        const result = hook.apply(nodeId, node, adapter);
+        expect(result).toBe(adapter);
+        expect(result.getNodeAttributes(nodeId)).toEqual(node);
+    });
+    it('shoud overwrite scalar values when merging', () => {
+        const nodeId = tgNodeIdFrom('resource', 'aws_iam_role.api');
+        const tg = {
+            schemaVersion: TG_SCHEMA_VERSION,
+            description: {},
+            nodes: {
+                [nodeId]: {
+                    id: nodeId,
+                    label: 'role',
+                },
+            },
+            edges: [],
+        };
+        const adapter = new GraphologyAdapter(new DirectedGraph()).withTgGraph(tg);
+        const node = adapter.getNodeAttributes(nodeId);
+        if (!node) {
+            throw new Error('Missing node attributes for role');
+        }
+        const hook = new NodeProperties({
+            node: { nodeId: { eq: String(nodeId) } },
+            options: {
+                label: 'override',
+            },
+        });
+        hook.match(nodeId, node, adapter);
+        const result = hook.apply(nodeId, node, adapter);
+        expect(result.getNodeAttributes(nodeId)).toEqual({
+            ...node,
+            label: 'override',
+        });
+    });
+    it('shoud ignore empty reference paths', () => {
+        const nodeId = tgNodeIdFrom('resource', 'aws_iam_role.api');
+        const tg = {
+            schemaVersion: TG_SCHEMA_VERSION,
+            description: {},
+            nodes: {
+                [nodeId]: {
+                    id: nodeId,
+                    label: 'role',
+                },
+            },
+            edges: [],
+        };
+        const adapter = new GraphologyAdapter(new DirectedGraph()).withTgGraph(tg);
+        const node = adapter.getNodeAttributes(nodeId);
+        if (!node) {
+            throw new Error('Missing node attributes for role');
+        }
+        const hook = new NodeProperties({
+            node: { nodeId: { eq: String(nodeId) } },
+            options: { from: '' },
+        });
+        hook.match(nodeId, node, adapter);
+        const result = hook.apply(nodeId, node, adapter);
+        expect(result).toBe(adapter);
+        expect(result.getNodeAttributes(nodeId)).toEqual(node);
+    });
+    it('shoud keep graph unchanged when options resolve to a top-level array', () => {
+        const nodeId = tgNodeIdFrom('resource', 'aws_iam_role.api');
+        const tg = {
+            schemaVersion: TG_SCHEMA_VERSION,
+            description: {},
+            nodes: {
+                [nodeId]: {
+                    id: nodeId,
+                    label: 'role',
+                    terraform: {
+                        kind: 'resource',
+                        address: 'aws_iam_role.api',
+                        resource: 'aws_iam_role',
+                        name: 'api',
+                    },
+                },
+            },
+            edges: [],
+        };
+        const adapter = new GraphologyAdapter(new DirectedGraph()).withTgGraph(tg);
+        const node = adapter.getNodeAttributes(nodeId);
+        if (!node) {
+            throw new Error('Missing node attributes for role');
+        }
+        const hook = new NodeProperties({
+            node: { nodeId: { eq: String(nodeId) } },
+            options: [{ from: 'terraform.resource' }],
+        });
+        hook.match(nodeId, node, adapter);
+        const result = hook.apply(nodeId, node, adapter);
+        expect(result).toBe(adapter);
+        expect(result.getNodeAttributes(nodeId)).toEqual(node);
+    });
+    it('shoud drop keys whose values resolve to undefined', () => {
+        const nodeId = tgNodeIdFrom('resource', 'aws_iam_role.api');
+        const tg = {
+            schemaVersion: TG_SCHEMA_VERSION,
+            description: {},
+            nodes: {
+                [nodeId]: {
+                    id: nodeId,
+                    label: 'role',
+                    terraform: {
+                        kind: 'resource',
+                        address: 'aws_iam_role.api',
+                        resource: 'aws_iam_role',
+                        name: 'api',
+                    },
+                },
+            },
+            edges: [],
+        };
+        const adapter = new GraphologyAdapter(new DirectedGraph()).withTgGraph(tg);
+        const node = adapter.getNodeAttributes(nodeId);
+        if (!node) {
+            throw new Error('Missing node attributes for role');
+        }
+        const hook = new NodeProperties({
+            node: { nodeId: { eq: String(nodeId) } },
+            options: {
+                hints: { from: 'terraform.missing' },
+            },
+        });
+        hook.match(nodeId, node, adapter);
+        const result = hook.apply(nodeId, node, adapter);
+        expect(result).toBe(adapter);
+        expect(result.getNodeAttributes(nodeId)).toEqual(node);
+    });
+    it('shoud treat missing options as an empty patch', () => {
+        const nodeId = tgNodeIdFrom('resource', 'aws_iam_role.api');
+        const tg = {
+            schemaVersion: TG_SCHEMA_VERSION,
+            description: {},
+            nodes: {
+                [nodeId]: {
+                    id: nodeId,
+                    label: 'role',
+                },
+            },
+            edges: [],
+        };
+        const adapter = new GraphologyAdapter(new DirectedGraph()).withTgGraph(tg);
+        const node = adapter.getNodeAttributes(nodeId);
+        if (!node) {
+            throw new Error('Missing node attributes for role');
+        }
+        const hook = new NodeProperties({
+            node: { nodeId: { eq: String(nodeId) } },
+            options: {
+                label: 'override',
+            },
+        });
+        hook.config.options = undefined;
+        hook.match(nodeId, node, adapter);
+        const result = hook.apply(nodeId, node, adapter);
+        expect(result).toBe(adapter);
+        expect(result.getNodeAttributes(nodeId)).toEqual(node);
+    });
+});

package/dist/esm/Graph/Rules/Node/RemoveLeafChain.d.ts

@@ -0,0 +1,12 @@
+import { AdapterOperations } from '../../Operations/Operations.js';
+import { NodeId, TgNodeAttributes } from '../../TgGraph.js';
+import { NodeRule } from '../Rule.js';
+export declare class RemoveLeafChain extends NodeRule {
+    private hasApplied;
+    apply(nodeId: NodeId, node: TgNodeAttributes, graph: AdapterOperations): AdapterOperations;
+    private removeLeafChainToFixpoint;
+    private collectRemovableNodes;
+    private isScopedNode;
+    private isLeafNode;
+    private isLeafNodeConsideringRemovals;
+}

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

@@ -0,0 +1,78 @@
+import { NodeRule } from '../Rule.js';
+export class RemoveLeafChain extends NodeRule {
+    hasApplied = false;
+    apply(nodeId, node, graph) {
+        if (!this.wasMatched(nodeId) || this.hasApplied) {
+            return graph;
+        }
+        this.hasApplied = true;
+        return this.removeLeafChainToFixpoint(graph);
+    }
+    removeLeafChainToFixpoint(graph) {
+        let updated = graph;
+        while (true) {
+            const removable = this.collectRemovableNodes(updated);
+            if (removable.size === 0) {
+                return updated;
+            }
+            for (const removableNodeId of removable) {
+                if (updated.getNodeAttributes(removableNodeId)) {
+                    updated = updated.removeNode(removableNodeId);
+                }
+            }
+        }
+    }
+    collectRemovableNodes(graph) {
+        const removable = new Set();
+        const queue = [];
+        for (const nodeId of graph.nodeIds()) {
+            if (!this.isScopedNode(nodeId, graph)) {
+                continue;
+            }
+            if (!this.isLeafNode(nodeId, graph)) {
+                continue;
+            }
+            queue.push(nodeId);
+        }
+        while (queue.length > 0) {
+            const currentNodeId = queue.shift();
+            if (!currentNodeId) {
+                continue;
+            }
+            if (removable.has(currentNodeId)) {
+                continue;
+            }
+            if (!this.isScopedNode(currentNodeId, graph)) {
+                continue;
+            }
+            if (!this.isLeafNodeConsideringRemovals(currentNodeId, graph, removable)) {
+                continue;
+            }
+            removable.add(currentNodeId);
+            for (const predecessorId of graph.predecessors(currentNodeId)) {
+                if (this.isScopedNode(predecessorId, graph)) {
+                    queue.push(predecessorId);
+                }
+            }
+        }
+        return removable;
+    }
+    isScopedNode(nodeId, graph) {
+        const node = graph.getNodeAttributes(nodeId);
+        if (!node) {
+            return false;
+        }
+        return this.query.match(nodeId, node, graph);
+    }
+    isLeafNode(nodeId, graph) {
+        return graph.outEdges(nodeId).length === 0;
+    }
+    isLeafNodeConsideringRemovals(nodeId, graph, removable) {
+        const outEdges = graph.outEdges(nodeId);
+        if (outEdges.length === 0) {
+            return true;
+        }
+        return outEdges.every((edgeId) => removable.has(graph.edgeTarget(edgeId)));
+    }
+}
+NodeRule.register(RemoveLeafChain);

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

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