@ontrails/core 1.0.0-beta.3 → 1.0.0-beta.32

package/src/__tests__/errors.test.ts

@@ -1,309 +0,0 @@
-import { describe, test, expect } from 'bun:test';
-
-import {
-  TrailsError,
-  ValidationError,
-  AmbiguousError,
-  AssertionError,
-  NotFoundError,
-  AlreadyExistsError,
-  ConflictError,
-  PermissionError,
-  TimeoutError,
-  RateLimitError,
-  NetworkError,
-  InternalError,
-  AuthError,
-  CancelledError,
-  exitCodeMap,
-  statusCodeMap,
-  jsonRpcCodeMap,
-  retryableMap,
-  isRetryable,
-  isTrailsError,
-} from '../errors.js';
-import type { ErrorCategory } from '../errors.js';
-
-// ---------------------------------------------------------------------------
-// Error class matrix
-// ---------------------------------------------------------------------------
-
-const errorMatrix: readonly {
-  Class: new (
-    message: string,
-    options?: { cause?: Error; context?: Record<string, unknown> }
-  ) => TrailsError;
-  category: ErrorCategory;
-  retryable: boolean;
-  name: string;
-}[] = [
-  {
-    Class: ValidationError,
-    category: 'validation',
-    name: 'ValidationError',
-    retryable: false,
-  },
-  {
-    Class: AmbiguousError,
-    category: 'validation',
-    name: 'AmbiguousError',
-    retryable: false,
-  },
-  {
-    Class: AssertionError,
-    category: 'internal',
-    name: 'AssertionError',
-    retryable: false,
-  },
-  {
-    Class: NotFoundError,
-    category: 'not_found',
-    name: 'NotFoundError',
-    retryable: false,
-  },
-  {
-    Class: AlreadyExistsError,
-    category: 'conflict',
-    name: 'AlreadyExistsError',
-    retryable: false,
-  },
-  {
-    Class: ConflictError,
-    category: 'conflict',
-    name: 'ConflictError',
-    retryable: false,
-  },
-  {
-    Class: PermissionError,
-    category: 'permission',
-    name: 'PermissionError',
-    retryable: false,
-  },
-  {
-    Class: TimeoutError,
-    category: 'timeout',
-    name: 'TimeoutError',
-    retryable: true,
-  },
-  {
-    Class: RateLimitError,
-    category: 'rate_limit',
-    name: 'RateLimitError',
-    retryable: true,
-  },
-  {
-    Class: NetworkError,
-    category: 'network',
-    name: 'NetworkError',
-    retryable: true,
-  },
-  {
-    Class: InternalError,
-    category: 'internal',
-    name: 'InternalError',
-    retryable: false,
-  },
-  { Class: AuthError, category: 'auth', name: 'AuthError', retryable: false },
-  {
-    Class: CancelledError,
-    category: 'cancelled',
-    name: 'CancelledError',
-    retryable: false,
-  },
-];
-
-describe('error classes', () => {
-  // oxlint-disable-next-line prefer-each -- describe.each loses type safety on heterogeneous class matrix
-  for (const { Class, category, retryable, name } of errorMatrix) {
-    describe(name, () => {
-      test('sets correct category', () => {
-        const err = new Class('test');
-        expect(err.category).toBe(category);
-      });
-
-      test('sets correct retryable', () => {
-        const err = new Class('test');
-        expect(err.retryable).toBe(retryable);
-      });
-
-      test('sets message', () => {
-        const err = new Class('something went wrong');
-        expect(err.message).toBe('something went wrong');
-      });
-
-      test('sets name to constructor name', () => {
-        const err = new Class('test');
-        expect(err.name).toBe(name);
-      });
-
-      test('sets cause when provided', () => {
-        const cause = new Error('root cause');
-        const err = new Class('test', { cause });
-        expect(err.cause).toBe(cause);
-      });
-
-      test('sets context when provided', () => {
-        const ctx = { action: 'delete', userId: 'u_123' };
-        const err = new Class('test', { context: ctx });
-        expect(err.context).toEqual(ctx);
-      });
-
-      test('context is undefined when not provided', () => {
-        const err = new Class('test');
-        expect(err.context).toBeUndefined();
-      });
-
-      test('is instanceof TrailsError', () => {
-        const err = new Class('test');
-        expect(err).toBeInstanceOf(TrailsError);
-      });
-
-      test('is instanceof Error', () => {
-        const err = new Class('test');
-        expect(err).toBeInstanceOf(Error);
-      });
-
-      test('is instanceof its own class', () => {
-        const err = new Class('test');
-        expect(err).toBeInstanceOf(Class);
-      });
-    });
-  }
-});
-
-// ---------------------------------------------------------------------------
-// RateLimitError.retryAfter
-// ---------------------------------------------------------------------------
-
-describe('RateLimitError.retryAfter', () => {
-  test('stores retryAfter when provided', () => {
-    const err = new RateLimitError('slow down', { retryAfter: 30 });
-    expect(err.retryAfter).toBe(30);
-  });
-
-  test('retryAfter is undefined when not provided', () => {
-    const err = new RateLimitError('slow down');
-    expect(err.retryAfter).toBeUndefined();
-  });
-
-  test('retryAfter coexists with cause and context', () => {
-    const cause = new Error('upstream');
-    const err = new RateLimitError('slow down', {
-      cause,
-      context: { endpoint: '/api' },
-      retryAfter: 60,
-    });
-    expect(err.retryAfter).toBe(60);
-    expect(err.cause).toBe(cause);
-    expect(err.context).toEqual({ endpoint: '/api' });
-  });
-});
-
-// ---------------------------------------------------------------------------
-// Taxonomy maps
-// ---------------------------------------------------------------------------
-
-describe('exitCodeMap', () => {
-  test('maps all categories to expected exit codes', () => {
-    expect(exitCodeMap.validation).toBe(1);
-    expect(exitCodeMap.not_found).toBe(2);
-    expect(exitCodeMap.conflict).toBe(3);
-    expect(exitCodeMap.permission).toBe(4);
-    expect(exitCodeMap.timeout).toBe(5);
-    expect(exitCodeMap.rate_limit).toBe(6);
-    expect(exitCodeMap.network).toBe(7);
-    expect(exitCodeMap.internal).toBe(8);
-    expect(exitCodeMap.auth).toBe(9);
-    expect(exitCodeMap.cancelled).toBe(130);
-  });
-});
-
-describe('statusCodeMap', () => {
-  test('maps all categories to expected HTTP status codes', () => {
-    expect(statusCodeMap.validation).toBe(400);
-    expect(statusCodeMap.not_found).toBe(404);
-    expect(statusCodeMap.conflict).toBe(409);
-    expect(statusCodeMap.permission).toBe(403);
-    expect(statusCodeMap.timeout).toBe(504);
-    expect(statusCodeMap.rate_limit).toBe(429);
-    expect(statusCodeMap.network).toBe(502);
-    expect(statusCodeMap.internal).toBe(500);
-    expect(statusCodeMap.auth).toBe(401);
-    expect(statusCodeMap.cancelled).toBe(499);
-  });
-});
-
-describe('jsonRpcCodeMap', () => {
-  test('maps all categories to expected JSON-RPC codes', () => {
-    expect(jsonRpcCodeMap.validation).toBe(-32_602);
-    expect(jsonRpcCodeMap.not_found).toBe(-32_601);
-    expect(jsonRpcCodeMap.conflict).toBe(-32_603);
-    expect(jsonRpcCodeMap.permission).toBe(-32_600);
-    expect(jsonRpcCodeMap.timeout).toBe(-32_603);
-    expect(jsonRpcCodeMap.rate_limit).toBe(-32_603);
-    expect(jsonRpcCodeMap.network).toBe(-32_603);
-    expect(jsonRpcCodeMap.internal).toBe(-32_603);
-    expect(jsonRpcCodeMap.auth).toBe(-32_600);
-    expect(jsonRpcCodeMap.cancelled).toBe(-32_603);
-  });
-});
-
-describe('retryableMap', () => {
-  test('only timeout, rate_limit, and network are retryable', () => {
-    expect(retryableMap.timeout).toBe(true);
-    expect(retryableMap.rate_limit).toBe(true);
-    expect(retryableMap.network).toBe(true);
-
-    expect(retryableMap.validation).toBe(false);
-    expect(retryableMap.not_found).toBe(false);
-    expect(retryableMap.conflict).toBe(false);
-    expect(retryableMap.permission).toBe(false);
-    expect(retryableMap.internal).toBe(false);
-    expect(retryableMap.auth).toBe(false);
-    expect(retryableMap.cancelled).toBe(false);
-  });
-});
-
-// ---------------------------------------------------------------------------
-// Helper functions
-// ---------------------------------------------------------------------------
-
-describe('isRetryable', () => {
-  test('returns true for retryable errors', () => {
-    expect(isRetryable(new TimeoutError('timed out'))).toBe(true);
-    expect(isRetryable(new RateLimitError('too fast'))).toBe(true);
-    expect(isRetryable(new NetworkError('disconnected'))).toBe(true);
-  });
-
-  test('returns false for non-retryable errors', () => {
-    expect(isRetryable(new ValidationError('bad input'))).toBe(false);
-    expect(isRetryable(new NotFoundError('missing'))).toBe(false);
-    expect(isRetryable(new AuthError('unauthorized'))).toBe(false);
-    expect(isRetryable(new InternalError('oops'))).toBe(false);
-    expect(isRetryable(new CancelledError('aborted'))).toBe(false);
-  });
-
-  test('returns false for plain Error', () => {
-    expect(isRetryable(new Error('generic'))).toBe(false);
-  });
-});
-
-describe('isTrailsError', () => {
-  test('returns true for TrailsError subclasses', () => {
-    expect(isTrailsError(new ValidationError('bad'))).toBe(true);
-    expect(isTrailsError(new NetworkError('down'))).toBe(true);
-    expect(isTrailsError(new CancelledError('stop'))).toBe(true);
-  });
-
-  test('returns false for plain Error', () => {
-    expect(isTrailsError(new Error('nope'))).toBe(false);
-  });
-
-  test('returns false for non-error values', () => {
-    expect(isTrailsError(null)).toBe(false);
-    expect(isTrailsError()).toBe(false);
-    expect(isTrailsError('string')).toBe(false);
-    expect(isTrailsError(42)).toBe(false);
-    expect(isTrailsError({})).toBe(false);
-  });
-});

package/src/__tests__/event.test.ts

@@ -1,82 +0,0 @@
-import { describe, test, expect } from 'bun:test';
-
-import { z } from 'zod';
-
-import { event } from '../event';
-
-const payloadSchema = z.object({
-  action: z.string(),
-  userId: z.string(),
-});
-
-const userAction = event('user.action', {
-  description: 'A user performed an action',
-  from: ['auth.login', 'auth.signup'],
-  markers: { domain: 'auth', priority: 1 },
-  payload: payloadSchema,
-});
-
-describe('event() basics', () => {
-  test("returns kind 'event'", () => {
-    expect(userAction.kind).toBe('event');
-  });
-
-  test('returns correct id', () => {
-    expect(userAction.id).toBe('user.action');
-  });
-
-  test('preserves payload schema', () => {
-    const parsed = userAction.payload.safeParse({
-      action: 'click',
-      userId: 'u-1',
-    });
-    expect(parsed.success).toBe(true);
-
-    const bad = userAction.payload.safeParse({ userId: 42 });
-    expect(bad.success).toBe(false);
-  });
-
-  test('preserves description', () => {
-    expect(userAction.description).toBe('A user performed an action');
-  });
-
-  test('result object is frozen', () => {
-    expect(Object.isFrozen(userAction)).toBe(true);
-  });
-});
-
-describe('event() from and markers', () => {
-  test('preserves from', () => {
-    expect(userAction.from).toEqual(['auth.login', 'auth.signup']);
-  });
-
-  test('from array is frozen', () => {
-    expect(Object.isFrozen(userAction.from)).toBe(true);
-  });
-
-  test('preserves markers', () => {
-    expect(userAction.markers).toEqual({ domain: 'auth', priority: 1 });
-  });
-
-  test('optional fields default to undefined', () => {
-    const minimal = event('minimal', {
-      payload: z.string(),
-    });
-    expect(minimal.description).toBeUndefined();
-    expect(minimal.from).toBeUndefined();
-    expect(minimal.markers).toBeUndefined();
-  });
-});
-
-describe('event() single-object overload', () => {
-  test('accepts spec with id property', () => {
-    const e = event({
-      from: ['entity.add', 'entity.delete'],
-      id: 'entity.updated',
-      payload: z.object({ entityId: z.string() }),
-    });
-    expect(e.id).toBe('entity.updated');
-    expect(e.kind).toBe('event');
-    expect(e.from).toEqual(['entity.add', 'entity.delete']);
-  });
-});

package/src/__tests__/fetch.test.ts

@@ -1,217 +0,0 @@
-/* oxlint-disable require-await -- test mocks satisfy async interface without awaiting */
-import { describe, test, expect, afterEach } from 'bun:test';
-
-import {
-  AuthError,
-  CancelledError,
-  InternalError,
-  NetworkError,
-  NotFoundError,
-  PermissionError,
-  ValidationError,
-  RateLimitError,
-  TimeoutError,
-} from '../errors.js';
-import { Result } from '../result.js';
-
-// ---------------------------------------------------------------------------
-// Mock fetch
-// ---------------------------------------------------------------------------
-
-const originalFetch = globalThis.fetch;
-
-const mockFetch = (impl: () => Promise<Response>) => {
-  globalThis.fetch = impl as unknown as typeof globalThis.fetch;
-};
-
-afterEach(() => {
-  globalThis.fetch = originalFetch;
-});
-
-const fakeResponse = (
-  status: number,
-  options?: { headers?: Record<string, string> }
-): Response => {
-  const init: ResponseInit = { status };
-  if (options?.headers) {
-    init.headers = options.headers;
-  }
-  return new Response(null, init);
-};
-
-// ---------------------------------------------------------------------------
-// Successful responses
-// ---------------------------------------------------------------------------
-
-describe('Result.fromFetch — success', () => {
-  test('returns Ok with Response for 200', async () => {
-    mockFetch(async () => fakeResponse(200));
-    const result = await Result.fromFetch('https://example.com/api');
-    expect(result.isOk()).toBe(true);
-    expect(result.unwrap().status).toBe(200);
-  });
-
-  test('returns Ok for 201', async () => {
-    mockFetch(async () => fakeResponse(201));
-    const result = await Result.fromFetch('https://example.com/api');
-    expect(result.isOk()).toBe(true);
-  });
-
-  test('returns Ok for 204', async () => {
-    mockFetch(async () => fakeResponse(204));
-    const result = await Result.fromFetch('https://example.com/api');
-    expect(result.isOk()).toBe(true);
-  });
-});
-
-// ---------------------------------------------------------------------------
-// HTTP error status mapping
-// ---------------------------------------------------------------------------
-
-describe('Result.fromFetch — status code mapping', () => {
-  test('401 → AuthError', async () => {
-    mockFetch(async () => fakeResponse(401));
-    const result = await Result.fromFetch('https://example.com/api');
-    expect(result.isErr()).toBe(true);
-    expect((result as unknown as { error: Error }).error).toBeInstanceOf(
-      AuthError
-    );
-  });
-
-  test('403 → PermissionError', async () => {
-    mockFetch(async () => fakeResponse(403));
-    const result = await Result.fromFetch('https://example.com/api');
-    expect(result.isErr()).toBe(true);
-    expect((result as unknown as { error: Error }).error).toBeInstanceOf(
-      PermissionError
-    );
-  });
-
-  test('404 → NotFoundError', async () => {
-    mockFetch(async () => fakeResponse(404));
-    const result = await Result.fromFetch('https://example.com/api');
-    expect(result.isErr()).toBe(true);
-    expect((result as unknown as { error: Error }).error).toBeInstanceOf(
-      NotFoundError
-    );
-  });
-
-  test('429 → RateLimitError', async () => {
-    mockFetch(async () => fakeResponse(429));
-    const result = await Result.fromFetch('https://example.com/api');
-    expect(result.isErr()).toBe(true);
-    expect((result as unknown as { error: Error }).error).toBeInstanceOf(
-      RateLimitError
-    );
-  });
-
-  test('429 with retry-after header', async () => {
-    mockFetch(async () =>
-      fakeResponse(429, { headers: { 'retry-after': '30' } })
-    );
-    const result = await Result.fromFetch('https://example.com/api');
-    expect(result.isErr()).toBe(true);
-    const err = (result as unknown as { error: RateLimitError }).error;
-    expect(err).toBeInstanceOf(RateLimitError);
-    expect(err.retryAfter).toBe(30);
-  });
-
-  test('500 → InternalError', async () => {
-    mockFetch(async () => fakeResponse(500));
-    const result = await Result.fromFetch('https://example.com/api');
-    expect(result.isErr()).toBe(true);
-    expect((result as unknown as { error: Error }).error).toBeInstanceOf(
-      InternalError
-    );
-  });
-
-  test('502 → NetworkError', async () => {
-    mockFetch(async () => fakeResponse(502));
-    const result = await Result.fromFetch('https://example.com/api');
-    expect(result.isErr()).toBe(true);
-    expect((result as unknown as { error: Error }).error).toBeInstanceOf(
-      NetworkError
-    );
-  });
-
-  test('504 → TimeoutError', async () => {
-    mockFetch(async () => fakeResponse(504));
-    const result = await Result.fromFetch('https://example.com/api');
-    expect(result.isErr()).toBe(true);
-    expect((result as unknown as { error: Error }).error).toBeInstanceOf(
-      TimeoutError
-    );
-  });
-
-  test('503 → InternalError (generic 5xx)', async () => {
-    mockFetch(async () => fakeResponse(503));
-    const result = await Result.fromFetch('https://example.com/api');
-    expect(result.isErr()).toBe(true);
-    expect((result as unknown as { error: Error }).error).toBeInstanceOf(
-      InternalError
-    );
-  });
-
-  test('400 → ValidationError', async () => {
-    mockFetch(async () => fakeResponse(400));
-    const result = await Result.fromFetch('https://example.com/api');
-    expect(result.isErr()).toBe(true);
-    expect((result as unknown as { error: Error }).error).toBeInstanceOf(
-      ValidationError
-    );
-  });
-});
-
-// ---------------------------------------------------------------------------
-// Network / abort errors
-// ---------------------------------------------------------------------------
-
-describe('Result.fromFetch — network errors', () => {
-  test('TypeError → NetworkError', async () => {
-    mockFetch(async () => {
-      throw new TypeError('Failed to fetch');
-    });
-    const result = await Result.fromFetch('https://example.com/api');
-    expect(result.isErr()).toBe(true);
-    expect((result as unknown as { error: Error }).error).toBeInstanceOf(
-      NetworkError
-    );
-  });
-
-  test('AbortError → CancelledError', async () => {
-    mockFetch(async () => {
-      throw new DOMException('The operation was aborted', 'AbortError');
-    });
-    const result = await Result.fromFetch('https://example.com/api');
-    expect(result.isErr()).toBe(true);
-    expect((result as unknown as { error: Error }).error).toBeInstanceOf(
-      CancelledError
-    );
-  });
-
-  test('unknown thrown value → NetworkError', async () => {
-    mockFetch(async () => {
-      // oxlint-disable-next-line no-throw-literal -- intentionally testing non-Error rejection handling
-      throw 'string error';
-    });
-    const result = await Result.fromFetch('https://example.com/api');
-    expect(result.isErr()).toBe(true);
-    expect((result as unknown as { error: Error }).error).toBeInstanceOf(
-      NetworkError
-    );
-  });
-});
-
-// ---------------------------------------------------------------------------
-// Error context
-// ---------------------------------------------------------------------------
-
-describe('Result.fromFetch — error context', () => {
-  test('includes status in error context', async () => {
-    mockFetch(async () => fakeResponse(404));
-    const result = await Result.fromFetch('https://example.com/api');
-    expect(result.isErr()).toBe(true);
-    const err = (result as unknown as { error: NotFoundError }).error;
-    expect(err.context?.['status']).toBe(404);
-  });
-});

package/src/__tests__/guards.test.ts

@@ -1,102 +0,0 @@
-import { describe, test, expect } from 'bun:test';
-
-import {
-  isDefined,
-  isNonEmptyString,
-  isPlainObject,
-  hasProperty,
-  assertNever,
-} from '../guards';
-
-describe('guards', () => {
-  describe('isDefined()', () => {
-    test('returns true for non-nullish values', () => {
-      expect(isDefined(0)).toBe(true);
-      expect(isDefined('')).toBe(true);
-      expect(isDefined(false)).toBe(true);
-      expect(isDefined([])).toBe(true);
-    });
-
-    test('returns false for null', () => {
-      expect(isDefined(null)).toBe(false);
-    });
-
-    test('returns false for undefined', () => {
-      expect(isDefined()).toBe(false);
-    });
-  });
-
-  describe('isNonEmptyString()', () => {
-    test('returns true for non-empty strings', () => {
-      expect(isNonEmptyString('hello')).toBe(true);
-      expect(isNonEmptyString(' ')).toBe(true);
-    });
-
-    test('returns false for empty string', () => {
-      expect(isNonEmptyString('')).toBe(false);
-    });
-
-    test('returns false for non-string types', () => {
-      expect(isNonEmptyString(42)).toBe(false);
-      expect(isNonEmptyString(null)).toBe(false);
-      expect(isNonEmptyString()).toBe(false);
-      expect(isNonEmptyString([])).toBe(false);
-    });
-  });
-
-  describe('isPlainObject()', () => {
-    test('returns true for plain objects', () => {
-      expect(isPlainObject({})).toBe(true);
-      expect(isPlainObject({ a: 1 })).toBe(true);
-      expect(isPlainObject(Object.create(null))).toBe(true);
-    });
-
-    test('returns false for arrays', () => {
-      expect(isPlainObject([])).toBe(false);
-    });
-
-    test('returns false for class instances', () => {
-      expect(isPlainObject(new Date())).toBe(false);
-      expect(isPlainObject(new Map())).toBe(false);
-    });
-
-    test('returns false for null', () => {
-      expect(isPlainObject(null)).toBe(false);
-    });
-
-    test('returns false for primitives', () => {
-      expect(isPlainObject('string')).toBe(false);
-      expect(isPlainObject(42)).toBe(false);
-    });
-  });
-
-  describe('hasProperty()', () => {
-    test('returns true when key exists', () => {
-      expect(hasProperty({ name: 'test' }, 'name')).toBe(true);
-    });
-
-    test('returns true for keys with undefined values', () => {
-      expect(hasProperty({ x: undefined }, 'x')).toBe(true);
-    });
-
-    test('returns false when key is missing', () => {
-      expect(hasProperty({}, 'missing')).toBe(false);
-    });
-
-    test('returns false for null', () => {
-      expect(hasProperty(null, 'key')).toBe(false);
-    });
-
-    test('returns false for primitives', () => {
-      expect(hasProperty(42, 'key')).toBe(false);
-    });
-  });
-
-  describe('assertNever()', () => {
-    test('throws with a descriptive message', () => {
-      expect(() => assertNever('unexpected' as never)).toThrow(
-        'Unexpected value: unexpected'
-      );
-    });
-  });
-});