@terra-graph/core 1.0.0-rc.4

package/dist/cjs/Graph/Rules/NamedRuleSetRegistry.test.js

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const NamedRuleSetRegistry_js_1 = require("./NamedRuleSetRegistry.js");
+const RuleSet_js_1 = require("./RuleSet.js");
+describe('NamedRuleSetRegistry.resolve', () => {
+    it('shoud resolve a named serialized rule set', () => {
+        const registry = new NamedRuleSetRegistry_js_1.NamedRuleSetRegistry({
+            core: {
+                rules: [{ namedRule: 'removeDataNodes' }],
+            },
+        });
+        const set = registry.resolve('core');
+        expect(set.serialize()).toEqual({
+            rules: [{ namedRule: 'removeDataNodes' }],
+        });
+    });
+    it('shoud resolve a fresh instance each time for a named rule set object', () => {
+        const registry = new NamedRuleSetRegistry_js_1.NamedRuleSetRegistry({
+            core: new RuleSet_js_1.RuleSet({
+                rules: [{ namedRule: 'removeDataNodes' }],
+            }),
+        });
+        const first = registry.resolve('core');
+        const second = registry.resolve('core');
+        expect(first).not.toBe(second);
+        expect(first.serialize()).toEqual(second.serialize());
+    });
+    it('shoud throw when a named rule set is not registered', () => {
+        const registry = new NamedRuleSetRegistry_js_1.NamedRuleSetRegistry();
+        expect(() => registry.resolve('doesNotExist')).toThrow("Named rule set 'doesNotExist' is not registered");
+    });
+});
+describe('NamedRuleSetRegistry.register', () => {
+    it('shoud return a new registry without mutating the original', () => {
+        const base = new NamedRuleSetRegistry_js_1.NamedRuleSetRegistry({
+            core: {
+                rules: [{ namedRule: 'removeDataNodes' }],
+            },
+        });
+        const next = base.register('extra', {
+            rules: [{ namedRule: 'removeLocalNodes' }],
+        });
+        expect(base.names()).toEqual(['core']);
+        expect(next.names()).toEqual(['core', 'extra']);
+    });
+});
+describe('NamedRuleSetRegistry.use', () => {
+    it('shoud combine registries immutably', () => {
+        const common = new NamedRuleSetRegistry_js_1.NamedRuleSetRegistry({
+            core: {
+                rules: [{ namedRule: 'removeDataNodes' }],
+            },
+        });
+        const aws = new NamedRuleSetRegistry_js_1.NamedRuleSetRegistry({
+            aws: {
+                rules: [{ namedRule: 'removeLocalNodes' }],
+            },
+        });
+        const combined = common.use(aws);
+        expect(common.names()).toEqual(['core']);
+        expect(aws.names()).toEqual(['aws']);
+        expect(combined.names()).toEqual(['core', 'aws']);
+    });
+});
+describe('NamedRuleSetRegistry.from', () => {
+    it('shoud combine an array of registries', () => {
+        const one = new NamedRuleSetRegistry_js_1.NamedRuleSetRegistry({
+            core: {
+                rules: [{ namedRule: 'removeDataNodes' }],
+            },
+        });
+        const two = new NamedRuleSetRegistry_js_1.NamedRuleSetRegistry({
+            aws: {
+                rules: [{ namedRule: 'removeLocalNodes' }],
+            },
+        });
+        const combined = NamedRuleSetRegistry_js_1.NamedRuleSetRegistry.from([one, two]);
+        expect(combined.names()).toEqual(['core', 'aws']);
+    });
+});

package/dist/cjs/Graph/Rules/Node/ConvertNodeToEdge.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 ConvertNodeToEdge extends NodeRule {
+    apply(nodeId: NodeId, node: TgNodeAttributes, graph: AdapterOperations): AdapterOperations;
+}

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

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConvertNodeToEdge = void 0;
+const TgGraph_js_1 = require("../../TgGraph.js");
+const Rule_js_1 = require("../Rule.js");
+class ConvertNodeToEdge 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);
+        if (inEdges.length !== 1 || outEdges.length !== 1) {
+            return graph;
+        }
+        const inEdgeId = inEdges[0];
+        const outEdgeId = outEdges[0];
+        const sourceId = graph.edgeSource(inEdgeId);
+        const targetId = graph.edgeTarget(outEdgeId);
+        const renderHints = {
+            resource: node.terraform?.resource ?? '',
+            name: node.terraform?.name ?? '',
+        };
+        let updated = graph.removeEdge(inEdgeId).removeEdge(outEdgeId);
+        const edgeId = (0, TgGraph_js_1.edgeIdFrom)(sourceId, targetId);
+        updated = updated.setEdge(edgeId, sourceId, targetId, { renderHints });
+        updated = updated.removeNode(nodeId);
+        return updated;
+    }
+}
+exports.ConvertNodeToEdge = ConvertNodeToEdge;
+Rule_js_1.NodeRule.register(ConvertNodeToEdge);

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

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

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

@@ -0,0 +1,152 @@
+"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 ConvertNodeToEdge_js_1 = require("./ConvertNodeToEdge.js");
+describe('ConvertNodeToEdge.apply', () => {
+    it('shoud convert a node with a single in/out edge into a labeled edge', () => {
+        const nodeA = (0, TgGraph_js_1.asNodeId)('node-a');
+        const nodeB = (0, TgGraph_js_1.asNodeId)('node-b');
+        const nodeLabel = (0, TgGraph_js_1.asNodeId)('resource.name');
+        const edgeIn = (0, TgGraph_js_1.asEdgeId)('edge-in');
+        const edgeOut = (0, TgGraph_js_1.asEdgeId)('edge-out');
+        const tg = {
+            schemaVersion: TgGraph_js_1.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_js_1.GraphologyAdapter(new graphology_1.DirectedGraph()).withTgGraph(tg);
+        const node = adapter.getNodeAttributes(nodeLabel);
+        if (!node) {
+            throw new Error('Missing node attributes for resource.name');
+        }
+        const hook = new ConvertNodeToEdge_js_1.ConvertNodeToEdge({
+            node: { attr: { key: 'label', eq: 'resource.name' } },
+        });
+        hook.match(nodeLabel, node, adapter);
+        const result = hook.apply(nodeLabel, node, adapter);
+        const edgeId = (0, TgGraph_js_1.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 = (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 nodeLabel = (0, TgGraph_js_1.asNodeId)('resource.name');
+        const tg = {
+            schemaVersion: TgGraph_js_1.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: (0, TgGraph_js_1.asEdgeId)('edge-in'), from: nodeA, to: nodeLabel },
+                { id: (0, TgGraph_js_1.asEdgeId)('edge-out-1'), from: nodeLabel, to: nodeB },
+                { id: (0, TgGraph_js_1.asEdgeId)('edge-out-2'), from: nodeLabel, to: nodeC },
+            ],
+        };
+        const adapter = new GraphologyAdapter_js_1.GraphologyAdapter(new graphology_1.DirectedGraph()).withTgGraph(tg);
+        const node = adapter.getNodeAttributes(nodeLabel);
+        if (!node) {
+            throw new Error('Missing node attributes for resource.name');
+        }
+        const hook = new ConvertNodeToEdge_js_1.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 = (0, TgGraph_js_1.asNodeId)('node-a');
+        const nodeB = (0, TgGraph_js_1.asNodeId)('node-b');
+        const nodeLabel = (0, TgGraph_js_1.asNodeId)('resource.name');
+        const edgeIn = (0, TgGraph_js_1.asEdgeId)('edge-in');
+        const edgeOut = (0, TgGraph_js_1.asEdgeId)('edge-out');
+        const tg = {
+            schemaVersion: TgGraph_js_1.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_js_1.GraphologyAdapter(new graphology_1.DirectedGraph()).withTgGraph(tg);
+        const node = adapter.getNodeAttributes(nodeLabel);
+        if (!node) {
+            throw new Error('Missing node attributes for resource.name');
+        }
+        const hook = new ConvertNodeToEdge_js_1.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 = (0, TgGraph_js_1.asNodeId)('node-a');
+        const nodeB = (0, TgGraph_js_1.asNodeId)('node-b');
+        const nodeLabel = (0, TgGraph_js_1.asNodeId)('resource.name');
+        const edgeIn = (0, TgGraph_js_1.asEdgeId)('edge-in');
+        const edgeOut = (0, TgGraph_js_1.asEdgeId)('edge-out');
+        const tg = {
+            schemaVersion: TgGraph_js_1.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_js_1.GraphologyAdapter(new graphology_1.DirectedGraph()).withTgGraph(tg);
+        const node = adapter.getNodeAttributes(nodeLabel);
+        if (!node) {
+            throw new Error('Missing node attributes for resource.name');
+        }
+        const hook = new ConvertNodeToEdge_js_1.ConvertNodeToEdge({
+            node: { attr: { key: 'label', eq: 'resource.name' } },
+        });
+        hook.match(nodeLabel, node, adapter);
+        const result = hook.apply(nodeLabel, node, adapter);
+        const edgeId = (0, TgGraph_js_1.edgeIdFrom)(nodeA, nodeB);
+        expect(result.getEdgeAttributes(edgeId)).toEqual({
+            renderHints: { resource: '', name: '' },
+        });
+    });
+});

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

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NodeDotProperties = void 0;
+const DotAdapter_js_1 = require("../../Adapters/DotAdapter.js");
+const Rule_js_1 = require("../Rule.js");
+class NodeDotProperties extends Rule_js_1.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_js_1.DotAdapter;
+    }
+    apply(nodeId, node, graph) {
+        if (!this.wasMatched(nodeId)) {
+            return graph;
+        }
+        const adapterKey = DotAdapter_js_1.DotAdapter.name;
+        const properties = this.config.options ?? {};
+        return graph.setNodeAttributes(nodeId, {
+            ...node,
+            adapter: {
+                ...(node.adapter ?? {}),
+                [adapterKey]: {
+                    ...(node.adapter?.[adapterKey] ?? {}),
+                    ...properties,
+                },
+            },
+        });
+    }
+}
+exports.NodeDotProperties = NodeDotProperties;
+Rule_js_1.NodeRule.register(NodeDotProperties);

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

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

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

@@ -0,0 +1,226 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const graphology_1 = require("graphology");
+const DotAdapter_js_1 = require("../../Adapters/DotAdapter.js");
+const GraphologyAdapter_js_1 = require("../../Adapters/GraphologyAdapter.js");
+const TgGraph_js_1 = require("../../TgGraph.js");
+const NodeDotProperties_js_1 = require("./NodeDotProperties.js");
+describe('NodeDotProperties.constructor', () => {
+    it('shoud require options', () => {
+        expect(() => new NodeDotProperties_js_1.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_js_1.NodeDotProperties({
+            node: { nodeId: { eq: 'node-a' } },
+            options: { peripheries: 1 },
+        });
+        const dotAdapter = new DotAdapter_js_1.DotAdapter(new graphology_1.DirectedGraph());
+        const graphAdapter = new GraphologyAdapter_js_1.GraphologyAdapter(new graphology_1.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 = (0, TgGraph_js_1.asNodeId)('cluster_module.example');
+        const tg = {
+            schemaVersion: TgGraph_js_1.TG_SCHEMA_VERSION,
+            description: {},
+            nodes: {
+                [moduleId]: { id: moduleId, label: 'module.example' },
+            },
+            edges: [],
+        };
+        const adapter = new DotAdapter_js_1.DotAdapter(new graphology_1.DirectedGraph()).withTgGraph(tg);
+        const node = adapter.getNodeAttributes(moduleId);
+        if (!node) {
+            throw new Error('Missing node attributes for module');
+        }
+        const hook = new NodeDotProperties_js_1.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_js_1.DotAdapter.name]: {
+                    peripheries: 0,
+                    label: '',
+                    height: 0,
+                    width: 0,
+                },
+            },
+        });
+    });
+    it('shoud merge dot adapter options with existing adapter values', () => {
+        const moduleId = (0, TgGraph_js_1.asNodeId)('cluster_module.example');
+        const tg = {
+            schemaVersion: TgGraph_js_1.TG_SCHEMA_VERSION,
+            description: {},
+            nodes: {
+                [moduleId]: {
+                    id: moduleId,
+                    label: 'module.example',
+                    adapter: {
+                        [DotAdapter_js_1.DotAdapter.name]: {
+                            color: 'red',
+                        },
+                    },
+                },
+            },
+            edges: [],
+        };
+        const adapter = new DotAdapter_js_1.DotAdapter(new graphology_1.DirectedGraph()).withTgGraph(tg);
+        const node = adapter.getNodeAttributes(moduleId);
+        if (!node) {
+            throw new Error('Missing node attributes for module');
+        }
+        const hook = new NodeDotProperties_js_1.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_js_1.DotAdapter.name]: {
+                    color: 'red',
+                    style: 'dashed',
+                },
+            },
+        });
+    });
+    it('shoud keep graph unchanged when the rule does not match', () => {
+        const moduleId = (0, TgGraph_js_1.asNodeId)('cluster_module.example');
+        const tg = {
+            schemaVersion: TgGraph_js_1.TG_SCHEMA_VERSION,
+            description: {},
+            nodes: {
+                [moduleId]: { id: moduleId, label: 'module.example' },
+            },
+            edges: [],
+        };
+        const adapter = new DotAdapter_js_1.DotAdapter(new graphology_1.DirectedGraph()).withTgGraph(tg);
+        const node = adapter.getNodeAttributes(moduleId);
+        if (!node) {
+            throw new Error('Missing node attributes for module');
+        }
+        const hook = new NodeDotProperties_js_1.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 = (0, TgGraph_js_1.asNodeId)('cluster_module.example');
+        const tg = {
+            schemaVersion: TgGraph_js_1.TG_SCHEMA_VERSION,
+            description: {},
+            nodes: {
+                [moduleId]: { id: moduleId, label: 'module.example' },
+            },
+            edges: [],
+        };
+        const adapter = new DotAdapter_js_1.DotAdapter(new graphology_1.DirectedGraph()).withTgGraph(tg);
+        const node = adapter.getNodeAttributes(moduleId);
+        if (!node) {
+            throw new Error('Missing node attributes for module');
+        }
+        const hook = new NodeDotProperties_js_1.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 = (0, TgGraph_js_1.asNodeId)('cluster_module.example');
+        const tg = {
+            schemaVersion: TgGraph_js_1.TG_SCHEMA_VERSION,
+            description: {},
+            nodes: {
+                [moduleId]: {
+                    id: moduleId,
+                    label: 'module.example',
+                    adapter: {
+                        OtherAdapter: { style: 'bold' },
+                    },
+                },
+            },
+            edges: [],
+        };
+        const adapter = new DotAdapter_js_1.DotAdapter(new graphology_1.DirectedGraph()).withTgGraph(tg);
+        const node = adapter.getNodeAttributes(moduleId);
+        if (!node) {
+            throw new Error('Missing node attributes for module');
+        }
+        const hook = new NodeDotProperties_js_1.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_js_1.DotAdapter.name]: {
+                    peripheries: 2,
+                },
+            },
+        });
+    });
+    it('shoud fall back to empty properties when options are cleared', () => {
+        const moduleId = (0, TgGraph_js_1.asNodeId)('cluster_module.example');
+        const tg = {
+            schemaVersion: TgGraph_js_1.TG_SCHEMA_VERSION,
+            description: {},
+            nodes: {
+                [moduleId]: { id: moduleId, label: 'module.example' },
+            },
+            edges: [],
+        };
+        const adapter = new DotAdapter_js_1.DotAdapter(new graphology_1.DirectedGraph()).withTgGraph(tg);
+        const node = adapter.getNodeAttributes(moduleId);
+        if (!node) {
+            throw new Error('Missing node attributes for module');
+        }
+        const hook = new NodeDotProperties_js_1.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_js_1.DotAdapter.name]: {},
+            },
+        });
+    });
+});

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

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NodeProperties = void 0;
+const Rule_js_1 = require("../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';
+};
+class NodeProperties extends Rule_js_1.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);
+    }
+}
+exports.NodeProperties = NodeProperties;
+Rule_js_1.NodeRule.register(NodeProperties);

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

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