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

package/src/__tests__/service.test.ts

@@ -1,197 +0,0 @@
-import { describe, expect, test } from 'bun:test';
-import { z } from 'zod';
-
-import {
-  Result,
-  createTrailContext,
-  findDuplicateProvisionId,
-  isProvision,
-  provision as defineProvision,
-} from '../index.js';
-import type {
-  Provision,
-  ProvisionContext,
-  ProvisionSpec,
-  TrailContext,
-} from '../index.js';
-
-const provisionCtx: ProvisionContext = {
-  cwd: '/tmp/trails',
-  env: { DATABASE_URL: 'file::memory:' },
-  workspaceRoot: '/tmp',
-};
-
-let disposedValue: number | undefined;
-
-const counterProvisionSpec: ProvisionSpec<number> = {
-  create: () => Result.ok(3),
-  description: 'Counter provision',
-  dispose: (provision) => {
-    disposedValue = provision;
-  },
-  health: (provision) => Result.ok({ healthy: provision > 0 }),
-  meta: { domain: 'data' },
-  mock: () => 1,
-};
-
-const resolvedServiceCtx = (id: string, instance: unknown): TrailContext =>
-  createTrailContext({
-    abortSignal: new AbortController().signal,
-    extensions: { [id]: instance },
-    requestId: `${id}-request`,
-  });
-
-describe('provision types', () => {
-  test('ProvisionContext exposes the stable process-scoped fields', () => {
-    expect(provisionCtx.cwd).toBe('/tmp/trails');
-    expect(provisionCtx.env?.DATABASE_URL).toBe('file::memory:');
-    expect(provisionCtx.workspaceRoot).toBe('/tmp');
-  });
-
-  test('ProvisionSpec stores description and meta', () => {
-    expect(counterProvisionSpec.description).toBe('Counter provision');
-    expect(counterProvisionSpec.meta).toEqual({ domain: 'data' });
-  });
-
-  test('ProvisionSpec can reserve a config schema for future composition', () => {
-    const config = z.object({ url: z.string().url() });
-    const spec: ProvisionSpec<number> = {
-      config,
-      create: () => Result.ok(1),
-    };
-
-    expect(spec.config).toBe(config);
-  });
-
-  test('ProvisionSpec create and health callbacks are callable', async () => {
-    const result = await counterProvisionSpec.create(provisionCtx);
-    expect(result.isOk()).toBe(true);
-    expect(result.unwrap()).toBe(3);
-
-    const health = await counterProvisionSpec.health?.(result.unwrap());
-    expect(health?.isOk()).toBe(true);
-    expect(health?.unwrap()).toEqual({ healthy: true });
-  });
-
-  test('ProvisionSpec mock and dispose callbacks are callable', async () => {
-    disposedValue = undefined;
-    const result = await counterProvisionSpec.create(provisionCtx);
-    expect(result.isOk()).toBe(true);
-
-    const provision = result.unwrap();
-    expect(await counterProvisionSpec.mock?.()).toBe(1);
-
-    await counterProvisionSpec.dispose?.(provision);
-    expect(disposedValue).toBe(3);
-  });
-
-  test('ProvisionSpec create can be async', async () => {
-    const spec: ProvisionSpec<number> = {
-      create: async () => {
-        await Bun.sleep(0);
-        return Result.ok(7);
-      },
-    };
-
-    const result = await spec.create(provisionCtx);
-    expect(result.isOk()).toBe(true);
-    expect(result.unwrap()).toBe(7);
-  });
-
-  test('Provision carries identity alongside the shared spec fields', async () => {
-    const counterProvision: Provision<number> = {
-      from(ctx) {
-        return ctx.provision(this);
-      },
-      id: 'counter.main',
-      kind: 'provision',
-      ...counterProvisionSpec,
-    };
-
-    expect(counterProvision.kind).toBe('provision');
-    expect(counterProvision.id).toBe('counter.main');
-
-    const created = await counterProvision.create(provisionCtx);
-    expect(created.isOk()).toBe(true);
-    expect(created.unwrap()).toBe(3);
-    expect(await counterProvision.mock?.()).toBe(1);
-  });
-});
-
-describe('provision()', () => {
-  test('returns a frozen provision object with kind and id', () => {
-    const counter = defineProvision('counter.main', counterProvisionSpec);
-
-    expect(counter.kind).toBe('provision');
-    expect(counter.id).toBe('counter.main');
-    expect(Object.isFrozen(counter)).toBe(true);
-  });
-
-  test('infers the provision type through from(ctx)', () => {
-    const db = defineProvision('db.main', {
-      create: () =>
-        Result.ok({
-          query(sql: string) {
-            return sql.length;
-          },
-        }),
-      description: 'Typed database service',
-    });
-
-    const store = {
-      query(sql: string) {
-        return sql.length;
-      },
-    };
-    const ctx = resolvedServiceCtx('db.main', store);
-
-    const resolved = db.from(ctx);
-    expect(resolved.query('select 1')).toBe(8);
-  });
-
-  test('from(ctx) throws when the provision is missing', () => {
-    const counter = defineProvision('counter.main', counterProvisionSpec);
-    const ctx = createTrailContext({
-      abortSignal: new AbortController().signal,
-      requestId: 'missing-provision',
-    });
-
-    expect(() => counter.from(ctx)).toThrow(
-      'Provision "counter.main" not found in trail context'
-    );
-  });
-
-  test('from(ctx) returns undefined when the provision key exists with an undefined value', () => {
-    const optional = defineProvision<undefined>('optional.main', {
-      create: () => Result.ok<undefined>(),
-    });
-    const ctx = createTrailContext({
-      abortSignal: new AbortController().signal,
-      extensions: { [optional.id]: undefined },
-      requestId: 'undefined-provision',
-    });
-
-    expect(optional.from(ctx)).toBeUndefined();
-  });
-});
-
-describe('provision helpers', () => {
-  test('isProvision identifies provision definitions', () => {
-    const counter = defineProvision('counter.main', counterProvisionSpec);
-
-    expect(isProvision(counter)).toBe(true);
-    expect(isProvision({ id: 'counter.main', kind: 'trail' })).toBe(false);
-    expect(isProvision(null)).toBe(false);
-  });
-
-  test('findDuplicateProvisionId returns the first repeated ID', () => {
-    const first = defineProvision('counter.main', counterProvisionSpec);
-    const duplicate = defineProvision('counter.main', counterProvisionSpec);
-    const other = defineProvision('counter.secondary', counterProvisionSpec);
-
-    expect(findDuplicateProvisionId([first, other])).toBeUndefined();
-    expect(findDuplicateProvisionId([first, other, duplicate])).toBe(
-      'counter.main'
-    );
-  });
-});

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__/topo-store-read.test.ts

@@ -1,251 +0,0 @@
-import { afterEach, describe, expect, test } from 'bun:test';
-import { mkdtempSync, rmSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-
-import { z } from 'zod';
-
-import {
-  createMockTopoStore,
-  createTopoStore,
-  provision,
-  Result,
-  signal,
-  topo,
-  topoStore,
-  trail,
-} from '../index.js';
-import { pinTopoSave } from '../internal/topo-saves.js';
-import type { TopoSaveRecord } from '../internal/topo-saves.js';
-import { persistEstablishedTopoSave } from '../internal/topo-store.js';
-import { openWriteTrailsDb } from '../internal/trails-db.js';
-
-const noop = () => Result.ok({ ok: true });
-
-const expectOk = async <T>(
-  result: Promise<Result<T, Error>> | Result<T, Error>
-): Promise<T> => {
-  const resolved = await result;
-  if (resolved.isErr()) {
-    throw resolved.error;
-  }
-  return resolved.value;
-};
-
-const requireValue = <T>(value: T | undefined, message: string): T => {
-  if (value === undefined) {
-    throw new Error(message);
-  }
-  return value;
-};
-
-const exampleApp = () => {
-  const dbMain = provision('db.main', {
-    create: () => Result.ok({ source: 'factory' }),
-    description: 'Primary database',
-    health: () => Result.ok({ ok: true }),
-    mock: () => ({ source: 'mock' }),
-  });
-
-  const entityAdded = signal('entity.added', {
-    description: 'An entity was added',
-    from: ['entity.add'],
-    payload: z.object({ id: z.string() }),
-  });
-
-  const entityAdd = trail('entity.add', {
-    blaze: (input: { readonly name: string }) =>
-      Result.ok({ id: input.name.toLowerCase(), ok: true }),
-    description: 'Add a new entity',
-    examples: [
-      {
-        expected: { id: 'ada', ok: true },
-        input: { name: 'Ada' },
-        name: 'Add Ada',
-      },
-    ],
-    input: z.object({ name: z.string() }),
-    output: z.object({ id: z.string(), ok: z.boolean() }),
-    provisions: [dbMain],
-  });
-
-  const entityList = trail('entity.list', {
-    blaze: noop,
-    crosses: ['entity.add'],
-    description: 'List entities',
-    detours: {
-      ConflictError: ['entity.add'],
-    },
-    idempotent: true,
-    input: z.object({}),
-    intent: 'read',
-    output: z.object({ ok: z.boolean() }),
-    provisions: [dbMain],
-  });
-
-  return topo('projection-app', {
-    dbMain,
-    entityAdd,
-    entityAdded,
-    entityList,
-  });
-};
-
-describe('read-only topo store', () => {
-  let tmpRoot: string | undefined;
-
-  afterEach(() => {
-    if (tmpRoot) {
-      rmSync(tmpRoot, { force: true, recursive: true });
-      tmpRoot = undefined;
-    }
-  });
-
-  const makeRoot = (): string => {
-    tmpRoot = mkdtempSync(join(tmpdir(), 'topo-store-read-'));
-    return tmpRoot;
-  };
-
-  const seedStore = (): {
-    readonly rootDir: string;
-    readonly save: TopoSaveRecord;
-  } => {
-    const rootDir = makeRoot();
-    const db = openWriteTrailsDb({ rootDir });
-
-    try {
-      const result = persistEstablishedTopoSave(db, exampleApp(), {
-        createdAt: '2026-04-03T14:00:00.000Z',
-        gitSha: 'abc123',
-      });
-      if (result.isErr()) {
-        throw result.error;
-      }
-      const save = result.value;
-      pinTopoSave(db, { name: 'baseline', saveId: save.id });
-      return { rootDir, save };
-    } finally {
-      db.close();
-    }
-  };
-
-  test('lists save-scoped trails and provisions through typed accessors', () => {
-    const { rootDir, save } = seedStore();
-    const store = createTopoStore({ rootDir });
-
-    expect(store.saves.latest()?.id).toBe(save.id);
-    expect(store.pins.get('baseline')?.saveId).toBe(save.id);
-
-    expect(store.trails.list({ save: { saveId: save.id } })).toEqual([
-      expect.objectContaining({
-        description: 'Add a new entity',
-        exampleCount: 1,
-        hasOutput: true,
-        id: 'entity.add',
-        intent: 'write',
-      }),
-      expect.objectContaining({
-        description: 'List entities',
-        exampleCount: 0,
-        id: 'entity.list',
-        intent: 'read',
-        safety: 'read',
-      }),
-    ]);
-
-    expect(store.provisions.list({ save: { saveId: save.id } })).toEqual([
-      expect.objectContaining({
-        description: 'Primary database',
-        health: 'available',
-        id: 'db.main',
-        usedBy: ['entity.add', 'entity.list'],
-      }),
-    ]);
-  });
-
-  test('filters trails by intent', () => {
-    const { rootDir, save } = seedStore();
-    const store = createTopoStore({ rootDir });
-
-    const writeTrails = store.trails.list({
-      intent: 'write',
-      save: { saveId: save.id },
-    });
-    expect(writeTrails).toHaveLength(1);
-    expect(writeTrails[0]?.id).toBe('entity.add');
-
-    const readTrails = store.trails.list({
-      intent: 'read',
-      save: { saveId: save.id },
-    });
-    expect(readTrails).toHaveLength(1);
-    expect(readTrails[0]?.id).toBe('entity.list');
-  });
-
-  test('returns detailed trail and export views, plus a query escape hatch', () => {
-    const { rootDir, save } = seedStore();
-    const store = createTopoStore({ rootDir });
-
-    const detail = store.trails.get('entity.list', {
-      save: { saveId: save.id },
-    });
-    expect(detail).toEqual(
-      expect.objectContaining({
-        crosses: ['entity.add'],
-        detours: { ConflictError: ['entity.add'] },
-        id: 'entity.list',
-        provisions: ['db.main'],
-      })
-    );
-    expect(detail?.examples).toEqual([]);
-
-    const exported = store.exports.get({ pin: 'baseline' });
-    expect(exported?.save.id).toBe(save.id);
-    expect(exported?.trailheadHash).toHaveLength(64);
-
-    const rows = store.query<{ id: string }>(
-      'SELECT id FROM topo_trails WHERE save_id = ? ORDER BY id ASC',
-      [save.id]
-    );
-    expect(rows).toEqual([{ id: 'entity.add' }, { id: 'entity.list' }]);
-  });
-
-  test('fails loudly when no saved topo state exists', () => {
-    const rootDir = makeRoot();
-    const store = createTopoStore({ rootDir });
-
-    expect(() => store.saves.latest()).toThrow('No saved topo state found');
-    expect(() => store.trails.list()).toThrow('No saved topo state found');
-    expect(() => store.exports.get()).toThrow('No saved topo state found');
-  });
-
-  test('exposes a provision factory and mock for topoStore', async () => {
-    const { rootDir } = seedStore();
-
-    const created = await expectOk(
-      topoStore.create({
-        config: undefined,
-        cwd: rootDir,
-        env: {},
-        workspaceRoot: rootDir,
-      })
-    );
-
-    expect(created.saves.latest()).toBeDefined();
-    expect(
-      created.query<{ count: number }>(
-        'SELECT COUNT(*) as count FROM topo_saves'
-      )[0]?.count
-    ).toBe(1);
-
-    expect(topoStore.mock).toBeDefined();
-    const mock = await requireValue(
-      topoStore.mock,
-      'Expected topoStore to define a mock factory'
-    )();
-    expect(mock).toBeDefined();
-    expect(() =>
-      createMockTopoStore().query('SELECT id FROM topo_trails')
-    ).toThrow('Mock topoStore.query() is unsupported');
-  });
-});