@terra-graph/core 1.0.0-rc.4

package/dist/esm/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/esm/Graph/Renderers/JsonRenderer.js

@@ -0,0 +1,9 @@
+export class JsonRenderer {
+    render(adapter) {
+        return {
+            content: JSON.stringify(adapter.toTgGraph()),
+            mediaType: 'application/json',
+            extension: 'json',
+        };
+    }
+}

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

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

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

@@ -0,0 +1,27 @@
+import { DirectedGraph } from 'graphology';
+import { GraphologyAdapter } from '../Adapters/GraphologyAdapter.js';
+import { TG_SCHEMA_VERSION, asNodeId } from '../TgGraph.js';
+import { JsonRenderer } from './JsonRenderer.js';
+describe('JsonRenderer.render', () => {
+    it('shoud render tg graph JSON as string content', () => {
+        const nodeA = asNodeId('json.node-a');
+        const nodeB = asNodeId('json.node-b');
+        const tg = {
+            schemaVersion: TG_SCHEMA_VERSION,
+            description: {
+                source: 'unit-test',
+            },
+            nodes: {
+                [nodeA]: { id: nodeA },
+                [nodeB]: { id: nodeB },
+            },
+            edges: [],
+        };
+        const adapter = new GraphologyAdapter(new DirectedGraph()).withTgGraph(tg);
+        const renderer = new 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/esm/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/esm/Graph/Renderers/RendererRegistry.js

@@ -0,0 +1,29 @@
+export 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();
+    }
+}

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

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

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

@@ -0,0 +1,37 @@
+import { DirectedGraph } from 'graphology';
+import { GraphologyAdapter } from '../Adapters/GraphologyAdapter.js';
+import { JsonRenderer } from './JsonRenderer.js';
+import { RendererRegistry } from './RendererRegistry.js';
+describe('RendererRegistry.resolve', () => {
+    it('shoud normalize names and resolve factories', () => {
+        const adapter = new GraphologyAdapter(new DirectedGraph());
+        const factory = jest.fn(() => new JsonRenderer());
+        const registry = new RendererRegistry({ ' JSON ': factory });
+        const renderer = registry.resolve('json', adapter, { pretty: true });
+        expect(factory).toHaveBeenCalledWith({
+            adapter,
+            options: { pretty: true },
+        });
+        expect(renderer).toBeInstanceOf(JsonRenderer);
+    });
+    it('shoud include available renderers in errors', () => {
+        const adapter = new GraphologyAdapter(new DirectedGraph());
+        const registry = new RendererRegistry({ Json: () => new 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(new DirectedGraph());
+        const registry = new 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({
+            Delta: () => new JsonRenderer(),
+            alpha: () => new JsonRenderer(),
+            Bravo: () => new JsonRenderer(),
+        });
+        expect(registry.list()).toEqual(['alpha', 'bravo', 'delta']);
+    });
+});

package/dist/esm/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/esm/Graph/Renderers/TgNodeLabel.js

@@ -0,0 +1,39 @@
+export 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);
+    }
+}

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

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

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

@@ -0,0 +1,74 @@
+import { asNodeId } from '../TgGraph.js';
+import { TgNodeLabel } from './TgNodeLabel.js';
+describe('TgNodeLabel.getLabelComponents', () => {
+    it('shoud return empty components when terraform is missing', () => {
+        const node = { id: asNodeId('node-a') };
+        const subject = new TgNodeLabel(node);
+        expect(subject.getLabelComponents()).toEqual({});
+    });
+    it('shoud prefer parentModuleName for the name component', () => {
+        const node = {
+            id: 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(node);
+        expect(subject.getLabelComponents()).toEqual({
+            resourceName: 'aws_security_group',
+            name: 'network',
+        });
+    });
+});
+describe('TgNodeLabel.getLabel', () => {
+    it('shoud prefer parentModuleName for resources', () => {
+        const node = {
+            id: 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(node);
+        expect(subject.getLabel()).toBe('aws_security_group.network');
+    });
+    it('shoud ignore parentModuleName for modules', () => {
+        const node = {
+            id: asNodeId('node-d'),
+            terraform: {
+                kind: 'module',
+                address: 'module.app',
+                resource: 'module',
+                name: 'app',
+                parentModuleName: 'parent',
+            },
+        };
+        const subject = new TgNodeLabel(node);
+        expect(subject.getLabel()).toBe('module.app');
+    });
+    it('shoud append label endings when present', () => {
+        const node = {
+            id: 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(node);
+        expect(subject.getLabel()).toBe('aws_s3_bucket.bucket.id');
+    });
+});

package/dist/esm/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/esm/Graph/Renderers/index.js

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

package/dist/esm/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/esm/Graph/RuleError.js

@@ -0,0 +1,14 @@
+export class RuleModifyError extends Error {
+    props;
+    constructor(options, props) {
+        super(`Rule was unable to modify node ${props.nodeId}`, options);
+        this.props = props;
+    }
+}
+export class RuleMatchError extends Error {
+    props;
+    constructor(options, props) {
+        super(`Rule was unable to match node ${props.nodeId}`, options);
+        this.props = props;
+    }
+}

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

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

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

@@ -0,0 +1,23 @@
+import { RuleMatchError, RuleModifyError } from './RuleError.js';
+describe('RuleMatchError', () => {
+    it('shoud include match failure context in the message', () => {
+        const cause = new Error('original');
+        const error = new 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 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/esm/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/esm/Graph/Rules/Edge/AlignNodes.js

@@ -0,0 +1,35 @@
+import { DotAdapter } from '../../Adapters/DotAdapter.js';
+import { EdgeRule } from '../Rule.js';
+export class AlignNodes extends EdgeRule {
+    supports(adapter) {
+        return adapter instanceof 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;
+    }
+}
+EdgeRule.register(AlignNodes);

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

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

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

@@ -0,0 +1,192 @@
+import { DirectedGraph } from 'graphology';
+import { DotAdapter } from '../../Adapters/DotAdapter.js';
+import { GraphologyAdapter } from '../../Adapters/GraphologyAdapter.js';
+import { TG_SCHEMA_VERSION, asEdgeId, asNodeId, } from '../../TgGraph.js';
+import { AlignNodes } from './AlignNodes.js';
+describe('AlignNodes.supports', () => {
+    it('shoud only support DotAdapter instances', () => {
+        const rule = new AlignNodes({
+            edge: { from: { any: true }, to: { any: true } },
+        });
+        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('AlignNodes.apply', () => {
+    it('shoud add a rank and edge attributes for matching nodes', () => {
+        const nodeA = asNodeId('node-a');
+        const nodeB = asNodeId('node-b');
+        const nodeC = asNodeId('node-c');
+        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: asEdgeId('edge-1'),
+                    from: nodeA,
+                    to: nodeB,
+                    attributes: {},
+                },
+                {
+                    id: 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(new 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(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(asEdgeId('edge-1'))).toEqual({});
+        expect(result.getEdgeAttributes(asEdgeId('edge-2'))).toEqual({
+            some: 'value',
+        });
+    });
+    it('shoud keep graph unchanged when the hook does not match', () => {
+        const nodeId = asNodeId('node-a');
+        const tg = {
+            schemaVersion: TG_SCHEMA_VERSION,
+            description: {},
+            nodes: {
+                [nodeId]: { id: nodeId, label: 'A' },
+            },
+            edges: [],
+        };
+        const adapter = new DotAdapter(new DirectedGraph()).withTgGraph(tg);
+        const node = adapter.getNodeAttributes(nodeId);
+        if (!node) {
+            throw new Error('Missing node attributes for node-a');
+        }
+        const hook = new 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 = asNodeId('node-a');
+        const nodeB = asNodeId('node-b');
+        const edgeId = asEdgeId('edge-1');
+        const tg = {
+            schemaVersion: 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(new DirectedGraph()).withTgGraph(tg);
+        const node = adapter.getNodeAttributes(nodeA);
+        if (!node) {
+            throw new Error('Missing node attributes for node-a');
+        }
+        const hook = new 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 = asNodeId('node-a');
+        const tg = {
+            schemaVersion: TG_SCHEMA_VERSION,
+            description: {},
+            nodes: {
+                [nodeA]: { id: nodeA, label: 'A' },
+            },
+            edges: [],
+        };
+        const adapter = new DotAdapter(new DirectedGraph()).withTgGraph(tg);
+        const node = adapter.getNodeAttributes(nodeA);
+        if (!node) {
+            throw new Error('Missing node attributes for node-a');
+        }
+        const hook = new 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 = asNodeId('node-a');
+        const nodeB = asNodeId('node-b');
+        const edgeId = asEdgeId('edge-a-b');
+        const tg = {
+            schemaVersion: 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(new DirectedGraph()).withTgGraph(tg);
+        const node = adapter.getNodeAttributes(nodeA);
+        if (!node) {
+            throw new Error('Missing node attributes for node-a');
+        }
+        const hook = new 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/esm/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;
+}

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

@@ -0,0 +1,74 @@
+import { isTgEdgeDirectionSemantic, } from '../../TgGraph.js';
+import { EdgeRule } from '../Rule.js';
+export class EdgeDirectionSemantic extends EdgeRule {
+    constructor(config) {
+        if (config.options === undefined) {
+            throw new Error(`Rule '${EdgeDirectionSemantic.name}' requires options in config`);
+        }
+        const options = config.options;
+        if (!isTgEdgeDirectionSemantic(options.semantic)) {
+            throw new Error(`Rule '${EdgeDirectionSemantic.name}' requires options.semantic`);
+        }
+        if (options.overwrite !== undefined &&
+            typeof options.overwrite !== 'boolean') {
+            throw new Error(`Rule '${EdgeDirectionSemantic.name}' options.overwrite must be a boolean when provided`);
+        }
+        if (options.enforceDirection !== undefined &&
+            typeof options.enforceDirection !== 'boolean') {
+            throw new Error(`Rule '${EdgeDirectionSemantic.name}' options.enforceDirection must be a boolean when provided`);
+        }
+        super(config);
+    }
+    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 options = this.config.options;
+        const shouldOverwrite = options.overwrite ?? false;
+        const shouldEnforceDirection = options.enforceDirection ?? false;
+        const edges = updated.outEdges(nodeId);
+        for (const edgeId of edges) {
+            const targetId = updated.edgeTarget(edgeId);
+            const target = updated.getNodeAttributes(targetId);
+            if (!target || !to.match(targetId, target, updated)) {
+                continue;
+            }
+            const current = updated.getEdgeAttributes(edgeId);
+            if (!shouldOverwrite && current.directionSemantic !== undefined) {
+                continue;
+            }
+            updated = updated.setEdge(edgeId, nodeId, targetId, {
+                ...current,
+                directionSemantic: options.semantic,
+            });
+        }
+        if (!shouldEnforceDirection) {
+            return updated;
+        }
+        const inboundEdgeIds = updated.inEdges(nodeId);
+        for (const edgeId of inboundEdgeIds) {
+            const sourceId = updated.edgeSource(edgeId);
+            const source = updated.getNodeAttributes(sourceId);
+            if (!source || !to.match(sourceId, source, updated)) {
+                continue;
+            }
+            const current = updated.getEdgeAttributes(edgeId);
+            if (!shouldOverwrite &&
+                current.directionSemantic !== undefined &&
+                current.directionSemantic !== options.semantic) {
+                continue;
+            }
+            updated = updated.removeEdge(edgeId).setEdge(edgeId, nodeId, sourceId, {
+                ...current,
+                directionSemantic: options.semantic,
+            });
+        }
+        return updated;
+    }
+}
+EdgeRule.register(EdgeDirectionSemantic);

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

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