@ontrails/core 1.0.0-beta.5 → 1.0.0-beta.50

package/src/__tests__/trail.test.ts

@@ -1,217 +0,0 @@
-import { describe, test, expect } from 'bun:test';
-
-import { z } from 'zod';
-
-import { Result } from '../result';
-import { trail } from '../trail';
-import type { TrailContext } from '../types';
-
-const stubCtx: TrailContext = {
-  requestId: 'test-123',
-  signal: AbortSignal.timeout(5000),
-};
-
-describe('trail()', () => {
-  const inputSchema = z.object({ name: z.string() });
-  const outputSchema = z.object({ greeting: z.string() });
-
-  const greet = trail('greet', {
-    description: 'Greet someone',
-    input: inputSchema,
-    output: outputSchema,
-    run: (input) => Result.ok({ greeting: `Hello, ${input.name}!` }),
-  });
-
-  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', {
-        input: z.object({}),
-        run: () => Result.ok(),
-      });
-      expect(minimal.output).toBeUndefined();
-    });
-
-    test('implementation is callable', async () => {
-      const result = await greet.run({ name: 'World' }, stubCtx);
-      expect(result.isOk()).toBe(true);
-      expect(result.unwrap()).toEqual({ greeting: 'Hello, World!' });
-    });
-  });
-
-  describe('metadata', () => {
-    test('examples are stored', () => {
-      const withExamples = trail('echo', {
-        examples: [
-          { error: 'ValidationError', input: { text: '' }, name: 'error-case' },
-          { expected: { text: 'hi' }, input: { text: 'hi' }, name: 'basic' },
-        ],
-        input: z.object({ text: z.string() }),
-        run: (input) => Result.ok({ text: input.text }),
-      });
-      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('metadata is stored', () => {
-      const withMetadata = trail('tagged', {
-        input: z.object({}),
-        metadata: { domain: 'billing', tier: 1 },
-        run: () => Result.ok(),
-      });
-      expect(withMetadata.metadata).toEqual({ domain: 'billing', tier: 1 });
-    });
-
-    test('detours are stored', () => {
-      const withDetours = trail('orchestrator', {
-        detours: {
-          onFailure: ['alert'],
-          onSuccess: ['notify', 'audit'],
-        },
-        input: z.object({}),
-        run: () => Result.ok(),
-      });
-      expect(withDetours.detours).toEqual({
-        onFailure: ['alert'],
-        onSuccess: ['notify', 'audit'],
-      });
-    });
-  });
-
-  describe('follow', () => {
-    test('defaults to empty frozen array when omitted', () => {
-      const minimal = trail('bare', {
-        input: z.object({}),
-        run: () => Result.ok(),
-      });
-      expect(minimal.follow).toEqual([]);
-      expect(Object.isFrozen(minimal.follow)).toBe(true);
-    });
-
-    test('preserves follow array', () => {
-      const withFollow = trail('composed', {
-        follow: ['authenticate', 'validate-session'],
-        input: z.object({}),
-        run: () => Result.ok(),
-      });
-      expect(withFollow.follow).toEqual(['authenticate', 'validate-session']);
-    });
-
-    test('follow array is frozen', () => {
-      const withFollow = trail('composed', {
-        follow: ['authenticate'],
-        input: z.object({}),
-        run: () => Result.ok(),
-      });
-      expect(Object.isFrozen(withFollow.follow)).toBe(true);
-    });
-  });
-
-  describe('intent and idempotent', () => {
-    test('intent defaults to write', () => {
-      const minimal = trail('bare', {
-        input: z.object({}),
-        run: () => Result.ok(),
-      });
-      expect(minimal.intent).toBe('write');
-      expect(minimal.idempotent).toBeUndefined();
-    });
-
-    test('intent is preserved when set', () => {
-      const readTrail = trail('reader', {
-        input: z.object({}),
-        intent: 'read',
-        run: () => Result.ok(),
-      });
-      expect(readTrail.intent).toBe('read');
-
-      const destroyTrail = trail('destroyer', {
-        input: z.object({}),
-        intent: 'destroy',
-        run: () => Result.ok(),
-      });
-      expect(destroyTrail.intent).toBe('destroy');
-    });
-
-    test('idempotent is preserved when set', () => {
-      const t = trail('idempotent', {
-        idempotent: true,
-        input: z.object({}),
-        run: () => Result.ok(),
-      });
-      expect(t.idempotent).toBe(true);
-    });
-  });
-
-  describe('single-object overload', () => {
-    test('accepts spec with id property', () => {
-      const t = trail({
-        id: 'entity.show',
-        input: inputSchema,
-        run: (input: { name: string }, _ctx: TrailContext) =>
-          Result.ok({ greeting: `Hi, ${input.name}` }),
-      });
-      expect(t.id).toBe('entity.show');
-      expect(t.kind).toBe('trail');
-    });
-
-    test('preserves all spec fields', () => {
-      const t = trail({
-        description: 'A full trail',
-        examples: [{ input: { name: 'World' }, name: 'test' }],
-        id: 'full',
-        input: inputSchema,
-        intent: 'read',
-        output: outputSchema,
-        run: (input: { name: string }, _ctx: TrailContext) =>
-          Result.ok({ greeting: `Hi, ${input.name}` }),
-      });
-      expect(t.description).toBe('A full trail');
-      expect(t.intent).toBe('read');
-      expect(t.examples).toHaveLength(1);
-    });
-
-    test('implementation is callable', async () => {
-      const t = trail({
-        id: 'callable',
-        input: z.object({ x: z.number() }),
-        run: (input: { x: number }) => Result.ok(input.x * 2),
-      });
-      const result = await t.run({ 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', {
-        input: z.object({ value: z.number() }),
-        run: (input: { value: number }) => Result.ok(input.value + 1),
-      });
-
-      const promise = t.run({ value: 2 }, stubCtx);
-      expect(promise).toBeInstanceOf(Promise);
-
-      const result = await promise;
-      expect(result.isOk()).toBe(true);
-      expect(result.unwrap()).toBe(3);
-    });
-  });
-});

package/src/__tests__/type-utils.test.ts

@@ -1,63 +0,0 @@
-import { describe, expect, test } from 'bun:test';
-
-import { z } from 'zod';
-
-import { Result } from '../result';
-import { trail } from '../trail';
-import type { TrailInput, TrailOutput } from '../type-utils';
-import { inputOf, outputOf } from '../type-utils';
-
-const greetTrail = trail('greet', {
-  input: z.object({ name: z.string() }),
-  output: z.object({ message: z.string() }),
-  run: (input) => Result.ok({ message: `Hello, ${input.name}!` }),
-});
-
-const noOutputTrail = trail('ping', {
-  input: z.object({}),
-  run: () => Result.ok(),
-});
-
-describe('type-utils', () => {
-  describe('inputOf', () => {
-    test('returns the Zod input schema and can parse valid input', () => {
-      const schema = inputOf(greetTrail);
-      const result = schema.safeParse({ name: 'Alice' });
-      expect(result.success).toBe(true);
-      expect(
-        (result as { success: true; data: { name: string } }).data
-      ).toEqual({
-        name: 'Alice',
-      });
-    });
-  });
-
-  describe('outputOf', () => {
-    test('returns the Zod output schema when defined', () => {
-      const schema = outputOf(greetTrail);
-      expect(schema).toBeDefined();
-      // oxlint-disable-next-line no-non-null-assertion -- guarded by toBeDefined() above
-      const result = schema!.safeParse({ message: 'hello' });
-      expect(result.success).toBe(true);
-    });
-
-    test('returns undefined when no output schema', () => {
-      const schema = outputOf(noOutputTrail);
-      expect(schema).toBeUndefined();
-    });
-  });
-
-  describe('type-level checks', () => {
-    test('TrailInput matches expected shape', () => {
-      // If this compiles, the type is correct
-      const _input: TrailInput<typeof greetTrail> = { name: 'test' };
-      expect(_input.name).toBe('test');
-    });
-
-    test('TrailOutput matches expected shape', () => {
-      // If this compiles, the type is correct
-      const _output: TrailOutput<typeof greetTrail> = { message: 'hello' };
-      expect(_output.message).toBe('hello');
-    });
-  });
-});

package/src/__tests__/validate-topo.test.ts

@@ -1,278 +0,0 @@
-import { describe, expect, test } from 'bun:test';
-
-import { z } from 'zod';
-
-import { Result } from '../result.js';
-import { topo } from '../topo.js';
-import type { TopoIssue } from '../validate-topo.js';
-import { validateTopo } from '../validate-topo.js';
-
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-
-// oxlint-disable-next-line require-await -- satisfies async interface
-const noop = async () => Result.ok();
-
-const mockTrail = (
-  id: string,
-  overrides?: {
-    follow?: readonly string[];
-    examples?: readonly {
-      name: string;
-      input: unknown;
-      expected?: unknown;
-      error?: string;
-    }[];
-    output?: z.ZodType;
-  }
-) => ({
-  follow: Object.freeze([...(overrides?.follow ?? [])]),
-  id,
-  input: z.object({ name: z.string() }),
-  kind: 'trail' as const,
-  run: noop,
-  ...overrides,
-});
-
-const mockEvent = (id: string, from?: readonly string[]) => ({
-  from,
-  id,
-  kind: 'event' as const,
-  payload: z.object({ data: z.string() }),
-});
-
-/** Extract issues from a failed validateTopo result. */
-const extractIssues = (result: Result<void, Error>): TopoIssue[] => {
-  if (result.isOk()) {
-    return [];
-  }
-  const ctx = (result.error as { context?: { issues?: TopoIssue[] } }).context;
-  return (ctx?.issues ?? []) as TopoIssue[];
-};
-
-// ---------------------------------------------------------------------------
-// Tests
-// ---------------------------------------------------------------------------
-
-describe('validateTopo', () => {
-  test('valid topo passes', () => {
-    const app = topo('app', {
-      add: mockTrail('entity.add'),
-      onboard: mockTrail('entity.onboard', {
-        follow: ['entity.add'],
-      }),
-      updated: mockEvent('entity.updated', ['entity.add']),
-    });
-
-    const result = validateTopo(app);
-    expect(result.isOk()).toBe(true);
-  });
-
-  describe('trail follow', () => {
-    test('trail following non-existent trail fails', () => {
-      const app = topo('app', {
-        onboard: mockTrail('entity.onboard', {
-          follow: ['entity.missing'],
-        }),
-      });
-
-      const result = validateTopo(app);
-      expect(result.isErr()).toBe(true);
-
-      const issues = extractIssues(result);
-      expect(issues).toHaveLength(1);
-      expect(issues[0]?.rule).toBe('follow-exists');
-      expect(issues[0]?.message).toContain('entity.missing');
-    });
-
-    test('trail following itself fails', () => {
-      const app = topo('app', {
-        loop: mockTrail('entity.loop', { follow: ['entity.loop'] }),
-      });
-
-      const result = validateTopo(app);
-      expect(result.isErr()).toBe(true);
-
-      const issues = extractIssues(result);
-      expect(issues.some((i) => i.rule === 'no-self-follow')).toBe(true);
-    });
-
-    test('two-node cycle (a→b→a) is detected', () => {
-      const app = topo('app', {
-        a: mockTrail('a', { follow: ['b'] }),
-        b: mockTrail('b', { follow: ['a'] }),
-      });
-
-      const result = validateTopo(app);
-      expect(result.isErr()).toBe(true);
-
-      const issues = extractIssues(result);
-      const cycleIssues = issues.filter((i) => i.rule === 'follow-cycle');
-      expect(cycleIssues.length).toBeGreaterThanOrEqual(1);
-      expect(cycleIssues[0]?.message).toContain('Cycle detected');
-    });
-
-    test('three-node cycle (a→b→c→a) is detected', () => {
-      const app = topo('app', {
-        a: mockTrail('a', { follow: ['b'] }),
-        b: mockTrail('b', { follow: ['c'] }),
-        c: mockTrail('c', { follow: ['a'] }),
-      });
-
-      const result = validateTopo(app);
-      expect(result.isErr()).toBe(true);
-
-      const issues = extractIssues(result);
-      const cycleIssues = issues.filter((i) => i.rule === 'follow-cycle');
-      expect(cycleIssues.length).toBeGreaterThanOrEqual(1);
-      expect(cycleIssues[0]?.message).toContain('Cycle detected');
-    });
-
-    test('valid DAG with shared targets is not flagged', () => {
-      const app = topo('app', {
-        a: mockTrail('a', { follow: ['c'] }),
-        b: mockTrail('b', { follow: ['c'] }),
-        c: mockTrail('c'),
-      });
-
-      const result = validateTopo(app);
-      expect(result.isOk()).toBe(true);
-    });
-  });
-
-  describe('example validation', () => {
-    test('example with invalid input fails', () => {
-      const app = topo('app', {
-        show: mockTrail('entity.show', {
-          examples: [{ input: { name: 123 }, name: 'Bad input' }],
-        }),
-      });
-
-      const result = validateTopo(app);
-      expect(result.isErr()).toBe(true);
-
-      const issues = extractIssues(result);
-      expect(issues).toHaveLength(1);
-      expect(issues[0]?.rule).toBe('example-input-valid');
-      expect(issues[0]?.message).toContain('Bad input');
-    });
-
-    test('example with expected output but no output schema warns', () => {
-      const app = topo('app', {
-        show: mockTrail('entity.show', {
-          examples: [
-            {
-              expected: { result: 'ok' },
-              input: { name: 'test' },
-              name: 'Has expected',
-            },
-          ],
-        }),
-      });
-
-      const result = validateTopo(app);
-      expect(result.isErr()).toBe(true);
-
-      const issues = extractIssues(result);
-      expect(issues).toHaveLength(1);
-      expect(issues[0]?.rule).toBe('output-schema-present');
-    });
-
-    test('ValidationError example with invalid input is allowed', () => {
-      const app = topo('app', {
-        show: mockTrail('entity.show', {
-          examples: [
-            {
-              error: 'ValidationError',
-              input: { name: 123 },
-              name: 'Error case',
-            },
-          ],
-        }),
-      });
-
-      const result = validateTopo(app);
-      expect(result.isOk()).toBe(true);
-    });
-
-    test('NotFoundError example with invalid input fails', () => {
-      const app = topo('app', {
-        show: mockTrail('entity.show', {
-          examples: [
-            {
-              error: 'NotFoundError',
-              input: { name: 123 },
-              name: 'Not found case',
-            },
-          ],
-        }),
-      });
-
-      const result = validateTopo(app);
-      expect(result.isErr()).toBe(true);
-
-      const issues = extractIssues(result);
-      expect(issues).toHaveLength(1);
-      expect(issues[0]?.rule).toBe('example-input-valid');
-    });
-
-    test('NotFoundError example with valid input passes', () => {
-      const app = topo('app', {
-        show: mockTrail('entity.show', {
-          examples: [
-            {
-              error: 'NotFoundError',
-              input: { name: 'test' },
-              name: 'Not found case',
-            },
-          ],
-        }),
-      });
-
-      const result = validateTopo(app);
-      expect(result.isOk()).toBe(true);
-    });
-  });
-
-  describe('event origins', () => {
-    test('event with non-existent origin fails', () => {
-      const app = topo('app', {
-        updated: mockEvent('entity.updated', ['entity.ghost']),
-      });
-
-      const result = validateTopo(app);
-      expect(result.isErr()).toBe(true);
-
-      const issues = extractIssues(result);
-      expect(issues).toHaveLength(1);
-      expect(issues[0]?.rule).toBe('event-origin-exists');
-      expect(issues[0]?.message).toContain('entity.ghost');
-    });
-
-    test('event without origins is accepted', () => {
-      const app = topo('app', {
-        updated: mockEvent('entity.updated'),
-      });
-
-      const result = validateTopo(app);
-      expect(result.isOk()).toBe(true);
-    });
-  });
-
-  test('collects multiple issues', () => {
-    const app = topo('app', {
-      broken: mockTrail('entity.broken', { follow: ['entity.missing'] }),
-      show: mockTrail('entity.show', {
-        examples: [{ input: { name: 123 }, name: 'Bad' }],
-      }),
-      updated: mockEvent('entity.updated', ['entity.ghost']),
-    });
-
-    const result = validateTopo(app);
-    expect(result.isErr()).toBe(true);
-
-    const issues = extractIssues(result);
-    expect(issues).toHaveLength(3);
-  });
-});