@terra-graph/core 1.0.0-rc.4

package/dist/cjs/Graph/Rules/Rule.d.ts

@@ -0,0 +1,40 @@
+import { NodeQuery } from '../Operations/Matchers/NodeQuery/NodeQuery.js';
+import { AdapterOperations } from '../Operations/Operations.js';
+import { NodeId, TgNodeAttributes } from '../TgGraph.js';
+import { EdgeRuleConfig, NodeRuleConfig, RuleConfig, SerializedRule } from './RuleConfig.js';
+type RuleClass<TConfig extends RuleConfig> = new (config: TConfig, ...args: unknown[]) => BaseRule<TConfig>;
+export type EdgeRuleMatcher = {
+    from: NodeQuery;
+    to: NodeQuery;
+};
+export declare abstract class BaseRule<TConfig extends RuleConfig = RuleConfig> {
+    protected readonly config: TConfig;
+    private static registry;
+    private lastMatch;
+    private lastMatchNodeId?;
+    protected abstract get query(): unknown;
+    static register<TConfig extends RuleConfig>(ruleClass: RuleClass<TConfig>): void;
+    static fromSerialized(rule: SerializedRule): BaseRule;
+    constructor(config: TConfig);
+    describe(_nodeName: NodeId, _node: TgNodeAttributes): string;
+    match(nodeId: NodeId, node: TgNodeAttributes, graph: AdapterOperations): boolean;
+    protected abstract matches(nodeId: NodeId, node: TgNodeAttributes, graph: AdapterOperations): boolean;
+    supports(_adapter: AdapterOperations): boolean;
+    abstract apply(nodeId: NodeId, node: TgNodeAttributes, graph: AdapterOperations): AdapterOperations;
+    serialize(): SerializedRule;
+    protected getId(): string;
+    protected wasMatched(_nodeId: NodeId): boolean;
+}
+export declare abstract class NodeRule extends BaseRule<NodeRuleConfig> {
+    private readonly queryValue;
+    constructor(config: NodeRuleConfig);
+    protected get query(): NodeQuery;
+    protected matches(nodeId: NodeId, node: TgNodeAttributes, graph: AdapterOperations): boolean;
+}
+export declare abstract class EdgeRule extends BaseRule<EdgeRuleConfig> {
+    private readonly queryValue;
+    constructor(config: EdgeRuleConfig);
+    protected get query(): EdgeRuleMatcher;
+    protected matches(nodeId: NodeId, node: TgNodeAttributes, graph: AdapterOperations): boolean;
+}
+export {};

package/dist/cjs/Graph/Rules/Rule.js

@@ -0,0 +1,91 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EdgeRule = exports.NodeRule = exports.BaseRule = void 0;
+const NodeQuery_js_1 = require("../Operations/Matchers/NodeQuery/NodeQuery.js");
+class BaseRule {
+    config;
+    static registry = {};
+    lastMatch = false;
+    lastMatchNodeId;
+    static register(ruleClass) {
+        BaseRule.registry[ruleClass.name] = (config) => new ruleClass(config);
+    }
+    static fromSerialized(rule) {
+        if (!rule || typeof rule.id !== 'string' || rule.id.length === 0) {
+            const rendered = rule === undefined
+                ? 'undefined'
+                : JSON.stringify(rule, (_key, value) => typeof value === 'function' ? '[Function]' : value);
+            throw new Error(`Invalid serialized rule (missing id): ${rendered}`);
+        }
+        const factory = BaseRule.registry[rule.id];
+        if (!factory) {
+            throw new Error(`Rule '${rule.id}' is not registered`);
+        }
+        return factory(rule.config);
+    }
+    constructor(config) {
+        this.config = config;
+    }
+    describe(_nodeName, _node) {
+        return this.getId();
+    }
+    match(nodeId, node, graph) {
+        const result = this.matches(nodeId, node, graph);
+        this.lastMatch = result;
+        this.lastMatchNodeId = nodeId;
+        return result;
+    }
+    supports(_adapter) {
+        return true;
+    }
+    serialize() {
+        return {
+            id: this.getId(),
+            config: this.config,
+        };
+    }
+    getId() {
+        return this.constructor.name;
+    }
+    wasMatched(_nodeId) {
+        return this.lastMatchNodeId === _nodeId && this.lastMatch;
+    }
+}
+exports.BaseRule = BaseRule;
+class NodeRule extends BaseRule {
+    queryValue;
+    constructor(config) {
+        if (!('node' in config)) {
+            throw new Error(`Rule '${new.target.name}' requires a node config`);
+        }
+        super(config);
+        this.queryValue = NodeQuery_js_1.NodeQuery.from(config.node);
+    }
+    get query() {
+        return this.queryValue;
+    }
+    matches(nodeId, node, graph) {
+        return this.query.match(nodeId, node, graph);
+    }
+}
+exports.NodeRule = NodeRule;
+class EdgeRule extends BaseRule {
+    queryValue;
+    constructor(config) {
+        if (!('edge' in config)) {
+            throw new Error(`Rule '${new.target.name}' requires an edge config`);
+        }
+        super(config);
+        this.queryValue = {
+            from: NodeQuery_js_1.NodeQuery.from(config.edge.from),
+            to: NodeQuery_js_1.NodeQuery.from(config.edge.to),
+        };
+    }
+    get query() {
+        return this.queryValue;
+    }
+    matches(nodeId, node, graph) {
+        return this.query.from.match(nodeId, node, graph);
+    }
+}
+exports.EdgeRule = EdgeRule;

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

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

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

@@ -0,0 +1,127 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const jest_mock_extended_1 = require("jest-mock-extended");
+const TgGraph_js_1 = require("../TgGraph.js");
+const Rule_js_1 = require("./Rule.js");
+describe('BaseRule.fromSerialized', () => {
+    class SerializableRule extends Rule_js_1.BaseRule {
+        get query() {
+            return {};
+        }
+        matches(_nodeId, _node, _graph) {
+            return false;
+        }
+        apply(_nodeId, _node, graph) {
+            return graph;
+        }
+    }
+    Rule_js_1.BaseRule.register(SerializableRule);
+    it('shoud deserialize a registered rule', () => {
+        const serialized = {
+            id: 'SerializableRule',
+            config: {
+                node: { any: true },
+                options: { value: 'ok' },
+            },
+        };
+        const rule = Rule_js_1.BaseRule.fromSerialized(serialized);
+        expect(rule).toBeInstanceOf(SerializableRule);
+        expect(rule.serialize()).toEqual(serialized);
+    });
+    it('shoud throw when resolving an unregistered rule', () => {
+        expect(() => Rule_js_1.BaseRule.fromSerialized({
+            id: 'UnknownRule',
+            config: { node: { any: true } },
+        })).toThrow("Rule 'UnknownRule' is not registered");
+    });
+});
+describe('NodeRule.match and apply', () => {
+    class MatchAwareNodeRule extends Rule_js_1.NodeRule {
+        applyCount = 0;
+        apply(nodeId, _node, graph) {
+            if (!this.wasMatched(nodeId)) {
+                return graph;
+            }
+            this.applyCount += 1;
+            return graph;
+        }
+    }
+    it('shoud require node configuration', () => {
+        expect(() => new MatchAwareNodeRule({})).toThrow("Rule 'MatchAwareNodeRule' requires a node config");
+    });
+    it('shoud match and apply only after a successful match', () => {
+        const nodeA = (0, TgGraph_js_1.asNodeId)('node.a');
+        const nodeB = (0, TgGraph_js_1.asNodeId)('node.b');
+        const graph = (0, jest_mock_extended_1.mock)();
+        const rule = new MatchAwareNodeRule({
+            node: { nodeId: { eq: String(nodeA) } },
+        });
+        expect(rule.match(nodeA, { label: 'node.a' }, graph)).toBe(true);
+        const afterFirstMatch = rule.apply(nodeA, { label: 'node.a' }, graph);
+        expect(rule.match(nodeB, { label: 'node.b' }, graph)).toBe(false);
+        const afterSecondMatch = rule.apply(nodeB, { label: 'node.b' }, graph);
+        expect(afterFirstMatch).toBe(graph);
+        expect(afterSecondMatch).toBe(graph);
+        expect(rule.applyCount).toBe(1);
+    });
+});
+describe('EdgeRule.match', () => {
+    class MatchAwareEdgeRule extends Rule_js_1.EdgeRule {
+        applyCount = 0;
+        apply(nodeId, _node, graph) {
+            if (!this.wasMatched(nodeId)) {
+                return graph;
+            }
+            this.applyCount += 1;
+            return graph;
+        }
+    }
+    it('shoud require edge configuration', () => {
+        expect(() => new MatchAwareEdgeRule({})).toThrow("Rule 'MatchAwareEdgeRule' requires an edge config");
+    });
+    it('shoud match only from-node for edge rules', () => {
+        const from = (0, TgGraph_js_1.asNodeId)('edge.from');
+        const to = (0, TgGraph_js_1.asNodeId)('edge.to');
+        const graph = (0, jest_mock_extended_1.mock)();
+        const rule = new MatchAwareEdgeRule({
+            edge: {
+                from: { nodeId: { eq: String(from) } },
+                to: { nodeId: { eq: String(to) } },
+            },
+        });
+        expect(rule.match(from, { label: 'from' }, graph)).toBe(true);
+        expect(rule.match(to, { label: 'to' }, graph)).toBe(false);
+        expect(rule.applyCount).toBe(0);
+    });
+});
+describe('BaseRule.fromSerialized (invalid inputs)', () => {
+    it('shoud throw when serialized rule is undefined', () => {
+        expect(() => Rule_js_1.BaseRule.fromSerialized(undefined)).toThrow('Invalid serialized rule');
+    });
+    it('shoud throw when serialized rule has an empty id', () => {
+        expect(() => Rule_js_1.BaseRule.fromSerialized({
+            id: '',
+            config: {
+                node: { any: true },
+                options: { render: () => 'x' },
+            },
+        })).toThrow('Invalid serialized rule');
+    });
+});
+describe('BaseRule.describe and supports', () => {
+    class DescribeRule extends Rule_js_1.NodeRule {
+        apply(_nodeId, _node, graph) {
+            return graph;
+        }
+    }
+    it('shoud default describe to the rule id', () => {
+        const rule = new DescribeRule({ node: { any: true } });
+        const nodeId = (0, TgGraph_js_1.asNodeId)('node.describe');
+        expect(rule.describe(nodeId, { label: 'node.describe' })).toBe('DescribeRule');
+    });
+    it('shoud default supports to true', () => {
+        const rule = new DescribeRule({ node: { any: true } });
+        const graph = (0, jest_mock_extended_1.mock)();
+        expect(rule.supports(graph)).toBe(true);
+    });
+});

package/dist/cjs/Graph/Rules/RuleConfig.d.ts

@@ -0,0 +1,20 @@
+import { QueryDsl } from '../Operations/Matchers/NodeQuery/QuerySchema.js';
+export type NodeRuleConfig = {
+    node: QueryDsl;
+    options?: Record<string, unknown>;
+};
+export type EdgeRuleQuery = {
+    from: QueryDsl;
+    to: QueryDsl;
+};
+export type EdgeRuleConfig = {
+    edge: EdgeRuleQuery;
+    options?: Record<string, unknown>;
+};
+export type RuleConfig = NodeRuleConfig | EdgeRuleConfig;
+export type SerializedRule = {
+    id: string;
+    config: RuleConfig;
+};
+export type SerializedRulePhase = SerializedRule[];
+export type SerializedRulePlan = SerializedRulePhase[];

package/dist/cjs/Graph/Rules/RuleConfig.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/Graph/Rules/RulePlan.d.ts

@@ -0,0 +1,27 @@
+import { BaseRule } from './Rule.js';
+import { SerializedRule } from './RuleConfig.js';
+export type NamedRuleRef = {
+    namedRule: string;
+};
+export type NamedRuleSetRef = {
+    namedRuleSet: string;
+};
+export type PhaseRule = BaseRule | SerializedRule | NamedRuleRef | NamedRuleSetRef;
+export type SerializedPhaseRule = SerializedRule | NamedRuleRef | NamedRuleSetRef;
+export declare const NAMED_PHASES: readonly ["pre", "normalize", "semantics", "main", "cleanup"];
+export type NamedPhase = (typeof NAMED_PHASES)[number];
+export type PhaseStep = {
+    phase: NamedPhase;
+    rules: PhaseRule[];
+};
+export type SerializedPhaseStep = {
+    phase: NamedPhase;
+    rules: SerializedPhaseRule[];
+};
+export type PhasePlan = PhaseStep[];
+export type SerializedPhasePlan = SerializedPhaseStep[];
+export type NamedRuleDefinition = SerializedRule | BaseRule | (() => BaseRule);
+export type NamedRuleDefinitions = Record<string, NamedRuleDefinition>;
+export declare const isNamedRuleRef: (rule: PhaseRule) => rule is NamedRuleRef;
+export declare const isNamedRuleSetRef: (rule: PhaseRule) => rule is NamedRuleSetRef;
+export declare const isNamedPhase: (value: unknown) => value is NamedPhase;

package/dist/cjs/Graph/Rules/RulePlan.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isNamedPhase = exports.isNamedRuleSetRef = exports.isNamedRuleRef = exports.NAMED_PHASES = void 0;
+exports.NAMED_PHASES = [
+    'pre',
+    'normalize',
+    'semantics',
+    'main',
+    'cleanup',
+];
+const isNamedRuleRef = (rule) => {
+    return (typeof rule === 'object' &&
+        rule !== null &&
+        'namedRule' in rule &&
+        typeof rule.namedRule === 'string');
+};
+exports.isNamedRuleRef = isNamedRuleRef;
+const isNamedRuleSetRef = (rule) => {
+    return (typeof rule === 'object' &&
+        rule !== null &&
+        'namedRuleSet' in rule &&
+        typeof rule.namedRuleSet === 'string');
+};
+exports.isNamedRuleSetRef = isNamedRuleSetRef;
+const isNamedPhase = (value) => {
+    return (typeof value === 'string' && exports.NAMED_PHASES.includes(value));
+};
+exports.isNamedPhase = isNamedPhase;

package/dist/cjs/Graph/Rules/RuleSet.d.ts

@@ -0,0 +1,25 @@
+import { NamedRuleRegistry } from './NamedRuleRegistry.js';
+import type { NamedRuleSetRegistry } from './NamedRuleSetRegistry.js';
+import { BaseRule } from './Rule.js';
+import { PhasePlan, PhaseRule, SerializedPhaseRule } from './RulePlan.js';
+export type RuleSetOptions = {
+    rules?: PhaseRule[];
+};
+export type SerializedRuleSet = {
+    name?: string;
+    rules?: SerializedPhaseRule[];
+};
+export declare class RuleSet {
+    private readonly rules;
+    constructor(options?: RuleSetOptions);
+    addRules(rules: PhaseRule[]): RuleSet;
+    toPhases(): PhasePlan;
+    resolvePhases(namedRules?: NamedRuleRegistry, namedRuleSets?: NamedRuleSetRegistry): BaseRule[][];
+    serialize(): SerializedRuleSet;
+    static deseriaize(json: SerializedRuleSet): RuleSet;
+    private resolveRule;
+    private static isRuleInstance;
+    private serializeRules;
+    private static deserializeRules;
+    private static deserializeRule;
+}

package/dist/cjs/Graph/Rules/RuleSet.js

@@ -0,0 +1,89 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RuleSet = void 0;
+const Rule_js_1 = require("./Rule.js");
+const RulePlan_js_1 = require("./RulePlan.js");
+class RuleSet {
+    rules;
+    constructor(options = {}) {
+        this.rules = options.rules ?? [];
+    }
+    addRules(rules) {
+        return new RuleSet({
+            rules: [...this.rules, ...rules],
+        });
+    }
+    toPhases() {
+        return [
+            {
+                phase: 'main',
+                rules: [...this.rules],
+            },
+        ];
+    }
+    resolvePhases(namedRules, namedRuleSets) {
+        return [
+            this.rules.flatMap((rule) => this.resolveRule(rule, namedRules, namedRuleSets)),
+        ];
+    }
+    serialize() {
+        return {
+            rules: this.serializeRules(this.rules),
+        };
+    }
+    static deseriaize(json) {
+        return new RuleSet({
+            rules: RuleSet.deserializeRules(json.rules ?? []),
+        });
+    }
+    resolveRule(rule, namedRules, namedRuleSets) {
+        if (RuleSet.isRuleInstance(rule)) {
+            return [RuleSet.deserializeRule(rule.serialize())];
+        }
+        if ((0, RulePlan_js_1.isNamedRuleRef)(rule)) {
+            if (!namedRules) {
+                throw new Error('RuleSet contains named rules but no NamedRuleRegistry was provided');
+            }
+            return [namedRules.resolve(rule.namedRule)];
+        }
+        if ((0, RulePlan_js_1.isNamedRuleSetRef)(rule)) {
+            if (!namedRuleSets) {
+                throw new Error('RuleSet contains named rule sets but no NamedRuleSetRegistry was provided');
+            }
+            const resolved = namedRuleSets
+                .resolve(rule.namedRuleSet)
+                .resolvePhases(namedRules, namedRuleSets);
+            return resolved[0] ?? [];
+        }
+        return [RuleSet.deserializeRule(rule)];
+    }
+    static isRuleInstance(rule) {
+        if (rule instanceof Rule_js_1.BaseRule) {
+            return true;
+        }
+        if ((0, RulePlan_js_1.isNamedRuleRef)(rule) || (0, RulePlan_js_1.isNamedRuleSetRef)(rule)) {
+            return false;
+        }
+        return (
+        /* istanbul ignore next */
+        typeof rule === 'object' &&
+            rule !== null &&
+            'serialize' in rule &&
+            typeof rule.serialize === 'function');
+    }
+    serializeRules(rules) {
+        return rules.map((rule) => {
+            if (rule instanceof Rule_js_1.BaseRule) {
+                return rule.serialize();
+            }
+            return rule;
+        });
+    }
+    static deserializeRules(rules) {
+        return rules.map((rule) => rule);
+    }
+    static deserializeRule(rule) {
+        return Rule_js_1.BaseRule.fromSerialized(rule);
+    }
+}
+exports.RuleSet = RuleSet;

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

@@ -0,0 +1 @@
+import './Node/RemoveNode.js';

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

@@ -0,0 +1,222 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const Profile_js_1 = require("../Profile.js");
+const NamedRuleRegistry_js_1 = require("./NamedRuleRegistry.js");
+const NamedRuleSetRegistry_js_1 = require("./NamedRuleSetRegistry.js");
+const Rule_js_1 = require("./Rule.js");
+const RuleSet_js_1 = require("./RuleSet.js");
+require("./Node/RemoveNode.js");
+describe('RuleSet.resolvePhases', () => {
+    it('shoud resolve named rules when a registry is provided', () => {
+        const registry = new NamedRuleRegistry_js_1.NamedRuleRegistry({
+            removeDataNodes: {
+                id: 'RemoveNode',
+                config: {
+                    node: {
+                        attr: {
+                            key: 'label',
+                            startsWith: 'data.',
+                        },
+                    },
+                },
+            },
+        });
+        const ruleSet = new RuleSet_js_1.RuleSet({
+            rules: [{ namedRule: 'removeDataNodes' }],
+        });
+        const phases = ruleSet.resolvePhases(registry);
+        expect(phases).toHaveLength(1);
+        expect(phases[0]).toHaveLength(1);
+        expect(phases[0][0].serialize()).toEqual({
+            id: 'RemoveNode',
+            config: {
+                node: {
+                    attr: {
+                        key: 'label',
+                        startsWith: 'data.',
+                    },
+                },
+            },
+        });
+    });
+    it('shoud throw when named rules are used without a registry', () => {
+        const ruleSet = new RuleSet_js_1.RuleSet({
+            rules: [{ namedRule: 'removeDataNodes' }],
+        });
+        expect(() => ruleSet.resolvePhases()).toThrow('RuleSet contains named rules but no NamedRuleRegistry was provided');
+    });
+    it('shoud resolve named rule sets when a registry is provided', () => {
+        const namedRules = new NamedRuleRegistry_js_1.NamedRuleRegistry({
+            removeDataNodes: {
+                id: 'RemoveNode',
+                config: {
+                    node: {
+                        attr: {
+                            key: 'label',
+                            startsWith: 'data.',
+                        },
+                    },
+                },
+            },
+        });
+        const namedRuleSets = new NamedRuleSetRegistry_js_1.NamedRuleSetRegistry({
+            baseSet: new RuleSet_js_1.RuleSet({
+                rules: [{ namedRule: 'removeDataNodes' }],
+            }),
+        });
+        const ruleSet = new RuleSet_js_1.RuleSet({
+            rules: [{ namedRuleSet: 'baseSet' }],
+        });
+        const phases = ruleSet.resolvePhases(namedRules, namedRuleSets);
+        expect(phases).toHaveLength(1);
+        expect(phases[0]).toHaveLength(1);
+        expect(phases[0][0].serialize()).toEqual({
+            id: 'RemoveNode',
+            config: {
+                node: {
+                    attr: {
+                        key: 'label',
+                        startsWith: 'data.',
+                    },
+                },
+            },
+        });
+    });
+    it('shoud throw when named rule sets are used without a registry', () => {
+        const ruleSet = new RuleSet_js_1.RuleSet({
+            rules: [{ namedRuleSet: 'baseSet' }],
+        });
+        expect(() => ruleSet.resolvePhases()).toThrow('RuleSet contains named rule sets but no NamedRuleSetRegistry was provided');
+    });
+    it('shoud handle named rule sets that resolve to no phases', () => {
+        const namedRuleSets = new NamedRuleSetRegistry_js_1.NamedRuleSetRegistry({
+            empty: () => ({ resolvePhases: () => [] }),
+        });
+        const ruleSet = new RuleSet_js_1.RuleSet({
+            rules: [{ namedRuleSet: 'empty' }],
+        });
+        const phases = ruleSet.resolvePhases(undefined, namedRuleSets);
+        expect(phases).toEqual([[]]);
+    });
+    it('shoud resolve named rule sets via the internal resolver path', () => {
+        const namedRuleSets = new NamedRuleSetRegistry_js_1.NamedRuleSetRegistry({
+            empty: new RuleSet_js_1.RuleSet(),
+        });
+        const ruleSet = new RuleSet_js_1.RuleSet();
+        const resolveRule = ruleSet;
+        const resolved = resolveRule.resolveRule({ namedRuleSet: 'empty' }, undefined, namedRuleSets);
+        expect(resolved).toEqual([]);
+    });
+    it('shoud resolve concrete rules by serializing and rehydrating', () => {
+        const rule = Rule_js_1.BaseRule.fromSerialized({
+            id: 'RemoveNode',
+            config: {
+                node: {
+                    attr: {
+                        key: 'label',
+                        startsWith: 'data.',
+                    },
+                },
+            },
+        });
+        const ruleSet = new RuleSet_js_1.RuleSet({
+            rules: [rule],
+        });
+        const phases = ruleSet.resolvePhases();
+        expect(phases).toHaveLength(1);
+        expect(phases[0]).toHaveLength(1);
+        expect(phases[0][0].serialize()).toEqual(rule.serialize());
+    });
+    it('shoud resolve serialized rules without registries', () => {
+        const serializedRule = {
+            id: 'RemoveNode',
+            config: {
+                node: {
+                    attr: {
+                        key: 'label',
+                        startsWith: 'data.',
+                    },
+                },
+            },
+        };
+        const ruleSet = new RuleSet_js_1.RuleSet({
+            rules: [serializedRule],
+        });
+        const phases = ruleSet.resolvePhases();
+        expect(phases).toHaveLength(1);
+        expect(phases[0]).toHaveLength(1);
+        expect(phases[0][0].serialize()).toEqual(serializedRule);
+    });
+});
+describe('RuleSet.serialize', () => {
+    it('shoud serialize and deserialize phases', () => {
+        const ruleSet = new RuleSet_js_1.RuleSet({
+            rules: [{ namedRule: 'removeDataNodes' }],
+        });
+        const serialized = ruleSet.serialize();
+        const restored = RuleSet_js_1.RuleSet.deseriaize(serialized);
+        expect(restored.serialize()).toStrictEqual(serialized);
+    });
+    it('shoud serialize concrete rules with their serialized form', () => {
+        const rule = Rule_js_1.BaseRule.fromSerialized({
+            id: 'RemoveNode',
+            config: {
+                node: {
+                    attr: {
+                        key: 'label',
+                        startsWith: 'data.',
+                    },
+                },
+            },
+        });
+        const ruleSet = new RuleSet_js_1.RuleSet({
+            rules: [rule],
+        });
+        expect(ruleSet.serialize()).toEqual({
+            rules: [rule.serialize()],
+        });
+    });
+});
+describe('RuleSet.deseriaize', () => {
+    it('shoud default to empty rules when none are provided', () => {
+        const restored = RuleSet_js_1.RuleSet.deseriaize({});
+        expect(restored.toPhases()).toEqual([{ phase: 'main', rules: [] }]);
+    });
+});
+describe('RuleSet.toPhases', () => {
+    it('shoud provide phases that can be consumed by a profile', () => {
+        const ruleSet = new RuleSet_js_1.RuleSet({
+            rules: [{ namedRule: 'removeDataNodes' }],
+        });
+        const profile = new Profile_js_1.Profile('overview', { phases: ruleSet.toPhases() });
+        const phases = profile.serialize().phases ?? [];
+        expect(phases).toHaveLength(1);
+        expect(phases[0]).toEqual({
+            phase: 'main',
+            rules: [{ namedRule: 'removeDataNodes' }],
+        });
+    });
+});
+describe('RuleSet.constructor', () => {
+    it('shoud default to empty rules when options are omitted', () => {
+        const ruleSet = new RuleSet_js_1.RuleSet();
+        expect(ruleSet.toPhases()).toEqual([{ phase: 'main', rules: [] }]);
+    });
+});
+describe('RuleSet.addRules', () => {
+    it('shoud return a new ruleset with appended rules', () => {
+        const ruleSet = new RuleSet_js_1.RuleSet({
+            rules: [{ namedRule: 'firstRule' }],
+        });
+        const next = ruleSet.addRules([{ namedRule: 'secondRule' }]);
+        expect(next).not.toBe(ruleSet);
+        expect(ruleSet.toPhases()[0]).toEqual({
+            phase: 'main',
+            rules: [{ namedRule: 'firstRule' }],
+        });
+        expect(next.toPhases()[0]).toEqual({
+            phase: 'main',
+            rules: [{ namedRule: 'firstRule' }, { namedRule: 'secondRule' }],
+        });
+    });
+});