@terra-graph/core 1.0.0-rc.4

package/dist/esm/Output/RenderPipeline.test.js

@@ -0,0 +1,78 @@
+import { RenderPipeline } from './RenderPipeline.js';
+class AppendSuffixTransformer {
+    suffix;
+    constructor(suffix) {
+        this.suffix = suffix;
+    }
+    async transform(input) {
+        if (typeof input.artifact.content !== 'string') {
+            throw new Error('Expected text artifact');
+        }
+        return {
+            ...input.artifact,
+            content: `${input.artifact.content}${this.suffix}`,
+        };
+    }
+}
+class CaptureWriter {
+    lastInput;
+    async write(input) {
+        this.lastInput = input;
+    }
+}
+describe('RenderPipeline.execute', () => {
+    it('shoud apply transformers in order and pass the final artifact to writer', async () => {
+        const pipeline = new RenderPipeline();
+        const writer = new CaptureWriter();
+        const result = await pipeline.execute({
+            artifact: {
+                content: 'base',
+                mediaType: 'text/plain',
+            },
+            transformers: [
+                new AppendSuffixTransformer('-one'),
+                new AppendSuffixTransformer('-two'),
+            ],
+            writer,
+            write: {
+                target: '/tmp/out.txt',
+            },
+        });
+        expect(result).toEqual({
+            content: 'base-one-two',
+            mediaType: 'text/plain',
+        });
+        expect(writer.lastInput).toEqual({
+            target: '/tmp/out.txt',
+            artifact: {
+                content: 'base-one-two',
+                mediaType: 'text/plain',
+            },
+        });
+    });
+    it('shoud write the original artifact when no transformers are provided', async () => {
+        const pipeline = new RenderPipeline();
+        const writer = new CaptureWriter();
+        const result = await pipeline.execute({
+            artifact: {
+                content: 'base',
+                mediaType: 'text/plain',
+            },
+            writer,
+            write: {
+                target: '/tmp/out.txt',
+            },
+        });
+        expect(result).toEqual({
+            content: 'base',
+            mediaType: 'text/plain',
+        });
+        expect(writer.lastInput).toEqual({
+            target: '/tmp/out.txt',
+            artifact: {
+                content: 'base',
+                mediaType: 'text/plain',
+            },
+        });
+    });
+});

package/dist/esm/Output/index.d.ts

@@ -0,0 +1,7 @@
+export * from './ArtifactTransformer.js';
+export * from './ArtifactTransformer/index.js';
+export * from './ArtifactTransformerFactory.js';
+export * from './ArtifactTransformerFactory/index.js';
+export * from './ArtifactWriter.js';
+export * from './ArtifactWriter/index.js';
+export * from './RenderPipeline.js';

package/dist/esm/Output/index.js

@@ -0,0 +1,7 @@
+export * from './ArtifactTransformer.js';
+export * from './ArtifactTransformer/index.js';
+export * from './ArtifactTransformerFactory.js';
+export * from './ArtifactTransformerFactory/index.js';
+export * from './ArtifactWriter.js';
+export * from './ArtifactWriter/index.js';
+export * from './RenderPipeline.js';

package/dist/esm/Runtime/RuntimeCatalog.d.ts

@@ -0,0 +1,25 @@
+import { GraphPluginRegistry } from '../Graph/GraphPlugin.js';
+import { Profile } from '../Graph/Profile.js';
+import { ProfileRegistry } from '../Graph/ProfileRegistry.js';
+import { NamedRuleRegistry } from '../Graph/Rules/NamedRuleRegistry.js';
+import { NamedRuleSetRegistry } from '../Graph/Rules/NamedRuleSetRegistry.js';
+import { BaseRule } from '../Graph/Rules/Rule.js';
+export type RuntimeCatalogProvider = {
+    namedRules?: NamedRuleRegistry;
+    namedRuleSets?: NamedRuleSetRegistry;
+    profiles?: ProfileRegistry;
+    plugins?: GraphPluginRegistry;
+};
+export declare class RuntimeCatalog {
+    readonly namedRules: NamedRuleRegistry;
+    readonly namedRuleSets: NamedRuleSetRegistry;
+    readonly profiles: ProfileRegistry;
+    readonly plugins: GraphPluginRegistry;
+    constructor(input?: RuntimeCatalogProvider);
+    static from(providers: RuntimeCatalogProvider[]): RuntimeCatalog;
+    use(provider: RuntimeCatalogProvider): RuntimeCatalog;
+    resolveProfile(name: string): Profile;
+    resolveProfilePhases(name: string): BaseRule[][];
+    resolveProfileRendererOptions<TOptions = Record<string, unknown>>(name: string): TOptions | undefined;
+    resolveProfileRenderer(name: string): string | undefined;
+}

package/dist/esm/Runtime/RuntimeCatalog.js

@@ -0,0 +1,47 @@
+import { GraphPluginRegistry } from '../Graph/GraphPlugin.js';
+import { ProfileRegistry } from '../Graph/ProfileRegistry.js';
+import { NamedRuleRegistry } from '../Graph/Rules/NamedRuleRegistry.js';
+import { NamedRuleSetRegistry } from '../Graph/Rules/NamedRuleSetRegistry.js';
+export class RuntimeCatalog {
+    namedRules;
+    namedRuleSets;
+    profiles;
+    plugins;
+    constructor(input = {}) {
+        this.namedRules = input.namedRules ?? new NamedRuleRegistry();
+        this.namedRuleSets = input.namedRuleSets ?? new NamedRuleSetRegistry();
+        this.profiles = input.profiles ?? new ProfileRegistry();
+        this.plugins = input.plugins ?? new GraphPluginRegistry();
+    }
+    static from(providers) {
+        return providers.reduce((combined, provider) => combined.use(provider), new RuntimeCatalog());
+    }
+    use(provider) {
+        return new RuntimeCatalog({
+            namedRules: provider.namedRules
+                ? this.namedRules.use(provider.namedRules)
+                : this.namedRules,
+            namedRuleSets: provider.namedRuleSets
+                ? this.namedRuleSets.use(provider.namedRuleSets)
+                : this.namedRuleSets,
+            profiles: provider.profiles
+                ? this.profiles.use(provider.profiles)
+                : this.profiles,
+            plugins: provider.plugins
+                ? this.plugins.use(provider.plugins)
+                : this.plugins,
+        });
+    }
+    resolveProfile(name) {
+        return this.profiles.resolve(name);
+    }
+    resolveProfilePhases(name) {
+        return this.resolveProfile(name).resolvePhases(this.namedRules, this.namedRuleSets, this.plugins);
+    }
+    resolveProfileRendererOptions(name) {
+        return this.resolveProfile(name).resolveRendererOptions();
+    }
+    resolveProfileRenderer(name) {
+        return this.resolveProfile(name).resolveRenderer();
+    }
+}

package/dist/esm/Runtime/RuntimeCatalog.test.d.ts

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

package/dist/esm/Runtime/RuntimeCatalog.test.js

@@ -0,0 +1,163 @@
+import { GraphPlugin, GraphPluginRegistry } from '../Graph/GraphPlugin.js';
+import { Profile } from '../Graph/Profile.js';
+import { ProfileRegistry } from '../Graph/ProfileRegistry.js';
+import { NamedRuleRegistry } from '../Graph/Rules/NamedRuleRegistry.js';
+import { NamedRuleSetRegistry } from '../Graph/Rules/NamedRuleSetRegistry.js';
+import { RemoveNode } from '../Graph/Rules/Node/RemoveNode.js';
+import { RuntimeCatalog } from './RuntimeCatalog.js';
+describe('RuntimeCatalog.from', () => {
+    it('shoud combine providers into one runtime catalog', () => {
+        const namedRules = new NamedRuleRegistry({
+            ruleOne: new RemoveNode({
+                node: { any: true },
+            }),
+        });
+        const namedRuleSets = new NamedRuleSetRegistry({
+            setOne: {
+                rules: [{ namedRule: 'ruleOne' }],
+            },
+        });
+        const profiles = new ProfileRegistry({
+            'example.profile': new Profile('example.profile', {}),
+        });
+        class ExamplePlugin extends GraphPlugin {
+            constructor() {
+                super('example.plugin');
+            }
+            build() {
+                return {};
+            }
+        }
+        const plugins = new GraphPluginRegistry({
+            'example.plugin': new ExamplePlugin(),
+        });
+        const catalog = RuntimeCatalog.from([
+            { namedRules },
+            { namedRuleSets },
+            { profiles },
+            { plugins },
+        ]);
+        expect(catalog.namedRules.names()).toEqual(['ruleOne']);
+        expect(catalog.namedRuleSets.names()).toEqual(['setOne']);
+        expect(catalog.profiles.names()).toEqual(['example.profile']);
+        expect(catalog.plugins.names()).toEqual(['example.plugin']);
+    });
+    it('shoud prefer later providers when names collide', () => {
+        const first = RuntimeCatalog.from([
+            {
+                namedRules: new NamedRuleRegistry({
+                    shared: new RemoveNode({
+                        node: { attr: { key: 'label', eq: 'first' } },
+                    }),
+                }),
+            },
+        ]);
+        const second = {
+            namedRules: new NamedRuleRegistry({
+                shared: new RemoveNode({
+                    node: { attr: { key: 'label', eq: 'second' } },
+                }),
+            }),
+        };
+        const combined = first.use(second);
+        const resolved = combined.namedRules.resolve('shared');
+        expect(resolved.serialize()).toEqual({
+            id: 'RemoveNode',
+            config: { node: { attr: { key: 'label', eq: 'second' } } },
+        });
+    });
+});
+describe('RuntimeCatalog.resolveProfile', () => {
+    it('shoud resolve a profile by name', () => {
+        const profile = new Profile('example.profile', {});
+        const catalog = new RuntimeCatalog({
+            profiles: new ProfileRegistry({
+                'example.profile': profile,
+            }),
+        });
+        expect(catalog.resolveProfile('example.profile')).toBe(profile);
+    });
+});
+describe('RuntimeCatalog.resolveProfilePhases', () => {
+    it('shoud resolve phases using catalog registries', () => {
+        const profile = new Profile('example.profile', {
+            phases: [
+                {
+                    phase: 'main',
+                    rules: [{ namedRuleSet: 'wrapper' }],
+                },
+            ],
+        });
+        const catalog = new RuntimeCatalog({
+            profiles: new ProfileRegistry({
+                'example.profile': profile,
+            }),
+            namedRules: new NamedRuleRegistry({
+                removeAlways: new RemoveNode({
+                    node: { any: true },
+                }),
+            }),
+            namedRuleSets: new NamedRuleSetRegistry({
+                wrapper: {
+                    rules: [{ namedRule: 'removeAlways' }],
+                },
+            }),
+        });
+        const phases = catalog.resolveProfilePhases('example.profile');
+        expect(phases).toHaveLength(1);
+        expect(phases[0]).toHaveLength(1);
+        expect(phases[0][0].serialize()).toEqual({
+            id: 'RemoveNode',
+            config: { node: { any: true } },
+        });
+    });
+});
+describe('RuntimeCatalog.resolveProfileRendererOptions', () => {
+    it('shoud resolve renderer options through the profile registry', () => {
+        const profile = new Profile('example.profile', {
+            render: {
+                options: {
+                    graph: { rankdir: 'LR' },
+                },
+            },
+        });
+        const catalog = new RuntimeCatalog({
+            profiles: new ProfileRegistry({
+                'example.profile': profile,
+            }),
+        });
+        const options = catalog.resolveProfileRendererOptions('example.profile');
+        expect(options).toEqual({
+            graph: { rankdir: 'LR' },
+        });
+    });
+});
+describe('RuntimeCatalog.resolveProfileRenderer', () => {
+    it('shoud resolve renderer by name through the profile registry', () => {
+        const profile = new Profile('example.profile', {
+            render: { renderer: 'dot' },
+        });
+        const catalog = new RuntimeCatalog({
+            profiles: new ProfileRegistry({
+                'example.profile': profile,
+            }),
+        });
+        expect(catalog.resolveProfileRenderer('example.profile')).toBe('dot');
+    });
+});
+describe('RuntimeCatalog.use', () => {
+    it('shoud preserve existing registries when provider omits them', () => {
+        const base = new RuntimeCatalog({
+            namedRules: new NamedRuleRegistry({
+                baseRule: new RemoveNode({ node: { any: true } }),
+            }),
+        });
+        const updated = base.use({
+            profiles: new ProfileRegistry({
+                'example.profile': new Profile('example.profile', {}),
+            }),
+        });
+        expect(updated.namedRules.names()).toEqual(['baseRule']);
+        expect(updated.profiles.names()).toEqual(['example.profile']);
+    });
+});

package/dist/esm/Runtime/RuntimeCatalogBuilder/RuntimeCatalogFromConfigBuilder.d.ts

@@ -0,0 +1,5 @@
+import { RuntimeCatalog } from '../RuntimeCatalog.js';
+import { RuntimeCatalogBuildInput, RuntimeCatalogBuilder } from '../RuntimeCatalogBuilder.js';
+export declare class RuntimeCatalogFromConfigBuilder<TOptions extends Record<string, unknown> = Record<string, unknown>> implements RuntimeCatalogBuilder<TOptions> {
+    build(input: RuntimeCatalogBuildInput<TOptions>): RuntimeCatalog;
+}

package/dist/esm/Runtime/RuntimeCatalogBuilder/RuntimeCatalogFromConfigBuilder.js

@@ -0,0 +1,6 @@
+import { RuntimeCatalogLoader } from '../RuntimeCatalogLoader.js';
+export class RuntimeCatalogFromConfigBuilder {
+    build(input) {
+        return RuntimeCatalogLoader.load(input);
+    }
+}

package/dist/esm/Runtime/RuntimeCatalogBuilder/RuntimeCatalogFromConfigBuilder.test.d.ts

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

package/dist/esm/Runtime/RuntimeCatalogBuilder/RuntimeCatalogFromConfigBuilder.test.js

@@ -0,0 +1,29 @@
+import { RemoveNode } from '../../Graph/Rules/Node/RemoveNode.js';
+import { RuntimeCatalogFromConfigBuilder } from './RuntimeCatalogFromConfigBuilder.js';
+describe('RuntimeCatalogFromConfigBuilder.build', () => {
+    it('shoud build a runtime catalog from serialized runtime config', () => {
+        const builder = new RuntimeCatalogFromConfigBuilder();
+        const catalog = builder.build({
+            config: {
+                namedRules: {
+                    removeAlways: {
+                        id: RemoveNode.name,
+                        config: { node: { any: true } },
+                    },
+                },
+                profiles: {
+                    profile: {
+                        phases: [{ phase: 'main', rules: [{ namedRule: 'removeAlways' }] }],
+                    },
+                },
+            },
+        });
+        const phases = catalog.resolveProfilePhases('profile');
+        expect(phases).toHaveLength(1);
+        expect(phases[0]).toHaveLength(1);
+        expect(phases[0][0].serialize()).toEqual({
+            id: RemoveNode.name,
+            config: { node: { any: true } },
+        });
+    });
+});

package/dist/esm/Runtime/RuntimeCatalogBuilder/index.d.ts

@@ -0,0 +1 @@
+export * from './RuntimeCatalogFromConfigBuilder.js';

package/dist/esm/Runtime/RuntimeCatalogBuilder/index.js

@@ -0,0 +1 @@
+export * from './RuntimeCatalogFromConfigBuilder.js';

package/dist/esm/Runtime/RuntimeCatalogBuilder.d.ts

@@ -0,0 +1,11 @@
+import { SupportedAdapterOperationsRegistry } from '../Graph/Serialization/Registry.js';
+import { RuntimeCatalog, RuntimeCatalogProvider } from './RuntimeCatalog.js';
+import { SerializedRuntimeConfig } from './RuntimeCatalogLoader.js';
+export type RuntimeCatalogBuildInput<TOptions extends Record<string, unknown> = Record<string, unknown>> = {
+    providers?: RuntimeCatalogProvider[];
+    config: SerializedRuntimeConfig<TOptions>;
+    supportedAdapterOperationsRegistry?: SupportedAdapterOperationsRegistry;
+};
+export interface RuntimeCatalogBuilder<TOptions extends Record<string, unknown> = Record<string, unknown>> {
+    build(input: RuntimeCatalogBuildInput<TOptions>): RuntimeCatalog;
+}

package/dist/esm/Runtime/RuntimeCatalogBuilder.js

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

package/dist/esm/Runtime/RuntimeCatalogBuilder.test.d.ts

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

package/dist/esm/Runtime/RuntimeCatalogBuilder.test.js

@@ -0,0 +1,25 @@
+import { RuntimeCatalog } from './RuntimeCatalog.js';
+describe('RuntimeCatalogBuilder.build', () => {
+    it('shoud allow implementations to consume runtime build input', () => {
+        class CaptureBuilder {
+            captured;
+            build(input) {
+                this.captured = input;
+                return new RuntimeCatalog();
+            }
+        }
+        const builder = new CaptureBuilder();
+        const input = {
+            config: {
+                profiles: {
+                    profile: {
+                        phases: [],
+                    },
+                },
+            },
+        };
+        const catalog = builder.build(input);
+        expect(catalog).toBeInstanceOf(RuntimeCatalog);
+        expect(builder.captured).toEqual(input);
+    });
+});

package/dist/esm/Runtime/RuntimeCatalogLoader.d.ts

@@ -0,0 +1,37 @@
+import { SerializedProfile } from '../Graph/Profile.js';
+import { ProfileRegistry } from '../Graph/ProfileRegistry.js';
+import { SerializedRule } from '../Graph/Rules/RuleConfig.js';
+import { SerializedRuleSet } from '../Graph/Rules/RuleSet.js';
+import { SupportedAdapterOperationsRegistry } from '../Graph/Serialization/Registry.js';
+import { RuntimeCatalog, RuntimeCatalogProvider } from './RuntimeCatalog.js';
+export type SerializedRuntimeProfile<TOptions extends Record<string, unknown> = Record<string, unknown>> = Omit<SerializedProfile<TOptions>, 'name' | 'usesProfiles'> & {
+    usesProfiles?: string[];
+};
+export type SerializedRuntimeConfig<TOptions extends Record<string, unknown> = Record<string, unknown>> = {
+    providers?: string[];
+    namedRules?: Record<string, SerializedRule>;
+    namedRuleSets?: Record<string, SerializedRuleSet>;
+    profiles?: Record<string, SerializedRuntimeProfile<TOptions>>;
+    run?: {
+        profile: string;
+        render?: {
+            renderer?: string;
+            options?: TOptions;
+        };
+    };
+};
+export type RuntimeCatalogLoaderInput<TOptions extends Record<string, unknown> = Record<string, unknown>> = {
+    providers?: RuntimeCatalogProvider[];
+    config?: SerializedRuntimeConfig<TOptions>;
+    supportedAdapterOperationsRegistry?: SupportedAdapterOperationsRegistry;
+};
+export declare class RuntimeCatalogLoader<TOptions extends Record<string, unknown> = Record<string, unknown>> {
+    private readonly input;
+    constructor(input?: RuntimeCatalogLoaderInput<TOptions>);
+    load(config?: SerializedRuntimeConfig<TOptions> | undefined): RuntimeCatalog;
+    fromSerialized(config: SerializedRuntimeConfig<TOptions>): RuntimeCatalog;
+    static fromSerialized<TOptions extends Record<string, unknown> = Record<string, unknown>>(config: SerializedRuntimeConfig<TOptions>, supportedAdapterOperationsRegistry?: SupportedAdapterOperationsRegistry, externalProfiles?: ProfileRegistry): RuntimeCatalog;
+    static load<TOptions extends Record<string, unknown> = Record<string, unknown>>(input?: RuntimeCatalogLoaderInput<TOptions>): RuntimeCatalog;
+    private static resolveProfilesFromSerialized;
+    private static coerceSerializedProfile;
+}

package/dist/esm/Runtime/RuntimeCatalogLoader.js

@@ -0,0 +1,102 @@
+import { Profile } from '../Graph/Profile.js';
+import { ProfileRegistry } from '../Graph/ProfileRegistry.js';
+import { NamedRuleRegistry } from '../Graph/Rules/NamedRuleRegistry.js';
+import { NamedRuleSetRegistry } from '../Graph/Rules/NamedRuleSetRegistry.js';
+import { RuntimeCatalog } from './RuntimeCatalog.js';
+export class RuntimeCatalogLoader {
+    input;
+    constructor(input = {}) {
+        this.input = input;
+    }
+    load(config = this.input.config) {
+        return RuntimeCatalogLoader.load({
+            ...this.input,
+            config,
+        });
+    }
+    fromSerialized(config) {
+        return RuntimeCatalogLoader.fromSerialized(config, this.input.supportedAdapterOperationsRegistry);
+    }
+    static fromSerialized(config, supportedAdapterOperationsRegistry, externalProfiles) {
+        return new RuntimeCatalog({
+            namedRules: new NamedRuleRegistry(config.namedRules ?? {}),
+            namedRuleSets: new NamedRuleSetRegistry(config.namedRuleSets ?? {}),
+            profiles: RuntimeCatalogLoader.resolveProfilesFromSerialized(config.profiles ?? {}, supportedAdapterOperationsRegistry, externalProfiles),
+        });
+    }
+    static load(input = {}) {
+        const providerCatalog = RuntimeCatalog.from(input.providers ?? []);
+        if (!input.config) {
+            return providerCatalog;
+        }
+        return RuntimeCatalog.from([
+            providerCatalog,
+            RuntimeCatalogLoader.fromSerialized(input.config, input.supportedAdapterOperationsRegistry, providerCatalog.profiles),
+        ]);
+    }
+    static resolveProfilesFromSerialized(profiles, supportedAdapterOperationsRegistry, externalProfiles) {
+        const externalNames = new Set(externalProfiles?.names() ?? []);
+        const externalSerialized = new Map();
+        const definitions = new Map();
+        for (const [name, profile] of Object.entries(profiles)) {
+            definitions.set(name, {
+                profile: {
+                    name,
+                    supports: profile.supports,
+                    render: profile.render,
+                    phases: profile.phases,
+                    plugins: profile.plugins,
+                },
+                usesProfiles: [...(profile.usesProfiles ?? [])],
+            });
+        }
+        const resolved = new Map();
+        const resolve = (name, stack = []) => {
+            const existing = resolved.get(name);
+            if (existing) {
+                return existing;
+            }
+            if (stack.includes(name)) {
+                throw new Error(`Runtime config profile inheritance cycle detected: ${[...stack, name].join(' -> ')}`);
+            }
+            const definition = definitions.get(name);
+            if (!definition) {
+                throw new Error(`Runtime config profile '${name}' is not defined`);
+            }
+            const usedProfiles = definition.usesProfiles.map((used) => {
+                if (!definitions.has(used)) {
+                    if (externalNames.has(used)) {
+                        const cached = externalSerialized.get(used);
+                        if (cached) {
+                            return RuntimeCatalogLoader.coerceSerializedProfile(cached);
+                        }
+                        const externalProfile = externalProfiles?.resolve(used);
+                        if (externalProfile) {
+                            const serialized = externalProfile.serialize();
+                            externalSerialized.set(used, serialized);
+                            return RuntimeCatalogLoader.coerceSerializedProfile(serialized);
+                        }
+                    }
+                    throw new Error(`Runtime config profile '${name}' uses unknown profile '${used}'`);
+                }
+                return resolve(used, [...stack, name]);
+            });
+            const profile = {
+                ...definition.profile,
+                usesProfiles: usedProfiles,
+            };
+            resolved.set(name, profile);
+            return profile;
+        };
+        for (const name of definitions.keys()) {
+            resolve(name);
+        }
+        return new ProfileRegistry(Object.fromEntries([...resolved.entries()].map(([name, profile]) => [
+            name,
+            () => Profile.deseriaize(profile, supportedAdapterOperationsRegistry),
+        ])));
+    }
+    static coerceSerializedProfile(profile) {
+        return profile;
+    }
+}

package/dist/esm/Runtime/RuntimeCatalogLoader.test.d.ts

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