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

package/src/__tests__/service-config.test.ts

@@ -1,224 +0,0 @@
-/* oxlint-disable require-await -- trail implementations satisfy async interface without awaiting */
-import { describe, expect, test } from 'bun:test';
-
-import { z } from 'zod';
-
-import { executeTrail } from '../execute.js';
-import { Result } from '../result.js';
-import { resource } from '../resource.js';
-import { trail } from '../trail.js';
-import type { ResourceContext } from '../resource.js';
-
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-
-const nextId = (name: string): string =>
-  `test.svc-config.${name}.${Bun.randomUUIDv7()}`;
-
-const createSingletonConfigTrail = (id: string) => {
-  const captures = { createCalls: 0 };
-  const svc = resource(id, {
-    config: z.object({ key: z.string() }),
-    create: (ctx: ResourceContext<{ key: string }>) => {
-      captures.createCalls += 1;
-      return Result.ok({
-        createCall: captures.createCalls,
-        key: ctx.config.key,
-      });
-    },
-  });
-
-  return {
-    captures,
-    trail: trail('svc-config.singleton', {
-      blaze: (_input, ctx) =>
-        Result.ok({
-          createCall: svc.from(ctx).createCall,
-          key: svc.from(ctx).key,
-        }),
-      input: z.object({}),
-      output: z.object({ createCall: z.number(), key: z.string() }),
-      resources: [svc],
-    }),
-  };
-};
-
-// ---------------------------------------------------------------------------
-// Tests
-// ---------------------------------------------------------------------------
-
-describe('ResourceContext.config', () => {
-  test('resource with config schema receives validated config in svc.config', async () => {
-    const id = nextId('typed-config');
-    let capturedConfig: unknown;
-
-    const db = resource(id, {
-      config: z.object({ poolSize: z.number(), url: z.string().url() }),
-      create: (svc: ResourceContext<{ url: string; poolSize: number }>) => {
-        capturedConfig = svc.config;
-        return Result.ok({ connected: true });
-      },
-    });
-
-    const dbTrail = trail('svc-config.typed', {
-      blaze: (_input, ctx) => Result.ok({ connected: db.from(ctx).connected }),
-      input: z.object({}),
-      output: z.object({ connected: z.boolean() }),
-      resources: [db],
-    });
-
-    const result = await executeTrail(
-      dbTrail,
-      {},
-      {
-        configValues: {
-          [id]: { poolSize: 5, url: 'https://example.com' },
-        },
-      }
-    );
-
-    expect(result.isOk()).toBe(true);
-    expect(capturedConfig).toEqual({ poolSize: 5, url: 'https://example.com' });
-  });
-
-  test('resource without config still works — svc.config is undefined', async () => {
-    const id = nextId('no-config');
-    let capturedConfig: unknown = 'sentinel';
-
-    const counter = resource(id, {
-      create: (svc) => {
-        capturedConfig = svc.config;
-        return Result.ok(42);
-      },
-    });
-
-    const counterTrail = trail('svc-config.no-config', {
-      blaze: (_input, ctx) => Result.ok({ value: counter.from(ctx) }),
-      input: z.object({}),
-      resources: [counter],
-    });
-
-    const result = await executeTrail(counterTrail, {});
-
-    expect(result.isOk()).toBe(true);
-    expect(capturedConfig).toBeUndefined();
-  });
-
-  test('config validation failure returns Result.err at resource creation time', async () => {
-    const id = nextId('invalid-config');
-
-    const db = resource(id, {
-      config: z.object({ url: z.string().url() }),
-      create: () => Result.ok({ connected: true }),
-    });
-
-    const dbTrail = trail('svc-config.invalid', {
-      blaze: () => Result.ok(null),
-      input: z.object({}),
-      resources: [db],
-    });
-
-    const result = await executeTrail(
-      dbTrail,
-      {},
-      {
-        configValues: {
-          [id]: { url: 'not-a-url' },
-        },
-      }
-    );
-
-    expect(result.isErr()).toBe(true);
-    expect(result.error.message).toContain(id);
-  });
-
-  test('missing configValues for a resource with config schema returns Result.err', async () => {
-    const id = nextId('missing-config');
-
-    const db = resource(id, {
-      config: z.object({ url: z.string().url() }),
-      create: () => Result.ok({ connected: true }),
-    });
-
-    const dbTrail = trail('svc-config.missing', {
-      blaze: () => Result.ok(null),
-      input: z.object({}),
-      resources: [db],
-    });
-
-    const result = await executeTrail(dbTrail, {});
-
-    expect(result.isErr()).toBe(true);
-    expect(result.error.message).toContain(id);
-  });
-
-  test('resource override bypasses config validation', async () => {
-    const id = nextId('override-bypass');
-
-    const db = resource(id, {
-      config: z.object({ url: z.string().url() }),
-      create: () => Result.ok({ connected: true }),
-    });
-
-    const dbTrail = trail('svc-config.override', {
-      blaze: (_input, ctx) => Result.ok({ value: db.from(ctx) as number }),
-      input: z.object({}),
-      output: z.object({ value: z.number() }),
-      resources: [db],
-    });
-
-    // Provide the resource via overrides without any configValues — should NOT fail
-    const result = await executeTrail(dbTrail, {}, { resources: { [id]: 42 } });
-
-    expect(result.isOk()).toBe(true);
-    expect(result.unwrap()).toEqual({ value: 42 });
-  });
-  test('config values passed through ExecuteTrailOptions.configValues', async () => {
-    const id = nextId('options-config');
-    const captures: unknown[] = [];
-
-    const svc = resource(id, {
-      config: z.object({ key: z.string() }),
-      create: (ctx: ResourceContext<{ key: string }>) => {
-        captures.push(ctx.config);
-        return Result.ok({ key: ctx.config.key });
-      },
-    });
-
-    const svcTrail = trail('svc-config.options', {
-      blaze: (_input, ctx) => Result.ok({ key: svc.from(ctx).key }),
-      input: z.object({}),
-      output: z.object({ key: z.string() }),
-      resources: [svc],
-    });
-
-    const result = await executeTrail(
-      svcTrail,
-      {},
-      {
-        configValues: { [id]: { key: 'hello' } },
-      }
-    );
-
-    expect(result.isOk()).toBe(true);
-    expect(result.unwrap()).toEqual({ key: 'hello' });
-    expect(captures).toEqual([{ key: 'hello' }]);
-  });
-
-  test('config-aware singleton resources reuse the cached instance', async () => {
-    const id = nextId('singleton-config');
-    const { captures, trail: singletonTrail } = createSingletonConfigTrail(id);
-    const options = {
-      configValues: { [id]: { key: 'hello' } },
-    };
-    const first = await executeTrail(singletonTrail, {}, options);
-    const second = await executeTrail(singletonTrail, {}, options);
-
-    expect(first.isOk()).toBe(true);
-    expect(second.isOk()).toBe(true);
-    expect(first.unwrap()).toEqual({ createCall: 1, key: 'hello' });
-    expect(second.unwrap()).toEqual({ createCall: 1, key: 'hello' });
-    expect(captures.createCalls).toBe(1);
-  });
-});

package/src/__tests__/signal.test.ts

@@ -1,82 +0,0 @@
-import { describe, expect, test } from 'bun:test';
-
-import { z } from 'zod';
-
-import { signal } from '../signal.js';
-
-const payloadSchema = z.object({
-  action: z.string(),
-  userId: z.string(),
-});
-
-const userAction = signal('user.action', {
-  description: 'A user performed an action',
-  from: ['auth.login', 'auth.signup'],
-  meta: { domain: 'auth', priority: 1 },
-  payload: payloadSchema,
-});
-
-describe('signal() basics', () => {
-  test("returns kind 'signal'", () => {
-    expect(userAction.kind).toBe('signal');
-  });
-
-  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('signal() from and meta', () => {
-  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 meta', () => {
-    expect(userAction.meta).toEqual({ domain: 'auth', priority: 1 });
-  });
-
-  test('optional fields default to undefined', () => {
-    const minimal = signal('minimal', {
-      payload: z.string(),
-    });
-    expect(minimal.description).toBeUndefined();
-    expect(minimal.from).toBeUndefined();
-    expect(minimal.meta).toBeUndefined();
-  });
-});
-
-describe('signal() single-object overload', () => {
-  test('accepts spec with id property', () => {
-    const e = signal({
-      from: ['entity.add', 'entity.delete'],
-      id: 'entity.updated',
-      payload: z.object({ entityId: z.string() }),
-    });
-    expect(e.id).toBe('entity.updated');
-    expect(e.kind).toBe('signal');
-    expect(e.from).toEqual(['entity.add', 'entity.delete']);
-  });
-});

package/src/__tests__/surface-filter.test.ts

@@ -1,196 +0,0 @@
-import { describe, expect, test } from 'bun:test';
-
-import { z } from 'zod';
-
-import { Result } from '../result.js';
-import { filterSurfaceTrails, matchesTrailPattern } from '../surface-filter.js';
-import { signal } from '../signal.js';
-import { trail } from '../trail.js';
-
-const orderPlaced = signal('order.placed', {
-  payload: z.object({ orderId: z.string() }),
-});
-
-const publicTrail = trail('entity.show', {
-  blaze: () => Result.ok({ ok: true }),
-  input: z.object({}),
-  intent: 'read',
-});
-
-const nestedTrail = trail('entity.admin.audit', {
-  blaze: () => Result.ok({ ok: true }),
-  input: z.object({}),
-  intent: 'destroy',
-});
-
-const internalTrail = trail('entity.secret.rotate', {
-  blaze: () => Result.ok({ ok: true }),
-  input: z.object({}),
-  visibility: 'internal',
-});
-
-const legacyInternalTrail = trail('entity.legacy.rotate', {
-  blaze: () => Result.ok({ ok: true }),
-  input: z.object({}),
-  meta: { internal: true },
-});
-
-const bareEntityTrail = trail('entity', {
-  blaze: () => Result.ok({ ok: true }),
-  input: z.object({}),
-});
-
-const otherTrail = trail('other', {
-  blaze: () => Result.ok({ ok: true }),
-  input: z.object({}),
-});
-
-const consumerTrail = trail('notify.email', {
-  blaze: () => Result.ok({ ok: true }),
-  input: z.object({}),
-  on: [orderPlaced],
-});
-
-describe('matchesTrailPattern', () => {
-  test('exact trail IDs match directly', () => {
-    expect(matchesTrailPattern('entity.show', 'entity.show')).toBe(true);
-  });
-
-  test('* matches a single dotted segment', () => {
-    expect(matchesTrailPattern('entity.show', 'entity.*')).toBe(true);
-    expect(matchesTrailPattern('entity.admin.show', 'entity.*')).toBe(false);
-  });
-
-  test('** matches any remaining dotted depth', () => {
-    expect(matchesTrailPattern('entity.admin.show', 'entity.**')).toBe(true);
-    expect(matchesTrailPattern('entity.show', 'entity.**')).toBe(true);
-  });
-
-  test('** terminal segment matches entity and all descendants', () => {
-    // Zero-remaining-segments case: bare parent matches entity.**.
-    expect(matchesTrailPattern('entity', 'entity.**')).toBe(true);
-    // One-remaining-segment case for completeness.
-    expect(matchesTrailPattern('entity.read', 'entity.**')).toBe(true);
-    // Sibling namespace must not match entity.**.
-    expect(matchesTrailPattern('other', 'entity.**')).toBe(false);
-  });
-});
-
-describe('filterSurfaceTrails', () => {
-  describe('visibility defaults', () => {
-    test('includes public trails by default', () => {
-      expect(filterSurfaceTrails([publicTrail])).toEqual([publicTrail]);
-    });
-
-    test('excludes internal trails by default', () => {
-      expect(filterSurfaceTrails([internalTrail])).toEqual([]);
-    });
-
-    test('does not expose internal trails for wildcard includes', () => {
-      expect(
-        filterSurfaceTrails([internalTrail], { include: ['entity.**'] })
-      ).toEqual([]);
-    });
-
-    test('allows exact include to expose an internal trail', () => {
-      expect(
-        filterSurfaceTrails([internalTrail], {
-          include: ['entity.secret.rotate'],
-        })
-      ).toEqual([internalTrail]);
-    });
-
-    test('legacy meta.internal is treated as internal visibility', () => {
-      // Default filter: legacy internal trails must not leak out.
-      expect(filterSurfaceTrails([legacyInternalTrail])).toEqual([]);
-
-      // Wildcard include must also refuse to expose the legacy internal trail.
-      expect(
-        filterSurfaceTrails([legacyInternalTrail], { include: ['entity.**'] })
-      ).toEqual([]);
-
-      // Explicit exact-id include is the documented escape hatch.
-      expect(
-        filterSurfaceTrails([legacyInternalTrail], {
-          include: ['entity.legacy.rotate'],
-        })
-      ).toEqual([legacyInternalTrail]);
-    });
-  });
-
-  describe('include and exclude patterns', () => {
-    test('exclude patterns remove matches before include narrowing', () => {
-      expect(
-        filterSurfaceTrails([publicTrail], {
-          exclude: ['entity.*'],
-          include: ['entity.show'],
-        })
-      ).toEqual([]);
-    });
-
-    test('include patterns narrow the visible trail set', () => {
-      expect(
-        filterSurfaceTrails([publicTrail, nestedTrail], {
-          include: ['entity.**'],
-        })
-      ).toEqual([publicTrail, nestedTrail]);
-      expect(
-        filterSurfaceTrails([publicTrail, nestedTrail], {
-          include: ['entity.*'],
-        })
-      ).toEqual([publicTrail]);
-    });
-
-    test('entity.** include matches bare entity and descendants', () => {
-      // Regression guard for the ** terminal-segment zero-depth case.
-      expect(
-        filterSurfaceTrails([bareEntityTrail, publicTrail, otherTrail], {
-          include: ['entity.**'],
-        })
-      ).toEqual([bareEntityTrail, publicTrail]);
-    });
-  });
-
-  describe('intent filtering', () => {
-    test('intent filtering narrows visible trails by behavior class', () => {
-      expect(
-        filterSurfaceTrails([publicTrail, nestedTrail], {
-          intent: ['read'],
-        })
-      ).toEqual([publicTrail]);
-
-      expect(
-        filterSurfaceTrails([publicTrail, nestedTrail], {
-          intent: ['destroy'],
-        })
-      ).toEqual([nestedTrail]);
-    });
-
-    test('intent filtering composes with glob include patterns using AND logic', () => {
-      expect(
-        filterSurfaceTrails([publicTrail, nestedTrail], {
-          include: ['entity.**'],
-          intent: ['read'],
-        })
-      ).toEqual([publicTrail]);
-    });
-
-    test('empty intent filters behave like no filter', () => {
-      expect(
-        filterSurfaceTrails([publicTrail, nestedTrail], {
-          intent: [],
-        })
-      ).toEqual([publicTrail, nestedTrail]);
-    });
-  });
-
-  describe('consumer trails', () => {
-    test('consumer trails are never exposed on trailheads', () => {
-      expect(
-        filterSurfaceTrails([consumerTrail], {
-          include: ['notify.email'],
-        })
-      ).toEqual([]);
-    });
-  });
-});