@terra-graph/core 1.0.0-rc.4

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

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RemoveEdge = void 0;
+const Rule_js_1 = require("../Rule.js");
+class RemoveEdge extends Rule_js_1.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 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;
+            }
+            updated = updated.removeEdge(edgeId);
+        }
+        return updated;
+    }
+}
+exports.RemoveEdge = RemoveEdge;
+Rule_js_1.EdgeRule.register(RemoveEdge);

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

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

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

@@ -0,0 +1,135 @@
+"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 RemoveEdge_js_1 = require("./RemoveEdge.js");
+describe('RemoveEdge.apply', () => {
+    it('shoud remove matching outbound edges', () => {
+        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 edgeAB = (0, TgGraph_js_1.asEdgeId)('edge-ab');
+        const edgeAC = (0, TgGraph_js_1.asEdgeId)('edge-ac');
+        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: edgeAB, from: nodeA, to: nodeB, attributes: {} },
+                { id: edgeAC, from: nodeA, to: nodeC, 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');
+        }
+        const hook = new RemoveEdge_js_1.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 = (0, TgGraph_js_1.asNodeId)('node-a');
+        const nodeB = (0, TgGraph_js_1.asNodeId)('node-b');
+        const edgeAB = (0, TgGraph_js_1.asEdgeId)('edge-ab');
+        const tg = {
+            schemaVersion: TgGraph_js_1.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_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');
+        }
+        const hook = new RemoveEdge_js_1.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 = (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 edgeAB = (0, TgGraph_js_1.asEdgeId)('edge-ab');
+        const edgeAC = (0, TgGraph_js_1.asEdgeId)('edge-ac');
+        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: edgeAB, from: nodeA, to: nodeB, attributes: {} },
+                { id: edgeAC, from: nodeA, to: nodeC, 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');
+        }
+        const hook = new RemoveEdge_js_1.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 = (0, TgGraph_js_1.asNodeId)('node-a');
+        const nodeB = (0, TgGraph_js_1.asNodeId)('node-b');
+        const edgeAB = (0, TgGraph_js_1.asEdgeId)('edge-ab');
+        const tg = {
+            schemaVersion: TgGraph_js_1.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_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');
+        }
+        const hook = new RemoveEdge_js_1.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/cjs/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/cjs/Graph/Rules/Edge/index.js

@@ -0,0 +1,24 @@
+"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("./AlignNodes.js"), exports);
+__exportStar(require("./EdgeDirectionSemantic.js"), exports);
+__exportStar(require("./EdgeDotProperties.js"), exports);
+__exportStar(require("./EdgeLegend.js"), exports);
+__exportStar(require("./EdgeReverse.js"), exports);
+__exportStar(require("./EdgeSemanticLegend.js"), exports);
+__exportStar(require("./ExplicitEdge.js"), exports);
+__exportStar(require("./RemoveEdge.js"), exports);

package/dist/cjs/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/cjs/Graph/Rules/NamedRuleRegistry.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NamedRuleRegistry = void 0;
+const Rule_js_1 = require("./Rule.js");
+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 Rule_js_1.BaseRule ? definition.serialize() : definition;
+        return () => Rule_js_1.BaseRule.fromSerialized({
+            id: serialized.id,
+            config: NamedRuleRegistry.cloneConfig(serialized.config),
+        });
+    }
+    static cloneConfig(config) {
+        return JSON.parse(JSON.stringify(config));
+    }
+}
+exports.NamedRuleRegistry = NamedRuleRegistry;

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

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

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

@@ -0,0 +1,243 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const NamedRuleRegistry_js_1 = require("./NamedRuleRegistry.js");
+const RemoveNode_js_1 = require("./Node/RemoveNode.js");
+describe('NamedRuleRegistry.resolve', () => {
+    it('shoud resolve a named serialized rule', () => {
+        const registry = new NamedRuleRegistry_js_1.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_js_1.NamedRuleRegistry({
+            removeLocalNodes: new RemoveNode_js_1.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_js_1.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_js_1.NamedRuleRegistry({
+            removeDataNodes: () => new RemoveNode_js_1.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_js_1.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_js_1.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_js_1.NamedRuleRegistry({
+            removeDataNodes: {
+                id: 'RemoveNode',
+                config: {
+                    node: {
+                        attr: {
+                            key: 'label',
+                            startsWith: 'data.',
+                        },
+                    },
+                },
+            },
+        });
+        const aws = new NamedRuleRegistry_js_1.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_js_1.NamedRuleRegistry({
+            removeDataNodes: {
+                id: 'RemoveNode',
+                config: {
+                    node: {
+                        attr: {
+                            key: 'label',
+                            startsWith: 'data.',
+                        },
+                    },
+                },
+            },
+        });
+        const two = new NamedRuleRegistry_js_1.NamedRuleRegistry({
+            removeLocalNodes: {
+                id: 'RemoveNode',
+                config: {
+                    node: {
+                        attr: {
+                            key: 'label',
+                            startsWith: 'local.',
+                        },
+                    },
+                },
+            },
+        });
+        const combined = NamedRuleRegistry_js_1.NamedRuleRegistry.from([one, two]);
+        expect(combined.names()).toEqual(['removeDataNodes', 'removeLocalNodes']);
+    });
+    it('shoud prefer later registries when names collide', () => {
+        const first = new NamedRuleRegistry_js_1.NamedRuleRegistry({
+            removeNodes: {
+                id: 'RemoveNode',
+                config: {
+                    node: {
+                        attr: {
+                            key: 'label',
+                            startsWith: 'data.',
+                        },
+                    },
+                },
+            },
+        });
+        const second = new NamedRuleRegistry_js_1.NamedRuleRegistry({
+            removeNodes: {
+                id: 'RemoveNode',
+                config: {
+                    node: {
+                        attr: {
+                            key: 'label',
+                            startsWith: 'local.',
+                        },
+                    },
+                },
+            },
+        });
+        const combined = NamedRuleRegistry_js_1.NamedRuleRegistry.from([first, second]);
+        const resolved = combined.resolve('removeNodes');
+        expect(resolved.serialize()).toEqual({
+            id: 'RemoveNode',
+            config: {
+                node: {
+                    attr: {
+                        key: 'label',
+                        startsWith: 'local.',
+                    },
+                },
+            },
+        });
+    });
+});

package/dist/cjs/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/cjs/Graph/Rules/NamedRuleSetRegistry.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NamedRuleSetRegistry = void 0;
+const RuleSet_js_1 = require("./RuleSet.js");
+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_js_1.RuleSet ? definition.serialize() : definition;
+        return () => RuleSet_js_1.RuleSet.deseriaize(NamedRuleSetRegistry.cloneSerialized(serialized));
+    }
+    static cloneSerialized(set) {
+        return JSON.parse(JSON.stringify(set));
+    }
+}
+exports.NamedRuleSetRegistry = NamedRuleSetRegistry;

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

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