@terra-graph/core 1.0.0-rc.4

package/dist/esm/Graph/Rules/Edge/RemoveEdge.test.d.ts

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

package/dist/esm/Graph/Rules/Edge/RemoveEdge.test.js

@@ -0,0 +1,133 @@
+import { DirectedGraph } from 'graphology';
+import { GraphologyAdapter } from '../../Adapters/GraphologyAdapter.js';
+import { TG_SCHEMA_VERSION, asEdgeId, asNodeId, } from '../../TgGraph.js';
+import { RemoveEdge } from './RemoveEdge.js';
+describe('RemoveEdge.apply', () => {
+    it('shoud remove matching outbound edges', () => {
+        const nodeA = asNodeId('node-a');
+        const nodeB = asNodeId('node-b');
+        const nodeC = asNodeId('node-c');
+        const edgeAB = asEdgeId('edge-ab');
+        const edgeAC = asEdgeId('edge-ac');
+        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: edgeAB, from: nodeA, to: nodeB, attributes: {} },
+                { id: edgeAC, from: nodeA, 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 RemoveEdge({
+            edge: {
+                from: { nodeId: { eq: 'node-a' } },
+                to: { nodeId: { eq: 'node-b' } },
+            },
+        });
+        hook.match(nodeA, node, adapter);
+        const result = hook.apply(nodeA, node, adapter);
+        expect(result.edgesBetween(nodeA, nodeB)).toEqual([]);
+        expect(result.edgesBetween(nodeA, nodeC)).toEqual([edgeAC]);
+    });
+    it('shoud keep graph unchanged when the hook does not match', () => {
+        const nodeA = asNodeId('node-a');
+        const nodeB = asNodeId('node-b');
+        const edgeAB = asEdgeId('edge-ab');
+        const tg = {
+            schemaVersion: TG_SCHEMA_VERSION,
+            description: {},
+            nodes: {
+                [nodeA]: { id: nodeA, label: 'A' },
+                [nodeB]: { id: nodeB, label: 'B' },
+            },
+            edges: [{ id: edgeAB, from: nodeA, to: nodeB, 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 RemoveEdge({
+            edge: {
+                from: { nodeId: { eq: 'node-a' } },
+                to: { nodeId: { eq: 'node-b' } },
+            },
+        });
+        hook.match(nodeB, node, adapter);
+        const result = hook.apply(nodeB, node, adapter);
+        expect(result.edgesBetween(nodeA, nodeB)).toEqual([edgeAB]);
+    });
+    it('shoud keep edges when the target does not match the query', () => {
+        const nodeA = asNodeId('node-a');
+        const nodeB = asNodeId('node-b');
+        const nodeC = asNodeId('node-c');
+        const edgeAB = asEdgeId('edge-ab');
+        const edgeAC = asEdgeId('edge-ac');
+        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: edgeAB, from: nodeA, to: nodeB, attributes: {} },
+                { id: edgeAC, from: nodeA, 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 RemoveEdge({
+            edge: {
+                from: { nodeId: { eq: 'node-a' } },
+                to: { nodeId: { eq: 'node-d' } },
+            },
+        });
+        hook.match(nodeA, node, adapter);
+        const result = hook.apply(nodeA, node, adapter);
+        expect(result.edgesBetween(nodeA, nodeB)).toEqual([edgeAB]);
+        expect(result.edgesBetween(nodeA, nodeC)).toEqual([edgeAC]);
+    });
+    it('shoud return early when the source node no longer matches', () => {
+        const nodeA = asNodeId('node-a');
+        const nodeB = asNodeId('node-b');
+        const edgeAB = asEdgeId('edge-ab');
+        const tg = {
+            schemaVersion: TG_SCHEMA_VERSION,
+            description: {},
+            nodes: {
+                [nodeA]: { id: nodeA, label: 'A' },
+                [nodeB]: { id: nodeB, label: 'B' },
+            },
+            edges: [{ id: edgeAB, from: nodeA, to: nodeB, 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 RemoveEdge({
+            edge: {
+                from: { attr: { key: 'label', eq: 'A' } },
+                to: { any: true },
+            },
+        });
+        hook.match(nodeA, node, adapter);
+        const mismatchedNode = { ...node, label: 'mismatch' };
+        const result = hook.apply(nodeA, mismatchedNode, adapter);
+        expect(result.edgesBetween(nodeA, nodeB)).toEqual([edgeAB]);
+    });
+});

package/dist/esm/Graph/Rules/Edge/index.d.ts

@@ -0,0 +1,8 @@
+export * from './AlignNodes.js';
+export * from './EdgeDirectionSemantic.js';
+export * from './EdgeDotProperties.js';
+export * from './EdgeLegend.js';
+export * from './EdgeReverse.js';
+export * from './EdgeSemanticLegend.js';
+export * from './ExplicitEdge.js';
+export * from './RemoveEdge.js';

package/dist/esm/Graph/Rules/Edge/index.js

@@ -0,0 +1,8 @@
+export * from './AlignNodes.js';
+export * from './EdgeDirectionSemantic.js';
+export * from './EdgeDotProperties.js';
+export * from './EdgeLegend.js';
+export * from './EdgeReverse.js';
+export * from './EdgeSemanticLegend.js';
+export * from './ExplicitEdge.js';
+export * from './RemoveEdge.js';

package/dist/esm/Graph/Rules/NamedRuleRegistry.d.ts

@@ -0,0 +1,20 @@
+import { BaseRule } from './Rule.js';
+import { NamedRuleDefinition, NamedRuleDefinitions } from './RulePlan.js';
+type NamedRuleFactory = () => BaseRule;
+export declare class NamedRuleRegistry {
+    private readonly definitions;
+    constructor(definitions?: NamedRuleDefinitions, factories?: Record<string, NamedRuleFactory>);
+    static from(registries: NamedRuleRegistry[]): NamedRuleRegistry;
+    register(name: string, definition: NamedRuleDefinition): NamedRuleRegistry;
+    registerMany(definitions: NamedRuleDefinitions): NamedRuleRegistry;
+    use(registry: NamedRuleRegistry): NamedRuleRegistry;
+    resolve(name: string): BaseRule;
+    resolveMany(names: string[]): BaseRule[];
+    resolvePhases(phases: string[][]): BaseRule[][];
+    names(): string[];
+    private static fromFactories;
+    private static toFactories;
+    private static toFactory;
+    private static cloneConfig;
+}
+export {};

package/dist/esm/Graph/Rules/NamedRuleRegistry.js

@@ -0,0 +1,67 @@
+import { BaseRule } from './Rule.js';
+export class NamedRuleRegistry {
+    definitions;
+    constructor(definitions = {}, factories) {
+        this.definitions = Object.freeze(factories ?? NamedRuleRegistry.toFactories(definitions));
+    }
+    static from(registries) {
+        return registries.reduce((combined, registry) => combined.use(registry), new NamedRuleRegistry());
+    }
+    register(name, definition) {
+        return NamedRuleRegistry.fromFactories({
+            ...this.definitions,
+            [name]: NamedRuleRegistry.toFactory(definition),
+        });
+    }
+    registerMany(definitions) {
+        const nextFactories = {
+            ...this.definitions,
+            ...NamedRuleRegistry.toFactories(definitions),
+        };
+        return NamedRuleRegistry.fromFactories(nextFactories);
+    }
+    use(registry) {
+        return NamedRuleRegistry.fromFactories({
+            ...this.definitions,
+            ...registry.definitions,
+        });
+    }
+    resolve(name) {
+        const factory = this.definitions[name];
+        if (!factory) {
+            throw new Error(`Named rule '${name}' is not registered`);
+        }
+        return factory();
+    }
+    resolveMany(names) {
+        return names.map((name) => this.resolve(name));
+    }
+    resolvePhases(phases) {
+        return phases.map((phase) => this.resolveMany(phase));
+    }
+    names() {
+        return Object.keys(this.definitions);
+    }
+    static fromFactories(definitions) {
+        return new NamedRuleRegistry({}, { ...definitions });
+    }
+    static toFactories(definitions) {
+        return Object.fromEntries(Object.entries(definitions).map(([name, definition]) => [
+            name,
+            NamedRuleRegistry.toFactory(definition),
+        ]));
+    }
+    static toFactory(definition) {
+        if (typeof definition === 'function') {
+            return definition;
+        }
+        const serialized = definition instanceof BaseRule ? definition.serialize() : definition;
+        return () => BaseRule.fromSerialized({
+            id: serialized.id,
+            config: NamedRuleRegistry.cloneConfig(serialized.config),
+        });
+    }
+    static cloneConfig(config) {
+        return JSON.parse(JSON.stringify(config));
+    }
+}

package/dist/esm/Graph/Rules/NamedRuleRegistry.test.d.ts

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

package/dist/esm/Graph/Rules/NamedRuleRegistry.test.js

@@ -0,0 +1,241 @@
+import { NamedRuleRegistry } from './NamedRuleRegistry.js';
+import { RemoveNode } from './Node/RemoveNode.js';
+describe('NamedRuleRegistry.resolve', () => {
+    it('shoud resolve a named serialized rule', () => {
+        const registry = new NamedRuleRegistry({
+            removeDataNodes: {
+                id: 'RemoveNode',
+                config: {
+                    node: {
+                        attr: {
+                            key: 'label',
+                            startsWith: 'data.',
+                        },
+                    },
+                },
+            },
+        });
+        const rule = registry.resolve('removeDataNodes');
+        expect(rule.serialize()).toEqual({
+            id: 'RemoveNode',
+            config: {
+                node: {
+                    attr: {
+                        key: 'label',
+                        startsWith: 'data.',
+                    },
+                },
+            },
+        });
+    });
+    it('shoud resolve a fresh instance each time for a named rule object', () => {
+        const registry = new NamedRuleRegistry({
+            removeLocalNodes: new RemoveNode({
+                node: {
+                    attr: {
+                        key: 'label',
+                        startsWith: 'local.',
+                    },
+                },
+            }),
+        });
+        const first = registry.resolve('removeLocalNodes');
+        const second = registry.resolve('removeLocalNodes');
+        expect(first).not.toBe(second);
+        expect(first.serialize()).toEqual(second.serialize());
+    });
+    it('shoud throw when a named rule is not registered', () => {
+        const registry = new NamedRuleRegistry();
+        expect(() => registry.resolve('doesNotExist')).toThrow("Named rule 'doesNotExist' is not registered");
+    });
+    it('shoud resolve named rule factories provided as functions', () => {
+        const registry = new NamedRuleRegistry({
+            removeDataNodes: () => new RemoveNode({
+                node: {
+                    attr: {
+                        key: 'label',
+                        startsWith: 'data.',
+                    },
+                },
+            }),
+        });
+        const first = registry.resolve('removeDataNodes');
+        const second = registry.resolve('removeDataNodes');
+        expect(first).not.toBe(second);
+        expect(first.serialize()).toEqual(second.serialize());
+    });
+});
+describe('NamedRuleRegistry.resolvePhases', () => {
+    it('shoud resolve a named phase plan into rule instances', () => {
+        const registry = new NamedRuleRegistry({
+            removeDataNodes: {
+                id: 'RemoveNode',
+                config: {
+                    node: {
+                        attr: {
+                            key: 'label',
+                            startsWith: 'data.',
+                        },
+                    },
+                },
+            },
+            removeLocalNodes: {
+                id: 'RemoveNode',
+                config: {
+                    node: {
+                        attr: {
+                            key: 'label',
+                            startsWith: 'local.',
+                        },
+                    },
+                },
+            },
+        });
+        const plan = registry.resolvePhases([
+            ['removeDataNodes'],
+            ['removeLocalNodes'],
+        ]);
+        expect(plan).toHaveLength(2);
+        expect(plan[0]).toHaveLength(1);
+        expect(plan[1]).toHaveLength(1);
+        expect(plan[0][0].serialize().id).toBe('RemoveNode');
+        expect(plan[1][0].serialize().id).toBe('RemoveNode');
+    });
+});
+describe('NamedRuleRegistry.register', () => {
+    it('shoud return a new registry without mutating the original', () => {
+        const base = new NamedRuleRegistry({
+            removeDataNodes: {
+                id: 'RemoveNode',
+                config: {
+                    node: {
+                        attr: {
+                            key: 'label',
+                            startsWith: 'data.',
+                        },
+                    },
+                },
+            },
+        });
+        const next = base.register('removeLocalNodes', {
+            id: 'RemoveNode',
+            config: {
+                node: {
+                    attr: {
+                        key: 'label',
+                        startsWith: 'local.',
+                    },
+                },
+            },
+        });
+        expect(base.names()).toEqual(['removeDataNodes']);
+        expect(next.names()).toEqual(['removeDataNodes', 'removeLocalNodes']);
+    });
+});
+describe('NamedRuleRegistry.use', () => {
+    it('shoud combine registries immutably', () => {
+        const common = new NamedRuleRegistry({
+            removeDataNodes: {
+                id: 'RemoveNode',
+                config: {
+                    node: {
+                        attr: {
+                            key: 'label',
+                            startsWith: 'data.',
+                        },
+                    },
+                },
+            },
+        });
+        const aws = new NamedRuleRegistry({
+            removeLocalNodes: {
+                id: 'RemoveNode',
+                config: {
+                    node: {
+                        attr: {
+                            key: 'label',
+                            startsWith: 'local.',
+                        },
+                    },
+                },
+            },
+        });
+        const combined = common.use(aws);
+        expect(common.names()).toEqual(['removeDataNodes']);
+        expect(aws.names()).toEqual(['removeLocalNodes']);
+        expect(combined.names()).toEqual(['removeDataNodes', 'removeLocalNodes']);
+    });
+});
+describe('NamedRuleRegistry.from', () => {
+    it('shoud combine an array of registries', () => {
+        const one = new NamedRuleRegistry({
+            removeDataNodes: {
+                id: 'RemoveNode',
+                config: {
+                    node: {
+                        attr: {
+                            key: 'label',
+                            startsWith: 'data.',
+                        },
+                    },
+                },
+            },
+        });
+        const two = new NamedRuleRegistry({
+            removeLocalNodes: {
+                id: 'RemoveNode',
+                config: {
+                    node: {
+                        attr: {
+                            key: 'label',
+                            startsWith: 'local.',
+                        },
+                    },
+                },
+            },
+        });
+        const combined = NamedRuleRegistry.from([one, two]);
+        expect(combined.names()).toEqual(['removeDataNodes', 'removeLocalNodes']);
+    });
+    it('shoud prefer later registries when names collide', () => {
+        const first = new NamedRuleRegistry({
+            removeNodes: {
+                id: 'RemoveNode',
+                config: {
+                    node: {
+                        attr: {
+                            key: 'label',
+                            startsWith: 'data.',
+                        },
+                    },
+                },
+            },
+        });
+        const second = new NamedRuleRegistry({
+            removeNodes: {
+                id: 'RemoveNode',
+                config: {
+                    node: {
+                        attr: {
+                            key: 'label',
+                            startsWith: 'local.',
+                        },
+                    },
+                },
+            },
+        });
+        const combined = NamedRuleRegistry.from([first, second]);
+        const resolved = combined.resolve('removeNodes');
+        expect(resolved.serialize()).toEqual({
+            id: 'RemoveNode',
+            config: {
+                node: {
+                    attr: {
+                        key: 'label',
+                        startsWith: 'local.',
+                    },
+                },
+            },
+        });
+    });
+});

package/dist/esm/Graph/Rules/NamedRuleSetRegistry.d.ts

@@ -0,0 +1,19 @@
+import { RuleSet, SerializedRuleSet } from './RuleSet.js';
+export type NamedRuleSetDefinition = SerializedRuleSet | RuleSet | (() => RuleSet);
+export type NamedRuleSetDefinitions = Record<string, NamedRuleSetDefinition>;
+type NamedRuleSetFactory = () => RuleSet;
+export declare class NamedRuleSetRegistry {
+    private readonly definitions;
+    constructor(definitions?: NamedRuleSetDefinitions, factories?: Record<string, NamedRuleSetFactory>);
+    static from(registries: NamedRuleSetRegistry[]): NamedRuleSetRegistry;
+    register(name: string, definition: NamedRuleSetDefinition): NamedRuleSetRegistry;
+    registerMany(definitions: NamedRuleSetDefinitions): NamedRuleSetRegistry;
+    use(registry: NamedRuleSetRegistry): NamedRuleSetRegistry;
+    resolve(name: string): RuleSet;
+    names(): string[];
+    private static fromFactories;
+    private static toFactories;
+    private static toFactory;
+    private static cloneSerialized;
+}
+export {};

package/dist/esm/Graph/Rules/NamedRuleSetRegistry.js

@@ -0,0 +1,58 @@
+import { RuleSet } from './RuleSet.js';
+export class NamedRuleSetRegistry {
+    definitions;
+    constructor(definitions = {}, factories) {
+        this.definitions = Object.freeze(factories ?? NamedRuleSetRegistry.toFactories(definitions));
+    }
+    static from(registries) {
+        return registries.reduce((combined, registry) => combined.use(registry), new NamedRuleSetRegistry());
+    }
+    register(name, definition) {
+        return NamedRuleSetRegistry.fromFactories({
+            ...this.definitions,
+            [name]: NamedRuleSetRegistry.toFactory(definition),
+        });
+    }
+    registerMany(definitions) {
+        const nextFactories = {
+            ...this.definitions,
+            ...NamedRuleSetRegistry.toFactories(definitions),
+        };
+        return NamedRuleSetRegistry.fromFactories(nextFactories);
+    }
+    use(registry) {
+        return NamedRuleSetRegistry.fromFactories({
+            ...this.definitions,
+            ...registry.definitions,
+        });
+    }
+    resolve(name) {
+        const factory = this.definitions[name];
+        if (!factory) {
+            throw new Error(`Named rule set '${name}' is not registered`);
+        }
+        return factory();
+    }
+    names() {
+        return Object.keys(this.definitions);
+    }
+    static fromFactories(definitions) {
+        return new NamedRuleSetRegistry({}, { ...definitions });
+    }
+    static toFactories(definitions) {
+        return Object.fromEntries(Object.entries(definitions).map(([name, definition]) => [
+            name,
+            NamedRuleSetRegistry.toFactory(definition),
+        ]));
+    }
+    static toFactory(definition) {
+        if (typeof definition === 'function') {
+            return definition;
+        }
+        const serialized = definition instanceof RuleSet ? definition.serialize() : definition;
+        return () => RuleSet.deseriaize(NamedRuleSetRegistry.cloneSerialized(serialized));
+    }
+    static cloneSerialized(set) {
+        return JSON.parse(JSON.stringify(set));
+    }
+}

package/dist/esm/Graph/Rules/NamedRuleSetRegistry.test.d.ts

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

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

@@ -0,0 +1,78 @@
+import { NamedRuleSetRegistry } from './NamedRuleSetRegistry.js';
+import { RuleSet } from './RuleSet.js';
+describe('NamedRuleSetRegistry.resolve', () => {
+    it('shoud resolve a named serialized rule set', () => {
+        const registry = new 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({
+            core: new 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();
+        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({
+            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({
+            core: {
+                rules: [{ namedRule: 'removeDataNodes' }],
+            },
+        });
+        const aws = new 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({
+            core: {
+                rules: [{ namedRule: 'removeDataNodes' }],
+            },
+        });
+        const two = new NamedRuleSetRegistry({
+            aws: {
+                rules: [{ namedRule: 'removeLocalNodes' }],
+            },
+        });
+        const combined = NamedRuleSetRegistry.from([one, two]);
+        expect(combined.names()).toEqual(['core', 'aws']);
+    });
+});

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

@@ -0,0 +1,28 @@
+import { edgeIdFrom } from '../../TgGraph.js';
+import { NodeRule } from '../Rule.js';
+export class ConvertNodeToEdge extends 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 = edgeIdFrom(sourceId, targetId);
+        updated = updated.setEdge(edgeId, sourceId, targetId, { renderHints });
+        updated = updated.removeNode(nodeId);
+        return updated;
+    }
+}
+NodeRule.register(ConvertNodeToEdge);