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

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

@@ -1,263 +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 loadouts', () => {
-    const base = { host: 'example.com' };
-    const loadouts = { production: { port: 443 } };
-
-    const config = defineConfig({ base, loadouts, schema });
-
-    expect(config.schema).toBe(schema);
-    expect(config.base).toBe(base);
-    expect(config.loadouts).toBe(loadouts);
-  });
-
-  test('resolve() uses TRAILS_ENV to select loadout', async () => {
-    const config = defineConfig({
-      base: { host: 'example.com' },
-      loadouts: {
-        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 loadout option overrides TRAILS_ENV', async () => {
-    const config = defineConfig({
-      base: { host: 'example.com' },
-      loadouts: {
-        production: { host: 'prod.example.com' },
-        test: { host: 'test.example.com' },
-      },
-      schema,
-    });
-
-    const result = await config.resolve({
-      env: { TRAILS_ENV: 'production' },
-      loadout: '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,
-      loadouts: {
-        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,
-        loadouts: {
-          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,
-      loadouts: {
-        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 loadout works when TRAILS_ENV=test', async () => {
-    const config = defineConfig({
-      base: { port: 8080 },
-      loadouts: {
-        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);
-  });
-
-  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 loadout 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 },
-        loadouts: {
-          dev: { port: 9090 },
-        },
-        schema,
-      });
-
-      // Local overrides should win over loadout (9090)
-      const result = await config.resolve({
-        cwd: tempDir,
-        env: { TRAILS_ENV: 'dev' },
-        loadout: '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__/describe.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 { describeConfig } from '../describe.js';
-
-describe('describeConfig', () => {
-  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 = describeConfig(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 = describeConfig(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 = describeConfig(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 = describeConfig(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 = describeConfig(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 = describeConfig(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 = describeConfig(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 = describeConfig(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 = describeConfig(schema);
-      const nickname = fields.find((f) => f.path === 'nickname');
-      expect(nickname?.required).toBe(false);
-    });
-  });
-});

package/src/__tests__/doctor.test.ts

@@ -1,172 +0,0 @@
-import { describe, expect, test } from 'bun:test';
-import { z } from 'zod';
-
-import { deprecated, env } from '../extensions.js';
-import { checkConfig } from '../doctor.js';
-
-const schema = z.object({
-  debug: z.boolean().default(false),
-  host: z.string(),
-  port: z.number().default(3000),
-});
-
-describe('checkConfig', () => {
-  describe('valid fields', () => {
-    test('reports status "valid" for present and valid fields', () => {
-      const result = checkConfig(schema, { host: 'localhost', port: 8080 });
-
-      const hostDiag = result.diagnostics.find((d) => d.path === 'host');
-      expect(hostDiag?.status).toBe('valid');
-      expect(hostDiag?.value).toBe('localhost');
-    });
-  });
-
-  describe('missing required fields', () => {
-    test('reports status "missing" for absent required fields', () => {
-      const result = checkConfig(schema, { port: 8080 });
-
-      const hostDiag = result.diagnostics.find((d) => d.path === 'host');
-      expect(hostDiag?.status).toBe('missing');
-      expect(hostDiag?.message).toContain('host');
-    });
-  });
-
-  describe('default fields', () => {
-    test('reports status "default" when field uses schema default', () => {
-      const result = checkConfig(schema, { host: 'localhost' });
-
-      const portDiag = result.diagnostics.find((d) => d.path === 'port');
-      expect(portDiag?.status).toBe('default');
-      expect(portDiag?.value).toBe(3000);
-
-      const debugDiag = result.diagnostics.find((d) => d.path === 'debug');
-      expect(debugDiag?.status).toBe('default');
-      expect(debugDiag?.value).toBe(false);
-    });
-  });
-
-  describe('invalid fields', () => {
-    test('reports status "invalid" with message for wrong-type values', () => {
-      const result = checkConfig(schema, {
-        host: 'localhost',
-        port: 'not-a-number',
-      });
-
-      const portDiag = result.diagnostics.find((d) => d.path === 'port');
-      expect(portDiag?.status).toBe('invalid');
-      expect(portDiag?.message).toBeDefined();
-    });
-  });
-
-  describe('deprecated fields', () => {
-    test('reports status "deprecated" with migration message', () => {
-      const deprecatedSchema = z.object({
-        host: z.string(),
-        legacyMode: deprecated(z.boolean(), 'Use "mode" instead').default(
-          false
-        ),
-      });
-
-      const result = checkConfig(deprecatedSchema, {
-        host: 'localhost',
-        legacyMode: true,
-      });
-
-      const legacyDiag = result.diagnostics.find(
-        (d) => d.path === 'legacyMode'
-      );
-      expect(legacyDiag?.status).toBe('deprecated');
-      expect(legacyDiag?.message).toContain('Use "mode" instead');
-    });
-  });
-
-  describe('valid flag', () => {
-    test('returns valid: true when no missing or invalid fields', () => {
-      const result = checkConfig(schema, { host: 'localhost', port: 8080 });
-      expect(result.valid).toBe(true);
-    });
-
-    test('returns valid: false when required field is missing', () => {
-      const result = checkConfig(schema, { port: 8080 });
-      expect(result.valid).toBe(false);
-    });
-
-    test('returns valid: false when field is invalid', () => {
-      const result = checkConfig(schema, {
-        host: 'localhost',
-        port: 'bad',
-      });
-      expect(result.valid).toBe(false);
-    });
-
-    test('returns valid: true when deprecated fields are present', () => {
-      const deprecatedSchema = z.object({
-        host: z.string(),
-        legacyMode: deprecated(z.boolean(), 'Use "mode" instead').default(
-          false
-        ),
-      });
-
-      const result = checkConfig(deprecatedSchema, {
-        host: 'localhost',
-        legacyMode: true,
-      });
-      expect(result.valid).toBe(true);
-    });
-  });
-
-  describe('env resolution', () => {
-    test('treats env-provided value as valid', () => {
-      const envSchema = z.object({
-        host: env(z.string(), 'APP_HOST'),
-      });
-
-      const result = checkConfig(
-        envSchema,
-        {},
-        { env: { APP_HOST: 'envhost' } }
-      );
-      const hostDiag = result.diagnostics.find((d) => d.path === 'host');
-      expect(hostDiag?.status).toBe('valid');
-      expect(hostDiag?.value).toBe('envhost');
-    });
-
-    test('resolves env vars for nested schema fields', () => {
-      const nestedSchema = z.object({
-        db: z.object({
-          host: env(z.string(), 'DB_HOST'),
-          port: z.number().default(5432),
-        }),
-      });
-
-      const result = checkConfig(
-        nestedSchema,
-        { db: {} },
-        { env: { DB_HOST: 'dbhost.local' } }
-      );
-      const dbHostDiag = result.diagnostics.find((d) => d.path === 'db.host');
-      expect(dbHostDiag?.status).toBe('valid');
-      expect(dbHostDiag?.value).toBe('dbhost.local');
-    });
-
-    test('walks optional nested object schemas for env overrides', () => {
-      const nestedSchema = z.object({
-        db: z
-          .object({
-            host: env(z.string(), 'DB_HOST'),
-          })
-          .optional(),
-      });
-
-      const result = checkConfig(
-        nestedSchema,
-        {},
-        { env: { DB_HOST: 'dbhost.local' } }
-      );
-      const dbHostDiag = result.diagnostics.find((d) => d.path === 'db.host');
-
-      expect(dbHostDiag?.status).toBe('valid');
-      expect(dbHostDiag?.value).toBe('dbhost.local');
-    });
-  });
-});