@terra-graph/core 1.0.0-rc.4

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

@@ -0,0 +1,331 @@
+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 { EdgeDotProperties } from './EdgeDotProperties.js';
+describe('EdgeDotProperties.constructor', () => {
+    it('shoud require options', () => {
+        expect(() => new EdgeDotProperties({
+            edge: { from: { any: true }, to: { any: true } },
+        })).toThrow(`Rule 'EdgeDotProperties' requires options in config`);
+    });
+});
+describe('EdgeDotProperties.supports', () => {
+    it('shoud only support DotAdapter instances', () => {
+        const rule = new EdgeDotProperties({
+            edge: { from: { any: true }, to: { any: true } },
+            options: { color: 'red' },
+        });
+        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('EdgeDotProperties.apply', () => {
+    it('shoud store dot adapter options for matching edges', () => {
+        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: { weight: 1 },
+                },
+            ],
+        };
+        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 EdgeDotProperties({
+            edge: {
+                from: { nodeId: { eq: 'node-a' } },
+                to: { nodeId: { eq: 'node-b' } },
+            },
+            options: {
+                color: 'red',
+                style: 'dashed',
+            },
+        });
+        hook.match(nodeA, node, adapter);
+        const result = hook.apply(nodeA, node, adapter);
+        expect(result.getEdgeAttributes(edgeId)).toEqual({
+            weight: 1,
+            adapter: {
+                [DotAdapter.name]: {
+                    color: 'red',
+                    style: 'dashed',
+                },
+            },
+        });
+    });
+    it('shoud keep graph unchanged when the hook does not match', () => {
+        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: { weight: 1 },
+                },
+            ],
+        };
+        const adapter = new DotAdapter(new DirectedGraph()).withTgGraph(tg);
+        const node = adapter.getNodeAttributes(nodeB);
+        if (!node) {
+            throw new Error('Missing node attributes for node-b');
+        }
+        const hook = new EdgeDotProperties({
+            edge: {
+                from: { nodeId: { eq: 'node-a' } },
+                to: { nodeId: { eq: 'node-b' } },
+            },
+            options: {
+                color: 'red',
+            },
+        });
+        hook.match(nodeB, node, adapter);
+        const result = hook.apply(nodeB, node, adapter);
+        expect(result.getEdgeAttributes(edgeId)).toEqual({ weight: 1 });
+    });
+    it('shoud merge dot adapter properties with existing attributes', () => {
+        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: {
+                        adapter: {
+                            [DotAdapter.name]: {
+                                style: 'dotted',
+                            },
+                        },
+                    },
+                },
+            ],
+        };
+        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 EdgeDotProperties({
+            edge: {
+                from: { nodeId: { eq: 'node-a' } },
+                to: { nodeId: { eq: 'node-b' } },
+            },
+            options: {
+                color: 'red',
+            },
+        });
+        hook.match(nodeA, node, adapter);
+        const result = hook.apply(nodeA, node, adapter);
+        expect(result.getEdgeAttributes(edgeId)).toEqual({
+            adapter: {
+                [DotAdapter.name]: {
+                    style: 'dotted',
+                    color: 'red',
+                },
+            },
+        });
+    });
+    it('shoud ignore outbound edges when the target does not match', () => {
+        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: { weight: 1 },
+                },
+            ],
+        };
+        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 EdgeDotProperties({
+            edge: {
+                from: { nodeId: { eq: 'node-a' } },
+                to: { nodeId: { eq: 'node-c' } },
+            },
+            options: {
+                color: 'red',
+            },
+        });
+        hook.match(nodeA, node, adapter);
+        const result = hook.apply(nodeA, node, adapter);
+        expect(result.getEdgeAttributes(edgeId)).toEqual({ weight: 1 });
+    });
+    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: { weight: 1 },
+                },
+            ],
+        };
+        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 EdgeDotProperties({
+            edge: {
+                from: { attr: { key: 'label', eq: 'A' } },
+                to: { any: true },
+            },
+            options: {
+                color: 'red',
+            },
+        });
+        hook.match(nodeA, node, adapter);
+        const mismatchedNode = { ...node, label: 'mismatch' };
+        const result = hook.apply(nodeA, mismatchedNode, adapter);
+        expect(result.getEdgeAttributes(edgeId)).toEqual({ weight: 1 });
+    });
+    it('shoud preserve non-dot adapter entries when applying dot properties', () => {
+        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: {
+                        adapter: {
+                            OtherAdapter: { style: 'bold' },
+                        },
+                    },
+                },
+            ],
+        };
+        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 EdgeDotProperties({
+            edge: {
+                from: { nodeId: { eq: 'node-a' } },
+                to: { nodeId: { eq: 'node-b' } },
+            },
+            options: {
+                color: 'red',
+            },
+        });
+        hook.match(nodeA, node, adapter);
+        const result = hook.apply(nodeA, node, adapter);
+        expect(result.getEdgeAttributes(edgeId)).toEqual({
+            adapter: {
+                OtherAdapter: { style: 'bold' },
+                [DotAdapter.name]: {
+                    color: 'red',
+                },
+            },
+        });
+    });
+    it('shoud fall back to empty properties when options are cleared', () => {
+        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 EdgeDotProperties({
+            edge: {
+                from: { nodeId: { eq: 'node-a' } },
+                to: { nodeId: { eq: 'node-b' } },
+            },
+            options: {
+                color: 'red',
+            },
+        });
+        hook.config.options = undefined;
+        hook.match(nodeA, node, adapter);
+        const result = hook.apply(nodeA, node, adapter);
+        expect(result.getEdgeAttributes(edgeId)).toEqual({
+            adapter: {
+                [DotAdapter.name]: {},
+            },
+        });
+    });
+});

package/dist/esm/Graph/Rules/Edge/EdgeLegend.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 EdgeLegend extends EdgeRule {
+    constructor(config: EdgeRuleConfig);
+    apply(nodeId: NodeId, node: TgNodeAttributes, graph: AdapterOperations): AdapterOperations;
+}

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

@@ -0,0 +1,43 @@
+import { EdgeRule } from '../Rule.js';
+export class EdgeLegend extends EdgeRule {
+    constructor(config) {
+        if (config.options === undefined) {
+            throw new Error(`Rule '${EdgeLegend.name}' requires options in config`);
+        }
+        const options = config.options;
+        if (typeof options.title !== 'string' ||
+            typeof options.colour !== 'string') {
+            throw new Error(`Rule '${EdgeLegend.name}' requires options.title and options.colour`);
+        }
+        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 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);
+            updated = updated.setEdge(edgeId, nodeId, targetId, {
+                ...current,
+                legend: {
+                    title: options.title,
+                    colour: options.colour,
+                },
+            });
+        }
+        return updated;
+    }
+}
+EdgeRule.register(EdgeLegend);

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

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

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

@@ -0,0 +1,184 @@
+import { DirectedGraph } from 'graphology';
+import { GraphologyAdapter } from '../../Adapters/GraphologyAdapter.js';
+import { TG_SCHEMA_VERSION, asEdgeId, asNodeId, } from '../../TgGraph.js';
+import { EdgeLegend } from './EdgeLegend.js';
+describe('EdgeLegend.constructor', () => {
+    it('shoud require options', () => {
+        expect(() => new EdgeLegend({
+            edge: { from: { any: true }, to: { any: true } },
+        })).toThrow(`Rule 'EdgeLegend' requires options in config`);
+    });
+    it('shoud require title and colour options', () => {
+        expect(() => new EdgeLegend({
+            edge: { from: { any: true }, to: { any: true } },
+            options: {
+                title: 'Missing colour',
+            },
+        })).toThrow(`Rule 'EdgeLegend' requires options.title and options.colour`);
+    });
+});
+describe('EdgeLegend.apply', () => {
+    it('shoud set legend attributes for matching edges', () => {
+        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: { weight: 1 },
+                },
+            ],
+        };
+        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 rule = new EdgeLegend({
+            edge: {
+                from: { nodeId: { eq: 'node-a' } },
+                to: { nodeId: { eq: 'node-b' } },
+            },
+            options: {
+                title: 'Dead Letter Queue',
+                colour: '#c20202',
+            },
+        });
+        rule.match(nodeA, node, adapter);
+        const result = rule.apply(nodeA, node, adapter);
+        expect(result.getEdgeAttributes(edgeId)).toEqual({
+            weight: 1,
+            legend: {
+                title: 'Dead Letter Queue',
+                colour: '#c20202',
+            },
+        });
+    });
+    it('shoud keep graph unchanged when the rule does not match', () => {
+        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: { weight: 1 },
+                },
+            ],
+        };
+        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 rule = new EdgeLegend({
+            edge: {
+                from: { nodeId: { eq: 'node-a' } },
+                to: { nodeId: { eq: 'node-b' } },
+            },
+            options: {
+                title: 'Dead Letter Queue',
+                colour: '#c20202',
+            },
+        });
+        rule.match(nodeB, node, adapter);
+        const result = rule.apply(nodeB, node, adapter);
+        expect(result.getEdgeAttributes(edgeId)).toEqual({ weight: 1 });
+    });
+    it('shoud ignore outbound edges when the target does not match', () => {
+        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: { weight: 1 },
+                },
+            ],
+        };
+        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 rule = new EdgeLegend({
+            edge: {
+                from: { nodeId: { eq: 'node-a' } },
+                to: { nodeId: { eq: 'node-c' } },
+            },
+            options: {
+                title: 'Dead Letter Queue',
+                colour: '#c20202',
+            },
+        });
+        rule.match(nodeA, node, adapter);
+        const result = rule.apply(nodeA, node, adapter);
+        expect(result.getEdgeAttributes(edgeId)).toEqual({ weight: 1 });
+    });
+    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: { weight: 1 },
+                },
+            ],
+        };
+        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 rule = new EdgeLegend({
+            edge: {
+                from: { attr: { key: 'label', eq: 'A' } },
+                to: { any: true },
+            },
+            options: {
+                title: 'Dead Letter Queue',
+                colour: '#c20202',
+            },
+        });
+        rule.match(nodeA, node, adapter);
+        const mismatchedNode = { ...node, label: 'mismatch' };
+        const result = rule.apply(nodeA, mismatchedNode, adapter);
+        expect(result.getEdgeAttributes(edgeId)).toEqual({ weight: 1 });
+    });
+});

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

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

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

@@ -0,0 +1,26 @@
+import { EdgeRule } from '../Rule.js';
+export class EdgeReverse extends EdgeRule {
+    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 inEdgeIds = updated.inEdges(nodeId);
+        for (const edgeId of inEdgeIds) {
+            const sourceId = updated.edgeSource(edgeId);
+            const source = updated.getNodeAttributes(sourceId);
+            if (!source || !to.match(sourceId, source, updated)) {
+                continue;
+            }
+            updated = updated.removeEdge(edgeId).setEdge(edgeId, nodeId, sourceId, {
+                ...updated.getEdgeAttributes(edgeId),
+            });
+        }
+        return updated;
+    }
+}
+EdgeRule.register(EdgeReverse);

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

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