@terra-graph/core 1.0.0-rc.4

package/dist/esm/Graph/Profile.js

@@ -0,0 +1,219 @@
+import { resolveGraphPlugins, } from './GraphPlugin.js';
+import { BaseRule } from './Rules/Rule.js';
+import { NAMED_PHASES, isNamedPhase, isNamedRuleRef, isNamedRuleSetRef, } from './Rules/RulePlan.js';
+export class Profile {
+    name;
+    supports;
+    render;
+    phases;
+    plugins;
+    usesProfiles;
+    constructor(name, options) {
+        this.name = name;
+        this.supports = options.supports;
+        this.render = options.render;
+        this.phases = options.phases ?? [];
+        this.plugins = options.plugins ?? [];
+        this.usesProfiles = options.usesProfiles ?? [];
+    }
+    use(profile) {
+        return new Profile(this.name, {
+            supports: this.supports,
+            render: this.render,
+            phases: this.phases,
+            plugins: this.plugins,
+            usesProfiles: [...this.usesProfiles, profile],
+        });
+    }
+    addPhases(phases) {
+        return new Profile(this.name, {
+            supports: this.supports,
+            render: this.render,
+            phases: [...this.phases, ...phases],
+            plugins: this.plugins,
+            usesProfiles: this.usesProfiles,
+        });
+    }
+    usePlugin(plugin, options) {
+        return new Profile(this.name, {
+            supports: this.supports,
+            render: this.render,
+            phases: this.phases,
+            plugins: [...this.plugins, { plugin, options }],
+            usesProfiles: this.usesProfiles,
+        });
+    }
+    resolvePhases(namedRules, namedRuleSets, pluginRegistry) {
+        if (this.supports) {
+            this.assertCompatibleSupportedAdapterOperations(this.supports);
+        }
+        const entries = this.resolvePhaseEntries(namedRules, namedRuleSets, pluginRegistry);
+        const ordered = this.orderPhaseEntries(entries);
+        return ordered.map((entry) => entry.rules);
+    }
+    serialize() {
+        return {
+            name: this.name,
+            supports: this.supports?.name,
+            render: this.render,
+            phases: this.serializePhases(this.phases),
+            plugins: this.plugins.length > 0 ? [...this.plugins] : undefined,
+            usesProfiles: this.usesProfiles.map((profile) => profile.serialize()),
+        };
+    }
+    static deseriaize(json, supportedAdpaterOperationsRegistry) {
+        const supports = json.supports
+            ? supportedAdpaterOperationsRegistry?.[json.supports]
+            : undefined;
+        if (json.supports && !supports) {
+            throw new Error(`Profile.supports ('${json.supports}') is not registered`);
+        }
+        return new Profile(json.name, {
+            supports,
+            render: json.render,
+            phases: Profile.deserializePhases(json.phases ?? []),
+            plugins: [...(json.plugins ?? [])],
+            usesProfiles: (json.usesProfiles ?? []).map((profile) => Profile.deseriaize(profile, supportedAdpaterOperationsRegistry)),
+        });
+    }
+    resolveRendererOptions() {
+        const inherited = this.usesProfiles.reduce((_acc, profile) => profile.resolveRendererOptions(), undefined);
+        return this.render?.options ?? inherited;
+    }
+    resolveRenderer() {
+        const inherited = this.usesProfiles.reduce((_acc, profile) => profile.resolveRenderer(), undefined);
+        return this.render?.renderer ?? inherited;
+    }
+    assertCompatibleSupportedAdapterOperations(supports) {
+        const conflicting = this.collectProfiles().filter((profile) => profile.supports && profile.supports !== supports);
+        if (conflicting.length > 0) {
+            const names = conflicting.map((profile) => profile.name).join(', ');
+            throw new Error(`Profile.supports conflict for ('${supports.name}') (conflicting profiles: ${names})`);
+        }
+    }
+    collectProfiles() {
+        return [
+            this,
+            ...this.usesProfiles.flatMap((profile) => profile.collectProfiles()),
+        ];
+    }
+    resolvePhaseEntries(namedRules, namedRuleSets, pluginRegistry) {
+        const ownEntries = this.resolveOwnPhaseEntries(namedRules, namedRuleSets, pluginRegistry);
+        const inheritedEntries = this.usesProfiles.reduce((acc, profile) => [
+            // biome-ignore lint/performance/noAccumulatingSpread: <explanation>
+            ...acc,
+            ...profile.resolvePhaseEntries(namedRules, namedRuleSets, pluginRegistry),
+        ], []);
+        return [...inheritedEntries, ...ownEntries];
+    }
+    resolveOwnPhaseEntries(namedRules, namedRuleSets, pluginRegistry) {
+        const resolvedPlugins = this.resolveOwnPlugins(namedRules, namedRuleSets, pluginRegistry);
+        const pluginEntries = this.resolvePhasePlan(resolvedPlugins.phases, resolvedPlugins.namedRules, resolvedPlugins.namedRuleSets);
+        const ownEntries = this.resolvePhasePlan(this.phases, resolvedPlugins.namedRules, resolvedPlugins.namedRuleSets);
+        return [...pluginEntries, ...ownEntries];
+    }
+    resolvePhasePlan(phases, namedRules, namedRuleSets) {
+        return phases.map((phase) => {
+            if (!isNamedPhase(phase.phase)) {
+                throw new Error(`Profile '${this.name}' contains unsupported phase '${String(phase.phase)}'`);
+            }
+            return {
+                phase: phase.phase,
+                rules: phase.rules.flatMap((rule) => this.resolveRule(rule, namedRules, namedRuleSets)),
+            };
+        });
+    }
+    orderPhaseEntries(entries) {
+        const buckets = new Map();
+        for (const namedPhase of NAMED_PHASES) {
+            buckets.set(namedPhase, []);
+        }
+        for (const entry of entries) {
+            const bucket = buckets.get(entry.phase);
+            if (!bucket) {
+                throw new Error(`Profile '${this.name}' contains unsupported phase '${String(entry.phase)}'`);
+            }
+            bucket.push(entry);
+        }
+        return NAMED_PHASES.flatMap((phase) => buckets.get(phase) ?? []);
+    }
+    resolveOwnPlugins(namedRules, namedRuleSets, pluginRegistry) {
+        if (this.plugins.length === 0) {
+            return {
+                phases: [],
+                namedRules,
+                namedRuleSets,
+            };
+        }
+        if (!pluginRegistry) {
+            throw new Error(`Profile '${this.name}' contains plugins but no GraphPluginRegistry was provided`);
+        }
+        return resolveGraphPlugins({
+            plugins: this.plugins,
+            pluginRegistry,
+            namedRules,
+            namedRuleSets,
+        });
+    }
+    resolveRule(rule, namedRules, namedRuleSets) {
+        if (Profile.isRuleInstance(rule)) {
+            return [Profile.deserializeRule(rule.serialize())];
+        }
+        if (isNamedRuleRef(rule)) {
+            if (!namedRules) {
+                throw new Error(`Profile '${this.name}' contains named rules but no NamedRuleRegistry was provided`);
+            }
+            return [namedRules.resolve(rule.namedRule)];
+        }
+        if (isNamedRuleSetRef(rule)) {
+            if (!namedRuleSets) {
+                throw new Error(`Profile '${this.name}' contains named rule sets but no NamedRuleSetRegistry was provided`);
+            }
+            const resolved = namedRuleSets
+                .resolve(rule.namedRuleSet)
+                .resolvePhases(namedRules, namedRuleSets);
+            if (resolved.length > 1) {
+                throw new Error(`Profile '${this.name}' references namedRuleSet '${rule.namedRuleSet}' with multiple phases, which cannot be inlined in a single phase`);
+            }
+            return resolved[0] ?? [];
+        }
+        return [Profile.deserializeRule(rule)];
+    }
+    static isRuleInstance(rule) {
+        if (rule instanceof BaseRule) {
+            return true;
+        }
+        if (isNamedRuleRef(rule) || isNamedRuleSetRef(rule)) {
+            return false;
+        }
+        return (typeof rule === 'object' &&
+            rule !== null &&
+            'serialize' in rule &&
+            typeof rule.serialize === 'function');
+    }
+    serializePhases(phases) {
+        return phases.map((phase) => ({
+            phase: phase.phase,
+            rules: phase.rules.map((rule) => {
+                if (rule instanceof BaseRule) {
+                    return rule.serialize();
+                }
+                return rule;
+            }),
+        }));
+    }
+    static deserializePhases(phases) {
+        return phases.map((phase) => {
+            if (!isNamedPhase(phase.phase)) {
+                throw new Error(`Profile.phases contains unsupported phase '${String(phase.phase)}'`);
+            }
+            return {
+                phase: phase.phase,
+                rules: phase.rules.map((rule) => rule),
+            };
+        });
+    }
+    static deserializeRule(rule) {
+        return BaseRule.fromSerialized(rule);
+    }
+}

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

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