@ontrails/core 1.0.0-beta.4 → 1.0.0-beta.41

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'
-      );
-    });
-  });
-});

package/src/__tests__/job.test.ts

@@ -1,98 +0,0 @@
-import { describe, test, expect } from 'bun:test';
-
-import { z } from 'zod';
-
-import { jobOutputSchema } from '../job';
-
-describe('jobOutputSchema', () => {
-  test('parses a valid completed job output', () => {
-    const input = {
-      completedAt: '2026-03-25T00:01:00Z',
-      current: 10,
-      jobId: 'job-123',
-      percentage: 100,
-      result: { rows: 42 },
-      startedAt: '2026-03-25T00:00:00Z',
-      status: 'completed',
-      total: 10,
-    };
-
-    const parsed = jobOutputSchema.parse(input);
-
-    expect(parsed.jobId).toBe('job-123');
-    expect(parsed.status).toBe('completed');
-    expect(parsed.current).toBe(10);
-    expect(parsed.total).toBe(10);
-  });
-
-  test('parses a minimal pending job output', () => {
-    const input = {
-      current: 0,
-      jobId: 'job-456',
-      status: 'pending',
-      total: 100,
-    };
-
-    const parsed = jobOutputSchema.parse(input);
-
-    expect(parsed.jobId).toBe('job-456');
-    expect(parsed.status).toBe('pending');
-    expect(parsed.result).toBeUndefined();
-    expect(parsed.error).toBeUndefined();
-  });
-
-  test('parses a failed job with error', () => {
-    const input = {
-      current: 3,
-      error: 'connection reset',
-      jobId: 'job-789',
-      status: 'failed',
-      total: 10,
-    };
-
-    const parsed = jobOutputSchema.parse(input);
-
-    expect(parsed.status).toBe('failed');
-    expect(parsed.error).toBe('connection reset');
-  });
-
-  test('rejects when jobId is missing', () => {
-    const input = {
-      current: 1,
-      status: 'running',
-      total: 5,
-    };
-
-    expect(() => jobOutputSchema.parse(input)).toThrow();
-  });
-
-  test('rejects an invalid status value', () => {
-    const input = {
-      current: 0,
-      jobId: 'job-bad',
-      status: 'unknown',
-      total: 0,
-    };
-
-    expect(() => jobOutputSchema.parse(input)).toThrow();
-  });
-
-  test('composes statusFields and progressFields correctly', () => {
-    const { shape } = jobOutputSchema;
-
-    // Status field from statusFields()
-    expect(shape.status).toBeInstanceOf(z.ZodEnum);
-
-    // Progress fields from progressFields()
-    expect(shape.current).toBeInstanceOf(z.ZodNumber);
-    expect(shape.total).toBeInstanceOf(z.ZodNumber);
-    expect(shape.percentage).toBeDefined();
-
-    // Job-specific fields
-    expect(shape.jobId).toBeInstanceOf(z.ZodString);
-    expect(shape.error).toBeDefined();
-    expect(shape.result).toBeDefined();
-    expect(shape.startedAt).toBeDefined();
-    expect(shape.completedAt).toBeDefined();
-  });
-});

package/src/__tests__/layer.test.ts

@@ -1,212 +0,0 @@
-/* oxlint-disable require-await -- adapter mocks and layer wrappers satisfy async interfaces without awaiting */
-import { describe, test, expect } from 'bun:test';
-
-import { z } from 'zod';
-
-import type {
-  IndexAdapter,
-  StorageAdapter,
-  CacheAdapter,
-  SearchOptions,
-  SearchResult,
-  StorageOptions,
-} from '../adapters';
-import type { HealthStatus, HealthResult, HealthCheck } from '../health';
-import { composeLayers } from '../layer';
-import type { Layer } from '../layer';
-import { Result } from '../result';
-import { trail } from '../trail';
-import type { TrailContext } from '../types';
-
-const stubCtx: TrailContext = {
-  requestId: 'test-layer',
-  signal: AbortSignal.timeout(5000),
-};
-
-const echoTrail = trail('echo', {
-  input: z.object({ value: z.string() }),
-  metadata: { domain: 'test' },
-  output: z.object({ value: z.string() }),
-  run: (input) => Result.ok({ value: input.value }),
-});
-
-// ---------------------------------------------------------------------------
-// Layer tests
-// ---------------------------------------------------------------------------
-
-describe('Layer', () => {
-  test('single layer wraps implementation', async () => {
-    const prefixLayer: Layer = {
-      name: 'prefix',
-      wrap(_trail, impl) {
-        return async (input, ctx) => {
-          const result = await impl(input, ctx);
-          return result.map((out) => ({
-            ...out,
-            value: `prefixed:${(out as { value: string }).value}`,
-          }));
-        };
-      },
-    };
-
-    const wrapped = composeLayers([prefixLayer], echoTrail, echoTrail.run);
-    const result = await wrapped({ value: 'hello' }, stubCtx);
-
-    expect(result.isOk()).toBe(true);
-    expect(result.unwrap()).toEqual({ value: 'prefixed:hello' });
-  });
-
-  test('multiple layers compose in outermost-first order', async () => {
-    const log: string[] = [];
-
-    const outer: Layer = {
-      name: 'outer',
-      wrap(_trail, impl) {
-        return async (input, ctx) => {
-          log.push('outer:before');
-          const r = await impl(input, ctx);
-          log.push('outer:after');
-          return r;
-        };
-      },
-    };
-
-    const inner: Layer = {
-      name: 'inner',
-      wrap(_trail, impl) {
-        return async (input, ctx) => {
-          log.push('inner:before');
-          const r = await impl(input, ctx);
-          log.push('inner:after');
-          return r;
-        };
-      },
-    };
-
-    const wrapped = composeLayers([outer, inner], echoTrail, echoTrail.run);
-    await wrapped({ value: 'x' }, stubCtx);
-
-    expect(log).toEqual([
-      'outer:before',
-      'inner:before',
-      'inner:after',
-      'outer:after',
-    ]);
-  });
-
-  test('layer can short-circuit without calling inner implementation', async () => {
-    const shortCircuit: Layer = {
-      name: 'short-circuit',
-      wrap() {
-        return async () => Result.err(new Error('blocked'));
-      },
-    };
-
-    const wrapped = composeLayers([shortCircuit], echoTrail, echoTrail.run);
-    const result = await wrapped({ value: 'hello' }, stubCtx);
-
-    expect(result.isErr()).toBe(true);
-    const err = result as unknown as { error: Error };
-    expect(err.error.message).toBe('blocked');
-  });
-
-  test('layer can inspect trail metadata', () => {
-    let capturedDomain: unknown;
-
-    const inspectLayer: Layer = {
-      name: 'inspect',
-      wrap(t, impl) {
-        capturedDomain = t.metadata?.['domain'];
-        return impl;
-      },
-    };
-
-    composeLayers([inspectLayer], echoTrail, echoTrail.run);
-
-    expect(capturedDomain).toBe('test');
-  });
-
-  test('empty layers array returns implementation unchanged', () => {
-    const wrapped = composeLayers([], echoTrail, echoTrail.run);
-    expect(wrapped).toBe(echoTrail.run);
-  });
-});
-
-// ---------------------------------------------------------------------------
-// Health types (compile-time verification)
-// ---------------------------------------------------------------------------
-
-describe('health types', () => {
-  test('HealthResult satisfies the interface', () => {
-    const check: HealthCheck = {
-      latency: 12,
-      message: 'ok',
-      status: 'healthy',
-    };
-    const result: HealthResult = {
-      checks: { db: check },
-      status: 'healthy',
-      uptime: 3600,
-      version: '1.0.0',
-    };
-
-    expect(result.status).toBe('healthy');
-    expect(result.checks['db']?.status).toBe('healthy');
-  });
-
-  test('HealthStatus union is exhaustive', () => {
-    const statuses: HealthStatus[] = ['healthy', 'degraded', 'unhealthy'];
-    expect(statuses).toHaveLength(3);
-  });
-});
-
-// ---------------------------------------------------------------------------
-// Adapter types (compile-time verification)
-// ---------------------------------------------------------------------------
-
-describe('adapter types', () => {
-  test('IndexAdapter mock satisfies the interface', () => {
-    const mock: IndexAdapter = {
-      index: async () => Result.ok(),
-      remove: async () => Result.ok(),
-      search: async () => Result.ok([]),
-    };
-    expect(mock.index).toBeDefined();
-    expect(mock.search).toBeDefined();
-    expect(mock.remove).toBeDefined();
-  });
-
-  test('StorageAdapter mock satisfies the interface', () => {
-    const mock: StorageAdapter = {
-      delete: async () => Result.ok(),
-      get: async () => Result.ok('value'),
-      has: async () => Result.ok(true),
-      set: async () => Result.ok(),
-    };
-    expect(mock.has).toBeDefined();
-  });
-
-  test('CacheAdapter mock satisfies the interface', () => {
-    const mock: CacheAdapter = {
-      clear: async () => Result.ok(),
-      delete: async () => Result.ok(),
-      get: async () => Result.ok(),
-      set: async () => Result.ok(),
-    };
-    expect(mock.clear).toBeDefined();
-  });
-
-  test('SearchOptions and SearchResult satisfy their shapes', () => {
-    const opts: SearchOptions = { filters: { tag: 'a' }, limit: 10, offset: 0 };
-    const hit: SearchResult = {
-      document: { title: 'x' },
-      id: '1',
-      score: 0.95,
-    };
-    const sopts: StorageOptions = { ttl: 5000 };
-
-    expect(opts.limit).toBe(10);
-    expect(hit.score).toBe(0.95);
-    expect(sopts.ttl).toBe(5000);
-  });
-});