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

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__/gate.test.ts

@@ -1,125 +0,0 @@
-/* oxlint-disable require-await -- gate wrappers satisfy async interfaces without awaiting */
-import { describe, test, expect } from 'bun:test';
-
-import { z } from 'zod';
-
-import { createTrailContext } from '../context';
-import { composeGates } from '../gate';
-import type { Gate } from '../gate';
-import { Result } from '../result';
-import { trail } from '../trail';
-import type { TrailContext } from '../types';
-
-const stubCtx: TrailContext = createTrailContext({
-  abortSignal: AbortSignal.timeout(5000),
-  requestId: 'test-gate',
-});
-
-const echoTrail = trail('echo', {
-  blaze: (input) => Result.ok({ value: input.value }),
-  input: z.object({ value: z.string() }),
-  meta: { domain: 'test' },
-  output: z.object({ value: z.string() }),
-});
-
-// ---------------------------------------------------------------------------
-// Gate tests
-// ---------------------------------------------------------------------------
-
-describe('Gate', () => {
-  test('single gate wraps implementation', async () => {
-    const prefixGate: Gate = {
-      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 = composeGates([prefixGate], echoTrail, echoTrail.blaze);
-    const result = await wrapped({ value: 'hello' }, stubCtx);
-
-    expect(result.isOk()).toBe(true);
-    expect(result.unwrap()).toEqual({ value: 'prefixed:hello' });
-  });
-
-  test('multiple gates compose in outermost-first order', async () => {
-    const log: string[] = [];
-
-    const outer: Gate = {
-      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: Gate = {
-      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 = composeGates([outer, inner], echoTrail, echoTrail.blaze);
-    await wrapped({ value: 'x' }, stubCtx);
-
-    expect(log).toEqual([
-      'outer:before',
-      'inner:before',
-      'inner:after',
-      'outer:after',
-    ]);
-  });
-
-  test('gate can short-circuit without calling inner implementation', async () => {
-    const shortCircuit: Gate = {
-      name: 'short-circuit',
-      wrap() {
-        return async () => Result.err(new Error('blocked'));
-      },
-    };
-
-    const wrapped = composeGates([shortCircuit], echoTrail, echoTrail.blaze);
-    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('gate can inspect trail meta', () => {
-    let capturedDomain: unknown;
-
-    const inspectGate: Gate = {
-      name: 'inspect',
-      wrap(t, impl) {
-        capturedDomain = t.meta?.['domain'];
-        return impl;
-      },
-    };
-
-    composeGates([inspectGate], echoTrail, echoTrail.blaze);
-
-    expect(capturedDomain).toBe('test');
-  });
-
-  test('empty gates array returns implementation unchanged', () => {
-    const wrapped = composeGates([], echoTrail, echoTrail.blaze);
-    expect(wrapped).toBe(echoTrail.blaze);
-  });
-});

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__/path-security.test.ts

@@ -1,114 +0,0 @@
-import { describe, test, expect } from 'bun:test';
-import { resolve, join } from 'node:path';
-
-import { PermissionError } from '../errors.js';
-import { securePath, isPathSafe, resolveSafePath } from '../path-security.js';
-
-// ---------------------------------------------------------------------------
-// securePath
-// ---------------------------------------------------------------------------
-
-describe('securePath', () => {
-  const base = '/project/workspace';
-
-  test('resolves a simple relative path', () => {
-    const result = securePath(base, 'src/index.ts');
-    expect(result.isOk()).toBe(true);
-    expect(result.unwrap()).toBe(resolve(base, 'src/index.ts'));
-  });
-
-  test('resolves nested paths', () => {
-    const result = securePath(base, 'src/../lib/utils.ts');
-    expect(result.isOk()).toBe(true);
-    expect(result.unwrap()).toBe(resolve(base, 'lib/utils.ts'));
-  });
-
-  test('accepts the base directory itself', () => {
-    const result = securePath(base, '.');
-    expect(result.isOk()).toBe(true);
-    expect(result.unwrap()).toBe(resolve(base));
-  });
-
-  test('rejects path traversal with ..', () => {
-    const result = securePath(base, '../../etc/passwd');
-    expect(result.isErr()).toBe(true);
-    const err = result as unknown as { error: PermissionError };
-    expect(err.error).toBeInstanceOf(PermissionError);
-    expect(err.error.message).toContain('Path traversal detected');
-  });
-
-  test('rejects absolute paths outside base', () => {
-    const result = securePath(base, '/etc/passwd');
-    expect(result.isErr()).toBe(true);
-    const err = result as unknown as { error: PermissionError };
-    expect(err.error).toBeInstanceOf(PermissionError);
-  });
-
-  test('rejects sneaky traversal (subdir/../../..)', () => {
-    const result = securePath(base, 'src/../../..');
-    expect(result.isErr()).toBe(true);
-  });
-
-  test('allows paths that mention .. but stay inside', () => {
-    const result = securePath(base, 'src/../src/file.ts');
-    expect(result.isOk()).toBe(true);
-    expect(result.unwrap()).toBe(resolve(base, 'src/file.ts'));
-  });
-});
-
-// ---------------------------------------------------------------------------
-// isPathSafe
-// ---------------------------------------------------------------------------
-
-describe('isPathSafe', () => {
-  const base = '/project/workspace';
-
-  test('returns true for child paths', () => {
-    expect(isPathSafe(base, 'src/index.ts')).toBe(true);
-  });
-
-  test('returns true for the base directory', () => {
-    expect(isPathSafe(base, '.')).toBe(true);
-  });
-
-  test('returns false for traversal', () => {
-    expect(isPathSafe(base, '../secret')).toBe(false);
-  });
-
-  test('returns false for absolute paths outside base', () => {
-    expect(isPathSafe(base, '/tmp/evil')).toBe(false);
-  });
-});
-
-// ---------------------------------------------------------------------------
-// resolveSafePath
-// ---------------------------------------------------------------------------
-
-describe('resolveSafePath', () => {
-  const base = '/project/workspace';
-
-  test('joins multiple segments safely', () => {
-    const result = resolveSafePath(base, 'src', 'lib', 'utils.ts');
-    expect(result.isOk()).toBe(true);
-    expect(result.unwrap()).toBe(join(resolve(base), 'src', 'lib', 'utils.ts'));
-  });
-
-  test('rejects when segments escape the base', () => {
-    const result = resolveSafePath(base, 'src', '../../../etc');
-    expect(result.isErr()).toBe(true);
-    const err = result as unknown as { error: PermissionError };
-    expect(err.error).toBeInstanceOf(PermissionError);
-  });
-
-  test('handles single segment', () => {
-    const result = resolveSafePath(base, 'file.txt');
-    expect(result.isOk()).toBe(true);
-    expect(result.unwrap()).toBe(resolve(base, 'file.txt'));
-  });
-
-  test('handles empty segments', () => {
-    const result = resolveSafePath(base);
-    expect(result.isOk()).toBe(true);
-    expect(result.unwrap()).toBe(resolve(base));
-  });
-});