@ontrails/config 1.0.0-beta.15 → 1.0.0-beta.17

package/src/__tests__/app-config.test.ts

@@ -1,342 +0,0 @@
-import { describe, expect, test, beforeEach, afterEach } from 'bun:test';
-import { mkdir, mkdtemp, rm } from 'node:fs/promises';
-import { join } from 'node:path';
-import { tmpdir } from 'node:os';
-import { z } from 'zod';
-
-import type { AppConfig } from '../app-config.js';
-import { appConfig } from '../app-config.js';
-import { deriveConfigFields } from '../derive-fields.js';
-import { checkConfig } from '../doctor.js';
-import { configRef } from '../ref.js';
-
-const testSchema = z.object({
-  output: z.string().describe('Output directory').default('./output'),
-  verbose: z.boolean().default(false),
-});
-
-const createJsonConfig = () =>
-  appConfig('myapp', {
-    formats: ['json'],
-    schema: testSchema,
-  });
-
-const writeJsonConfig = (filePath: string, output: string) =>
-  Bun.write(filePath, JSON.stringify({ output }));
-
-const resolveOutput = async (
-  config: AppConfig<typeof testSchema>,
-  filePath: string
-): Promise<string> => {
-  const result = await config.resolve({ path: filePath });
-  expect(result.isOk()).toBe(true);
-  return result.unwrap().output;
-};
-
-describe('appConfig()', () => {
-  describe('creation', () => {
-    test('returns an object with the provided name', () => {
-      const config = appConfig('myapp', { schema: testSchema });
-      expect(config.name).toBe('myapp');
-    });
-
-    test('returns the provided schema', () => {
-      const config = appConfig('myapp', { schema: testSchema });
-      expect(config.schema).toBe(testSchema);
-    });
-
-    test('defaults formats to toml, json, jsonc, yaml when not specified', () => {
-      const config = appConfig('myapp', { schema: testSchema });
-      expect(config.formats).toEqual(['toml', 'json', 'jsonc', 'yaml']);
-    });
-
-    test('uses provided formats', () => {
-      const config = appConfig('myapp', {
-        formats: ['json', 'jsonc'],
-        schema: testSchema,
-      });
-      expect(config.formats).toEqual(['json', 'jsonc']);
-    });
-
-    test('defaults dotfile to false when not specified', () => {
-      const config = appConfig('myapp', { schema: testSchema });
-      expect(config.dotfile).toBe(false);
-    });
-
-    test('uses provided dotfile value', () => {
-      const config = appConfig('myapp', {
-        dotfile: true,
-        schema: testSchema,
-      });
-      expect(config.dotfile).toBe(true);
-    });
-  });
-
-  describe('resolve() with explicit path', () => {
-    let tempDir: string;
-
-    beforeEach(async () => {
-      tempDir = await mkdtemp(join(tmpdir(), 'trails-config-'));
-    });
-
-    afterEach(async () => {
-      await rm(tempDir, { force: true, recursive: true });
-    });
-
-    test('reads and validates a JSON config file', async () => {
-      const filePath = join(tempDir, 'myapp.config.json');
-      await Bun.write(
-        filePath,
-        JSON.stringify({ output: './dist', verbose: true })
-      );
-
-      const config = createJsonConfig();
-      const result = await config.resolve({ path: filePath });
-
-      expect(result.isOk()).toBe(true);
-      expect(result.unwrap()).toEqual({ output: './dist', verbose: true });
-    });
-
-    test('reads and validates a TOML config file', async () => {
-      const filePath = join(tempDir, 'myapp.config.toml');
-      await Bun.write(filePath, 'output = "./build"\nverbose = true\n');
-
-      const config = appConfig('myapp', {
-        formats: ['toml'],
-        schema: testSchema,
-      });
-      const result = await config.resolve({ path: filePath });
-
-      expect(result.isOk()).toBe(true);
-      expect(result.unwrap()).toEqual({ output: './build', verbose: true });
-    });
-
-    test('applies schema defaults for missing fields', async () => {
-      const filePath = join(tempDir, 'myapp.config.json');
-      await Bun.write(filePath, JSON.stringify({}));
-
-      const config = createJsonConfig();
-      const result = await config.resolve({ path: filePath });
-
-      expect(result.isOk()).toBe(true);
-      expect(result.unwrap()).toEqual({ output: './output', verbose: false });
-    });
-
-    test('re-reads config files after they change on disk', async () => {
-      const filePath = join(tempDir, 'myapp.config.json');
-      await writeJsonConfig(filePath, './first');
-
-      const config = createJsonConfig();
-
-      expect(await resolveOutput(config, filePath)).toBe('./first');
-
-      await Bun.sleep(10);
-      await writeJsonConfig(filePath, './second');
-
-      expect(await resolveOutput(config, filePath)).toBe('./second');
-    });
-
-    test('returns Result.err when file does not exist', async () => {
-      const filePath = join(tempDir, 'nonexistent.json');
-
-      const config = createJsonConfig();
-      const result = await config.resolve({ path: filePath });
-
-      expect(result.isErr()).toBe(true);
-    });
-
-    test('returns Result.err when file has invalid content', async () => {
-      const filePath = join(tempDir, 'myapp.config.json');
-      await Bun.write(
-        filePath,
-        JSON.stringify({ output: 42, verbose: 'not-a-bool' })
-      );
-
-      const config = createJsonConfig();
-      const result = await config.resolve({ path: filePath });
-
-      expect(result.isErr()).toBe(true);
-    });
-  });
-
-  describe('resolve() with discovery', () => {
-    let tempDir: string;
-
-    beforeEach(async () => {
-      tempDir = await mkdtemp(join(tmpdir(), 'trails-config-'));
-    });
-
-    afterEach(async () => {
-      await rm(tempDir, { force: true, recursive: true });
-    });
-
-    test('discovers config file in cwd', async () => {
-      const filePath = join(tempDir, 'myapp.config.json');
-      await writeJsonConfig(filePath, './found');
-
-      const config = createJsonConfig();
-      const result = await config.resolve({ cwd: tempDir });
-
-      expect(result.isOk()).toBe(true);
-      expect(result.unwrap().output).toBe('./found');
-    });
-
-    test('discovers config file by walking up directories', async () => {
-      const nested = join(tempDir, 'a', 'b', 'c');
-      await mkdir(nested, { recursive: true });
-
-      const filePath = join(tempDir, 'myapp.config.json');
-      await Bun.write(filePath, JSON.stringify({ output: './parent' }));
-
-      const config = appConfig('myapp', {
-        formats: ['json'],
-        schema: testSchema,
-      });
-      const result = await config.resolve({ cwd: nested });
-
-      expect(result.isOk()).toBe(true);
-      expect(result.unwrap().output).toBe('./parent');
-    });
-
-    test('tries formats in order', async () => {
-      await Bun.write(
-        join(tempDir, 'myapp.config.toml'),
-        'output = "./from-toml"\n'
-      );
-      await Bun.write(
-        join(tempDir, 'myapp.config.json'),
-        JSON.stringify({ output: './from-json' })
-      );
-
-      const config = appConfig('myapp', {
-        formats: ['toml', 'json'],
-        schema: testSchema,
-      });
-      const result = await config.resolve({ cwd: tempDir });
-
-      expect(result.isOk()).toBe(true);
-      expect(result.unwrap().output).toBe('./from-toml');
-    });
-
-    test('includes jsonc in the default discovery set', async () => {
-      await Bun.write(
-        join(tempDir, 'myapp.config.jsonc'),
-        '{\n  // comment\n  "output": "./from-jsonc"\n}\n'
-      );
-
-      const config = appConfig('myapp', { schema: testSchema });
-      const result = await config.resolve({ cwd: tempDir });
-
-      expect(result.isOk()).toBe(true);
-      expect(result.unwrap().output).toBe('./from-jsonc');
-    });
-
-    test('returns Result.err when no config file found', async () => {
-      const config = appConfig('myapp', { schema: testSchema });
-      const result = await config.resolve({ cwd: tempDir });
-
-      expect(result.isErr()).toBe(true);
-    });
-  });
-
-  describe('file naming conventions', () => {
-    let tempDir: string;
-
-    beforeEach(async () => {
-      tempDir = await mkdtemp(join(tmpdir(), 'trails-config-'));
-    });
-
-    afterEach(async () => {
-      await rm(tempDir, { force: true, recursive: true });
-    });
-
-    test('dotfile: true searches for .myapprc.* files', async () => {
-      await Bun.write(
-        join(tempDir, '.myapprc.json'),
-        JSON.stringify({ output: './dotfile' })
-      );
-
-      const config = appConfig('myapp', {
-        dotfile: true,
-        formats: ['json'],
-        schema: testSchema,
-      });
-      const result = await config.resolve({ cwd: tempDir });
-
-      expect(result.isOk()).toBe(true);
-      expect(result.unwrap().output).toBe('./dotfile');
-    });
-
-    test('dotfile: false searches for myapp.config.* files', async () => {
-      await Bun.write(
-        join(tempDir, 'myapp.config.json'),
-        JSON.stringify({ output: './standard' })
-      );
-
-      const config = appConfig('myapp', {
-        dotfile: false,
-        formats: ['json'],
-        schema: testSchema,
-      });
-      const result = await config.resolve({ cwd: tempDir });
-
-      expect(result.isOk()).toBe(true);
-      expect(result.unwrap().output).toBe('./standard');
-    });
-
-    test('dotfile: true does NOT find myapp.config.* files', async () => {
-      await Bun.write(
-        join(tempDir, 'myapp.config.json'),
-        JSON.stringify({ output: './nope' })
-      );
-
-      const config = appConfig('myapp', {
-        dotfile: true,
-        formats: ['json'],
-        schema: testSchema,
-      });
-      const result = await config.resolve({ cwd: tempDir });
-
-      expect(result.isErr()).toBe(true);
-    });
-  });
-
-  describe('method delegations', () => {
-    test('describe() returns same result as deriveConfigFields(schema)', () => {
-      const config = appConfig('myapp', { schema: testSchema });
-      const methodResult = config.describe();
-      const standaloneResult = deriveConfigFields(testSchema);
-
-      expect(methodResult).toEqual(standaloneResult);
-    });
-
-    test('check() returns same result as checkConfig(schema, values)', () => {
-      const config = appConfig('myapp', { schema: testSchema });
-      const values = { output: './dist', verbose: true };
-
-      const methodResult = config.check(values);
-      const standaloneResult = checkConfig(testSchema, values);
-
-      expect(methodResult).toEqual(standaloneResult);
-    });
-
-    test('ref() returns same result as configRef(path)', () => {
-      const config = appConfig('myapp', { schema: testSchema });
-      const methodResult = config.ref('output');
-      const standaloneResult = configRef('output');
-
-      expect(methodResult).toEqual(standaloneResult);
-    });
-
-    test('explain() delegates to deriveConfigProvenance with bound schema', () => {
-      const config = appConfig('myapp', { schema: testSchema });
-      const resolved = { output: './dist', verbose: true };
-
-      const result = config.explain({ resolved });
-
-      expect(result.length).toBeGreaterThan(0);
-      expect(result[0]?.path).toBeDefined();
-      expect(result[0]?.source).toBeDefined();
-    });
-  });
-});

package/src/__tests__/compose.test.ts

@@ -1,59 +0,0 @@
-import { describe, expect, test } from 'bun:test';
-
-import { z } from 'zod';
-
-import { collectResourceConfigs } from '../compose.js';
-
-// ---------------------------------------------------------------------------
-// Tests
-// ---------------------------------------------------------------------------
-
-describe('collectResourceConfigs', () => {
-  test('extracts config schemas from resources that declare them', () => {
-    const dbSchema = z.object({ url: z.string().url() });
-    const cacheSchema = z.object({ ttl: z.number() });
-
-    const resources = [
-      { config: dbSchema, id: 'db.main' },
-      { config: cacheSchema, id: 'cache.main' },
-    ];
-
-    const entries = collectResourceConfigs(resources);
-
-    expect(entries).toHaveLength(2);
-    expect(entries[0]).toEqual({ resourceId: 'db.main', schema: dbSchema });
-    expect(entries[1]).toEqual({
-      resourceId: 'cache.main',
-      schema: cacheSchema,
-    });
-  });
-
-  test('excludes resources without config', () => {
-    const schema = z.object({ url: z.string() });
-
-    const resources = [
-      { config: schema, id: 'db.main' },
-      { id: 'counter.main' },
-      { config: undefined, id: 'logger.main' },
-    ];
-
-    const entries = collectResourceConfigs(resources);
-
-    expect(entries).toHaveLength(1);
-    expect(entries[0]?.resourceId).toBe('db.main');
-  });
-
-  test('returns empty array when no resources have config', () => {
-    const resources = [{ id: 'counter.main' }, { id: 'logger.main' }];
-
-    const entries = collectResourceConfigs(resources);
-
-    expect(entries).toEqual([]);
-  });
-
-  test('returns empty array for empty input', () => {
-    const entries = collectResourceConfigs([]);
-
-    expect(entries).toEqual([]);
-  });
-});

package/src/__tests__/config-check.test.ts

@@ -1,171 +0,0 @@
-import { describe, expect, test } from 'bun:test';
-import { createResourceLookup } from '@ontrails/core';
-import type { TrailContext } from '@ontrails/core';
-import { z } from 'zod';
-
-import { configCheck } from '../trails/config-check.js';
-import type { ConfigState } from '../registry.js';
-
-/**
- * Build a TrailContext with configResource resolved in extensions.
- */
-const buildCtx = (state: ConfigState): TrailContext => {
-  const extensions = { config: state };
-  const ctx: TrailContext = {
-    abortSignal: AbortSignal.timeout(5000),
-    cwd: '/tmp',
-    env: {},
-    extensions,
-    requestId: 'test',
-    resource: undefined as unknown as TrailContext['resource'],
-    workspaceRoot: '/tmp',
-  };
-  const withLookup = {
-    ...ctx,
-    resource: createResourceLookup(() => withLookup),
-  };
-  return withLookup;
-};
-
-describe('config.check trail', () => {
-  describe('identity', () => {
-    test('has id "config.check"', () => {
-      expect(configCheck.id).toBe('config.check');
-    });
-
-    test('has kind "trail"', () => {
-      expect(configCheck.kind).toBe('trail');
-    });
-
-    test('has intent "read"', () => {
-      expect(configCheck.intent).toBe('read');
-    });
-
-    test('has infrastructure meta', () => {
-      expect(configCheck.meta).toEqual({ category: 'infrastructure' });
-    });
-
-    test('has output schema', () => {
-      expect(configCheck.output).toBeDefined();
-    });
-
-    test('declares configResource dependency', () => {
-      expect(configCheck.resources).toBeDefined();
-      expect(configCheck.resources?.length).toBe(1);
-    });
-  });
-
-  describe('examples', () => {
-    test('has at least one example', () => {
-      expect(configCheck.examples?.length).toBeGreaterThanOrEqual(1);
-    });
-  });
-
-  describe('wired behavior', () => {
-    test('reports valid when all required fields present', async () => {
-      const schema = z.object({
-        host: z.string().default('localhost'),
-        port: z.number().default(3000),
-      });
-      const state: ConfigState = {
-        resolved: { host: 'localhost', port: 3000 },
-        schema,
-      };
-      const ctx = buildCtx(state);
-      const result = await configCheck.blaze({ values: {} }, ctx);
-
-      expect(result.isOk()).toBe(true);
-      const value = result.unwrap();
-      expect(value.valid).toBe(true);
-      expect(value.diagnostics.length).toBeGreaterThan(0);
-    });
-
-    test('reports missing for required fields without values', async () => {
-      const schema = z.object({
-        host: z.string(),
-        port: z.number(),
-      });
-      const state: ConfigState = {
-        resolved: {},
-        schema,
-      };
-      const ctx = buildCtx(state);
-      const result = await configCheck.blaze({ values: {} }, ctx);
-
-      expect(result.isOk()).toBe(true);
-      const value = result.unwrap();
-      expect(value.valid).toBe(false);
-      const missing = value.diagnostics.filter((d) => d.status === 'missing');
-      expect(missing.length).toBe(2);
-    });
-
-    test('uses input values when provided to override resolved', async () => {
-      const schema = z.object({
-        port: z.number(),
-      });
-      const state: ConfigState = {
-        resolved: {},
-        schema,
-      };
-      const ctx = buildCtx(state);
-      const result = await configCheck.blaze({ values: { port: 8080 } }, ctx);
-
-      expect(result.isOk()).toBe(true);
-      const value = result.unwrap();
-      expect(value.valid).toBe(true);
-      expect(value.diagnostics.length).toBe(1);
-      expect(value.diagnostics[0]?.status).toBe('valid');
-    });
-
-    test('deep merges nested input overrides with resolved values', async () => {
-      const schema = z.object({
-        db: z.object({
-          host: z.string(),
-          port: z.number(),
-        }),
-      });
-      const state: ConfigState = {
-        resolved: { db: { host: 'localhost', port: 5432 } },
-        schema,
-      };
-      const ctx = buildCtx(state);
-      const result = await configCheck.blaze(
-        { values: { db: { port: 6543 } } },
-        ctx
-      );
-
-      expect(result.isOk()).toBe(true);
-      expect(result.unwrap().valid).toBe(true);
-      expect(result.unwrap().diagnostics).toEqual([
-        expect.objectContaining({
-          path: 'db.host',
-          status: 'valid',
-          value: 'localhost',
-        }),
-        expect.objectContaining({
-          path: 'db.port',
-          status: 'valid',
-          value: 6543,
-        }),
-      ]);
-    });
-
-    test('reports default status for fields using defaults', async () => {
-      const schema = z.object({
-        port: z.number().default(3000),
-      });
-      const state: ConfigState = {
-        resolved: {},
-        schema,
-      };
-      const ctx = buildCtx(state);
-      const result = await configCheck.blaze({ values: {} }, ctx);
-
-      expect(result.isOk()).toBe(true);
-      const defaults = result
-        .unwrap()
-        .diagnostics.filter((d) => d.status === 'default');
-      expect(defaults.length).toBe(1);
-    });
-  });
-});