@terra-graph/core 1.0.0-rc.4

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

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

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

@@ -0,0 +1,150 @@
+import { DirectedGraph } from 'graphology';
+import { GraphologyAdapter } from '../../Adapters/GraphologyAdapter.js';
+import { TG_SCHEMA_VERSION, asEdgeId, asNodeId, edgeIdFrom, } from '../../TgGraph.js';
+import { ConvertNodeToEdge } from './ConvertNodeToEdge.js';
+describe('ConvertNodeToEdge.apply', () => {
+    it('shoud convert a node with a single in/out edge into a labeled edge', () => {
+        const nodeA = asNodeId('node-a');
+        const nodeB = asNodeId('node-b');
+        const nodeLabel = asNodeId('resource.name');
+        const edgeIn = asEdgeId('edge-in');
+        const edgeOut = asEdgeId('edge-out');
+        const tg = {
+            schemaVersion: TG_SCHEMA_VERSION,
+            description: {},
+            nodes: {
+                [nodeA]: { id: nodeA, label: 'A' },
+                [nodeLabel]: {
+                    id: nodeLabel,
+                    label: 'resource.name',
+                    terraform: {
+                        kind: 'resource',
+                        address: 'resource.name',
+                        resource: 'resource',
+                        name: 'name',
+                    },
+                },
+                [nodeB]: { id: nodeB, label: 'B' },
+            },
+            edges: [
+                { id: edgeIn, from: nodeA, to: nodeLabel, attributes: {} },
+                { id: edgeOut, from: nodeLabel, to: nodeB, attributes: {} },
+            ],
+        };
+        const adapter = new GraphologyAdapter(new DirectedGraph()).withTgGraph(tg);
+        const node = adapter.getNodeAttributes(nodeLabel);
+        if (!node) {
+            throw new Error('Missing node attributes for resource.name');
+        }
+        const hook = new ConvertNodeToEdge({
+            node: { attr: { key: 'label', eq: 'resource.name' } },
+        });
+        hook.match(nodeLabel, node, adapter);
+        const result = hook.apply(nodeLabel, node, adapter);
+        const edgeId = edgeIdFrom(nodeA, nodeB);
+        expect(result.getEdgeAttributes(edgeId)).toEqual({
+            renderHints: { resource: 'resource', name: 'name' },
+        });
+        expect(result.edgeSource(edgeId)).toBe(nodeA);
+        expect(result.edgeTarget(edgeId)).toBe(nodeB);
+        expect(result.nodeIds()).not.toContain(nodeLabel);
+    });
+    it('shoud keep graph unchanged when the node does not have a single in/out edge', () => {
+        const nodeA = asNodeId('node-a');
+        const nodeB = asNodeId('node-b');
+        const nodeC = asNodeId('node-c');
+        const nodeLabel = asNodeId('resource.name');
+        const tg = {
+            schemaVersion: TG_SCHEMA_VERSION,
+            description: {},
+            nodes: {
+                [nodeA]: { id: nodeA, label: 'A' },
+                [nodeLabel]: { id: nodeLabel, label: 'resource.name' },
+                [nodeB]: { id: nodeB, label: 'B' },
+                [nodeC]: { id: nodeC, label: 'C' },
+            },
+            edges: [
+                { id: asEdgeId('edge-in'), from: nodeA, to: nodeLabel },
+                { id: asEdgeId('edge-out-1'), from: nodeLabel, to: nodeB },
+                { id: asEdgeId('edge-out-2'), from: nodeLabel, to: nodeC },
+            ],
+        };
+        const adapter = new GraphologyAdapter(new DirectedGraph()).withTgGraph(tg);
+        const node = adapter.getNodeAttributes(nodeLabel);
+        if (!node) {
+            throw new Error('Missing node attributes for resource.name');
+        }
+        const hook = new ConvertNodeToEdge({
+            node: { attr: { key: 'label', eq: 'resource.name' } },
+        });
+        hook.match(nodeLabel, node, adapter);
+        const result = hook.apply(nodeLabel, node, adapter);
+        expect(result).toBe(adapter);
+    });
+    it('shoud keep graph unchanged when the node was not matched', () => {
+        const nodeA = asNodeId('node-a');
+        const nodeB = asNodeId('node-b');
+        const nodeLabel = asNodeId('resource.name');
+        const edgeIn = asEdgeId('edge-in');
+        const edgeOut = asEdgeId('edge-out');
+        const tg = {
+            schemaVersion: TG_SCHEMA_VERSION,
+            description: {},
+            nodes: {
+                [nodeA]: { id: nodeA, label: 'A' },
+                [nodeLabel]: { id: nodeLabel, label: 'resource.name' },
+                [nodeB]: { id: nodeB, label: 'B' },
+            },
+            edges: [
+                { id: edgeIn, from: nodeA, to: nodeLabel, attributes: {} },
+                { id: edgeOut, from: nodeLabel, to: nodeB, attributes: {} },
+            ],
+        };
+        const adapter = new GraphologyAdapter(new DirectedGraph()).withTgGraph(tg);
+        const node = adapter.getNodeAttributes(nodeLabel);
+        if (!node) {
+            throw new Error('Missing node attributes for resource.name');
+        }
+        const hook = new ConvertNodeToEdge({
+            node: { attr: { key: 'label', eq: 'different' } },
+        });
+        hook.match(nodeLabel, node, adapter);
+        const result = hook.apply(nodeLabel, node, adapter);
+        expect(result).toBe(adapter);
+        expect(result.getNodeAttributes(nodeLabel)).toBeDefined();
+    });
+    it('shoud default render hints when terraform metadata is missing', () => {
+        const nodeA = asNodeId('node-a');
+        const nodeB = asNodeId('node-b');
+        const nodeLabel = asNodeId('resource.name');
+        const edgeIn = asEdgeId('edge-in');
+        const edgeOut = asEdgeId('edge-out');
+        const tg = {
+            schemaVersion: TG_SCHEMA_VERSION,
+            description: {},
+            nodes: {
+                [nodeA]: { id: nodeA, label: 'A' },
+                [nodeLabel]: { id: nodeLabel, label: 'resource.name' },
+                [nodeB]: { id: nodeB, label: 'B' },
+            },
+            edges: [
+                { id: edgeIn, from: nodeA, to: nodeLabel, attributes: {} },
+                { id: edgeOut, from: nodeLabel, to: nodeB, attributes: {} },
+            ],
+        };
+        const adapter = new GraphologyAdapter(new DirectedGraph()).withTgGraph(tg);
+        const node = adapter.getNodeAttributes(nodeLabel);
+        if (!node) {
+            throw new Error('Missing node attributes for resource.name');
+        }
+        const hook = new ConvertNodeToEdge({
+            node: { attr: { key: 'label', eq: 'resource.name' } },
+        });
+        hook.match(nodeLabel, node, adapter);
+        const result = hook.apply(nodeLabel, node, adapter);
+        const edgeId = edgeIdFrom(nodeA, nodeB);
+        expect(result.getEdgeAttributes(edgeId)).toEqual({
+            renderHints: { resource: '', name: '' },
+        });
+    });
+});

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

@@ -0,0 +1,9 @@
+import { AdapterOperations } from '../../Operations/Operations.js';
+import { NodeId, TgNodeAttributes } from '../../TgGraph.js';
+import { NodeRule } from '../Rule.js';
+import { NodeRuleConfig } from '../RuleConfig.js';
+export declare class NodeDotProperties extends NodeRule {
+    constructor(config: NodeRuleConfig);
+    supports(adapter: AdapterOperations): boolean;
+    apply(nodeId: NodeId, node: TgNodeAttributes, graph: AdapterOperations): AdapterOperations;
+}

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

@@ -0,0 +1,39 @@
+import { DotAdapter } from '../../Adapters/DotAdapter.js';
+import { NodeRule } from '../Rule.js';
+export class NodeDotProperties extends NodeRule {
+    // private static readonly defaultConfig: NodeRuleConfig = {
+    //   node: {
+    //     and: [
+    //       { nodeId: { startsWith: 'cluster_module.' } },
+    //       { attr: { key: 'label', exists: true } },
+    //     ],
+    //   },
+    // };
+    constructor(config) {
+        if (config.options === undefined) {
+            throw new Error(`Rule '${NodeDotProperties.name}' requires options in config`);
+        }
+        super(config);
+    }
+    supports(adapter) {
+        return adapter instanceof DotAdapter;
+    }
+    apply(nodeId, node, graph) {
+        if (!this.wasMatched(nodeId)) {
+            return graph;
+        }
+        const adapterKey = DotAdapter.name;
+        const properties = this.config.options ?? {};
+        return graph.setNodeAttributes(nodeId, {
+            ...node,
+            adapter: {
+                ...(node.adapter ?? {}),
+                [adapterKey]: {
+                    ...(node.adapter?.[adapterKey] ?? {}),
+                    ...properties,
+                },
+            },
+        });
+    }
+}
+NodeRule.register(NodeDotProperties);

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

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

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

@@ -0,0 +1,224 @@
+import { DirectedGraph } from 'graphology';
+import { DotAdapter } from '../../Adapters/DotAdapter.js';
+import { GraphologyAdapter } from '../../Adapters/GraphologyAdapter.js';
+import { TG_SCHEMA_VERSION, asNodeId } from '../../TgGraph.js';
+import { NodeDotProperties } from './NodeDotProperties.js';
+describe('NodeDotProperties.constructor', () => {
+    it('shoud require options', () => {
+        expect(() => new NodeDotProperties({
+            node: { nodeId: { eq: 'node-a' } },
+        })).toThrow(`Rule 'NodeDotProperties' requires options in config`);
+    });
+});
+describe('NodeDotProperties.supports', () => {
+    it('shoud only support DotAdapter instances', () => {
+        const rule = new NodeDotProperties({
+            node: { nodeId: { eq: 'node-a' } },
+            options: { peripheries: 1 },
+        });
+        const dotAdapter = new DotAdapter(new DirectedGraph());
+        const graphAdapter = new GraphologyAdapter(new DirectedGraph());
+        expect(rule.supports(dotAdapter)).toBe(true);
+        expect(rule.supports(graphAdapter)).toBe(false);
+    });
+});
+describe('NodeDotProperties.apply', () => {
+    it('shoud store dot adapter options for module nodes', () => {
+        const moduleId = asNodeId('cluster_module.example');
+        const tg = {
+            schemaVersion: TG_SCHEMA_VERSION,
+            description: {},
+            nodes: {
+                [moduleId]: { id: moduleId, label: 'module.example' },
+            },
+            edges: [],
+        };
+        const adapter = new DotAdapter(new DirectedGraph()).withTgGraph(tg);
+        const node = adapter.getNodeAttributes(moduleId);
+        if (!node) {
+            throw new Error('Missing node attributes for module');
+        }
+        const hook = new NodeDotProperties({
+            node: { nodeId: { eq: moduleId.toString() } },
+            options: {
+                peripheries: 0,
+                label: '',
+                height: 0,
+                width: 0,
+            },
+        });
+        hook.match(moduleId, node, adapter);
+        const result = hook.apply(moduleId, node, adapter);
+        expect(result.getNodeAttributes(moduleId)).toEqual({
+            ...node,
+            adapter: {
+                [DotAdapter.name]: {
+                    peripheries: 0,
+                    label: '',
+                    height: 0,
+                    width: 0,
+                },
+            },
+        });
+    });
+    it('shoud merge dot adapter options with existing adapter values', () => {
+        const moduleId = asNodeId('cluster_module.example');
+        const tg = {
+            schemaVersion: TG_SCHEMA_VERSION,
+            description: {},
+            nodes: {
+                [moduleId]: {
+                    id: moduleId,
+                    label: 'module.example',
+                    adapter: {
+                        [DotAdapter.name]: {
+                            color: 'red',
+                        },
+                    },
+                },
+            },
+            edges: [],
+        };
+        const adapter = new DotAdapter(new DirectedGraph()).withTgGraph(tg);
+        const node = adapter.getNodeAttributes(moduleId);
+        if (!node) {
+            throw new Error('Missing node attributes for module');
+        }
+        const hook = new NodeDotProperties({
+            node: { nodeId: { eq: moduleId.toString() } },
+            options: {
+                style: 'dashed',
+            },
+        });
+        hook.match(moduleId, node, adapter);
+        const result = hook.apply(moduleId, node, adapter);
+        expect(result.getNodeAttributes(moduleId)).toEqual({
+            ...node,
+            adapter: {
+                [DotAdapter.name]: {
+                    color: 'red',
+                    style: 'dashed',
+                },
+            },
+        });
+    });
+    it('shoud keep graph unchanged when the rule does not match', () => {
+        const moduleId = asNodeId('cluster_module.example');
+        const tg = {
+            schemaVersion: TG_SCHEMA_VERSION,
+            description: {},
+            nodes: {
+                [moduleId]: { id: moduleId, label: 'module.example' },
+            },
+            edges: [],
+        };
+        const adapter = new DotAdapter(new DirectedGraph()).withTgGraph(tg);
+        const node = adapter.getNodeAttributes(moduleId);
+        if (!node) {
+            throw new Error('Missing node attributes for module');
+        }
+        const hook = new NodeDotProperties({
+            node: { nodeId: { eq: 'different-node' } },
+            options: {
+                peripheries: 2,
+            },
+        });
+        hook.match(moduleId, node, adapter);
+        const result = hook.apply(moduleId, node, adapter);
+        expect(result.getNodeAttributes(moduleId)).toEqual(node);
+    });
+    it('shoud keep graph unchanged when apply is called without a match', () => {
+        const moduleId = asNodeId('cluster_module.example');
+        const tg = {
+            schemaVersion: TG_SCHEMA_VERSION,
+            description: {},
+            nodes: {
+                [moduleId]: { id: moduleId, label: 'module.example' },
+            },
+            edges: [],
+        };
+        const adapter = new DotAdapter(new DirectedGraph()).withTgGraph(tg);
+        const node = adapter.getNodeAttributes(moduleId);
+        if (!node) {
+            throw new Error('Missing node attributes for module');
+        }
+        const hook = new NodeDotProperties({
+            node: { nodeId: { eq: moduleId.toString() } },
+            options: {
+                peripheries: 1,
+            },
+        });
+        const result = hook.apply(moduleId, node, adapter);
+        expect(result.getNodeAttributes(moduleId)).toEqual(node);
+    });
+    it('shoud preserve other adapter entries when dot adapter data is missing', () => {
+        const moduleId = asNodeId('cluster_module.example');
+        const tg = {
+            schemaVersion: TG_SCHEMA_VERSION,
+            description: {},
+            nodes: {
+                [moduleId]: {
+                    id: moduleId,
+                    label: 'module.example',
+                    adapter: {
+                        OtherAdapter: { style: 'bold' },
+                    },
+                },
+            },
+            edges: [],
+        };
+        const adapter = new DotAdapter(new DirectedGraph()).withTgGraph(tg);
+        const node = adapter.getNodeAttributes(moduleId);
+        if (!node) {
+            throw new Error('Missing node attributes for module');
+        }
+        const hook = new NodeDotProperties({
+            node: { nodeId: { eq: moduleId.toString() } },
+            options: {
+                peripheries: 2,
+            },
+        });
+        hook.match(moduleId, node, adapter);
+        const result = hook.apply(moduleId, node, adapter);
+        expect(result.getNodeAttributes(moduleId)).toEqual({
+            ...node,
+            adapter: {
+                OtherAdapter: { style: 'bold' },
+                [DotAdapter.name]: {
+                    peripheries: 2,
+                },
+            },
+        });
+    });
+    it('shoud fall back to empty properties when options are cleared', () => {
+        const moduleId = asNodeId('cluster_module.example');
+        const tg = {
+            schemaVersion: TG_SCHEMA_VERSION,
+            description: {},
+            nodes: {
+                [moduleId]: { id: moduleId, label: 'module.example' },
+            },
+            edges: [],
+        };
+        const adapter = new DotAdapter(new DirectedGraph()).withTgGraph(tg);
+        const node = adapter.getNodeAttributes(moduleId);
+        if (!node) {
+            throw new Error('Missing node attributes for module');
+        }
+        const hook = new NodeDotProperties({
+            node: { nodeId: { eq: moduleId.toString() } },
+            options: {
+                peripheries: 1,
+            },
+        });
+        hook.config.options = undefined;
+        hook.match(moduleId, node, adapter);
+        const result = hook.apply(moduleId, node, adapter);
+        expect(result.getNodeAttributes(moduleId)).toEqual({
+            ...node,
+            adapter: {
+                [DotAdapter.name]: {},
+            },
+        });
+    });
+});

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

@@ -0,0 +1,12 @@
+import { AdapterOperations } from '../../Operations/Operations.js';
+import { NodeId, TgNodeAttributes } from '../../TgGraph.js';
+import { NodeRule } from '../Rule.js';
+import { NodeRuleConfig } from '../RuleConfig.js';
+export declare class NodeProperties extends NodeRule {
+    constructor(config: NodeRuleConfig);
+    apply(nodeId: NodeId, node: TgNodeAttributes, graph: AdapterOperations): AdapterOperations;
+    private resolveOptions;
+    private resolveValueReference;
+    private static deepMerge;
+    private static getValueAtPath;
+}

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

@@ -0,0 +1,77 @@
+import { NodeRule } from '../Rule.js';
+const isObjectRecord = (value) => {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+};
+const isValueReference = (value) => {
+    if (!isObjectRecord(value)) {
+        return false;
+    }
+    const keys = Object.keys(value);
+    return keys.length === 1 && typeof value.from === 'string';
+};
+export class NodeProperties extends NodeRule {
+    constructor(config) {
+        if (config.options === undefined) {
+            throw new Error(`Rule '${NodeProperties.name}' requires options in config`);
+        }
+        super(config);
+    }
+    apply(nodeId, node, graph) {
+        if (!this.wasMatched(nodeId)) {
+            return graph;
+        }
+        const resolved = this.resolveOptions(nodeId, node, this.config.options ?? {});
+        if (!isObjectRecord(resolved) || Object.keys(resolved).length === 0) {
+            return graph;
+        }
+        return graph.setNodeAttributes(nodeId, NodeProperties.deepMerge(node, resolved));
+    }
+    resolveOptions(nodeId, node, input) {
+        if (isValueReference(input)) {
+            return this.resolveValueReference(nodeId, node, input);
+        }
+        if (Array.isArray(input)) {
+            return input.map((item) => this.resolveOptions(nodeId, node, item));
+        }
+        if (isObjectRecord(input)) {
+            const resolved = {};
+            for (const [key, value] of Object.entries(input)) {
+                const next = this.resolveOptions(nodeId, node, value);
+                if (next !== undefined) {
+                    resolved[key] = next;
+                }
+            }
+            return resolved;
+        }
+        return input;
+    }
+    resolveValueReference(nodeId, node, value) {
+        const from = value.from.trim();
+        if (from === 'nodeId') {
+            return String(nodeId);
+        }
+        return NodeProperties.getValueAtPath(node, from);
+    }
+    static deepMerge(base, patch) {
+        if (!isObjectRecord(base) || !isObjectRecord(patch)) {
+            return patch;
+        }
+        const merged = { ...base };
+        for (const [key, value] of Object.entries(patch)) {
+            merged[key] = NodeProperties.deepMerge(merged[key], value);
+        }
+        return merged;
+    }
+    static getValueAtPath(target, path) {
+        if (!path) {
+            return undefined;
+        }
+        return path.split('.').reduce((acc, key) => {
+            if (acc && typeof acc === 'object' && key in acc) {
+                return acc[key];
+            }
+            return undefined;
+        }, target);
+    }
+}
+NodeRule.register(NodeProperties);

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

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