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

package/src/__tests__/hike.test.ts

@@ -1,117 +0,0 @@
-import { describe, test, expect } from 'bun:test';
-
-import { z } from 'zod';
-
-import { Result } from '../result';
-import { hike } from '../hike';
-import type { TrailContext } from '../types';
-
-const stubCtx: TrailContext = {
-  requestId: 'test-123',
-  signal: AbortSignal.timeout(5000),
-};
-
-describe('hike()', () => {
-  const inputSchema = z.object({ userId: z.string() });
-  const outputSchema = z.object({ profile: z.string() });
-
-  const fetchProfile = hike('fetch-profile', {
-    description: 'Fetch a user profile',
-    follows: ['authenticate', 'validate-session'],
-    implementation: (input) =>
-      Result.ok({ profile: `Profile for ${input.userId}` }),
-    input: inputSchema,
-    output: outputSchema,
-  });
-
-  describe('basics', () => {
-    test("returns kind 'hike'", () => {
-      expect(fetchProfile.kind).toBe('hike');
-    });
-
-    test('returns correct id', () => {
-      expect(fetchProfile.id).toBe('fetch-profile');
-    });
-
-    test('preserves follows array', () => {
-      expect(fetchProfile.follows).toEqual([
-        'authenticate',
-        'validate-session',
-      ]);
-    });
-
-    test('follows array is frozen', () => {
-      expect(Object.isFrozen(fetchProfile.follows)).toBe(true);
-    });
-  });
-
-  describe('trail compatibility', () => {
-    test('extends Trail — has input schema', () => {
-      const parsed = fetchProfile.input.safeParse({ userId: 'u-1' });
-      expect(parsed.success).toBe(true);
-    });
-
-    test('extends Trail — has output schema', () => {
-      expect(fetchProfile.output).toBeDefined();
-    });
-
-    test('extends Trail — implementation is callable', async () => {
-      const result = await fetchProfile.implementation(
-        { userId: 'u-1' },
-        stubCtx
-      );
-      expect(result.isOk()).toBe(true);
-      expect(result.unwrap()).toEqual({ profile: 'Profile for u-1' });
-    });
-
-    test('preserves description', () => {
-      expect(fetchProfile.description).toBe('Fetch a user profile');
-    });
-
-    test('result object is frozen', () => {
-      expect(Object.isFrozen(fetchProfile)).toBe(true);
-    });
-  });
-
-  test('markers are preserved', () => {
-    const withMarkers = hike('tagged-hike', {
-      follows: ['setup'],
-      implementation: () => Result.ok(),
-      input: z.object({}),
-      markers: { domain: 'auth' },
-    });
-    expect(withMarkers.markers).toEqual({ domain: 'auth' });
-  });
-
-  describe('single-object overload', () => {
-    test('accepts spec with id property', () => {
-      const r = hike({
-        follows: ['entity.add', 'entity.relate'],
-        id: 'entity.onboard',
-        implementation: () => Result.ok(),
-        input: z.object({}),
-      });
-      expect(r.id).toBe('entity.onboard');
-      expect(r.kind).toBe('hike');
-      expect(r.follows).toEqual(['entity.add', 'entity.relate']);
-    });
-
-    test('sync implementations are normalized to an awaitable runtime function', async () => {
-      const r = hike({
-        follows: ['entity.add'],
-        id: 'entity.check',
-        implementation: (input: { userId: string }) =>
-          Result.ok({ profile: input.userId }),
-        input: inputSchema,
-        output: outputSchema,
-      });
-
-      const promise = r.implementation({ userId: 'u-2' }, stubCtx);
-      expect(promise).toBeInstanceOf(Promise);
-
-      const result = await promise;
-      expect(result.isOk()).toBe(true);
-      expect(result.unwrap()).toEqual({ profile: 'u-2' });
-    });
-  });
-});

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,224 +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', {
-  implementation: (input) => Result.ok({ value: input.value }),
-  input: z.object({ value: z.string() }),
-  markers: { domain: 'test' },
-  output: z.object({ value: z.string() }),
-});
-
-// ---------------------------------------------------------------------------
-// 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.implementation
-    );
-    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.implementation
-    );
-    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.implementation
-    );
-    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 markers', () => {
-    let capturedDomain: unknown;
-
-    const inspectLayer: Layer = {
-      name: 'inspect',
-      wrap(t, impl) {
-        capturedDomain = t.markers?.['domain'];
-        return impl;
-      },
-    };
-
-    composeLayers([inspectLayer], echoTrail, echoTrail.implementation);
-
-    expect(capturedDomain).toBe('test');
-  });
-
-  test('empty layers array returns implementation unchanged', () => {
-    const wrapped = composeLayers([], echoTrail, echoTrail.implementation);
-    expect(wrapped).toBe(echoTrail.implementation);
-  });
-});
-
-// ---------------------------------------------------------------------------
-// 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);
-  });
-});

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