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

package/src/__tests__/fork-ctx.test.ts

@@ -1,83 +0,0 @@
-import { describe, expect, test } from 'bun:test';
-
-import { forkCtx } from '../internal/fork-ctx';
-import type { CrossFn, FireFn, TrailContext } from '../types';
-
-// Sentinel values — the helper never invokes these, so their shapes are
-// irrelevant. What matters is identity: a forked ctx must either clear
-// them or preserve the exact reference.
-const noopCross = {} as unknown as CrossFn;
-const noopFire = {} as unknown as FireFn;
-const noopResource = {} as unknown as TrailContext['resource'];
-
-describe('forkCtx', () => {
-  test('clears cross, fire, and resource by default', () => {
-    const parent = {
-      cross: noopCross,
-      env: { NODE_ENV: 'test' },
-      extensions: { trailhead: 'cli' },
-      fire: noopFire,
-      logger: undefined,
-      resource: noopResource,
-    };
-
-    const forked = forkCtx(parent, {});
-
-    expect(forked.cross).toBeUndefined();
-    expect(forked.fire).toBeUndefined();
-    expect(forked.resource).toBeUndefined();
-    // Non-reset keys are preserved.
-    expect(forked.env).toEqual({ NODE_ENV: 'test' });
-    expect(forked.extensions).toEqual({ trailhead: 'cli' });
-  });
-
-  test('applies overrides after reset so overrides win', () => {
-    const parent = {
-      cross: noopCross,
-      env: { NODE_ENV: 'test' },
-      extensions: { a: 1 },
-      fire: noopFire,
-      resource: noopResource,
-    };
-
-    const forked = forkCtx(parent, {
-      env: { NODE_ENV: 'prod' },
-      extensions: { b: 2 },
-    });
-
-    expect(forked.env).toEqual({ NODE_ENV: 'prod' });
-    expect(forked.extensions).toEqual({ b: 2 });
-    expect(forked.cross).toBeUndefined();
-    expect(forked.fire).toBeUndefined();
-    expect(forked.resource).toBeUndefined();
-  });
-
-  test('does not mutate the parent context', () => {
-    const parent = {
-      cross: noopCross,
-      fire: noopFire,
-      resource: noopResource,
-    };
-
-    forkCtx(parent, {});
-
-    expect(parent.cross).toBe(noopCross);
-    expect(parent.fire).toBe(noopFire);
-    expect(parent.resource).toBe(noopResource);
-  });
-
-  test('honours a caller-supplied reset list', () => {
-    const parent = {
-      cross: noopCross,
-      fire: noopFire,
-      resource: noopResource,
-    };
-
-    const forked = forkCtx(parent, {}, ['fire']);
-
-    expect(forked.fire).toBeUndefined();
-    // Only `fire` is reset when caller overrides the list.
-    expect(forked.cross).toBe(noopCross);
-    expect(forked.resource).toBe(noopResource);
-  });
-});

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

@@ -1,191 +0,0 @@
-/* oxlint-disable require-await -- layer wrappers satisfy async interfaces without awaiting */
-import { describe, expect, test } from 'bun:test';
-
-import { z } from 'zod';
-
-import { ValidationError } from '../errors.js';
-import type { Layer } from '../layer.js';
-import { Result } from '../result.js';
-import { run } from '../run.js';
-import { signal } from '../signal.js';
-import { topo } from '../topo.js';
-import { trail } from '../trail.js';
-import { ingest } from '../trails/index.js';
-
-const withExamples = <TSchema extends z.ZodType>(
-  schema: TSchema,
-  examples: readonly z.input<TSchema>[]
-): TSchema & { readonly examples: readonly z.input<TSchema>[] } =>
-  Object.assign(schema, { examples });
-
-const paymentCompleted = signal('payment.completed', {
-  payload: z.object({
-    amount: z.number(),
-    paymentId: z.string(),
-  }),
-});
-
-const rawPaymentEvent = z.object({
-  amount: z.number(),
-  paymentId: z.string(),
-});
-
-const stripeEvent = z.object({
-  data: z.object({
-    object: z.object({
-      amount: z.number(),
-      id: z.string(),
-    }),
-  }),
-});
-
-const createConsumer = (
-  id: string,
-  capture: { payloads: unknown[] },
-  source = paymentCompleted
-) =>
-  trail(id, {
-    blaze: (input) => {
-      capture.payloads.push(input);
-      return Result.ok({ ok: true });
-    },
-    input: source.payload,
-    on: [source],
-  });
-
-describe('ingest()', () => {
-  test('derives id, intent, fires, output schema, and examples from schema examples', () => {
-    const schema = withExamples(rawPaymentEvent, [
-      { amount: 42, paymentId: 'pay_1' },
-      { amount: 7, paymentId: 'pay_2' },
-    ]);
-
-    const paymentIngest = ingest({
-      schema,
-      signal: paymentCompleted,
-    });
-
-    expect(paymentIngest.id).toBe('payment.completed.ingest');
-    expect(paymentIngest.intent).toBe('write');
-    expect(paymentIngest.pattern).toBe('ingest');
-    expect(paymentIngest.fires).toEqual(['payment.completed']);
-    expect(paymentIngest.output?.safeParse().success).toBe(true);
-    expect(paymentIngest.examples).toEqual([
-      {
-        input: { amount: 42, paymentId: 'pay_1' },
-        name: 'Ingest payment.completed 1',
-      },
-      {
-        input: { amount: 7, paymentId: 'pay_2' },
-        name: 'Ingest payment.completed 2',
-      },
-    ]);
-  });
-
-  test('validates input before attempting to emit the signal', async () => {
-    const capture = { payloads: [] as unknown[] };
-    const paymentIngest = ingest({
-      schema: rawPaymentEvent,
-      signal: paymentCompleted,
-    });
-
-    const app = topo('ingest-validation', {
-      consumer: createConsumer('payments.capture', capture),
-      paymentCompleted,
-      paymentIngest,
-    });
-
-    const result = await run(app, paymentIngest.id, {
-      amount: '42',
-      paymentId: 'pay_1',
-    });
-
-    expect(result.isErr()).toBe(true);
-    expect(result.error).toBeInstanceOf(ValidationError);
-    expect(capture.payloads).toEqual([]);
-  });
-
-  test('applies the verification layer when provided', async () => {
-    const wrapped: string[] = [];
-    const verify: Layer = {
-      name: 'verify',
-      wrap: (trailDef, implementation) => async (input, ctx) => {
-        wrapped.push(trailDef.id);
-        return await implementation(input, ctx);
-      },
-    };
-    const capture = { payloads: [] as unknown[] };
-    const paymentIngest = ingest({
-      schema: rawPaymentEvent,
-      signal: paymentCompleted,
-      verify,
-    });
-
-    const app = topo('ingest-verify', {
-      consumer: createConsumer('payments.capture', capture),
-      paymentCompleted,
-      paymentIngest,
-    });
-
-    const result = await run(app, paymentIngest.id, {
-      amount: 42,
-      paymentId: 'pay_1',
-    });
-
-    expect(result.isOk()).toBe(true);
-    expect(wrapped).toEqual(['payment.completed.ingest']);
-    expect(capture.payloads).toEqual([{ amount: 42, paymentId: 'pay_1' }]);
-  });
-
-  test('emits the declared signal after successful ingestion', async () => {
-    const capture = { payloads: [] as unknown[] };
-    const paymentIngest = ingest({
-      schema: rawPaymentEvent,
-      signal: paymentCompleted,
-    });
-
-    const app = topo('ingest-fire', {
-      consumer: createConsumer('payments.capture', capture),
-      paymentCompleted,
-      paymentIngest,
-    });
-
-    const result = await run(app, paymentIngest.id, {
-      amount: 42,
-      paymentId: 'pay_1',
-    });
-
-    expect(result.isOk()).toBe(true);
-    expect(capture.payloads).toEqual([{ amount: 42, paymentId: 'pay_1' }]);
-  });
-
-  test('applies the transform before emitting the signal payload', async () => {
-    const capture = { payloads: [] as unknown[] };
-    const paymentIngest = ingest({
-      schema: stripeEvent,
-      signal: paymentCompleted,
-      transform: (payload) => ({
-        amount: payload.data.object.amount,
-        paymentId: payload.data.object.id,
-      }),
-    });
-
-    const app = topo('ingest-transform', {
-      consumer: createConsumer('payments.capture', capture),
-      paymentCompleted,
-      paymentIngest,
-    });
-
-    const result = await run(app, paymentIngest.id, {
-      data: {
-        object: {
-          amount: 99,
-          id: 'pay_99',
-        },
-      },
-    });
-
-    expect(result.isOk()).toBe(true);
-    expect(capture.payloads).toEqual([{ amount: 99, paymentId: 'pay_99' }]);
-  });
-});

package/src/__tests__/layer.test.ts

@@ -1,125 +0,0 @@
-/* oxlint-disable require-await -- layer wrappers satisfy async interfaces without awaiting */
-import { describe, test, expect } from 'bun:test';
-
-import { z } from 'zod';
-
-import { createTrailContext } from '../context';
-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 = createTrailContext({
-  abortSignal: AbortSignal.timeout(5000),
-  requestId: 'test-layer',
-});
-
-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() }),
-});
-
-// ---------------------------------------------------------------------------
-// Layer tests
-// ---------------------------------------------------------------------------
-
-describe('Layer', () => {
-  test('single layer wraps implementation', async () => {
-    const prefixGate: 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([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 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.blaze);
-    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.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('layer can inspect trail meta', () => {
-    let capturedDomain: unknown;
-
-    const inspectGate: Layer = {
-      name: 'inspect',
-      wrap(t, impl) {
-        capturedDomain = t.meta?.['domain'];
-        return impl;
-      },
-    };
-
-    composeLayers([inspectGate], echoTrail, echoTrail.blaze);
-
-    expect(capturedDomain).toBe('test');
-  });
-
-  test('empty layers array returns implementation unchanged', () => {
-    const wrapped = composeLayers([], echoTrail, echoTrail.blaze);
-    expect(wrapped).toBe(echoTrail.blaze);
-  });
-});

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, deriveSafePath } 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);
-  });
-});
-
-// ---------------------------------------------------------------------------
-// deriveSafePath
-// ---------------------------------------------------------------------------
-
-describe('deriveSafePath', () => {
-  const base = '/project/workspace';
-
-  test('joins multiple segments safely', () => {
-    const result = deriveSafePath(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 = deriveSafePath(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 = deriveSafePath(base, 'file.txt');
-    expect(result.isOk()).toBe(true);
-    expect(result.unwrap()).toBe(resolve(base, 'file.txt'));
-  });
-
-  test('handles empty segments', () => {
-    const result = deriveSafePath(base);
-    expect(result.isOk()).toBe(true);
-    expect(result.unwrap()).toBe(resolve(base));
-  });
-});