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

package/src/__tests__/topo.test.ts

@@ -1,277 +0,0 @@
-import { describe, test, expect } from 'bun:test';
-
-import { z } from 'zod';
-
-import { ValidationError } from '../errors.js';
-import { provision } from '../provision.js';
-import { Result } from '../result.js';
-import { topo } from '../topo.js';
-
-// ---------------------------------------------------------------------------
-// Mock factories
-// ---------------------------------------------------------------------------
-
-// oxlint-disable-next-line require-await -- satisfies async interface without needing await
-const noop = async () => Result.ok();
-
-const mockTrail = (id: string, crosses?: readonly string[]) => ({
-  blaze: noop,
-  crosses: Object.freeze([...(crosses ?? [])]),
-  id,
-  input: z.object({ x: z.number() }),
-  kind: 'trail' as const,
-  output: z.object({ y: z.number() }),
-});
-
-const mockEvent = (id: string) => ({
-  id,
-  kind: 'signal' as const,
-  payload: z.object({ payload: z.string() }),
-});
-
-const mockProvision = (id: string) =>
-  provision(id, {
-    create: () => Result.ok({ id }),
-    description: `${id} provision`,
-  });
-
-// ---------------------------------------------------------------------------
-// topo()
-// ---------------------------------------------------------------------------
-
-describe('topo', () => {
-  describe('collection', () => {
-    test('returns Topo with name', () => {
-      const t = topo('my-app');
-      expect(t.name).toBe('my-app');
-    });
-
-    test('collects trails from modules', () => {
-      const mod = { myTrail: mockTrail('create-user') };
-      const t = topo('app', mod);
-
-      expect(t.trails.size).toBe(1);
-      expect(t.trails.get('create-user')).toBe(mod.myTrail);
-    });
-
-    test('auto-scans exports by kind discriminant', () => {
-      const mod = {
-        event1: mockEvent('e1'),
-        provision1: mockProvision('s1'),
-        trail1: mockTrail('t1'),
-        trail2: mockTrail('t2', ['t1']),
-      };
-      const t = topo('app', mod);
-
-      expect(t.trails.size).toBe(2);
-      expect(t.signals.size).toBe(1);
-      expect(t.provisions.size).toBe(1);
-    });
-
-    test('collects from multiple modules', () => {
-      const mod1 = { a: mockTrail('t1') };
-      const mod2 = { b: mockTrail('t2'), c: mockTrail('t3', ['t1']) };
-      const t = topo('app', mod1, mod2);
-
-      expect(t.trails.size).toBe(3);
-    });
-
-    test('non-trail exports are silently ignored', () => {
-      const mod = {
-        config: { port: 3000 },
-        helper: () => 'not a trail',
-        name: 'some-string',
-        nothing: null,
-        num: 42,
-        trail1: mockTrail('t1'),
-        undef: undefined,
-      };
-      const t = topo('app', mod);
-
-      expect(t.trails.size).toBe(1);
-      expect(t.signals.size).toBe(0);
-      expect(t.provisions.size).toBe(0);
-    });
-
-    test('trail with crossings registers correctly', () => {
-      const mod = { t: mockTrail('trail-1', ['trail-2']) };
-      const t = topo('app', mod);
-
-      expect(t.trails.size).toBe(1);
-      const registered = t.trails.get('trail-1');
-      expect(registered?.crosses).toEqual(['trail-2']);
-    });
-
-    test('collects provisions from modules', () => {
-      const mod = { db: mockProvision('db.main') };
-      const t = topo('app', mod);
-
-      expect(t.provisions.size).toBe(1);
-      expect(t.provisions.get('db.main')).toBe(mod.db);
-    });
-  });
-
-  describe('duplicate rejection', () => {
-    test('rejects duplicate trail IDs', () => {
-      const mod1 = { a: mockTrail('dup') };
-      const mod2 = { b: mockTrail('dup') };
-
-      expect(() => topo('app', mod1, mod2)).toThrow(ValidationError);
-      expect(() => topo('app', mod1, mod2)).toThrow(
-        'Duplicate trail ID: "dup"'
-      );
-    });
-
-    test('rejects duplicate event IDs', () => {
-      const mod1 = { a: mockEvent('dup') };
-      const mod2 = { b: mockEvent('dup') };
-
-      expect(() => topo('app', mod1, mod2)).toThrow(ValidationError);
-      expect(() => topo('app', mod1, mod2)).toThrow(
-        'Duplicate signal ID: "dup"'
-      );
-    });
-
-    test('rejects duplicate provision IDs', () => {
-      const mod1 = { a: mockProvision('dup') };
-      const mod2 = { b: mockProvision('dup') };
-
-      expect(() => topo('app', mod1, mod2)).toThrow(ValidationError);
-      expect(() => topo('app', mod1, mod2)).toThrow(
-        'Duplicate provision ID: "dup"'
-      );
-    });
-  });
-});
-
-// ---------------------------------------------------------------------------
-// topo accessors
-// ---------------------------------------------------------------------------
-
-describe('topo accessors', () => {
-  test('ids() returns all trail IDs', () => {
-    const a = mockTrail('alpha');
-    const b = mockTrail('beta');
-    const app = topo('test', { a, b });
-    expect(app.ids().toSorted()).toEqual(['alpha', 'beta']);
-  });
-
-  test('count returns number of trails', () => {
-    const a = mockTrail('alpha');
-    const app = topo('test', { a });
-    expect(app.count).toBe(1);
-  });
-
-  test('provisionCount returns number of provisions', () => {
-    const db = mockProvision('db.main');
-    const cache = mockProvision('cache.main');
-    const app = topo('test', { cache, db });
-    expect(app.provisionCount).toBe(2);
-  });
-
-  test('empty topo has zero count and empty ids', () => {
-    const app = topo('empty');
-    expect(app.count).toBe(0);
-    expect(app.ids()).toEqual([]);
-    expect(app.provisionCount).toBe(0);
-    expect(app.provisionIds()).toEqual([]);
-  });
-
-  test('provisionIds() returns all provision IDs', () => {
-    const db = mockProvision('db.main');
-    const cache = mockProvision('cache.main');
-    const app = topo('test', { cache, db });
-    expect(app.provisionIds().toSorted()).toEqual(['cache.main', 'db.main']);
-  });
-});
-
-// ---------------------------------------------------------------------------
-// Topo
-// ---------------------------------------------------------------------------
-
-describe('Topo', () => {
-  const mod = {
-    e1: mockEvent('event-1'),
-    p1: mockProvision('provision-1'),
-    t1: mockTrail('trail-1'),
-    t2: mockTrail('trail-2'),
-    t3: mockTrail('trail-3', ['trail-1']),
-  };
-
-  // Build once for the describe block
-  const app = topo('app', mod);
-
-  describe('get()', () => {
-    test('retrieves trail by ID', () => {
-      expect(app.get('trail-1')).toBe(mod.t1);
-    });
-
-    test('retrieves trail with crossings by ID', () => {
-      expect(app.get('trail-3')).toBe(mod.t3);
-    });
-
-    test('returns undefined for unknown ID', () => {
-      expect(app.get('nope')).toBeUndefined();
-    });
-  });
-
-  describe('has()', () => {
-    test('returns true for known trail', () => {
-      expect(app.has('trail-1')).toBe(true);
-    });
-
-    test('returns true for trail with crossings', () => {
-      expect(app.has('trail-3')).toBe(true);
-    });
-
-    test('returns false for unknown ID', () => {
-      expect(app.has('nope')).toBe(false);
-    });
-
-    test('returns false for event ID (signals are not trails)', () => {
-      expect(app.has('event-1')).toBe(false);
-    });
-  });
-
-  describe('getProvision()', () => {
-    test('retrieves provision by ID', () => {
-      expect(app.getProvision('provision-1')).toBe(mod.p1);
-    });
-
-    test('returns undefined for unknown provision ID', () => {
-      expect(app.getProvision('missing-provision')).toBeUndefined();
-    });
-  });
-
-  describe('hasProvision()', () => {
-    test('returns true for known provision', () => {
-      expect(app.hasProvision('provision-1')).toBe(true);
-    });
-
-    test('returns false for unknown provision', () => {
-      expect(app.hasProvision('missing-provision')).toBe(false);
-    });
-  });
-
-  describe('listing', () => {
-    test('list() returns all trails (with and without crossings)', () => {
-      const items = app.list();
-      expect(items).toHaveLength(3);
-      expect(items).toContain(mod.t1);
-      expect(items).toContain(mod.t2);
-      expect(items).toContain(mod.t3);
-    });
-
-    test('listEvents() returns all signals', () => {
-      const items = app.listSignals();
-      expect(items).toHaveLength(1);
-      expect(items).toContain(mod.e1);
-    });
-
-    test('listProvisions() returns all provisions', () => {
-      const items = app.listProvisions();
-      expect(items).toHaveLength(1);
-      expect(items).toContain(mod.p1);
-    });
-  });
-});

package/src/__tests__/trail-permit.test.ts

@@ -1,60 +0,0 @@
-import { describe, expect, test } from 'bun:test';
-
-import { z } from 'zod';
-
-import { Result } from '../result';
-import { trail } from '../trail';
-import type { PermitRequirement } from '../types';
-
-describe('PermitRequirement type', () => {
-  test('accepts a scopes object', () => {
-    const req: PermitRequirement = { scopes: ['user:write', 'user:read'] };
-    expect(req).toEqual({ scopes: ['user:write', 'user:read'] });
-  });
-
-  test('accepts public literal', () => {
-    const req: PermitRequirement = 'public';
-    expect(req).toBe('public');
-  });
-});
-
-describe('trail() with permit field', () => {
-  test('accepts permit with scopes', () => {
-    const t = trail('user.delete', {
-      blaze: (input) => Result.ok({ deleted: input.id }),
-      input: z.object({ id: z.string() }),
-      intent: 'destroy',
-      permit: { scopes: ['user:write'] },
-    });
-    expect(t.permit).toEqual({ scopes: ['user:write'] });
-  });
-
-  test('accepts permit: public', () => {
-    const t = trail('health.check', {
-      blaze: () => Result.ok({ status: 'ok' }),
-      input: z.object({}),
-      intent: 'read',
-      permit: 'public',
-    });
-    expect(t.permit).toBe('public');
-  });
-
-  test('permit is undefined when omitted (backward compatible)', () => {
-    const t = trail('legacy.trail', {
-      blaze: () => Result.ok(),
-      input: z.object({}),
-    });
-    expect(t.permit).toBeUndefined();
-  });
-
-  test('preserves permit on the frozen Trail object', () => {
-    const t = trail('user.list', {
-      blaze: () => Result.ok([]),
-      input: z.object({}),
-      intent: 'read',
-      permit: { scopes: ['user:read'] },
-    });
-    expect(Object.isFrozen(t)).toBe(true);
-    expect(t.permit).toEqual({ scopes: ['user:read'] });
-  });
-});

package/src/__tests__/trail.test.ts

@@ -1,261 +0,0 @@
-import { describe, test, expect } from 'bun:test';
-
-import { z } from 'zod';
-
-import { createTrailContext } from '../context';
-import { Result } from '../result';
-import { provision } from '../provision';
-import { trail } from '../trail';
-import type { TrailContext } from '../types';
-
-const stubCtx: TrailContext = createTrailContext({
-  abortSignal: AbortSignal.timeout(5000),
-  requestId: 'test-123',
-});
-
-const dbProvision = provision('db.main', {
-  create: () =>
-    Result.ok({
-      query(sql: string) {
-        return sql.length;
-      },
-    }),
-  description: 'Primary database provision',
-});
-
-describe('trail()', () => {
-  const inputSchema = z.object({ name: z.string() });
-  const outputSchema = z.object({ greeting: z.string() });
-
-  const greet = trail('greet', {
-    blaze: (input) => Result.ok({ greeting: `Hello, ${input.name}!` }),
-    description: 'Greet someone',
-    input: inputSchema,
-    output: outputSchema,
-  });
-
-  describe('basics', () => {
-    test('returns correct id', () => {
-      expect(greet.id).toBe('greet');
-    });
-
-    test("returns kind 'trail'", () => {
-      expect(greet.kind).toBe('trail');
-    });
-
-    test('preserves input schema', () => {
-      const parsed = greet.input.safeParse({ name: 'World' });
-      expect(parsed.success).toBe(true);
-
-      const bad = greet.input.safeParse({ name: 42 });
-      expect(bad.success).toBe(false);
-    });
-
-    test('output schema is optional', () => {
-      const minimal = trail('noop', {
-        blaze: () => Result.ok(),
-        input: z.object({}),
-      });
-      expect(minimal.output).toBeUndefined();
-    });
-
-    test('implementation is callable', async () => {
-      const result = await greet.blaze({ name: 'World' }, stubCtx);
-      expect(result.isOk()).toBe(true);
-      expect(result.unwrap()).toEqual({ greeting: 'Hello, World!' });
-    });
-  });
-
-  describe('meta', () => {
-    test('examples are stored', () => {
-      const withExamples = trail('echo', {
-        blaze: (input) => Result.ok({ text: input.text }),
-        examples: [
-          { error: 'ValidationError', input: { text: '' }, name: 'error-case' },
-          { expected: { text: 'hi' }, input: { text: 'hi' }, name: 'basic' },
-        ],
-        input: z.object({ text: z.string() }),
-      });
-      expect(withExamples.examples).toHaveLength(2);
-      const first = withExamples.examples?.[0];
-      expect(first?.name).toBe('error-case');
-      const second = withExamples.examples?.[1];
-      expect(second?.name).toBe('basic');
-    });
-
-    test('meta is stored', () => {
-      const withMeta = trail('tagged', {
-        blaze: () => Result.ok(),
-        input: z.object({}),
-        meta: { domain: 'billing', tier: 1 },
-      });
-      expect(withMeta.meta).toEqual({ domain: 'billing', tier: 1 });
-    });
-
-    test('detours are stored', () => {
-      const withDetours = trail('orchestrator', {
-        blaze: () => Result.ok(),
-        detours: {
-          onFailure: ['alert'],
-          onSuccess: ['notify', 'audit'],
-        },
-        input: z.object({}),
-      });
-      expect(withDetours.detours).toEqual({
-        onFailure: ['alert'],
-        onSuccess: ['notify', 'audit'],
-      });
-    });
-  });
-
-  describe('crosses', () => {
-    test('defaults to empty frozen array when omitted', () => {
-      const minimal = trail('bare', {
-        blaze: () => Result.ok(),
-        input: z.object({}),
-      });
-      expect(minimal.crosses).toEqual([]);
-      expect(Object.isFrozen(minimal.crosses)).toBe(true);
-    });
-
-    test('preserves crosses array', () => {
-      const withCrosses = trail('composed', {
-        blaze: () => Result.ok(),
-        crosses: ['authenticate', 'validate-session'],
-        input: z.object({}),
-      });
-      expect(withCrosses.crosses).toEqual(['authenticate', 'validate-session']);
-    });
-
-    test('crosses array is frozen', () => {
-      const withCrosses = trail('composed', {
-        blaze: () => Result.ok(),
-        crosses: ['authenticate'],
-        input: z.object({}),
-      });
-      expect(Object.isFrozen(withCrosses.crosses)).toBe(true);
-    });
-  });
-
-  describe('provisions', () => {
-    test('defaults to empty frozen array when omitted', () => {
-      const minimal = trail('bare', {
-        blaze: () => Result.ok(),
-        input: z.object({}),
-      });
-      expect(minimal.provisions).toEqual([]);
-      expect(Object.isFrozen(minimal.provisions)).toBe(true);
-    });
-
-    test('preserves declared provision objects', () => {
-      const withProvisions = trail('search', {
-        blaze: () => Result.ok(),
-        input: z.object({}),
-        provisions: [dbProvision],
-      });
-      expect(withProvisions.provisions).toEqual([dbProvision]);
-      expect(withProvisions.provisions[0]).toBe(dbProvision);
-    });
-
-    test('provisions array is frozen', () => {
-      const withProvisions = trail('search', {
-        blaze: () => Result.ok(),
-        input: z.object({}),
-        provisions: [dbProvision],
-      });
-      expect(Object.isFrozen(withProvisions.provisions)).toBe(true);
-    });
-  });
-
-  describe('intent and idempotent', () => {
-    test('intent defaults to write', () => {
-      const minimal = trail('bare', {
-        blaze: () => Result.ok(),
-        input: z.object({}),
-      });
-      expect(minimal.intent).toBe('write');
-      expect(minimal.idempotent).toBeUndefined();
-    });
-
-    test('intent is preserved when set', () => {
-      const readTrail = trail('reader', {
-        blaze: () => Result.ok(),
-        input: z.object({}),
-        intent: 'read',
-      });
-      expect(readTrail.intent).toBe('read');
-
-      const destroyTrail = trail('destroyer', {
-        blaze: () => Result.ok(),
-        input: z.object({}),
-        intent: 'destroy',
-      });
-      expect(destroyTrail.intent).toBe('destroy');
-    });
-
-    test('idempotent is preserved when set', () => {
-      const t = trail('idempotent', {
-        blaze: () => Result.ok(),
-        idempotent: true,
-        input: z.object({}),
-      });
-      expect(t.idempotent).toBe(true);
-    });
-  });
-
-  describe('single-object overload', () => {
-    test('accepts spec with id property', () => {
-      const t = trail({
-        blaze: (input: { name: string }, _ctx: TrailContext) =>
-          Result.ok({ greeting: `Hi, ${input.name}` }),
-        id: 'entity.show',
-        input: inputSchema,
-      });
-      expect(t.id).toBe('entity.show');
-      expect(t.kind).toBe('trail');
-    });
-
-    test('preserves all spec fields', () => {
-      const t = trail({
-        blaze: (input: { name: string }, _ctx: TrailContext) =>
-          Result.ok({ greeting: `Hi, ${input.name}` }),
-        description: 'A full trail',
-        examples: [{ input: { name: 'World' }, name: 'test' }],
-        id: 'full',
-        input: inputSchema,
-        intent: 'read',
-        output: outputSchema,
-        provisions: [dbProvision],
-      });
-      expect(t.description).toBe('A full trail');
-      expect(t.intent).toBe('read');
-      expect(t.examples).toHaveLength(1);
-      expect(t.provisions).toEqual([dbProvision]);
-    });
-
-    test('implementation is callable', async () => {
-      const t = trail({
-        blaze: (input: { x: number }) => Result.ok(input.x * 2),
-        id: 'callable',
-        input: z.object({ x: z.number() }),
-      });
-      const result = await t.blaze({ x: 5 }, stubCtx);
-      expect(result.isOk()).toBe(true);
-      expect(result.unwrap()).toBe(10);
-    });
-
-    test('sync implementations are normalized to an awaitable runtime function', async () => {
-      const t = trail('normalized', {
-        blaze: (input: { value: number }) => Result.ok(input.value + 1),
-        input: z.object({ value: z.number() }),
-      });
-
-      const promise = t.blaze({ value: 2 }, stubCtx);
-      expect(promise).toBeInstanceOf(Promise);
-
-      const result = await promise;
-      expect(result.isOk()).toBe(true);
-      expect(result.unwrap()).toBe(3);
-    });
-  });
-});