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

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

@@ -1,269 +0,0 @@
-import { afterEach, beforeEach, describe, expect, test } from 'bun:test';
-import { mkdir, mkdtemp, rm } from 'node:fs/promises';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { z } from 'zod';
-
-import { defineConfig } from '../define-config.js';
-
-const schema = z.object({
-  debug: z.boolean().default(false),
-  host: z.string().default('localhost'),
-  port: z.number().default(3000),
-});
-
-type EnvKey = 'NODE_ENV' | 'TRAILS_ENV';
-
-interface EnvSnapshot {
-  readonly NODE_ENV: string | undefined;
-  readonly TRAILS_ENV: string | undefined;
-}
-
-const readEnvSnapshot = (): EnvSnapshot => ({
-  NODE_ENV: process.env.NODE_ENV,
-  TRAILS_ENV: process.env.TRAILS_ENV,
-});
-
-const setEnvVar = (key: EnvKey, value: string | undefined): void => {
-  if (value === undefined) {
-    if (key === 'NODE_ENV') {
-      delete process.env.NODE_ENV;
-    } else {
-      delete process.env.TRAILS_ENV;
-    }
-    return;
-  }
-  if (key === 'NODE_ENV') {
-    process.env.NODE_ENV = value;
-  } else {
-    process.env.TRAILS_ENV = value;
-  }
-};
-
-const restoreEnv = (snapshot: EnvSnapshot): void => {
-  setEnvVar('NODE_ENV', snapshot.NODE_ENV);
-  setEnvVar('TRAILS_ENV', snapshot.TRAILS_ENV);
-};
-
-describe('defineConfig', () => {
-  test('returns an object with schema, base, and profiles', () => {
-    const base = { host: 'example.com' };
-    const profiles = { production: { port: 443 } };
-
-    const config = defineConfig({ base, profiles, schema });
-
-    expect(config.schema).toBe(schema);
-    expect(config.base).toBe(base);
-    expect(config.profiles).toBe(profiles);
-  });
-
-  test('resolve() uses TRAILS_ENV to select profile', async () => {
-    const config = defineConfig({
-      base: { host: 'example.com' },
-      profiles: {
-        production: { host: 'prod.example.com', port: 443 },
-        test: { host: 'test.example.com', port: 9999 },
-      },
-      schema,
-    });
-
-    const result = await config.resolve({
-      env: { TRAILS_ENV: 'production' },
-    });
-
-    expect(result.isOk()).toBe(true);
-    expect(result.unwrap().host).toBe('prod.example.com');
-    expect(result.unwrap().port).toBe(443);
-  });
-
-  test('resolve() with explicit profile option overrides TRAILS_ENV', async () => {
-    const config = defineConfig({
-      base: { host: 'example.com' },
-      profiles: {
-        production: { host: 'prod.example.com' },
-        test: { host: 'test.example.com' },
-      },
-      schema,
-    });
-
-    const result = await config.resolve({
-      env: { TRAILS_ENV: 'production' },
-      profile: 'test',
-    });
-
-    expect(result.isOk()).toBe(true);
-    expect(result.unwrap().host).toBe('test.example.com');
-  });
-
-  test('envFromNodeEnv maps NODE_ENV to TRAILS_ENV when unset', async () => {
-    const config = defineConfig({
-      base: { host: 'example.com' },
-      envFromNodeEnv: true,
-      profiles: {
-        production: { host: 'prod.example.com', port: 443 },
-      },
-      schema,
-    });
-
-    const result = await config.resolve({
-      env: { NODE_ENV: 'production' },
-    });
-
-    expect(result.isOk()).toBe(true);
-    expect(result.unwrap().host).toBe('prod.example.com');
-    expect(result.unwrap().port).toBe(443);
-  });
-
-  test('envFromNodeEnv does not mutate process.env', async () => {
-    const snapshot = readEnvSnapshot();
-    setEnvVar('TRAILS_ENV', undefined);
-    setEnvVar('NODE_ENV', 'production');
-
-    try {
-      const config = defineConfig({
-        base: { host: 'example.com' },
-        envFromNodeEnv: true,
-        profiles: {
-          production: { host: 'prod.example.com', port: 443 },
-        },
-        schema,
-      });
-
-      const result = await config.resolve();
-
-      expect(result.isOk()).toBe(true);
-      expect(result.unwrap().host).toBe('prod.example.com');
-      expect(process.env.TRAILS_ENV).toBeUndefined();
-    } finally {
-      restoreEnv(snapshot);
-    }
-  });
-
-  test('envFromNodeEnv does not override explicit TRAILS_ENV', async () => {
-    const config = defineConfig({
-      base: { host: 'example.com' },
-      envFromNodeEnv: true,
-      profiles: {
-        production: { host: 'prod.example.com' },
-        test: { host: 'test.example.com' },
-      },
-      schema,
-    });
-
-    const result = await config.resolve({
-      env: { NODE_ENV: 'production', TRAILS_ENV: 'test' },
-    });
-
-    expect(result.isOk()).toBe(true);
-    expect(result.unwrap().host).toBe('test.example.com');
-  });
-
-  test('test profile works when TRAILS_ENV=test', async () => {
-    const config = defineConfig({
-      base: { port: 8080 },
-      profiles: {
-        test: { debug: true, port: 0 },
-      },
-      schema,
-    });
-
-    const result = await config.resolve({
-      env: { TRAILS_ENV: 'test' },
-    });
-
-    expect(result.isOk()).toBe(true);
-    const value = result.unwrap();
-    expect(value.debug).toBe(true);
-    expect(value.port).toBe(0);
-  });
-
-  test('inherits the canonical appConfig format list, including jsonc', () => {
-    const config = defineConfig({ schema });
-
-    expect(config.formats).toEqual(['toml', 'json', 'jsonc', 'yaml']);
-  });
-
-  describe('local overrides', () => {
-    let tempDir: string;
-
-    beforeEach(async () => {
-      tempDir = await mkdtemp(join(tmpdir(), 'trails-define-config-'));
-    });
-
-    afterEach(async () => {
-      await rm(tempDir, { force: true, recursive: true });
-    });
-
-    test('applies local overrides from .trails/config/local.ts', async () => {
-      const configDir = join(tempDir, '.trails', 'config');
-      await mkdir(configDir, { recursive: true });
-      await Bun.write(
-        join(configDir, 'local.ts'),
-        'export default { port: 4444 };'
-      );
-
-      const config = defineConfig({
-        base: { host: 'example.com' },
-        schema,
-      });
-
-      const result = await config.resolve({
-        cwd: tempDir,
-        env: {},
-      });
-
-      expect(result.isOk()).toBe(true);
-      expect(result.unwrap().port).toBe(4444);
-    });
-
-    test('local overrides applied between profile and env', async () => {
-      const configDir = join(tempDir, '.trails', 'config');
-      await mkdir(configDir, { recursive: true });
-      await Bun.write(
-        join(configDir, 'local.js'),
-        'export default { port: 5555 };'
-      );
-
-      const config = defineConfig({
-        base: { port: 8080 },
-        profiles: {
-          dev: { port: 9090 },
-        },
-        schema,
-      });
-
-      // Local overrides should win over profile (9090)
-      const result = await config.resolve({
-        cwd: tempDir,
-        env: { TRAILS_ENV: 'dev' },
-        profile: 'dev',
-      });
-
-      expect(result.isOk()).toBe(true);
-      expect(result.unwrap().port).toBe(5555);
-    });
-
-    test('skips local overrides when TRAILS_ENV=test', async () => {
-      const configDir = join(tempDir, '.trails', 'config');
-      await mkdir(configDir, { recursive: true });
-      await Bun.write(
-        join(configDir, 'local.ts'),
-        'export default { port: 4444 };'
-      );
-
-      const config = defineConfig({
-        base: { port: 8080 },
-        schema,
-      });
-
-      const result = await config.resolve({
-        cwd: tempDir,
-        env: { TRAILS_ENV: 'test' },
-      });
-
-      expect(result.isOk()).toBe(true);
-      // Should NOT apply local overrides, so port stays at base 8080
-      expect(result.unwrap().port).toBe(8080);
-    });
-  });
-});

package/src/__tests__/derive-fields.test.ts

@@ -1,158 +0,0 @@
-import { describe, expect, test } from 'bun:test';
-import { z } from 'zod';
-
-import { deprecated, env, secret } from '../extensions.js';
-import { deriveConfigFields } from '../derive-fields.js';
-
-describe('deriveConfigFields', () => {
-  describe('basic field descriptions', () => {
-    test('returns path, type, and required for each field', () => {
-      const schema = z.object({
-        debug: z.boolean(),
-        host: z.string(),
-        port: z.number(),
-      });
-
-      const fields = deriveConfigFields(schema);
-
-      expect(fields).toHaveLength(3);
-      const host = fields.find((f) => f.path === 'host');
-      expect(host?.type).toBe('string');
-      expect(host?.required).toBe(true);
-
-      const port = fields.find((f) => f.path === 'port');
-      expect(port?.type).toBe('number');
-      expect(port?.required).toBe(true);
-    });
-  });
-
-  describe('Zod describe() metadata', () => {
-    test('includes description from .describe()', () => {
-      const schema = z.object({
-        host: z.string().describe('The server hostname'),
-      });
-
-      const fields = deriveConfigFields(schema);
-      const host = fields.find((f) => f.path === 'host');
-      expect(host?.description).toBe('The server hostname');
-    });
-  });
-
-  describe('config metadata', () => {
-    test('includes env, secret, deprecated from metadata', () => {
-      const schema = z.object({
-        apiKey: secret(env(z.string(), 'API_KEY')),
-        legacyMode: deprecated(z.boolean(), 'Use "mode" instead').default(
-          false
-        ),
-      });
-
-      const fields = deriveConfigFields(schema);
-
-      const apiKey = fields.find((f) => f.path === 'apiKey');
-      expect(apiKey?.env).toBe('API_KEY');
-      expect(apiKey?.secret).toBe(true);
-
-      const legacy = fields.find((f) => f.path === 'legacyMode');
-      expect(legacy?.deprecated).toBe('Use "mode" instead');
-    });
-  });
-
-  describe('defaults', () => {
-    test('detects default values', () => {
-      const schema = z.object({
-        debug: z.boolean().default(false),
-        port: z.number().default(3000),
-      });
-
-      const fields = deriveConfigFields(schema);
-
-      const port = fields.find((f) => f.path === 'port');
-      expect(port?.default).toBe(3000);
-      expect(port?.required).toBe(false);
-
-      const debug = fields.find((f) => f.path === 'debug');
-      expect(debug?.default).toBe(false);
-    });
-  });
-
-  describe('nested objects', () => {
-    test('handles nested object schemas with dot paths', () => {
-      const schema = z.object({
-        db: z.object({
-          host: z.string(),
-          port: z.number().default(5432),
-        }),
-      });
-
-      const fields = deriveConfigFields(schema);
-
-      const dbHost = fields.find((f) => f.path === 'db.host');
-      expect(dbHost?.type).toBe('string');
-      expect(dbHost?.required).toBe(true);
-
-      const dbPort = fields.find((f) => f.path === 'db.port');
-      expect(dbPort?.type).toBe('number');
-      expect(dbPort?.default).toBe(5432);
-    });
-
-    test('unwraps optional nested object schemas before walking', () => {
-      const schema = z.object({
-        db: z
-          .object({
-            host: z.string(),
-            port: z.number().default(5432),
-          })
-          .optional(),
-      });
-
-      const fields = deriveConfigFields(schema);
-
-      expect(fields).toEqual([
-        expect.objectContaining({ path: 'db.host', required: true }),
-        expect.objectContaining({ default: 5432, path: 'db.port' }),
-      ]);
-    });
-  });
-
-  describe('constraints', () => {
-    test('detects enum values', () => {
-      const schema = z.object({
-        env: z.enum(['development', 'production', 'test']),
-      });
-
-      const fields = deriveConfigFields(schema);
-      const envField = fields.find((f) => f.path === 'env');
-      expect(envField?.type).toBe('enum');
-      expect(envField?.constraints?.values).toEqual([
-        'development',
-        'production',
-        'test',
-      ]);
-    });
-
-    test('detects number min/max constraints', () => {
-      const schema = z.object({
-        port: z.number().min(1).max(65_535),
-      });
-
-      const fields = deriveConfigFields(schema);
-      const port = fields.find((f) => f.path === 'port');
-      expect(port?.constraints?.min).toBe(1);
-      expect(port?.constraints?.max).toBe(65_535);
-    });
-  });
-
-  describe('optional fields', () => {
-    test('marks optional fields as not required', () => {
-      const schema = z.object({
-        host: z.string(),
-        nickname: z.string().optional(),
-      });
-
-      const fields = deriveConfigFields(schema);
-      const nickname = fields.find((f) => f.path === 'nickname');
-      expect(nickname?.required).toBe(false);
-    });
-  });
-});

package/src/__tests__/derive-provenance.test.ts

@@ -1,139 +0,0 @@
-import { describe, expect, test } from 'bun:test';
-import { z } from 'zod';
-
-import { env, secret } from '../extensions.js';
-import { deriveConfigProvenance } from '../derive-provenance.js';
-
-const schema = z.object({
-  debug: z.boolean().default(false),
-  host: z.string().default('localhost'),
-  port: z.number().default(3000),
-});
-
-describe('deriveConfigProvenance', () => {
-  describe('default source', () => {
-    test('reports "default" when no other source provides value', () => {
-      const entries = deriveConfigProvenance({
-        resolved: { debug: false, host: 'localhost', port: 3000 },
-        schema,
-      });
-
-      const host = entries.find((e) => e.path === 'host');
-      expect(host?.source).toBe('default');
-      expect(host?.value).toBe('localhost');
-    });
-  });
-
-  describe('base overrides default', () => {
-    test('reports "base" when base provides value', () => {
-      const entries = deriveConfigProvenance({
-        base: { host: 'base.example.com' },
-        resolved: { debug: false, host: 'base.example.com', port: 3000 },
-        schema,
-      });
-
-      const host = entries.find((e) => e.path === 'host');
-      expect(host?.source).toBe('base');
-      expect(host?.value).toBe('base.example.com');
-    });
-  });
-
-  describe('profile overrides base', () => {
-    test('reports "profile" when profile provides winning value', () => {
-      const entries = deriveConfigProvenance({
-        base: { host: 'base.example.com' },
-        profile: { host: 'profile.example.com' },
-        resolved: { debug: false, host: 'profile.example.com', port: 3000 },
-        schema,
-      });
-
-      const host = entries.find((e) => e.path === 'host');
-      expect(host?.source).toBe('profile');
-      expect(host?.value).toBe('profile.example.com');
-    });
-  });
-
-  describe('local overrides profile', () => {
-    test('reports "local" when local provides winning value', () => {
-      const entries = deriveConfigProvenance({
-        base: { host: 'base.example.com' },
-        local: { host: 'local.example.com' },
-        profile: { host: 'profile.example.com' },
-        resolved: { debug: false, host: 'local.example.com', port: 3000 },
-        schema,
-      });
-
-      const host = entries.find((e) => e.path === 'host');
-      expect(host?.source).toBe('local');
-    });
-  });
-
-  describe('env overrides everything', () => {
-    test('reports "env" when env provides winning value', () => {
-      const envSchema = z.object({
-        host: env(z.string(), 'APP_HOST').default('localhost'),
-        port: z.number().default(3000),
-      });
-
-      const entries = deriveConfigProvenance({
-        base: { host: 'base.example.com' },
-        env: { APP_HOST: 'env.example.com' },
-        resolved: { host: 'env.example.com', port: 3000 },
-        schema: envSchema,
-      });
-
-      const host = entries.find((e) => e.path === 'host');
-      expect(host?.source).toBe('env');
-      expect(host?.value).toBe('env.example.com');
-    });
-
-    test('walks optional nested object schemas for env-backed entries', () => {
-      const envSchema = z.object({
-        db: z
-          .object({
-            host: env(z.string(), 'DB_HOST').default('localhost'),
-          })
-          .optional(),
-      });
-
-      const entries = deriveConfigProvenance({
-        env: { DB_HOST: 'env.example.com' },
-        resolved: { db: { host: 'env.example.com' } },
-        schema: envSchema,
-      });
-
-      const host = entries.find((entry) => entry.path === 'db.host');
-      expect(host?.source).toBe('env');
-      expect(host?.value).toBe('env.example.com');
-    });
-  });
-
-  describe('secret redaction', () => {
-    test('redacts secret fields', () => {
-      const secretSchema = z.object({
-        apiKey: secret(env(z.string(), 'API_KEY')),
-        host: z.string().default('localhost'),
-      });
-
-      const entries = deriveConfigProvenance({
-        env: { API_KEY: 'super-secret-key' },
-        resolved: { apiKey: 'super-secret-key', host: 'localhost' },
-        schema: secretSchema,
-      });
-
-      const apiKey = entries.find((e) => e.path === 'apiKey');
-      expect(apiKey?.redacted).toBe(true);
-      expect(apiKey?.value).toBe('[REDACTED]');
-    });
-
-    test('does not redact non-secret fields', () => {
-      const entries = deriveConfigProvenance({
-        resolved: { debug: false, host: 'localhost', port: 3000 },
-        schema,
-      });
-
-      const host = entries.find((e) => e.path === 'host');
-      expect(host?.redacted).toBe(false);
-    });
-  });
-});