@terra-graph/core 1.0.0-rc.4

package/dist/cjs/Runtime/RuntimeConfigLoader.js

@@ -0,0 +1,93 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RuntimeConfigLoader = void 0;
+const RuntimeCatalogFromConfigBuilder_js_1 = require("./RuntimeCatalogBuilder/RuntimeCatalogFromConfigBuilder.js");
+const RuntimeConfigParserRegistry_js_1 = require("./RuntimeConfigParserRegistry.js");
+const RuntimeConfigSource_js_1 = require("./RuntimeConfigSource.js");
+const ZodRuntimeConfigValidator_js_1 = require("./RuntimeConfigValidator/ZodRuntimeConfigValidator.js");
+const ModuleRuntimeProviderLoader_js_1 = require("./RuntimeProviderLoader/ModuleRuntimeProviderLoader.js");
+class RuntimeConfigLoader {
+    parserRegistry;
+    validator;
+    catalogBuilder;
+    providerLoader;
+    baseProviders;
+    constructor(dependencies = {}) {
+        this.parserRegistry =
+            dependencies.parserRegistry ?? RuntimeConfigParserRegistry_js_1.RuntimeConfigParserRegistry.defaults();
+        this.validator = dependencies.validator ?? new ZodRuntimeConfigValidator_js_1.ZodRuntimeConfigValidator();
+        this.catalogBuilder =
+            dependencies.catalogBuilder ??
+                new RuntimeCatalogFromConfigBuilder_js_1.RuntimeCatalogFromConfigBuilder();
+        this.providerLoader =
+            dependencies.providerLoader ?? new ModuleRuntimeProviderLoader_js_1.ModuleRuntimeProviderLoader();
+        this.baseProviders = Object.freeze([...(dependencies.baseProviders ?? [])]);
+    }
+    async load(input) {
+        const document = await input.source.read();
+        const format = document.format ??
+            (0, RuntimeConfigSource_js_1.inferRuntimeConfigFormatFromReference)(document.reference);
+        if (!format) {
+            const from = document.reference ? ` from '${document.reference}'` : '';
+            throw new Error(`Unable to determine runtime config format${from}`);
+        }
+        let parsed;
+        try {
+            parsed = this.parserRegistry.resolve(format).parse(document.content);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            throw new Error(`Failed to parse runtime config as '${format}': ${message}`);
+        }
+        let config;
+        try {
+            config = this.validator.validate(parsed);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            throw new Error(`Runtime config validation failed: ${message}`);
+        }
+        const loadedProviders = await this.loadProviders(config.providers ?? [], document.reference);
+        const providers = [...this.baseProviders, ...loadedProviders];
+        const supportedAdapterOperationsRegistry = this.mergeSupportedAdapterOperationsRegistry([
+            ...providers.map((provider) => provider.supportedAdapterOperationsRegistry),
+        ]);
+        const catalog = this.catalogBuilder.build({
+            providers,
+            config,
+            supportedAdapterOperationsRegistry,
+        });
+        return { catalog, config };
+    }
+    async loadProviders(providerReferences, sourceReference) {
+        const uniqueSpecifiers = [...new Set(providerReferences)];
+        const loadedProviders = [];
+        for (const specifier of uniqueSpecifiers) {
+            try {
+                loadedProviders.push(await this.providerLoader.load({
+                    specifier,
+                    sourceReference,
+                }));
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                throw new Error(`Failed to load runtime provider '${specifier}': ${message}`);
+            }
+        }
+        return loadedProviders;
+    }
+    mergeSupportedAdapterOperationsRegistry(registries) {
+        const merged = registries.reduce((acc, registry) => {
+            if (!registry) {
+                return acc;
+            }
+            return {
+                // biome-ignore lint/performance/noAccumulatingSpread: <explanation>
+                ...acc,
+                ...registry,
+            };
+        }, {});
+        return Object.keys(merged).length > 0 ? merged : undefined;
+    }
+}
+exports.RuntimeConfigLoader = RuntimeConfigLoader;

package/dist/cjs/Runtime/RuntimeConfigLoader.test.d.ts

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

package/dist/cjs/Runtime/RuntimeConfigLoader.test.js

@@ -0,0 +1,345 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const promises_1 = require("node:fs/promises");
+const node_os_1 = require("node:os");
+const node_path_1 = require("node:path");
+const DotAdapter_js_1 = require("../Graph/Adapters/DotAdapter.js");
+const Profile_js_1 = require("../Graph/Profile.js");
+const ProfileRegistry_js_1 = require("../Graph/ProfileRegistry.js");
+const NamedRuleRegistry_js_1 = require("../Graph/Rules/NamedRuleRegistry.js");
+const NamedRuleSetRegistry_js_1 = require("../Graph/Rules/NamedRuleSetRegistry.js");
+const RemoveNode_js_1 = require("../Graph/Rules/Node/RemoveNode.js");
+const RuntimeConfigLoader_js_1 = require("./RuntimeConfigLoader.js");
+const RuntimeConfigParserRegistry_js_1 = require("./RuntimeConfigParserRegistry.js");
+const FileRuntimeConfigSource_js_1 = require("./RuntimeConfigSource/FileRuntimeConfigSource.js");
+const InMemoryRuntimeConfigSource_js_1 = require("./RuntimeConfigSource/InMemoryRuntimeConfigSource.js");
+describe('RuntimeConfigParserRegistry.resolve', () => {
+    it('shoud resolve default json and yaml parsers', () => {
+        const registry = RuntimeConfigParserRegistry_js_1.RuntimeConfigParserRegistry.defaults();
+        expect(registry.resolve('json').parse('{"a":1}')).toEqual({ a: 1 });
+        expect(registry.resolve('yaml').parse('value: ok')).toEqual({
+            value: 'ok',
+        });
+    });
+    it('shoud throw when no parser is registered for a format', () => {
+        const registry = RuntimeConfigParserRegistry_js_1.RuntimeConfigParserRegistry.defaults();
+        expect(() => registry.resolve('toml')).toThrow("No RuntimeConfigParser registered for format 'toml'");
+    });
+});
+describe('FileRuntimeConfigSource.read', () => {
+    it('shoud read file contents and infer format from file extension', async () => {
+        const dir = await (0, promises_1.mkdtemp)((0, node_path_1.join)((0, node_os_1.tmpdir)(), 'runtime-config-loader-'));
+        const filePath = (0, node_path_1.join)(dir, 'runtime.json');
+        await (0, promises_1.writeFile)(filePath, '{"profiles":{}}', 'utf8');
+        try {
+            const source = new FileRuntimeConfigSource_js_1.FileRuntimeConfigSource(filePath);
+            const doc = await source.read();
+            expect(doc.content).toBe('{"profiles":{}}');
+            expect(doc.format).toBe('json');
+            expect(doc.reference).toBe(filePath);
+        }
+        finally {
+            await (0, promises_1.rm)(dir, { recursive: true, force: true });
+        }
+    });
+});
+describe('RuntimeConfigLoader.load', () => {
+    it('shoud load a runtime catalog from in-memory json config', async () => {
+        const source = new InMemoryRuntimeConfigSource_js_1.InMemoryRuntimeConfigSource(JSON.stringify({
+            namedRules: {
+                removeAlways: {
+                    id: RemoveNode_js_1.RemoveNode.name,
+                    config: { node: { any: true } },
+                },
+            },
+            profiles: {
+                profile: {
+                    phases: [{ phase: 'main', rules: [{ namedRule: 'removeAlways' }] }],
+                },
+            },
+        }));
+        const loader = new RuntimeConfigLoader_js_1.RuntimeConfigLoader();
+        const loaded = await loader.load({ source });
+        const phases = loaded.catalog.resolveProfilePhases('profile');
+        expect(phases).toHaveLength(1);
+        expect(phases[0]).toHaveLength(1);
+        expect(phases[0][0].serialize()).toEqual({
+            id: 'RemoveNode',
+            config: { node: { any: true } },
+        });
+    });
+    it('shoud load a runtime catalog from in-memory yaml config', async () => {
+        const source = new InMemoryRuntimeConfigSource_js_1.InMemoryRuntimeConfigSource(`
+namedRules:
+  removeAlways:
+    id: RemoveNode
+    config:
+      node:
+        any: true
+profiles:
+  profile:
+    phases:
+      - phase: main
+        rules:
+          - namedRule: removeAlways
+`, 'yaml');
+        const loader = new RuntimeConfigLoader_js_1.RuntimeConfigLoader();
+        const loaded = await loader.load({ source });
+        const phases = loaded.catalog.resolveProfilePhases('profile');
+        expect(phases).toHaveLength(1);
+        expect(phases[0]).toHaveLength(1);
+        expect(phases[0][0].serialize()).toEqual({
+            id: 'RemoveNode',
+            config: { node: { any: true } },
+        });
+    });
+    it('shoud fail when runtime config schema validation fails', async () => {
+        const source = new InMemoryRuntimeConfigSource_js_1.InMemoryRuntimeConfigSource(JSON.stringify({
+            profiles: {
+                profile: {
+                    phases: [{ phase: 'invalid_phase', rules: [] }],
+                },
+            },
+        }));
+        const loader = new RuntimeConfigLoader_js_1.RuntimeConfigLoader();
+        await expect(loader.load({ source })).rejects.toThrow(/Runtime config validation failed:/);
+    });
+    it('shoud support custom parsers via dependency injection', async () => {
+        class FakeYamlParser {
+            supports(format) {
+                return format === 'yaml';
+            }
+            parse(_content) {
+                return {
+                    namedRules: {
+                        removeAlways: {
+                            id: RemoveNode_js_1.RemoveNode.name,
+                            config: { node: { any: true } },
+                        },
+                    },
+                    profiles: {
+                        profile: {
+                            phases: [
+                                { phase: 'main', rules: [{ namedRule: 'removeAlways' }] },
+                            ],
+                        },
+                    },
+                };
+            }
+        }
+        const parserRegistry = new RuntimeConfigParserRegistry_js_1.RuntimeConfigParserRegistry([
+            new FakeYamlParser(),
+        ]);
+        const loader = new RuntimeConfigLoader_js_1.RuntimeConfigLoader({ parserRegistry });
+        const source = new InMemoryRuntimeConfigSource_js_1.InMemoryRuntimeConfigSource('profiles:\n  profile: {}', 'yaml');
+        const loaded = await loader.load({ source });
+        const phases = loaded.catalog.resolveProfilePhases('profile');
+        expect(phases).toHaveLength(1);
+        expect(phases[0]).toHaveLength(1);
+        expect(phases[0][0].serialize()).toEqual({
+            id: 'RemoveNode',
+            config: { node: { any: true } },
+        });
+    });
+    it('shoud infer the config format from the source reference', async () => {
+        class ReferencedSource {
+            async read() {
+                return {
+                    content: JSON.stringify({
+                        profiles: {
+                            profile: { phases: [] },
+                        },
+                    }),
+                    reference: '/tmp/runtime.json',
+                };
+            }
+        }
+        const loader = new RuntimeConfigLoader_js_1.RuntimeConfigLoader();
+        const loaded = await loader.load({ source: new ReferencedSource() });
+        expect(loaded.catalog.resolveProfilePhases('profile')).toEqual([]);
+    });
+    it('shoud fail when source format is unknown', async () => {
+        const source = new InMemoryRuntimeConfigSource_js_1.InMemoryRuntimeConfigSource('{}', 'custom');
+        const loader = new RuntimeConfigLoader_js_1.RuntimeConfigLoader();
+        await expect(loader.load({ source })).rejects.toThrow("Failed to parse runtime config as 'custom': No RuntimeConfigParser registered for format 'custom'");
+    });
+    it('shoud fail when runtime config format cannot be inferred', async () => {
+        class UnknownFormatSource {
+            async read() {
+                return { content: '{}' };
+            }
+        }
+        const source = new UnknownFormatSource();
+        const loader = new RuntimeConfigLoader_js_1.RuntimeConfigLoader();
+        await expect(loader.load({ source })).rejects.toThrow('Unable to determine runtime config format');
+    });
+    it('shoud include the source reference when format inference fails', async () => {
+        class UnknownReferencedSource {
+            async read() {
+                return { content: '{}', reference: '/tmp/runtime.unknown' };
+            }
+        }
+        const loader = new RuntimeConfigLoader_js_1.RuntimeConfigLoader();
+        await expect(loader.load({ source: new UnknownReferencedSource() })).rejects.toThrow("Unable to determine runtime config format from '/tmp/runtime.unknown'");
+    });
+    it('shoud surface non-error parser failures', async () => {
+        class ThrowingParser {
+            supports(format) {
+                return format === 'json';
+            }
+            parse(_content) {
+                throw 'parser-failed';
+            }
+        }
+        const parserRegistry = new RuntimeConfigParserRegistry_js_1.RuntimeConfigParserRegistry([
+            new ThrowingParser(),
+        ]);
+        const loader = new RuntimeConfigLoader_js_1.RuntimeConfigLoader({ parserRegistry });
+        const source = new InMemoryRuntimeConfigSource_js_1.InMemoryRuntimeConfigSource('{}', 'json');
+        await expect(loader.load({ source })).rejects.toThrow("Failed to parse runtime config as 'json': parser-failed");
+    });
+    it('shoud surface non-error validation failures', async () => {
+        const validator = {
+            validate(_input) {
+                throw 'validation-failed';
+            },
+        };
+        const loader = new RuntimeConfigLoader_js_1.RuntimeConfigLoader({ validator });
+        const source = new InMemoryRuntimeConfigSource_js_1.InMemoryRuntimeConfigSource('{}', 'json');
+        await expect(loader.load({ source })).rejects.toThrow('Runtime config validation failed: validation-failed');
+    });
+    it('shoud surface non-error provider load failures', async () => {
+        class ThrowingProviderLoader {
+            async load(_input) {
+                throw 'provider-failed';
+            }
+        }
+        const loader = new RuntimeConfigLoader_js_1.RuntimeConfigLoader({
+            providerLoader: new ThrowingProviderLoader(),
+        });
+        const source = new InMemoryRuntimeConfigSource_js_1.InMemoryRuntimeConfigSource(JSON.stringify({
+            providers: ['@example/runtime-provider'],
+            profiles: {
+                profile: {
+                    phases: [],
+                },
+            },
+        }), 'json');
+        await expect(loader.load({ source })).rejects.toThrow("Failed to load runtime provider '@example/runtime-provider': provider-failed");
+    });
+    it('shoud return validated config alongside catalog with load', async () => {
+        const source = new InMemoryRuntimeConfigSource_js_1.InMemoryRuntimeConfigSource(JSON.stringify({
+            profiles: {
+                profile: {
+                    phases: [],
+                },
+            },
+            run: {
+                profile: 'profile',
+            },
+        }));
+        const loader = new RuntimeConfigLoader_js_1.RuntimeConfigLoader();
+        const loaded = await loader.load({ source });
+        expect(loaded.config.run?.profile).toBe('profile');
+        expect(loaded.catalog.resolveProfilePhases('profile')).toEqual([]);
+    });
+    it('shoud load runtime providers declared in config and merge adapter support registries', async () => {
+        class FakeRuntimeProviderLoader {
+            async load(_input) {
+                return {
+                    supportedAdapterOperationsRegistry: {
+                        ExternalDotAdapter: DotAdapter_js_1.DotAdapter,
+                    },
+                };
+            }
+        }
+        const source = new InMemoryRuntimeConfigSource_js_1.InMemoryRuntimeConfigSource(JSON.stringify({
+            providers: ['@example/runtime-provider'],
+            profiles: {
+                profile: {
+                    supports: 'ExternalDotAdapter',
+                    phases: [],
+                },
+            },
+        }), 'json', '/tmp/runtime.json');
+        const loader = new RuntimeConfigLoader_js_1.RuntimeConfigLoader({
+            providerLoader: new FakeRuntimeProviderLoader(),
+        });
+        const loaded = await loader.load({ source });
+        const profile = loaded.catalog.resolveProfile('profile');
+        expect(profile.supports).toBe(DotAdapter_js_1.DotAdapter);
+    });
+    it('shoud merge base provider adapter support registries configured on the loader', async () => {
+        const source = new InMemoryRuntimeConfigSource_js_1.InMemoryRuntimeConfigSource(JSON.stringify({
+            profiles: {
+                profile: {
+                    supports: 'ExternalDotAdapter',
+                    phases: [],
+                },
+            },
+        }), 'json', '/tmp/runtime.json');
+        const loader = new RuntimeConfigLoader_js_1.RuntimeConfigLoader({
+            baseProviders: [
+                {
+                    supportedAdapterOperationsRegistry: {
+                        ExternalDotAdapter: DotAdapter_js_1.DotAdapter,
+                    },
+                },
+            ],
+        });
+        const loaded = await loader.load({ source });
+        const profile = loaded.catalog.resolveProfile('profile');
+        expect(profile.supports).toBe(DotAdapter_js_1.DotAdapter);
+    });
+    it('shoud merge provider catalog contributions declared in config', async () => {
+        class FakeRuntimeProviderLoader {
+            async load(_input) {
+                return {
+                    namedRules: new NamedRuleRegistry_js_1.NamedRuleRegistry({
+                        removeAlways: new RemoveNode_js_1.RemoveNode({
+                            node: { any: true },
+                        }),
+                    }),
+                    namedRuleSets: new NamedRuleSetRegistry_js_1.NamedRuleSetRegistry({
+                        wrapper: {
+                            rules: [{ namedRule: 'removeAlways' }],
+                        },
+                    }),
+                    profiles: new ProfileRegistry_js_1.ProfileRegistry({
+                        'provider.profile': new Profile_js_1.Profile('provider.profile', {
+                            phases: [{ phase: 'main', rules: [{ namedRuleSet: 'wrapper' }] }],
+                        }),
+                    }),
+                };
+            }
+        }
+        const source = new InMemoryRuntimeConfigSource_js_1.InMemoryRuntimeConfigSource(JSON.stringify({
+            providers: ['@example/runtime-provider'],
+        }), 'json', '/tmp/runtime.json');
+        const loader = new RuntimeConfigLoader_js_1.RuntimeConfigLoader({
+            providerLoader: new FakeRuntimeProviderLoader(),
+        });
+        const loaded = await loader.load({ source });
+        const phases = loaded.catalog.resolveProfilePhases('provider.profile');
+        expect(phases).toHaveLength(1);
+        expect(phases[0]).toHaveLength(1);
+        expect(phases[0][0].serialize()).toEqual({
+            id: 'RemoveNode',
+            config: { node: { any: true } },
+        });
+    });
+    it('shoud throw a contextual error when loading a runtime provider fails', async () => {
+        class ThrowingRuntimeProviderLoader {
+            async load(_input) {
+                throw new Error('boom');
+            }
+        }
+        const source = new InMemoryRuntimeConfigSource_js_1.InMemoryRuntimeConfigSource(JSON.stringify({
+            providers: ['@example/broken-provider'],
+        }), 'json', '/tmp/runtime.json');
+        const loader = new RuntimeConfigLoader_js_1.RuntimeConfigLoader({
+            providerLoader: new ThrowingRuntimeProviderLoader(),
+        });
+        await expect(loader.load({ source })).rejects.toThrow("Failed to load runtime provider '@example/broken-provider': boom");
+    });
+});

package/dist/cjs/Runtime/RuntimeConfigParser/JsonRuntimeConfigParser.d.ts

@@ -0,0 +1,5 @@
+import { RuntimeConfigParser } from '../RuntimeConfigParser.js';
+export declare class JsonRuntimeConfigParser implements RuntimeConfigParser {
+    supports(format: string): boolean;
+    parse(content: string): unknown;
+}

package/dist/cjs/Runtime/RuntimeConfigParser/JsonRuntimeConfigParser.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JsonRuntimeConfigParser = void 0;
+const RuntimeConfigParser_js_1 = require("../RuntimeConfigParser.js");
+class JsonRuntimeConfigParser {
+    supports(format) {
+        const normalized = (0, RuntimeConfigParser_js_1.normalizeRuntimeConfigParserFormat)(format);
+        return (normalized === 'json' ||
+            normalized === '.json' ||
+            normalized === 'application/json');
+    }
+    parse(content) {
+        return JSON.parse(content);
+    }
+}
+exports.JsonRuntimeConfigParser = JsonRuntimeConfigParser;

package/dist/cjs/Runtime/RuntimeConfigParser/JsonRuntimeConfigParser.test.d.ts

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

package/dist/cjs/Runtime/RuntimeConfigParser/JsonRuntimeConfigParser.test.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const JsonRuntimeConfigParser_js_1 = require("./JsonRuntimeConfigParser.js");
+describe('JsonRuntimeConfigParser.supports', () => {
+    it('shoud support json aliases', () => {
+        const parser = new JsonRuntimeConfigParser_js_1.JsonRuntimeConfigParser();
+        expect(parser.supports('json')).toBe(true);
+        expect(parser.supports('.json')).toBe(true);
+        expect(parser.supports('application/json')).toBe(true);
+        expect(parser.supports('yaml')).toBe(false);
+    });
+});
+describe('JsonRuntimeConfigParser.parse', () => {
+    it('shoud parse json content into an object', () => {
+        const parser = new JsonRuntimeConfigParser_js_1.JsonRuntimeConfigParser();
+        expect(parser.parse('{"value":1}')).toEqual({ value: 1 });
+    });
+    it('shoud throw when json is invalid', () => {
+        const parser = new JsonRuntimeConfigParser_js_1.JsonRuntimeConfigParser();
+        expect(() => parser.parse('{invalid-json')).toThrow();
+    });
+});

package/dist/cjs/Runtime/RuntimeConfigParser/YamlRuntimeConfigParser.d.ts

@@ -0,0 +1,5 @@
+import { RuntimeConfigParser } from '../RuntimeConfigParser.js';
+export declare class YamlRuntimeConfigParser implements RuntimeConfigParser {
+    supports(format: string): boolean;
+    parse(content: string): unknown;
+}

package/dist/cjs/Runtime/RuntimeConfigParser/YamlRuntimeConfigParser.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.YamlRuntimeConfigParser = void 0;
+const yaml_1 = require("yaml");
+const RuntimeConfigParser_js_1 = require("../RuntimeConfigParser.js");
+class YamlRuntimeConfigParser {
+    supports(format) {
+        const normalized = (0, RuntimeConfigParser_js_1.normalizeRuntimeConfigParserFormat)(format);
+        return (normalized === 'yaml' ||
+            normalized === '.yaml' ||
+            normalized === '.yml' ||
+            normalized === 'application/yaml' ||
+            normalized === 'application/x-yaml' ||
+            normalized === 'text/yaml');
+    }
+    parse(content) {
+        return (0, yaml_1.parse)(content);
+    }
+}
+exports.YamlRuntimeConfigParser = YamlRuntimeConfigParser;

package/dist/cjs/Runtime/RuntimeConfigParser/YamlRuntimeConfigParser.test.d.ts

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

package/dist/cjs/Runtime/RuntimeConfigParser/YamlRuntimeConfigParser.test.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const YamlRuntimeConfigParser_js_1 = require("./YamlRuntimeConfigParser.js");
+describe('YamlRuntimeConfigParser.supports', () => {
+    it('shoud support yaml aliases and mime types', () => {
+        const parser = new YamlRuntimeConfigParser_js_1.YamlRuntimeConfigParser();
+        expect(parser.supports('yaml')).toBe(true);
+        expect(parser.supports('.yaml')).toBe(true);
+        expect(parser.supports('.yml')).toBe(true);
+        expect(parser.supports('application/yaml')).toBe(true);
+        expect(parser.supports('application/x-yaml')).toBe(true);
+        expect(parser.supports('text/yaml')).toBe(true);
+        expect(parser.supports('json')).toBe(false);
+    });
+});
+describe('YamlRuntimeConfigParser.parse', () => {
+    it('shoud parse yaml documents into objects', () => {
+        const parser = new YamlRuntimeConfigParser_js_1.YamlRuntimeConfigParser();
+        expect(parser.parse('profiles:\n  test:\n    phases: []')).toEqual({
+            profiles: {
+                test: {
+                    phases: [],
+                },
+            },
+        });
+    });
+    it('shoud throw when yaml is invalid', () => {
+        const parser = new YamlRuntimeConfigParser_js_1.YamlRuntimeConfigParser();
+        expect(() => parser.parse('profiles: [')).toThrow();
+    });
+});

package/dist/cjs/Runtime/RuntimeConfigParser/index.d.ts

@@ -0,0 +1,2 @@
+export * from './JsonRuntimeConfigParser.js';
+export * from './YamlRuntimeConfigParser.js';

package/dist/cjs/Runtime/RuntimeConfigParser/index.js

@@ -0,0 +1,18 @@
+"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("./JsonRuntimeConfigParser.js"), exports);
+__exportStar(require("./YamlRuntimeConfigParser.js"), exports);

package/dist/cjs/Runtime/RuntimeConfigParser.d.ts

@@ -0,0 +1,5 @@
+export interface RuntimeConfigParser {
+    supports(format: string): boolean;
+    parse(content: string): unknown;
+}
+export declare const normalizeRuntimeConfigParserFormat: (format: string) => string;

package/dist/cjs/Runtime/RuntimeConfigParser.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeRuntimeConfigParserFormat = void 0;
+const RuntimeConfigSource_js_1 = require("./RuntimeConfigSource.js");
+const normalizeRuntimeConfigParserFormat = (format) => (0, RuntimeConfigSource_js_1.normalizeRuntimeConfigFormat)(format);
+exports.normalizeRuntimeConfigParserFormat = normalizeRuntimeConfigParserFormat;

package/dist/cjs/Runtime/RuntimeConfigParser.test.d.ts

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

package/dist/cjs/Runtime/RuntimeConfigParser.test.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const RuntimeConfigParser_js_1 = require("./RuntimeConfigParser.js");
+describe('RuntimeConfigParser.normalizeRuntimeConfigParserFormat', () => {
+    it('shoud normalize parser format values by trimming and lowering case', () => {
+        expect((0, RuntimeConfigParser_js_1.normalizeRuntimeConfigParserFormat)('  APPLICATION/JSON  ')).toBe('application/json');
+    });
+});

package/dist/cjs/Runtime/RuntimeConfigParserRegistry.d.ts

@@ -0,0 +1,9 @@
+import { RuntimeConfigParser } from './RuntimeConfigParser.js';
+export declare class RuntimeConfigParserRegistry {
+    private readonly parsers;
+    constructor(parsers?: RuntimeConfigParser[]);
+    static defaults(): RuntimeConfigParserRegistry;
+    register(parser: RuntimeConfigParser): RuntimeConfigParserRegistry;
+    use(registry: RuntimeConfigParserRegistry): RuntimeConfigParserRegistry;
+    resolve(format: string): RuntimeConfigParser;
+}

package/dist/cjs/Runtime/RuntimeConfigParserRegistry.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RuntimeConfigParserRegistry = void 0;
+const RuntimeConfigParser_js_1 = require("./RuntimeConfigParser.js");
+const JsonRuntimeConfigParser_js_1 = require("./RuntimeConfigParser/JsonRuntimeConfigParser.js");
+const YamlRuntimeConfigParser_js_1 = require("./RuntimeConfigParser/YamlRuntimeConfigParser.js");
+class RuntimeConfigParserRegistry {
+    parsers;
+    constructor(parsers = []) {
+        this.parsers = Object.freeze([...parsers]);
+    }
+    static defaults() {
+        return new RuntimeConfigParserRegistry([
+            new JsonRuntimeConfigParser_js_1.JsonRuntimeConfigParser(),
+            new YamlRuntimeConfigParser_js_1.YamlRuntimeConfigParser(),
+        ]);
+    }
+    register(parser) {
+        return new RuntimeConfigParserRegistry([...this.parsers, parser]);
+    }
+    use(registry) {
+        return new RuntimeConfigParserRegistry([
+            ...this.parsers,
+            ...registry.parsers,
+        ]);
+    }
+    resolve(format) {
+        const normalized = (0, RuntimeConfigParser_js_1.normalizeRuntimeConfigParserFormat)(format);
+        const parser = this.parsers.find((candidate) => candidate.supports(normalized));
+        if (!parser) {
+            throw new Error(`No RuntimeConfigParser registered for format '${format}'`);
+        }
+        return parser;
+    }
+}
+exports.RuntimeConfigParserRegistry = RuntimeConfigParserRegistry;

package/dist/cjs/Runtime/RuntimeConfigParserRegistry.test.d.ts

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