@terra-graph/core 1.0.0-rc.4

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

@@ -0,0 +1,134 @@
+"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 EdgeReverse_js_1 = require("./EdgeReverse.js");
+describe('EdgeReverse.apply', () => {
+    it('shoud reverse matching inbound edges', () => {
+        const hook = new EdgeReverse_js_1.EdgeReverse({
+            edge: {
+                from: { nodeId: { eq: 'node-b' } },
+                to: { nodeId: { eq: 'node-a' } },
+            },
+        });
+        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 edgeId = (0, TgGraph_js_1.asEdgeId)('edge-1');
+        const otherEdgeId = (0, TgGraph_js_1.asEdgeId)('edge-2');
+        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: edgeId, from: nodeA, to: nodeB, attributes: {} },
+                { id: otherEdgeId, from: nodeC, to: nodeB, attributes: {} },
+            ],
+        };
+        const adapter = new GraphologyAdapter_js_1.GraphologyAdapter(new graphology_1.DirectedGraph()).withTgGraph(tg);
+        const node = adapter.getNodeAttributes(nodeB);
+        if (!node) {
+            throw new Error('Missing node attributes for node-b');
+        }
+        hook.match(nodeB, node, adapter);
+        const result = hook.apply(nodeB, node, adapter);
+        expect(result.edgeSource(edgeId)).toBe(nodeB);
+        expect(result.edgeTarget(edgeId)).toBe(nodeA);
+        expect(result.edgeSource(otherEdgeId)).toBe(nodeC);
+        expect(result.edgeTarget(otherEdgeId)).toBe(nodeB);
+        expect(result.getEdgeAttributes(edgeId)).toEqual({});
+    });
+    it('shoud keep graph unchanged when the hook does not match', () => {
+        const hook = new EdgeReverse_js_1.EdgeReverse({
+            edge: {
+                from: { nodeId: { eq: 'node-b' } },
+                to: { nodeId: { eq: 'node-a' } },
+            },
+        });
+        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 GraphologyAdapter_js_1.GraphologyAdapter(new graphology_1.DirectedGraph()).withTgGraph(tg);
+        const node = adapter.getNodeAttributes(nodeA);
+        if (!node) {
+            throw new Error('Missing node attributes for node-a');
+        }
+        hook.match(nodeA, node, adapter);
+        const result = hook.apply(nodeA, node, adapter);
+        expect(result.edgeSource(edgeId)).toBe(nodeA);
+        expect(result.edgeTarget(edgeId)).toBe(nodeB);
+    });
+    it('shoud ignore inbound edges that do not match the target query', () => {
+        const hook = new EdgeReverse_js_1.EdgeReverse({
+            edge: {
+                from: { nodeId: { eq: 'node-b' } },
+                to: { nodeId: { eq: 'node-c' } },
+            },
+        });
+        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 GraphologyAdapter_js_1.GraphologyAdapter(new graphology_1.DirectedGraph()).withTgGraph(tg);
+        const node = adapter.getNodeAttributes(nodeB);
+        if (!node) {
+            throw new Error('Missing node attributes for node-b');
+        }
+        hook.match(nodeB, node, adapter);
+        const result = hook.apply(nodeB, node, adapter);
+        expect(result.edgeSource(edgeId)).toBe(nodeA);
+        expect(result.edgeTarget(edgeId)).toBe(nodeB);
+    });
+    it('shoud return early when the source node no longer matches', () => {
+        const hook = new EdgeReverse_js_1.EdgeReverse({
+            edge: {
+                from: { attr: { key: 'label', eq: 'B' } },
+                to: { any: true },
+            },
+        });
+        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 GraphologyAdapter_js_1.GraphologyAdapter(new graphology_1.DirectedGraph()).withTgGraph(tg);
+        const node = adapter.getNodeAttributes(nodeB);
+        if (!node) {
+            throw new Error('Missing node attributes for node-b');
+        }
+        hook.match(nodeB, node, adapter);
+        const mismatchedNode = { ...node, label: 'mismatch' };
+        const result = hook.apply(nodeB, mismatchedNode, adapter);
+        expect(result.edgeSource(edgeId)).toBe(nodeA);
+        expect(result.edgeTarget(edgeId)).toBe(nodeB);
+    });
+});

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

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

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EdgeSemanticLegend = void 0;
+const TgGraph_js_1 = require("../../TgGraph.js");
+const Rule_js_1 = require("../Rule.js");
+class EdgeSemanticLegend extends Rule_js_1.EdgeRule {
+    constructor(config) {
+        if (config.options === undefined) {
+            throw new Error(`Rule '${EdgeSemanticLegend.name}' requires options in config`);
+        }
+        const options = config.options;
+        if (typeof options.legendBySemantic !== 'object' ||
+            options.legendBySemantic === null) {
+            throw new Error(`Rule '${EdgeSemanticLegend.name}' requires options.legendBySemantic`);
+        }
+        for (const [semantic, legend] of Object.entries(options.legendBySemantic)) {
+            if (!(0, TgGraph_js_1.isTgEdgeDirectionSemantic)(semantic)) {
+                throw new Error(`Rule '${EdgeSemanticLegend.name}' has an invalid semantic key '${semantic}'`);
+            }
+            if (typeof legend?.title !== 'string' ||
+                typeof legend?.colour !== 'string') {
+                throw new Error(`Rule '${EdgeSemanticLegend.name}' requires title and colour for semantic '${semantic}'`);
+            }
+        }
+        if (options.overwrite !== undefined &&
+            typeof options.overwrite !== 'boolean') {
+            throw new Error(`Rule '${EdgeSemanticLegend.name}' options.overwrite 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 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 (!(0, TgGraph_js_1.isTgEdgeDirectionSemantic)(current.directionSemantic)) {
+                continue;
+            }
+            const legend = options.legendBySemantic[current.directionSemantic];
+            if (!legend) {
+                continue;
+            }
+            if (!shouldOverwrite && current.legend !== undefined) {
+                continue;
+            }
+            updated = updated.setEdge(edgeId, nodeId, targetId, {
+                ...current,
+                legend: {
+                    title: legend.title,
+                    colour: legend.colour,
+                },
+            });
+        }
+        return updated;
+    }
+}
+exports.EdgeSemanticLegend = EdgeSemanticLegend;
+Rule_js_1.EdgeRule.register(EdgeSemanticLegend);

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

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