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

package/src/__tests__/run.test.ts

@@ -1,181 +0,0 @@
-/* oxlint-disable require-await -- trail implementations satisfy async interface without awaiting */
-import { describe, test, expect } from 'bun:test';
-
-import { z } from 'zod';
-
-import { run } from '../run';
-import { InternalError, NotFoundError, ValidationError } from '../errors';
-import type { Layer } from '../layer';
-import { Result } from '../result';
-import { resource } from '../resource';
-import { topo } from '../topo';
-import { trail } from '../trail';
-import type { TrailContext, TrailContextInit } from '../types';
-
-// ---------------------------------------------------------------------------
-// Fixtures
-// ---------------------------------------------------------------------------
-
-const echoTrail = trail('echo', {
-  blaze: (input) => Result.ok({ value: input.value }),
-  input: z.object({ value: z.string() }),
-  output: z.object({ value: z.string() }),
-});
-
-const throwingTrail = trail('throws', {
-  blaze: () => {
-    throw new Error('kaboom');
-  },
-  input: z.object({}),
-});
-
-const testTopo = topo('test', { echoTrail, throwingTrail });
-
-// ---------------------------------------------------------------------------
-// Tests
-// ---------------------------------------------------------------------------
-
-describe('run', () => {
-  describe('happy path', () => {
-    test('executes by ID and returns Result.ok with expected value', async () => {
-      const result = await run(testTopo, 'echo', { value: 'hello' });
-
-      expect(result.isOk()).toBe(true);
-      expect(result.unwrap()).toEqual({ value: 'hello' });
-    });
-
-    test('passes resource overrides through to executeTrail', async () => {
-      const id = `run.resource.${Bun.randomUUIDv7()}`;
-      const db = resource(id, {
-        create: () => Result.ok({ source: 'factory' }),
-      });
-      const searchTrail = trail('search', {
-        blaze: (_input, ctx) => Result.ok({ source: db.from(ctx).source }),
-        input: z.object({}),
-        output: z.object({ source: z.string() }),
-        resources: [db],
-      });
-      const searchTopo = topo('resource-test', { searchTrail });
-
-      const result = await run(
-        searchTopo,
-        'search',
-        {},
-        {
-          resources: { [id]: { source: 'override' } },
-        }
-      );
-
-      expect(result.isOk()).toBe(true);
-      expect(result.unwrap()).toEqual({ source: 'override' });
-    });
-  });
-
-  describe('not found', () => {
-    test('returns NotFoundError for unknown trail ID', async () => {
-      const result = await run(testTopo, 'nonexistent', {});
-
-      expect(result.isErr()).toBe(true);
-      expect(result.error).toBeInstanceOf(NotFoundError);
-      expect(result.error.message).toContain('nonexistent');
-      expect(result.error.message).toContain('test');
-    });
-  });
-
-  describe('validation', () => {
-    test('returns ValidationError for invalid input', async () => {
-      const result = await run(testTopo, 'echo', { value: 42 });
-
-      expect(result.isErr()).toBe(true);
-      expect(result.error).toBeInstanceOf(ValidationError);
-    });
-  });
-
-  describe('layers', () => {
-    test('layer composition works through run', async () => {
-      const log: string[] = [];
-      const layer: Layer = {
-        name: 'test-layer',
-        wrap(_trail, impl) {
-          return async (input, ctx) => {
-            log.push('before');
-            const r = await impl(input, ctx);
-            log.push('after');
-            return r;
-          };
-        },
-      };
-
-      const result = await run(
-        testTopo,
-        'echo',
-        { value: 'x' },
-        { layers: [layer] }
-      );
-
-      expect(result.isOk()).toBe(true);
-      expect(log).toEqual(['before', 'after']);
-    });
-  });
-
-  describe('context', () => {
-    test('context overrides work through run', async () => {
-      let capturedCtx: TrailContext | undefined;
-      const ctxTrail = trail('ctx-run-test', {
-        blaze: (_input, ctx) => {
-          capturedCtx = ctx;
-          return Result.ok(null);
-        },
-        input: z.object({}),
-      });
-
-      const ctxTopo = topo('ctx-test', { ctxTrail });
-      await run(
-        ctxTopo,
-        'ctx-run-test',
-        {},
-        { ctx: { requestId: 'override-id' } }
-      );
-
-      expect(capturedCtx?.requestId).toBe('override-id');
-    });
-
-    test('createContext factory works through run', async () => {
-      let capturedCtx: TrailContext | undefined;
-      const ctxTrail = trail('factory-run-test', {
-        blaze: (_input, ctx) => {
-          capturedCtx = ctx;
-          return Result.ok(null);
-        },
-        input: z.object({}),
-      });
-
-      const ctxTopo = topo('factory-test', { ctxTrail });
-      const customCtx: TrailContextInit = {
-        abortSignal: new AbortController().signal,
-        cwd: '/custom',
-        requestId: 'factory-id',
-      };
-
-      await run(
-        ctxTopo,
-        'factory-run-test',
-        {},
-        { createContext: () => customCtx }
-      );
-
-      expect(capturedCtx?.requestId).toBe('factory-id');
-      expect(capturedCtx?.cwd).toBe('/custom');
-    });
-  });
-
-  describe('error handling', () => {
-    test('never throws — exceptions become InternalError', async () => {
-      const result = await run(testTopo, 'throws', {});
-
-      expect(result.isErr()).toBe(true);
-      expect(result.error).toBeInstanceOf(InternalError);
-      expect(result.error.message).toBe('kaboom');
-    });
-  });
-});

package/src/__tests__/serialization.test.ts

@@ -1,401 +0,0 @@
-import { describe, test, expect } from 'bun:test';
-
-import {
-  ValidationError,
-  AmbiguousError,
-  AssertionError,
-  NetworkError,
-  RateLimitError,
-  InternalError,
-  TimeoutError,
-  NotFoundError,
-  AlreadyExistsError,
-  ConflictError,
-  PermissionError,
-  AuthError,
-  CancelledError,
-} from '../errors.js';
-import {
-  serializeError,
-  deserializeError,
-  safeStringify,
-} from '../serialization.js';
-import { Result } from '../result.js';
-import type { SerializedError } from '../serialization.js';
-
-// ---------------------------------------------------------------------------
-// serializeError
-// ---------------------------------------------------------------------------
-
-describe('serializeError', () => {
-  test('serializes a plain Error', () => {
-    const err = new Error('boom');
-    const serialized = serializeError(err);
-    expect(serialized.name).toBe('Error');
-    expect(serialized.message).toBe('boom');
-    expect(serialized.stack).toBeDefined();
-    expect(serialized.category).toBeUndefined();
-    expect(serialized.retryable).toBeUndefined();
-  });
-
-  test('serializes a TrailsError with category', () => {
-    const err = new NetworkError('disconnected');
-    const serialized = serializeError(err);
-    expect(serialized.name).toBe('NetworkError');
-    expect(serialized.message).toBe('disconnected');
-    expect(serialized.category).toBe('network');
-    expect(serialized.retryable).toBe(true);
-  });
-
-  test('serializes context', () => {
-    const err = new ValidationError('bad input', {
-      context: { field: 'email' },
-    });
-    const serialized = serializeError(err);
-    expect(serialized.context).toEqual({ field: 'email' });
-  });
-
-  test('serializes RateLimitError.retryAfter', () => {
-    const err = new RateLimitError('slow down', { retryAfter: 30 });
-    const serialized = serializeError(err);
-    expect(serialized.retryAfter).toBe(30);
-  });
-
-  test('retryAfter is undefined for non-RateLimitError', () => {
-    const err = new TimeoutError('timed out');
-    const serialized = serializeError(err);
-    expect(serialized.retryAfter).toBeUndefined();
-  });
-});
-
-// ---------------------------------------------------------------------------
-// deserializeError
-// ---------------------------------------------------------------------------
-
-describe('deserializeError', () => {
-  test('reconstructs a validation error', () => {
-    const data: SerializedError = {
-      category: 'validation',
-      message: 'bad input',
-      name: 'ValidationError',
-      retryable: false,
-    };
-    const err = deserializeError(data);
-    expect(err).toBeInstanceOf(ValidationError);
-    expect(err.message).toBe('bad input');
-    expect(err.category).toBe('validation');
-  });
-
-  test('reconstructs a rate limit error with retryAfter', () => {
-    const data: SerializedError = {
-      category: 'rate_limit',
-      message: 'slow down',
-      name: 'RateLimitError',
-      retryAfter: 60,
-      retryable: true,
-    };
-    const err = deserializeError(data);
-    expect(err).toBeInstanceOf(RateLimitError);
-    expect((err as RateLimitError).retryAfter).toBe(60);
-  });
-
-  test('restores stack trace', () => {
-    const data: SerializedError = {
-      category: 'internal',
-      message: 'oops',
-      name: 'InternalError',
-      stack: 'Error: oops\n    at test.ts:1:1',
-    };
-    const err = deserializeError(data);
-    expect(err.stack).toBe('Error: oops\n    at test.ts:1:1');
-  });
-
-  test('restores context', () => {
-    const data: SerializedError = {
-      category: 'auth',
-      context: { endpoint: '/api/secret' },
-      message: 'unauthorized',
-      name: 'AuthError',
-    };
-    const err = deserializeError(data);
-    expect(err.context).toEqual({ endpoint: '/api/secret' });
-  });
-
-  test('defaults to InternalError when category is missing', () => {
-    const data: SerializedError = {
-      message: 'unknown',
-      name: 'SomeError',
-    };
-    const err = deserializeError(data);
-    expect(err).toBeInstanceOf(InternalError);
-    expect(err.category).toBe('internal');
-  });
-
-  test('round-trips through serialize/deserialize', () => {
-    const original = new NotFoundError('missing resource', {
-      context: { id: 'abc' },
-    });
-    const serialized = serializeError(original);
-    const restored = deserializeError(serialized);
-    expect(restored).toBeInstanceOf(NotFoundError);
-    expect(restored.message).toBe('missing resource');
-    expect(restored.context).toEqual({ id: 'abc' });
-    expect(restored.category).toBe('not_found');
-  });
-
-  test('handles all error categories', () => {
-    const categories = [
-      'validation',
-      'not_found',
-      'conflict',
-      'permission',
-      'timeout',
-      'rate_limit',
-      'network',
-      'internal',
-      'auth',
-      'cancelled',
-    ] as const;
-
-    for (const category of categories) {
-      const data: SerializedError = {
-        category,
-        message: 'test',
-        name: 'Test',
-      };
-      const err = deserializeError(data);
-      expect(err.category).toBe(category);
-    }
-  });
-
-  describe('round-trips all subclasses by name', () => {
-    const subclasses = [
-      { Ctor: ValidationError, category: 'validation' },
-      { Ctor: AmbiguousError, category: 'validation' },
-      { Ctor: AssertionError, category: 'internal' },
-      { Ctor: NotFoundError, category: 'not_found' },
-      { Ctor: AlreadyExistsError, category: 'conflict' },
-      { Ctor: ConflictError, category: 'conflict' },
-      { Ctor: PermissionError, category: 'permission' },
-      { Ctor: TimeoutError, category: 'timeout' },
-      { Ctor: NetworkError, category: 'network' },
-      { Ctor: InternalError, category: 'internal' },
-      { Ctor: AuthError, category: 'auth' },
-      { Ctor: CancelledError, category: 'cancelled' },
-    ] as const;
-
-    test.each(subclasses)(
-      '$Ctor.name round-trips with correct identity',
-      ({ Ctor, category }) => {
-        const original = new Ctor(`test ${Ctor.name}`, {
-          context: { key: 'value' },
-        });
-        const serialized = serializeError(original);
-        const restored = deserializeError(serialized);
-
-        expect(restored).toBeInstanceOf(Ctor);
-        expect(restored.constructor.name).toBe(Ctor.name);
-        expect(restored.name).toBe(Ctor.name);
-        expect(restored.category).toBe(category);
-        expect(restored.message).toBe(`test ${Ctor.name}`);
-        expect(restored.context).toEqual({ key: 'value' });
-      }
-    );
-
-    test('RateLimitError round-trips with retryAfter', () => {
-      const original = new RateLimitError('slow down', {
-        context: { endpoint: '/api' },
-        retryAfter: 42,
-      });
-      const serialized = serializeError(original);
-      const restored = deserializeError(serialized);
-
-      expect(restored).toBeInstanceOf(RateLimitError);
-      expect(restored.constructor.name).toBe('RateLimitError');
-      expect((restored as RateLimitError).retryAfter).toBe(42);
-      expect(restored.context).toEqual({ endpoint: '/api' });
-    });
-
-    test('falls back to category when name is unknown', () => {
-      const data: SerializedError = {
-        category: 'conflict',
-        message: 'custom error',
-        name: 'CustomConflictError',
-      };
-      const err = deserializeError(data);
-      expect(err).toBeInstanceOf(ConflictError);
-      expect(err.category).toBe('conflict');
-    });
-  });
-});
-
-// ---------------------------------------------------------------------------
-// Result.fromJson
-// ---------------------------------------------------------------------------
-
-describe('Result.fromJson (safeParse)', () => {
-  test('parses valid JSON', () => {
-    const result = Result.fromJson('{"key": "value"}');
-    expect(result.isOk()).toBe(true);
-    expect(result.unwrap()).toEqual({ key: 'value' });
-  });
-
-  test('parses JSON arrays', () => {
-    const result = Result.fromJson('[1, 2, 3]');
-    expect(result.isOk()).toBe(true);
-    expect(result.unwrap()).toEqual([1, 2, 3]);
-  });
-
-  test('parses JSON primitives', () => {
-    expect(Result.fromJson('"hello"').unwrap()).toBe('hello');
-    expect(Result.fromJson('42').unwrap()).toBe(42);
-    expect(Result.fromJson('true').unwrap()).toBe(true);
-    expect(Result.fromJson('null').unwrap()).toBe(null);
-  });
-
-  test('returns ValidationError for invalid JSON', () => {
-    const result = Result.fromJson('not json');
-    expect(result.isErr()).toBe(true);
-    const err = result as unknown as { error: ValidationError };
-    expect(err.error).toBeInstanceOf(ValidationError);
-    expect(err.error.message).toBe('Invalid JSON');
-  });
-
-  test('includes truncated input in context', () => {
-    const result = Result.fromJson('{bad}');
-    expect(result.isErr()).toBe(true);
-    const err = result as unknown as { error: ValidationError };
-    expect(err.error.context).toBeDefined();
-    expect(err.error.context?.['input']).toBe('{bad}');
-  });
-});
-
-// ---------------------------------------------------------------------------
-// Result.toJson
-// ---------------------------------------------------------------------------
-
-describe('Result.toJson (safeStringify)', () => {
-  test('stringifies objects', () => {
-    const result = Result.toJson({ key: 'value' });
-    expect(result.isOk()).toBe(true);
-    expect(result.unwrap()).toBe('{"key":"value"}');
-  });
-
-  test('stringifies arrays', () => {
-    const result = Result.toJson([1, 2, 3]);
-    expect(result.isOk()).toBe(true);
-    expect(result.unwrap()).toBe('[1,2,3]');
-  });
-
-  test('stringifies primitives', () => {
-    expect(Result.toJson('hello').unwrap()).toBe('"hello"');
-    expect(Result.toJson(42).unwrap()).toBe('42');
-    expect(Result.toJson(true).unwrap()).toBe('true');
-    expect(Result.toJson(null).unwrap()).toBe('null');
-  });
-
-  test('handles circular references gracefully', () => {
-    const obj: Record<string, unknown> = { a: 1 };
-    obj['self'] = obj;
-    const result = Result.toJson(obj);
-    expect(result.isOk()).toBe(true);
-    const ok = result as unknown as { value: string };
-    const parsed = JSON.parse(ok.value) as Record<string, unknown>;
-    expect(parsed['a']).toBe(1);
-    expect(parsed['self']).toBe('[Circular]');
-  });
-
-  test('serializes shared references in a DAG without marking as circular', () => {
-    const shared = { x: 1 };
-    const obj = { a: shared, b: shared };
-    const result = Result.toJson(obj);
-    expect(result.isOk()).toBe(true);
-    const parsed = JSON.parse(result.unwrap()) as Record<string, unknown>;
-    expect(parsed['a']).toEqual({ x: 1 });
-    expect(parsed['b']).toEqual({ x: 1 });
-  });
-
-  test('detects deep circular references', () => {
-    const inner: Record<string, unknown> = { value: 'deep' };
-    const obj: Record<string, unknown> = { child: { nested: inner } };
-    inner['back'] = obj;
-    const result = Result.toJson(obj);
-    expect(result.isOk()).toBe(true);
-    const parsed = JSON.parse(result.unwrap()) as Record<string, unknown>;
-    const child = parsed['child'] as Record<string, unknown>;
-    const nested = child['nested'] as Record<string, unknown>;
-    expect(nested['value']).toBe('deep');
-    expect(nested['back']).toBe('[Circular]');
-  });
-
-  test('handles shared ref used in sibling subtrees of a DAG', () => {
-    const shared = { id: 42 };
-    const obj = {
-      left: { extra: 'l', ref: shared },
-      right: { extra: 'r', ref: shared },
-    };
-    const result = Result.toJson(obj);
-    expect(result.isOk()).toBe(true);
-    const parsed = JSON.parse(result.unwrap()) as Record<
-      string,
-      Record<string, unknown>
-    >;
-    expect(parsed['left']?.['ref']).toEqual({ id: 42 });
-    expect(parsed['right']?.['ref']).toEqual({ id: 42 });
-  });
-});
-
-// ---------------------------------------------------------------------------
-// safeStringify (shared DAG / circular detection)
-// ---------------------------------------------------------------------------
-
-describe('safeStringify', () => {
-  test('serializes shared references in a DAG without marking as circular', () => {
-    const shared = { x: 1 };
-    const obj = { a: shared, b: shared };
-    const result = safeStringify(obj);
-    expect(result.isOk()).toBe(true);
-    const parsed = JSON.parse(result.unwrap()) as Record<string, unknown>;
-    expect(parsed['a']).toEqual({ x: 1 });
-    expect(parsed['b']).toEqual({ x: 1 });
-  });
-
-  test('detects true circular references', () => {
-    const obj: Record<string, unknown> = { a: 1 };
-    obj['self'] = obj;
-    const result = safeStringify(obj);
-    expect(result.isOk()).toBe(true);
-    const parsed = JSON.parse(result.unwrap()) as Record<string, unknown>;
-    expect(parsed['a']).toBe(1);
-    expect(parsed['self']).toBe('[Circular]');
-  });
-
-  test('detects deep circular references', () => {
-    const inner: Record<string, unknown> = { value: 'deep' };
-    const obj: Record<string, unknown> = { child: { nested: inner } };
-    inner['back'] = obj;
-    const result = safeStringify(obj);
-    expect(result.isOk()).toBe(true);
-    const parsed = JSON.parse(result.unwrap()) as Record<string, unknown>;
-    const child = parsed['child'] as Record<string, unknown>;
-    const nested = child['nested'] as Record<string, unknown>;
-    expect(nested['value']).toBe('deep');
-    expect(nested['back']).toBe('[Circular]');
-  });
-
-  test('handles shared ref used in sibling subtrees of a DAG', () => {
-    const shared = { id: 42 };
-    const obj = {
-      left: { extra: 'l', ref: shared },
-      right: { extra: 'r', ref: shared },
-    };
-    const result = safeStringify(obj);
-    expect(result.isOk()).toBe(true);
-    const parsed = JSON.parse(result.unwrap()) as Record<
-      string,
-      Record<string, unknown>
-    >;
-    expect(parsed['left']?.['ref']).toEqual({ id: 42 });
-    expect(parsed['right']?.['ref']).toEqual({ id: 42 });
-  });
-});