@ontrails/config 1.0.0-beta.14 → 1.0.0-beta.16

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

@@ -1,154 +0,0 @@
-import { describe, expect, test } from 'bun:test';
-import { createProvisionLookup } from '@ontrails/core';
-import type { TrailContext } from '@ontrails/core';
-import { z } from 'zod';
-
-import { configDescribe } from '../trails/config-describe.js';
-import { env, secret } from '../extensions.js';
-import type { ConfigState } from '../registry.js';
-
-/**
- * Build a TrailContext with configProvision resolved in extensions.
- */
-const buildCtx = (state: ConfigState): TrailContext => {
-  const extensions = { config: state };
-  const ctx: TrailContext = {
-    abortSignal: AbortSignal.timeout(5000),
-    cwd: '/tmp',
-    env: {},
-    extensions,
-    provision: undefined as unknown as TrailContext['provision'],
-    requestId: 'test',
-    workspaceRoot: '/tmp',
-  };
-  const withLookup = {
-    ...ctx,
-    provision: createProvisionLookup(() => withLookup),
-  };
-  return withLookup;
-};
-
-describe('config.describe trail', () => {
-  describe('identity', () => {
-    test('has id "config.describe"', () => {
-      expect(configDescribe.id).toBe('config.describe');
-    });
-
-    test('has kind "trail"', () => {
-      expect(configDescribe.kind).toBe('trail');
-    });
-
-    test('has intent "read"', () => {
-      expect(configDescribe.intent).toBe('read');
-    });
-
-    test('has infrastructure meta', () => {
-      expect(configDescribe.meta).toEqual({ category: 'infrastructure' });
-    });
-
-    test('has output schema', () => {
-      expect(configDescribe.output).toBeDefined();
-    });
-
-    test('declares configProvision dependency', () => {
-      expect(configDescribe.provisions).toBeDefined();
-      expect(configDescribe.provisions?.length).toBe(1);
-    });
-  });
-
-  describe('examples', () => {
-    test('has at least one example', () => {
-      expect(configDescribe.examples?.length).toBeGreaterThanOrEqual(1);
-    });
-  });
-
-  describe('wired behavior', () => {
-    test('returns one field description per schema field', 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 configDescribe.blaze({}, ctx);
-
-      expect(result.isOk()).toBe(true);
-      expect(result.unwrap().fields.length).toBe(2);
-    });
-
-    test('includes path and type for each field', 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 configDescribe.blaze({}, ctx);
-      const { fields } = result.unwrap();
-
-      expect(fields[0]?.path).toBe('host');
-      expect(fields[0]?.type).toBe('string');
-      expect(fields[1]?.path).toBe('port');
-      expect(fields[1]?.type).toBe('number');
-    });
-
-    test('includes env annotation when present', async () => {
-      const schema = z.object({
-        port: env(z.number(), 'PORT').default(3000),
-      });
-      const state: ConfigState = {
-        resolved: { port: 3000 },
-        schema,
-      };
-      const ctx = buildCtx(state);
-      const result = await configDescribe.blaze({}, ctx);
-
-      expect(result.isOk()).toBe(true);
-      const [field] = result.unwrap().fields;
-      expect(field?.env).toBe('PORT');
-    });
-
-    test('includes secret annotation when present', async () => {
-      const schema = z.object({
-        token: secret(z.string()).default('tok'),
-      });
-      const state: ConfigState = {
-        resolved: { token: 'tok' },
-        schema,
-      };
-      const ctx = buildCtx(state);
-      const result = await configDescribe.blaze({}, ctx);
-
-      expect(result.isOk()).toBe(true);
-      const [field] = result.unwrap().fields;
-      expect(field?.secret).toBe(true);
-    });
-
-    test('reports required status correctly', async () => {
-      const schema = z.object({
-        optional: z.string().optional(),
-        required: z.string(),
-        withDefault: z.string().default('val'),
-      });
-      const state: ConfigState = {
-        resolved: { required: 'x', withDefault: 'val' },
-        schema,
-      };
-      const ctx = buildCtx(state);
-      const result = await configDescribe.blaze({}, ctx);
-
-      expect(result.isOk()).toBe(true);
-      const { fields } = result.unwrap();
-      const findField = (path: string) => fields.find((f) => f.path === path);
-      expect(findField('required')?.required).toBe(true);
-      expect(findField('optional')?.required).toBe(false);
-      expect(findField('withDefault')?.required).toBe(false);
-    });
-  });
-});

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

@@ -1,167 +0,0 @@
-import { describe, expect, test } from 'bun:test';
-import { createProvisionLookup } from '@ontrails/core';
-import type { TrailContext } from '@ontrails/core';
-import { z } from 'zod';
-
-import { configExplain } from '../trails/config-explain.js';
-import { env } from '../extensions.js';
-import type { ConfigState } from '../registry.js';
-
-/**
- * Build a TrailContext with configProvision resolved in extensions.
- */
-const buildCtx = (state: ConfigState): TrailContext => {
-  const extensions = { config: state };
-  const ctx: TrailContext = {
-    abortSignal: AbortSignal.timeout(5000),
-    cwd: '/tmp',
-    env: {},
-    extensions,
-    provision: undefined as unknown as TrailContext['provision'],
-    requestId: 'test',
-    workspaceRoot: '/tmp',
-  };
-  const withLookup = {
-    ...ctx,
-    provision: createProvisionLookup(() => withLookup),
-  };
-  return withLookup;
-};
-
-describe('config.explain trail', () => {
-  describe('identity', () => {
-    test('has id "config.explain"', () => {
-      expect(configExplain.id).toBe('config.explain');
-    });
-
-    test('has kind "trail"', () => {
-      expect(configExplain.kind).toBe('trail');
-    });
-
-    test('has intent "read"', () => {
-      expect(configExplain.intent).toBe('read');
-    });
-
-    test('has infrastructure meta', () => {
-      expect(configExplain.meta).toEqual({ category: 'infrastructure' });
-    });
-
-    test('has output schema', () => {
-      expect(configExplain.output).toBeDefined();
-    });
-
-    test('declares configProvision dependency', () => {
-      expect(configExplain.provisions).toBeDefined();
-      expect(configExplain.provisions?.length).toBe(1);
-    });
-  });
-
-  describe('examples', () => {
-    test('has at least one example', () => {
-      expect(configExplain.examples?.length).toBeGreaterThanOrEqual(1);
-    });
-  });
-
-  describe('wired behavior', () => {
-    test('returns provenance entries for all fields', 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 configExplain.blaze({ path: '' }, ctx);
-
-      expect(result.isOk()).toBe(true);
-      const value = result.unwrap();
-      expect(value.entries.length).toBe(2);
-      expect(value.entries[0]?.path).toBe('host');
-      expect(value.entries[0]?.source).toBe('default');
-      expect(value.entries[1]?.path).toBe('port');
-    });
-
-    test('filters entries by path prefix', async () => {
-      const schema = z.object({
-        db: z.object({
-          host: z.string().default('localhost'),
-          port: z.number().default(5432),
-        }),
-        name: z.string().default('app'),
-      });
-      const state: ConfigState = {
-        resolved: { db: { host: 'localhost', port: 5432 }, name: 'app' },
-        schema,
-      };
-      const ctx = buildCtx(state);
-      const result = await configExplain.blaze({ path: 'db' }, ctx);
-
-      expect(result.isOk()).toBe(true);
-      const value = result.unwrap();
-      expect(value.entries.length).toBe(2);
-      expect(value.entries[0]?.path).toBe('db.host');
-    });
-
-    test('does not match sibling roots that only share a prefix', async () => {
-      const schema = z.object({
-        db: z.object({
-          host: z.string().default('localhost'),
-        }),
-        dbReplica: z.object({
-          host: z.string().default('replica.local'),
-        }),
-      });
-      const state: ConfigState = {
-        resolved: {
-          db: { host: 'localhost' },
-          dbReplica: { host: 'replica.local' },
-        },
-        schema,
-      };
-      const ctx = buildCtx(state);
-      const result = await configExplain.blaze({ path: 'db' }, ctx);
-
-      expect(result.isOk()).toBe(true);
-      expect(result.unwrap().entries).toEqual([
-        expect.objectContaining({ path: 'db.host' }),
-      ]);
-    });
-
-    test('shows base layer as source when base provides value', async () => {
-      const schema = z.object({
-        port: z.number().default(3000),
-      });
-      const state: ConfigState = {
-        base: { port: 8080 },
-        resolved: { port: 8080 },
-        schema,
-      };
-      const ctx = buildCtx(state);
-      const result = await configExplain.blaze({ path: '' }, ctx);
-
-      expect(result.isOk()).toBe(true);
-      const [entry] = result.unwrap().entries;
-      expect(entry?.source).toBe('base');
-      expect(entry?.value).toBe(8080);
-    });
-
-    test('shows env as source when env provides value', async () => {
-      const schema = z.object({
-        token: env(z.string(), 'TOKEN').default('fallback'),
-      });
-      const state: ConfigState = {
-        env: { TOKEN: 'real-secret' },
-        resolved: { token: 'real-secret' },
-        schema,
-      };
-      const ctx = buildCtx(state);
-      const result = await configExplain.blaze({ path: '' }, ctx);
-
-      expect(result.isOk()).toBe(true);
-      const [entry] = result.unwrap().entries;
-      expect(entry?.source).toBe('env');
-    });
-  });
-});

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

@@ -1,53 +0,0 @@
-import { describe, expect, test } from 'bun:test';
-import { Result } from '@ontrails/core';
-import type { TrailContext } from '@ontrails/core';
-import { z } from 'zod';
-
-import { configGate } from '../config-gate.js';
-
-const stubTrail = {
-  blaze: (_input: unknown, _ctx: TrailContext) => Result.ok({}),
-  crosses: [],
-  description: undefined,
-  detours: undefined,
-  examples: undefined,
-  fields: undefined,
-  id: 'test.stub',
-  idempotent: undefined,
-  input: z.object({}),
-  intent: 'read' as const,
-  kind: 'trail' as const,
-  meta: undefined,
-  output: undefined,
-  provisions: [],
-};
-
-describe('configGate', () => {
-  describe('identity', () => {
-    test('has name "config"', () => {
-      expect(configGate.name).toBe('config');
-    });
-
-    test('has a description', () => {
-      expect(configGate.description).toBeDefined();
-    });
-  });
-
-  describe('wrap', () => {
-    test('passes through to the base implementation', async () => {
-      const impl = (_input: unknown, _ctx: TrailContext) =>
-        Result.ok({ called: true });
-
-      const wrapped = configGate.wrap(stubTrail, impl);
-      const ctx = {
-        cwd: '/tmp',
-        env: {},
-        workspaceRoot: '/tmp',
-      } as TrailContext;
-      const result = await wrapped({}, ctx);
-
-      expect(result.isOk()).toBe(true);
-      expect(result.unwrap()).toEqual({ called: true });
-    });
-  });
-});

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

@@ -1,210 +0,0 @@
-import { afterEach, beforeEach, describe, expect, test } from 'bun:test';
-import { mkdtemp, readFile, rm } from 'node:fs/promises';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { createProvisionLookup } from '@ontrails/core';
-import type { TrailContext } from '@ontrails/core';
-import { z } from 'zod';
-
-import { env } from '../extensions.js';
-import type { ConfigState } from '../registry.js';
-import { configInit } from '../trails/config-init.js';
-
-/**
- * Build a TrailContext with configProvision resolved in extensions.
- */
-const buildCtx = (state: ConfigState): TrailContext => {
-  const extensions = { config: state };
-  const ctx: TrailContext = {
-    abortSignal: AbortSignal.timeout(5000),
-    cwd: '/tmp',
-    env: {},
-    extensions,
-    provision: undefined as unknown as TrailContext['provision'],
-    requestId: 'test',
-    workspaceRoot: '/tmp',
-  };
-  const withLookup = {
-    ...ctx,
-    provision: createProvisionLookup(() => withLookup),
-  };
-  return withLookup;
-};
-
-const testSchema = z.object({
-  host: z.string().default('localhost'),
-  port: z.number().default(3000),
-});
-
-const testState: ConfigState = {
-  resolved: { host: 'localhost', port: 3000 },
-  schema: testSchema,
-};
-
-describe('config.init trail', () => {
-  describe('identity', () => {
-    test('has id "config.init"', () => {
-      expect(configInit.id).toBe('config.init');
-    });
-
-    test('has kind "trail"', () => {
-      expect(configInit.kind).toBe('trail');
-    });
-
-    test('has intent "write"', () => {
-      expect(configInit.intent).toBe('write');
-    });
-
-    test('has infrastructure meta', () => {
-      expect(configInit.meta).toEqual({ category: 'infrastructure' });
-    });
-
-    test('has output schema', () => {
-      expect(configInit.output).toBeDefined();
-    });
-
-    test('declares configProvision dependency', () => {
-      expect(configInit.provisions).toBeDefined();
-      expect(configInit.provisions?.length).toBe(1);
-    });
-  });
-
-  describe('examples', () => {
-    test('has at least one example', () => {
-      expect(configInit.examples?.length).toBeGreaterThanOrEqual(1);
-    });
-  });
-
-  describe('wired behavior', () => {
-    test('generates TOML output by default', async () => {
-      const ctx = buildCtx(testState);
-      const result = await configInit.blaze({ format: 'toml' }, ctx);
-
-      expect(result.isOk()).toBe(true);
-      const value = result.unwrap();
-      expect(value.format).toBe('toml');
-      expect(value.content).toContain('host');
-      expect(value.content).toContain('port');
-      expect(value.content.length).toBeGreaterThan(0);
-    });
-
-    test('generates JSON output when requested', async () => {
-      const ctx = buildCtx(testState);
-      const result = await configInit.blaze({ format: 'json' }, ctx);
-
-      expect(result.isOk()).toBe(true);
-      const value = result.unwrap();
-      expect(value.format).toBe('json');
-      expect(value.content).toContain('"host"');
-      expect(value.content).toContain('"port"');
-    });
-
-    test('generates YAML output when requested', async () => {
-      const ctx = buildCtx(testState);
-      const result = await configInit.blaze({ format: 'yaml' }, ctx);
-
-      expect(result.isOk()).toBe(true);
-      const value = result.unwrap();
-      expect(value.format).toBe('yaml');
-      expect(value.content).toContain('host:');
-    });
-
-    test('generates JSONC output when requested', async () => {
-      const ctx = buildCtx(testState);
-      const result = await configInit.blaze({ format: 'jsonc' }, ctx);
-
-      expect(result.isOk()).toBe(true);
-      const value = result.unwrap();
-      expect(value.format).toBe('jsonc');
-      expect(value.content).toContain('"host"');
-    });
-
-    test('output content is non-empty for schema with fields', async () => {
-      const ctx = buildCtx(testState);
-      const result = await configInit.blaze({ format: 'toml' }, ctx);
-
-      expect(result.isOk()).toBe(true);
-      expect(result.unwrap().content.trim().length).toBeGreaterThan(0);
-    });
-
-    test('returns content without writtenFiles when dir is not provided', async () => {
-      const ctx = buildCtx(testState);
-      const result = await configInit.blaze({ format: 'toml' }, ctx);
-
-      expect(result.isOk()).toBe(true);
-      expect(result.unwrap().writtenFiles).toBeUndefined();
-    });
-  });
-
-  describe('artifact generation', () => {
-    let tempDir: string;
-
-    const envSchema = z.object({
-      host: env(z.string(), 'APP_HOST').default('localhost'),
-      port: z.number().default(3000),
-    });
-
-    const envState: ConfigState = {
-      resolved: { host: 'localhost', port: 3000 },
-      schema: envSchema,
-    };
-
-    beforeEach(async () => {
-      tempDir = await mkdtemp(join(tmpdir(), 'trails-config-init-'));
-    });
-
-    afterEach(async () => {
-      await rm(tempDir, { force: true, recursive: true });
-    });
-
-    test('writes .schema.json when dir is provided', async () => {
-      const ctx = buildCtx(envState);
-      const result = await configInit.blaze(
-        { dir: tempDir, format: 'toml' },
-        ctx
-      );
-
-      expect(result.isOk()).toBe(true);
-      const value = result.unwrap();
-      expect(value.writtenFiles).toBeDefined();
-      expect(value.writtenFiles).toContainEqual(join(tempDir, '.schema.json'));
-
-      const schemaContent = await readFile(
-        join(tempDir, '.schema.json'),
-        'utf8'
-      );
-      const parsed = JSON.parse(schemaContent);
-      expect(parsed['$schema']).toBe(
-        'https://json-schema.org/draft/2020-12/schema'
-      );
-    });
-
-    test('writes .env.example when schema has env bindings', async () => {
-      const ctx = buildCtx(envState);
-      const result = await configInit.blaze(
-        { dir: tempDir, format: 'toml' },
-        ctx
-      );
-
-      expect(result.isOk()).toBe(true);
-      const value = result.unwrap();
-      expect(value.writtenFiles).toContainEqual(join(tempDir, '.env.example'));
-
-      const envContent = await readFile(join(tempDir, '.env.example'), 'utf8');
-      expect(envContent).toContain('APP_HOST');
-    });
-
-    test('still returns content alongside written files', async () => {
-      const ctx = buildCtx(envState);
-      const result = await configInit.blaze(
-        { dir: tempDir, format: 'json' },
-        ctx
-      );
-
-      expect(result.isOk()).toBe(true);
-      const value = result.unwrap();
-      expect(value.content.length).toBeGreaterThan(0);
-      expect(value.format).toBe('json');
-    });
-  });
-});

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

@@ -1,87 +0,0 @@
-import { afterEach, describe, expect, test } from 'bun:test';
-import { z } from 'zod';
-
-import { configProvision } from '../config-provision.js';
-import type { ConfigState } from '../registry.js';
-import { clearConfigState, registerConfigState } from '../registry.js';
-
-/** Stub ProvisionContext for create calls. */
-const stubSvcCtx = {
-  config: undefined,
-  cwd: '/tmp',
-  env: {},
-  workspaceRoot: '/tmp',
-};
-
-describe('configProvision', () => {
-  afterEach(() => {
-    clearConfigState();
-  });
-
-  describe('identity', () => {
-    test('has id "config"', () => {
-      expect(configProvision.id).toBe('config');
-    });
-
-    test('has kind "provision"', () => {
-      expect(configProvision.kind).toBe('provision');
-    });
-
-    test('has infrastructure meta', () => {
-      expect(configProvision.meta).toEqual({ category: 'infrastructure' });
-    });
-
-    test('has description', () => {
-      expect(configProvision.description).toBeDefined();
-    });
-  });
-
-  describe('mock', () => {
-    test('returns a ConfigState with empty schema and resolved', () => {
-      const value = configProvision.mock?.() as ConfigState;
-      expect(value).toBeDefined();
-      expect(value.resolved).toEqual({});
-      expect(value.schema).toBeDefined();
-    });
-  });
-
-  describe('create', () => {
-    test('returns Result.ok with registered ConfigState', async () => {
-      const schema = z.object({ port: z.number().default(3000) });
-      const state: ConfigState = { resolved: { port: 3000 }, schema };
-      registerConfigState(state);
-
-      const result = await configProvision.create(stubSvcCtx);
-
-      expect(result.isOk()).toBe(true);
-      const value = result.unwrap() as ConfigState;
-      expect(value.resolved).toEqual({ port: 3000 });
-      expect(value.schema).toBe(schema);
-    });
-
-    test('includes optional layer data when present', async () => {
-      const schema = z.object({ port: z.number() });
-      const state: ConfigState = {
-        base: { port: 8080 },
-        local: { port: 3000 },
-        resolved: { port: 3000 },
-        schema,
-      };
-      registerConfigState(state);
-
-      const result = await configProvision.create(stubSvcCtx);
-
-      expect(result.isOk()).toBe(true);
-      const value = result.unwrap() as ConfigState;
-      expect(value.base).toEqual({ port: 8080 });
-      expect(value.local).toEqual({ port: 3000 });
-    });
-
-    test('returns Result.err when no state is registered', async () => {
-      const result = await configProvision.create(stubSvcCtx);
-
-      expect(result.isErr()).toBe(true);
-      expect(result.error.message).toContain('Config state not registered');
-    });
-  });
-});