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

package/src/__tests__/compose.test.ts

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

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

@@ -1,5 +1,5 @@
 import { describe, expect, test } from 'bun:test';
-import { createServiceLookup } from '@ontrails/core';
+import { createProvisionLookup } from '@ontrails/core';
 import type { TrailContext } from '@ontrails/core';
 import { z } from 'zod';
 
@@ -7,22 +7,22 @@ import { configCheck } from '../trails/config-check.js';
 import type { ConfigState } from '../registry.js';
 
 /**
- * Build a TrailContext with configService resolved in extensions.
+ * 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',
-    service: undefined as unknown as TrailContext['service'],
-    signal: AbortSignal.timeout(5000),
     workspaceRoot: '/tmp',
   };
   const withLookup = {
     ...ctx,
-    service: createServiceLookup(() => withLookup),
+    provision: createProvisionLookup(() => withLookup),
   };
   return withLookup;
 };
@@ -41,17 +41,17 @@ describe('config.check trail', () => {
       expect(configCheck.intent).toBe('read');
     });
 
-    test('has infrastructure metadata', () => {
-      expect(configCheck.metadata).toEqual({ category: 'infrastructure' });
+    test('has infrastructure meta', () => {
+      expect(configCheck.meta).toEqual({ category: 'infrastructure' });
     });
 
     test('has output schema', () => {
       expect(configCheck.output).toBeDefined();
     });
 
-    test('declares configService dependency', () => {
-      expect(configCheck.services).toBeDefined();
-      expect(configCheck.services?.length).toBe(1);
+    test('declares configProvision dependency', () => {
+      expect(configCheck.provisions).toBeDefined();
+      expect(configCheck.provisions?.length).toBe(1);
     });
   });
 
@@ -72,7 +72,7 @@ describe('config.check trail', () => {
         schema,
       };
       const ctx = buildCtx(state);
-      const result = await configCheck.run({ values: {} }, ctx);
+      const result = await configCheck.blaze({ values: {} }, ctx);
 
       expect(result.isOk()).toBe(true);
       const value = result.unwrap();
@@ -90,7 +90,7 @@ describe('config.check trail', () => {
         schema,
       };
       const ctx = buildCtx(state);
-      const result = await configCheck.run({ values: {} }, ctx);
+      const result = await configCheck.blaze({ values: {} }, ctx);
 
       expect(result.isOk()).toBe(true);
       const value = result.unwrap();
@@ -108,7 +108,7 @@ describe('config.check trail', () => {
         schema,
       };
       const ctx = buildCtx(state);
-      const result = await configCheck.run({ values: { port: 8080 } }, ctx);
+      const result = await configCheck.blaze({ values: { port: 8080 } }, ctx);
 
       expect(result.isOk()).toBe(true);
       const value = result.unwrap();
@@ -129,7 +129,7 @@ describe('config.check trail', () => {
         schema,
       };
       const ctx = buildCtx(state);
-      const result = await configCheck.run(
+      const result = await configCheck.blaze(
         { values: { db: { port: 6543 } } },
         ctx
       );
@@ -159,7 +159,7 @@ describe('config.check trail', () => {
         schema,
       };
       const ctx = buildCtx(state);
-      const result = await configCheck.run({ values: {} }, ctx);
+      const result = await configCheck.blaze({ values: {} }, ctx);
 
       expect(result.isOk()).toBe(true);
       const defaults = result

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

@@ -1,5 +1,5 @@
 import { describe, expect, test } from 'bun:test';
-import { createServiceLookup } from '@ontrails/core';
+import { createProvisionLookup } from '@ontrails/core';
 import type { TrailContext } from '@ontrails/core';
 import { z } from 'zod';
 
@@ -8,22 +8,22 @@ import { env, secret } from '../extensions.js';
 import type { ConfigState } from '../registry.js';
 
 /**
- * Build a TrailContext with configService resolved in extensions.
+ * 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',
-    service: undefined as unknown as TrailContext['service'],
-    signal: AbortSignal.timeout(5000),
     workspaceRoot: '/tmp',
   };
   const withLookup = {
     ...ctx,
-    service: createServiceLookup(() => withLookup),
+    provision: createProvisionLookup(() => withLookup),
   };
   return withLookup;
 };
@@ -42,17 +42,17 @@ describe('config.describe trail', () => {
       expect(configDescribe.intent).toBe('read');
     });
 
-    test('has infrastructure metadata', () => {
-      expect(configDescribe.metadata).toEqual({ category: 'infrastructure' });
+    test('has infrastructure meta', () => {
+      expect(configDescribe.meta).toEqual({ category: 'infrastructure' });
     });
 
     test('has output schema', () => {
       expect(configDescribe.output).toBeDefined();
     });
 
-    test('declares configService dependency', () => {
-      expect(configDescribe.services).toBeDefined();
-      expect(configDescribe.services?.length).toBe(1);
+    test('declares configProvision dependency', () => {
+      expect(configDescribe.provisions).toBeDefined();
+      expect(configDescribe.provisions?.length).toBe(1);
     });
   });
 
@@ -73,7 +73,7 @@ describe('config.describe trail', () => {
         schema,
       };
       const ctx = buildCtx(state);
-      const result = await configDescribe.run({}, ctx);
+      const result = await configDescribe.blaze({}, ctx);
 
       expect(result.isOk()).toBe(true);
       expect(result.unwrap().fields.length).toBe(2);
@@ -89,7 +89,7 @@ describe('config.describe trail', () => {
         schema,
       };
       const ctx = buildCtx(state);
-      const result = await configDescribe.run({}, ctx);
+      const result = await configDescribe.blaze({}, ctx);
       const { fields } = result.unwrap();
 
       expect(fields[0]?.path).toBe('host');
@@ -107,7 +107,7 @@ describe('config.describe trail', () => {
         schema,
       };
       const ctx = buildCtx(state);
-      const result = await configDescribe.run({}, ctx);
+      const result = await configDescribe.blaze({}, ctx);
 
       expect(result.isOk()).toBe(true);
       const [field] = result.unwrap().fields;
@@ -123,7 +123,7 @@ describe('config.describe trail', () => {
         schema,
       };
       const ctx = buildCtx(state);
-      const result = await configDescribe.run({}, ctx);
+      const result = await configDescribe.blaze({}, ctx);
 
       expect(result.isOk()).toBe(true);
       const [field] = result.unwrap().fields;
@@ -141,7 +141,7 @@ describe('config.describe trail', () => {
         schema,
       };
       const ctx = buildCtx(state);
-      const result = await configDescribe.run({}, ctx);
+      const result = await configDescribe.blaze({}, ctx);
 
       expect(result.isOk()).toBe(true);
       const { fields } = result.unwrap();

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

@@ -1,5 +1,5 @@
 import { describe, expect, test } from 'bun:test';
-import { createServiceLookup } from '@ontrails/core';
+import { createProvisionLookup } from '@ontrails/core';
 import type { TrailContext } from '@ontrails/core';
 import { z } from 'zod';
 
@@ -8,22 +8,22 @@ import { env } from '../extensions.js';
 import type { ConfigState } from '../registry.js';
 
 /**
- * Build a TrailContext with configService resolved in extensions.
+ * 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',
-    service: undefined as unknown as TrailContext['service'],
-    signal: AbortSignal.timeout(5000),
     workspaceRoot: '/tmp',
   };
   const withLookup = {
     ...ctx,
-    service: createServiceLookup(() => withLookup),
+    provision: createProvisionLookup(() => withLookup),
   };
   return withLookup;
 };
@@ -42,17 +42,17 @@ describe('config.explain trail', () => {
       expect(configExplain.intent).toBe('read');
     });
 
-    test('has infrastructure metadata', () => {
-      expect(configExplain.metadata).toEqual({ category: 'infrastructure' });
+    test('has infrastructure meta', () => {
+      expect(configExplain.meta).toEqual({ category: 'infrastructure' });
     });
 
     test('has output schema', () => {
       expect(configExplain.output).toBeDefined();
     });
 
-    test('declares configService dependency', () => {
-      expect(configExplain.services).toBeDefined();
-      expect(configExplain.services?.length).toBe(1);
+    test('declares configProvision dependency', () => {
+      expect(configExplain.provisions).toBeDefined();
+      expect(configExplain.provisions?.length).toBe(1);
     });
   });
 
@@ -73,7 +73,7 @@ describe('config.explain trail', () => {
         schema,
       };
       const ctx = buildCtx(state);
-      const result = await configExplain.run({ path: '' }, ctx);
+      const result = await configExplain.blaze({ path: '' }, ctx);
 
       expect(result.isOk()).toBe(true);
       const value = result.unwrap();
@@ -96,7 +96,7 @@ describe('config.explain trail', () => {
         schema,
       };
       const ctx = buildCtx(state);
-      const result = await configExplain.run({ path: 'db' }, ctx);
+      const result = await configExplain.blaze({ path: 'db' }, ctx);
 
       expect(result.isOk()).toBe(true);
       const value = result.unwrap();
@@ -121,7 +121,7 @@ describe('config.explain trail', () => {
         schema,
       };
       const ctx = buildCtx(state);
-      const result = await configExplain.run({ path: 'db' }, ctx);
+      const result = await configExplain.blaze({ path: 'db' }, ctx);
 
       expect(result.isOk()).toBe(true);
       expect(result.unwrap().entries).toEqual([
@@ -139,7 +139,7 @@ describe('config.explain trail', () => {
         schema,
       };
       const ctx = buildCtx(state);
-      const result = await configExplain.run({ path: '' }, ctx);
+      const result = await configExplain.blaze({ path: '' }, ctx);
 
       expect(result.isOk()).toBe(true);
       const [entry] = result.unwrap().entries;
@@ -157,7 +157,7 @@ describe('config.explain trail', () => {
         schema,
       };
       const ctx = buildCtx(state);
-      const result = await configExplain.run({ path: '' }, ctx);
+      const result = await configExplain.blaze({ path: '' }, ctx);
 
       expect(result.isOk()).toBe(true);
       const [entry] = result.unwrap().entries;

package/src/__tests__/{config-layer.test.ts → config-gate.test.ts}

@@ -3,33 +3,33 @@ import { Result } from '@ontrails/core';
 import type { TrailContext } from '@ontrails/core';
 import { z } from 'zod';
 
-import { configLayer } from '../config-layer.js';
+import { configGate } from '../config-gate.js';
 
 const stubTrail = {
+  blaze: (_input: unknown, _ctx: TrailContext) => Result.ok({}),
+  crosses: [],
   description: undefined,
   detours: undefined,
   examples: undefined,
   fields: undefined,
-  follow: [],
   id: 'test.stub',
   idempotent: undefined,
   input: z.object({}),
   intent: 'read' as const,
   kind: 'trail' as const,
-  metadata: undefined,
+  meta: undefined,
   output: undefined,
-  run: (_input: unknown, _ctx: TrailContext) => Result.ok({}),
-  services: [],
+  provisions: [],
 };
 
-describe('configLayer', () => {
+describe('configGate', () => {
   describe('identity', () => {
     test('has name "config"', () => {
-      expect(configLayer.name).toBe('config');
+      expect(configGate.name).toBe('config');
     });
 
     test('has a description', () => {
-      expect(configLayer.description).toBeDefined();
+      expect(configGate.description).toBeDefined();
     });
   });
 
@@ -38,7 +38,7 @@ describe('configLayer', () => {
       const impl = (_input: unknown, _ctx: TrailContext) =>
         Result.ok({ called: true });
 
-      const wrapped = configLayer.wrap(stubTrail, impl);
+      const wrapped = configGate.wrap(stubTrail, impl);
       const ctx = {
         cwd: '/tmp',
         env: {},

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

@@ -2,7 +2,7 @@ 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 { createServiceLookup } from '@ontrails/core';
+import { createProvisionLookup } from '@ontrails/core';
 import type { TrailContext } from '@ontrails/core';
 import { z } from 'zod';
 
@@ -11,22 +11,22 @@ import type { ConfigState } from '../registry.js';
 import { configInit } from '../trails/config-init.js';
 
 /**
- * Build a TrailContext with configService resolved in extensions.
+ * 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',
-    service: undefined as unknown as TrailContext['service'],
-    signal: AbortSignal.timeout(5000),
     workspaceRoot: '/tmp',
   };
   const withLookup = {
     ...ctx,
-    service: createServiceLookup(() => withLookup),
+    provision: createProvisionLookup(() => withLookup),
   };
   return withLookup;
 };
@@ -55,17 +55,17 @@ describe('config.init trail', () => {
       expect(configInit.intent).toBe('write');
     });
 
-    test('has infrastructure metadata', () => {
-      expect(configInit.metadata).toEqual({ category: 'infrastructure' });
+    test('has infrastructure meta', () => {
+      expect(configInit.meta).toEqual({ category: 'infrastructure' });
     });
 
     test('has output schema', () => {
       expect(configInit.output).toBeDefined();
     });
 
-    test('declares configService dependency', () => {
-      expect(configInit.services).toBeDefined();
-      expect(configInit.services?.length).toBe(1);
+    test('declares configProvision dependency', () => {
+      expect(configInit.provisions).toBeDefined();
+      expect(configInit.provisions?.length).toBe(1);
     });
   });
 
@@ -78,7 +78,7 @@ describe('config.init trail', () => {
   describe('wired behavior', () => {
     test('generates TOML output by default', async () => {
       const ctx = buildCtx(testState);
-      const result = await configInit.run({ format: 'toml' }, ctx);
+      const result = await configInit.blaze({ format: 'toml' }, ctx);
 
       expect(result.isOk()).toBe(true);
       const value = result.unwrap();
@@ -90,7 +90,7 @@ describe('config.init trail', () => {
 
     test('generates JSON output when requested', async () => {
       const ctx = buildCtx(testState);
-      const result = await configInit.run({ format: 'json' }, ctx);
+      const result = await configInit.blaze({ format: 'json' }, ctx);
 
       expect(result.isOk()).toBe(true);
       const value = result.unwrap();
@@ -101,7 +101,7 @@ describe('config.init trail', () => {
 
     test('generates YAML output when requested', async () => {
       const ctx = buildCtx(testState);
-      const result = await configInit.run({ format: 'yaml' }, ctx);
+      const result = await configInit.blaze({ format: 'yaml' }, ctx);
 
       expect(result.isOk()).toBe(true);
       const value = result.unwrap();
@@ -111,7 +111,7 @@ describe('config.init trail', () => {
 
     test('generates JSONC output when requested', async () => {
       const ctx = buildCtx(testState);
-      const result = await configInit.run({ format: 'jsonc' }, ctx);
+      const result = await configInit.blaze({ format: 'jsonc' }, ctx);
 
       expect(result.isOk()).toBe(true);
       const value = result.unwrap();
@@ -121,7 +121,7 @@ describe('config.init trail', () => {
 
     test('output content is non-empty for schema with fields', async () => {
       const ctx = buildCtx(testState);
-      const result = await configInit.run({ format: 'toml' }, ctx);
+      const result = await configInit.blaze({ format: 'toml' }, ctx);
 
       expect(result.isOk()).toBe(true);
       expect(result.unwrap().content.trim().length).toBeGreaterThan(0);
@@ -129,7 +129,7 @@ describe('config.init trail', () => {
 
     test('returns content without writtenFiles when dir is not provided', async () => {
       const ctx = buildCtx(testState);
-      const result = await configInit.run({ format: 'toml' }, ctx);
+      const result = await configInit.blaze({ format: 'toml' }, ctx);
 
       expect(result.isOk()).toBe(true);
       expect(result.unwrap().writtenFiles).toBeUndefined();
@@ -159,7 +159,7 @@ describe('config.init trail', () => {
 
     test('writes .schema.json when dir is provided', async () => {
       const ctx = buildCtx(envState);
-      const result = await configInit.run(
+      const result = await configInit.blaze(
         { dir: tempDir, format: 'toml' },
         ctx
       );
@@ -181,7 +181,7 @@ describe('config.init trail', () => {
 
     test('writes .env.example when schema has env bindings', async () => {
       const ctx = buildCtx(envState);
-      const result = await configInit.run(
+      const result = await configInit.blaze(
         { dir: tempDir, format: 'toml' },
         ctx
       );
@@ -196,7 +196,7 @@ describe('config.init trail', () => {
 
     test('still returns content alongside written files', async () => {
       const ctx = buildCtx(envState);
-      const result = await configInit.run(
+      const result = await configInit.blaze(
         { dir: tempDir, format: 'json' },
         ctx
       );

package/src/__tests__/{config-service.test.ts → config-provision.test.ts}

@@ -1,11 +1,11 @@
 import { afterEach, describe, expect, test } from 'bun:test';
 import { z } from 'zod';
 
-import { configService } from '../config-service.js';
+import { configProvision } from '../config-provision.js';
 import type { ConfigState } from '../registry.js';
 import { clearConfigState, registerConfigState } from '../registry.js';
 
-/** Stub ServiceContext for create calls. */
+/** Stub ProvisionContext for create calls. */
 const stubSvcCtx = {
   config: undefined,
   cwd: '/tmp',
@@ -13,32 +13,32 @@ const stubSvcCtx = {
   workspaceRoot: '/tmp',
 };
 
-describe('configService', () => {
+describe('configProvision', () => {
   afterEach(() => {
     clearConfigState();
   });
 
   describe('identity', () => {
     test('has id "config"', () => {
-      expect(configService.id).toBe('config');
+      expect(configProvision.id).toBe('config');
     });
 
-    test('has kind "service"', () => {
-      expect(configService.kind).toBe('service');
+    test('has kind "provision"', () => {
+      expect(configProvision.kind).toBe('provision');
     });
 
-    test('has infrastructure metadata', () => {
-      expect(configService.metadata).toEqual({ category: 'infrastructure' });
+    test('has infrastructure meta', () => {
+      expect(configProvision.meta).toEqual({ category: 'infrastructure' });
     });
 
     test('has description', () => {
-      expect(configService.description).toBeDefined();
+      expect(configProvision.description).toBeDefined();
     });
   });
 
   describe('mock', () => {
     test('returns a ConfigState with empty schema and resolved', () => {
-      const value = configService.mock?.() as ConfigState;
+      const value = configProvision.mock?.() as ConfigState;
       expect(value).toBeDefined();
       expect(value.resolved).toEqual({});
       expect(value.schema).toBeDefined();
@@ -51,7 +51,7 @@ describe('configService', () => {
       const state: ConfigState = { resolved: { port: 3000 }, schema };
       registerConfigState(state);
 
-      const result = await configService.create(stubSvcCtx);
+      const result = await configProvision.create(stubSvcCtx);
 
       expect(result.isOk()).toBe(true);
       const value = result.unwrap() as ConfigState;
@@ -69,7 +69,7 @@ describe('configService', () => {
       };
       registerConfigState(state);
 
-      const result = await configService.create(stubSvcCtx);
+      const result = await configProvision.create(stubSvcCtx);
 
       expect(result.isOk()).toBe(true);
       const value = result.unwrap() as ConfigState;
@@ -78,7 +78,7 @@ describe('configService', () => {
     });
 
     test('returns Result.err when no state is registered', async () => {
-      const result = await configService.create(stubSvcCtx);
+      const result = await configProvision.create(stubSvcCtx);
 
       expect(result.isErr()).toBe(true);
       expect(result.error.message).toContain('Config state not registered');