@terra-graph/core 1.0.0-rc.4

package/dist/cjs/Graph/Renderers/JsonRenderer.d.ts

@@ -0,0 +1,5 @@
+import { Adapter } from '../Adapter.js';
+import { RenderArtifact, Renderer } from '../Renderer.js';
+export declare class JsonRenderer<TAdapter extends Adapter = Adapter> implements Renderer<TAdapter> {
+    render(adapter: TAdapter): RenderArtifact;
+}

package/dist/cjs/Graph/Renderers/JsonRenderer.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JsonRenderer = void 0;
+class JsonRenderer {
+    render(adapter) {
+        return {
+            content: JSON.stringify(adapter.toTgGraph()),
+            mediaType: 'application/json',
+            extension: 'json',
+        };
+    }
+}
+exports.JsonRenderer = JsonRenderer;

package/dist/cjs/Graph/Renderers/JsonRenderer.test.d.ts

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

package/dist/cjs/Graph/Renderers/JsonRenderer.test.js

@@ -0,0 +1,29 @@
+"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 JsonRenderer_js_1 = require("./JsonRenderer.js");
+describe('JsonRenderer.render', () => {
+    it('shoud render tg graph JSON as string content', () => {
+        const nodeA = (0, TgGraph_js_1.asNodeId)('json.node-a');
+        const nodeB = (0, TgGraph_js_1.asNodeId)('json.node-b');
+        const tg = {
+            schemaVersion: TgGraph_js_1.TG_SCHEMA_VERSION,
+            description: {
+                source: 'unit-test',
+            },
+            nodes: {
+                [nodeA]: { id: nodeA },
+                [nodeB]: { id: nodeB },
+            },
+            edges: [],
+        };
+        const adapter = new GraphologyAdapter_js_1.GraphologyAdapter(new graphology_1.DirectedGraph()).withTgGraph(tg);
+        const renderer = new JsonRenderer_js_1.JsonRenderer();
+        const artifact = renderer.render(adapter);
+        expect(artifact.mediaType).toBe('application/json');
+        expect(artifact.extension).toBe('json');
+        expect(artifact.content).toBe(JSON.stringify(adapter.toTgGraph()));
+    });
+});

package/dist/cjs/Graph/Renderers/RendererRegistry.d.ts

@@ -0,0 +1,15 @@
+import { AdapterOperations } from '../Operations/Operations.js';
+import { Renderer } from '../Renderer.js';
+export type RendererFactoryInput = {
+    adapter: AdapterOperations;
+    options?: Record<string, unknown>;
+};
+export type RendererFactory = (input: RendererFactoryInput) => Renderer<AdapterOperations>;
+export declare class RendererRegistry {
+    private readonly renderers;
+    constructor(renderers?: Record<string, RendererFactory>);
+    resolve(name: string, adapter: AdapterOperations, options?: Record<string, unknown>): Renderer<AdapterOperations>;
+    list(): string[];
+    private static normalizeRegistry;
+    private static normalizeName;
+}

package/dist/cjs/Graph/Renderers/RendererRegistry.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RendererRegistry = void 0;
+class RendererRegistry {
+    renderers;
+    constructor(renderers = {}) {
+        this.renderers = RendererRegistry.normalizeRegistry(renderers);
+    }
+    resolve(name, adapter, options) {
+        const key = RendererRegistry.normalizeName(name);
+        const factory = this.renderers[key];
+        if (!factory) {
+            const available = Object.keys(this.renderers).sort().join(', ');
+            const suffix = available ? ` Available: ${available}.` : '';
+            throw new Error(`Renderer '${name}' is not registered.${suffix}`);
+        }
+        return factory({ adapter, options });
+    }
+    list() {
+        return Object.keys(this.renderers).sort();
+    }
+    static normalizeRegistry(renderers) {
+        const normalized = {};
+        for (const [name, factory] of Object.entries(renderers)) {
+            normalized[RendererRegistry.normalizeName(name)] = factory;
+        }
+        return normalized;
+    }
+    static normalizeName(name) {
+        return name.trim().toLowerCase();
+    }
+}
+exports.RendererRegistry = RendererRegistry;

package/dist/cjs/Graph/Renderers/RendererRegistry.test.d.ts

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

package/dist/cjs/Graph/Renderers/RendererRegistry.test.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const graphology_1 = require("graphology");
+const GraphologyAdapter_js_1 = require("../Adapters/GraphologyAdapter.js");
+const JsonRenderer_js_1 = require("./JsonRenderer.js");
+const RendererRegistry_js_1 = require("./RendererRegistry.js");
+describe('RendererRegistry.resolve', () => {
+    it('shoud normalize names and resolve factories', () => {
+        const adapter = new GraphologyAdapter_js_1.GraphologyAdapter(new graphology_1.DirectedGraph());
+        const factory = jest.fn(() => new JsonRenderer_js_1.JsonRenderer());
+        const registry = new RendererRegistry_js_1.RendererRegistry({ ' JSON ': factory });
+        const renderer = registry.resolve('json', adapter, { pretty: true });
+        expect(factory).toHaveBeenCalledWith({
+            adapter,
+            options: { pretty: true },
+        });
+        expect(renderer).toBeInstanceOf(JsonRenderer_js_1.JsonRenderer);
+    });
+    it('shoud include available renderers in errors', () => {
+        const adapter = new GraphologyAdapter_js_1.GraphologyAdapter(new graphology_1.DirectedGraph());
+        const registry = new RendererRegistry_js_1.RendererRegistry({ Json: () => new JsonRenderer_js_1.JsonRenderer() });
+        expect(() => registry.resolve('missing', adapter)).toThrow("Renderer 'missing' is not registered. Available: json.");
+    });
+    it('shoud omit available renderers when none are registered', () => {
+        const adapter = new GraphologyAdapter_js_1.GraphologyAdapter(new graphology_1.DirectedGraph());
+        const registry = new RendererRegistry_js_1.RendererRegistry();
+        expect(() => registry.resolve('missing', adapter)).toThrow("Renderer 'missing' is not registered.");
+    });
+});
+describe('RendererRegistry.list', () => {
+    it('shoud return sorted renderer names', () => {
+        const registry = new RendererRegistry_js_1.RendererRegistry({
+            Delta: () => new JsonRenderer_js_1.JsonRenderer(),
+            alpha: () => new JsonRenderer_js_1.JsonRenderer(),
+            Bravo: () => new JsonRenderer_js_1.JsonRenderer(),
+        });
+        expect(registry.list()).toEqual(['alpha', 'bravo', 'delta']);
+    });
+});

package/dist/cjs/Graph/Renderers/TgNodeLabel.d.ts

@@ -0,0 +1,11 @@
+import { TgNode } from '../TgGraph.js';
+export type TgNodeLabelComponents = {
+    resourceName?: string;
+    name?: string;
+};
+export declare class TgNodeLabel {
+    private readonly node;
+    constructor(node: TgNode);
+    getLabelComponents(): TgNodeLabelComponents;
+    getLabel(): string;
+}

package/dist/cjs/Graph/Renderers/TgNodeLabel.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TgNodeLabel = void 0;
+class TgNodeLabel {
+    node;
+    constructor(node) {
+        this.node = node;
+    }
+    getLabelComponents() {
+        const terraform = this.node.terraform;
+        if (!terraform) {
+            return {};
+        }
+        return {
+            resourceName: terraform.resource,
+            name: terraform.parentModuleName ?? terraform.name,
+        };
+    }
+    getLabel() {
+        const { resourceName, name } = this.getLabelComponents();
+        const kind = this.node.terraform?.kind;
+        const parentModuleName = this.node.terraform?.parentModuleName ?? '';
+        const terraformName = this.node.terraform?.name ?? '';
+        let labelName = name ?? '';
+        if (parentModuleName && kind === 'module') {
+            labelName = terraformName;
+        }
+        if (this.node.hints?.label?.end) {
+            labelName = `${labelName}.${this.node.hints.label.end}`;
+        }
+        if (resourceName && labelName) {
+            return `${resourceName}.${labelName}`;
+        }
+        if (labelName) {
+            return labelName;
+        }
+        if (resourceName) {
+            return resourceName;
+        }
+        return String(this.node.id);
+    }
+}
+exports.TgNodeLabel = TgNodeLabel;

package/dist/cjs/Graph/Renderers/TgNodeLabel.test.d.ts

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

package/dist/cjs/Graph/Renderers/TgNodeLabel.test.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const TgGraph_js_1 = require("../TgGraph.js");
+const TgNodeLabel_js_1 = require("./TgNodeLabel.js");
+describe('TgNodeLabel.getLabelComponents', () => {
+    it('shoud return empty components when terraform is missing', () => {
+        const node = { id: (0, TgGraph_js_1.asNodeId)('node-a') };
+        const subject = new TgNodeLabel_js_1.TgNodeLabel(node);
+        expect(subject.getLabelComponents()).toEqual({});
+    });
+    it('shoud prefer parentModuleName for the name component', () => {
+        const node = {
+            id: (0, TgGraph_js_1.asNodeId)('node-b'),
+            terraform: {
+                kind: 'resource',
+                address: 'module.network.aws_security_group.this',
+                resource: 'aws_security_group',
+                name: 'this',
+                parentModuleName: 'network',
+            },
+        };
+        const subject = new TgNodeLabel_js_1.TgNodeLabel(node);
+        expect(subject.getLabelComponents()).toEqual({
+            resourceName: 'aws_security_group',
+            name: 'network',
+        });
+    });
+});
+describe('TgNodeLabel.getLabel', () => {
+    it('shoud prefer parentModuleName for resources', () => {
+        const node = {
+            id: (0, TgGraph_js_1.asNodeId)('node-c'),
+            terraform: {
+                kind: 'resource',
+                address: 'module.network.aws_security_group.this',
+                resource: 'aws_security_group',
+                name: 'this',
+                parentModuleName: 'network',
+            },
+        };
+        const subject = new TgNodeLabel_js_1.TgNodeLabel(node);
+        expect(subject.getLabel()).toBe('aws_security_group.network');
+    });
+    it('shoud ignore parentModuleName for modules', () => {
+        const node = {
+            id: (0, TgGraph_js_1.asNodeId)('node-d'),
+            terraform: {
+                kind: 'module',
+                address: 'module.app',
+                resource: 'module',
+                name: 'app',
+                parentModuleName: 'parent',
+            },
+        };
+        const subject = new TgNodeLabel_js_1.TgNodeLabel(node);
+        expect(subject.getLabel()).toBe('module.app');
+    });
+    it('shoud append label endings when present', () => {
+        const node = {
+            id: (0, TgGraph_js_1.asNodeId)('node-e'),
+            terraform: {
+                kind: 'resource',
+                address: 'aws_s3_bucket.bucket',
+                resource: 'aws_s3_bucket',
+                name: 'bucket',
+            },
+            hints: {
+                label: {
+                    end: 'id',
+                },
+            },
+        };
+        const subject = new TgNodeLabel_js_1.TgNodeLabel(node);
+        expect(subject.getLabel()).toBe('aws_s3_bucket.bucket.id');
+    });
+});

package/dist/cjs/Graph/Renderers/index.d.ts

@@ -0,0 +1,4 @@
+export * from '../Renderer.js';
+export * from './DotRenderer.js';
+export * from './JsonRenderer.js';
+export * from './RendererRegistry.js';

package/dist/cjs/Graph/Renderers/index.js

@@ -0,0 +1,20 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("../Renderer.js"), exports);
+__exportStar(require("./DotRenderer.js"), exports);
+__exportStar(require("./JsonRenderer.js"), exports);
+__exportStar(require("./RendererRegistry.js"), exports);

package/dist/cjs/Graph/RuleError.d.ts

@@ -0,0 +1,12 @@
+export type RuleErrorProps<NodeAttributes> = {
+    nodeId: string;
+    nodeAttributes: NodeAttributes;
+};
+export declare class RuleModifyError<NodeAttributes> extends Error {
+    private readonly props;
+    constructor(options: ErrorOptions, props: RuleErrorProps<NodeAttributes>);
+}
+export declare class RuleMatchError<NodeAttributes> extends Error {
+    private readonly props;
+    constructor(options: ErrorOptions, props: RuleErrorProps<NodeAttributes>);
+}

package/dist/cjs/Graph/RuleError.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RuleMatchError = exports.RuleModifyError = void 0;
+class RuleModifyError extends Error {
+    props;
+    constructor(options, props) {
+        super(`Rule was unable to modify node ${props.nodeId}`, options);
+        this.props = props;
+    }
+}
+exports.RuleModifyError = RuleModifyError;
+class RuleMatchError extends Error {
+    props;
+    constructor(options, props) {
+        super(`Rule was unable to match node ${props.nodeId}`, options);
+        this.props = props;
+    }
+}
+exports.RuleMatchError = RuleMatchError;

package/dist/cjs/Graph/RuleError.test.d.ts

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

package/dist/cjs/Graph/RuleError.test.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const RuleError_js_1 = require("./RuleError.js");
+describe('RuleMatchError', () => {
+    it('shoud include match failure context in the message', () => {
+        const cause = new Error('original');
+        const error = new RuleError_js_1.RuleMatchError({ cause }, {
+            nodeId: 'node-a',
+            nodeAttributes: { label: 'node-a' },
+        });
+        expect(error.message).toBe('Rule was unable to match node node-a');
+        expect(error.cause).toBe(cause);
+    });
+});
+describe('RuleModifyError', () => {
+    it('shoud include modify failure context in the message', () => {
+        const cause = new Error('original');
+        const error = new RuleError_js_1.RuleModifyError({ cause }, {
+            nodeId: 'node-b',
+            nodeAttributes: { label: 'node-b' },
+        });
+        expect(error.message).toBe('Rule was unable to modify node node-b');
+        expect(error.cause).toBe(cause);
+    });
+});

package/dist/cjs/Graph/Rules/Edge/AlignNodes.d.ts

@@ -0,0 +1,7 @@
+import { AdapterOperations } from '../../Operations/Operations.js';
+import { NodeId, TgNodeAttributes } from '../../TgGraph.js';
+import { EdgeRule } from '../Rule.js';
+export declare class AlignNodes extends EdgeRule {
+    supports(adapter: AdapterOperations): boolean;
+    apply(nodeId: NodeId, node: TgNodeAttributes, graph: AdapterOperations): AdapterOperations;
+}

package/dist/cjs/Graph/Rules/Edge/AlignNodes.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AlignNodes = void 0;
+const DotAdapter_js_1 = require("../../Adapters/DotAdapter.js");
+const Rule_js_1 = require("../Rule.js");
+class AlignNodes extends Rule_js_1.EdgeRule {
+    supports(adapter) {
+        return adapter instanceof DotAdapter_js_1.DotAdapter;
+    }
+    apply(nodeId, node, graph) {
+        if (!this.wasMatched(nodeId)) {
+            return graph;
+        }
+        let updated = graph;
+        const { from, to } = this.query;
+        if (!from.match(nodeId, node, updated)) {
+            return updated;
+        }
+        const edgeIds = updated.outEdges(nodeId);
+        const nodes = [nodeId];
+        for (const edgeId of edgeIds) {
+            const targetId = updated.edgeTarget(edgeId);
+            const target = updated.getNodeAttributes(targetId);
+            if (!target || !to.match(targetId, target, updated)) {
+                continue;
+            }
+            nodes.push(targetId);
+            updated = updated.setEdge(edgeId, nodeId, targetId, {
+                ...updated.getEdgeAttributes(edgeId),
+            });
+        }
+        if (nodes.length > 1) {
+            updated = updated.addRank(nodes, 'same');
+        }
+        return updated;
+    }
+}
+exports.AlignNodes = AlignNodes;
+Rule_js_1.EdgeRule.register(AlignNodes);

package/dist/cjs/Graph/Rules/Edge/AlignNodes.test.d.ts

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

package/dist/cjs/Graph/Rules/Edge/AlignNodes.test.js

@@ -0,0 +1,194 @@
+"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 AlignNodes_js_1 = require("./AlignNodes.js");
+describe('AlignNodes.supports', () => {
+    it('shoud only support DotAdapter instances', () => {
+        const rule = new AlignNodes_js_1.AlignNodes({
+            edge: { from: { any: true }, to: { any: true } },
+        });
+        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('AlignNodes.apply', () => {
+    it('shoud add a rank and edge attributes for matching nodes', () => {
+        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 tg = {
+            schemaVersion: TgGraph_js_1.TG_SCHEMA_VERSION,
+            description: {},
+            nodes: {
+                [nodeA]: { id: nodeA, label: 'A' },
+                [nodeB]: { id: nodeB, label: 'B' },
+                [nodeC]: { id: nodeC, label: 'C' },
+            },
+            edges: [
+                {
+                    id: (0, TgGraph_js_1.asEdgeId)('edge-1'),
+                    from: nodeA,
+                    to: nodeB,
+                    attributes: {},
+                },
+                {
+                    id: (0, TgGraph_js_1.asEdgeId)('edge-2'),
+                    from: nodeB,
+                    to: nodeC,
+                    attributes: {
+                        some: 'value',
+                    },
+                },
+            ],
+        };
+        const matcher = {
+            edge: {
+                from: { nodeId: { eq: 'node-b' } },
+                to: { nodeId: { eq: 'node-c' } },
+            },
+        };
+        const adapter = new DotAdapter_js_1.DotAdapter(new graphology_1.DirectedGraph()).withTgGraph(tg);
+        const moduleNode = adapter.getNodeAttributes(nodeB);
+        if (!moduleNode) {
+            throw new Error('Missing node attributes for node-b');
+        }
+        // const hook = new AlignNodes(matcher, { legend: { label: 'rank' } });
+        const hook = new AlignNodes_js_1.AlignNodes(matcher);
+        hook.match(nodeB, moduleNode, adapter);
+        const result = hook.apply(nodeB, moduleNode, adapter);
+        expect(result.getRanks()).toEqual([
+            { mode: 'same', nodes: [nodeB, nodeC] },
+        ]);
+        expect(result.getEdgeAttributes((0, TgGraph_js_1.asEdgeId)('edge-1'))).toEqual({});
+        expect(result.getEdgeAttributes((0, TgGraph_js_1.asEdgeId)('edge-2'))).toEqual({
+            some: 'value',
+        });
+    });
+    it('shoud keep graph unchanged when the hook does not match', () => {
+        const nodeId = (0, TgGraph_js_1.asNodeId)('node-a');
+        const tg = {
+            schemaVersion: TgGraph_js_1.TG_SCHEMA_VERSION,
+            description: {},
+            nodes: {
+                [nodeId]: { id: nodeId, label: 'A' },
+            },
+            edges: [],
+        };
+        const adapter = new DotAdapter_js_1.DotAdapter(new graphology_1.DirectedGraph()).withTgGraph(tg);
+        const node = adapter.getNodeAttributes(nodeId);
+        if (!node) {
+            throw new Error('Missing node attributes for node-a');
+        }
+        const hook = new AlignNodes_js_1.AlignNodes({
+            edge: {
+                from: { nodeId: { eq: 'node-a' } },
+                to: { nodeId: { eq: 'node-b' } },
+            },
+        });
+        hook.match(nodeId, node, adapter);
+        const result = hook.apply(nodeId, node, adapter);
+        expect(result.getRanks()).toEqual([]);
+    });
+    it('shoud skip target nodes that do not match the query', () => {
+        const nodeA = (0, TgGraph_js_1.asNodeId)('node-a');
+        const nodeB = (0, TgGraph_js_1.asNodeId)('node-b');
+        const edgeId = (0, TgGraph_js_1.asEdgeId)('edge-1');
+        const tg = {
+            schemaVersion: TgGraph_js_1.TG_SCHEMA_VERSION,
+            description: {},
+            nodes: {
+                [nodeA]: { id: nodeA, label: 'A' },
+                [nodeB]: { id: nodeB, label: 'B' },
+            },
+            edges: [
+                {
+                    id: edgeId,
+                    from: nodeA,
+                    to: nodeB,
+                    attributes: {},
+                },
+            ],
+        };
+        const adapter = new DotAdapter_js_1.DotAdapter(new graphology_1.DirectedGraph()).withTgGraph(tg);
+        const node = adapter.getNodeAttributes(nodeA);
+        if (!node) {
+            throw new Error('Missing node attributes for node-a');
+        }
+        const hook = new AlignNodes_js_1.AlignNodes({
+            edge: {
+                from: { nodeId: { eq: 'node-a' } },
+                to: { nodeId: { eq: 'node-c' } },
+            },
+        });
+        hook.match(nodeA, node, adapter);
+        const result = hook.apply(nodeA, node, adapter);
+        expect(result.getRanks()).toEqual([]);
+        expect(result.getEdgeAttributes(edgeId)).toEqual({});
+    });
+    it('shoud keep graph unchanged when apply is called without a match', () => {
+        const nodeA = (0, TgGraph_js_1.asNodeId)('node-a');
+        const tg = {
+            schemaVersion: TgGraph_js_1.TG_SCHEMA_VERSION,
+            description: {},
+            nodes: {
+                [nodeA]: { id: nodeA, label: 'A' },
+            },
+            edges: [],
+        };
+        const adapter = new DotAdapter_js_1.DotAdapter(new graphology_1.DirectedGraph()).withTgGraph(tg);
+        const node = adapter.getNodeAttributes(nodeA);
+        if (!node) {
+            throw new Error('Missing node attributes for node-a');
+        }
+        const hook = new AlignNodes_js_1.AlignNodes({
+            edge: {
+                from: { nodeId: { eq: 'node-a' } },
+                to: { nodeId: { eq: 'node-b' } },
+            },
+        });
+        const result = hook.apply(nodeA, node, adapter);
+        expect(result.getRanks()).toEqual([]);
+    });
+    it('shoud return early when the source node no longer matches', () => {
+        const nodeA = (0, TgGraph_js_1.asNodeId)('node-a');
+        const nodeB = (0, TgGraph_js_1.asNodeId)('node-b');
+        const edgeId = (0, TgGraph_js_1.asEdgeId)('edge-a-b');
+        const tg = {
+            schemaVersion: TgGraph_js_1.TG_SCHEMA_VERSION,
+            description: {},
+            nodes: {
+                [nodeA]: { id: nodeA, label: 'A' },
+                [nodeB]: { id: nodeB, label: 'B' },
+            },
+            edges: [
+                {
+                    id: edgeId,
+                    from: nodeA,
+                    to: nodeB,
+                    attributes: {},
+                },
+            ],
+        };
+        const adapter = new DotAdapter_js_1.DotAdapter(new graphology_1.DirectedGraph()).withTgGraph(tg);
+        const node = adapter.getNodeAttributes(nodeA);
+        if (!node) {
+            throw new Error('Missing node attributes for node-a');
+        }
+        const hook = new AlignNodes_js_1.AlignNodes({
+            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.getRanks()).toEqual([]);
+        expect(result.getEdgeAttributes(edgeId)).toEqual({});
+    });
+});

package/dist/cjs/Graph/Rules/Edge/EdgeDirectionSemantic.d.ts

@@ -0,0 +1,8 @@
+import { AdapterOperations } from '../../Operations/Operations.js';
+import { NodeId, TgNodeAttributes } from '../../TgGraph.js';
+import { EdgeRule } from '../Rule.js';
+import { EdgeRuleConfig } from '../RuleConfig.js';
+export declare class EdgeDirectionSemantic extends EdgeRule {
+    constructor(config: EdgeRuleConfig);
+    apply(nodeId: NodeId, node: TgNodeAttributes, graph: AdapterOperations): AdapterOperations;
+}