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

package/src/__tests__/create.test.ts

@@ -1,415 +0,0 @@
-import { describe, expect, test } from 'bun:test';
-import {
-  existsSync,
-  mkdirSync,
-  readFileSync,
-  rmSync,
-  writeFileSync,
-} from 'node:fs';
-import { tmpdir } from 'node:os';
-import { basename, dirname, join } from 'node:path';
-
-import { Result } from '@ontrails/core';
-
-import { addSurface } from '../trails/add-surface.js';
-import { addVerify } from '../trails/add-verify.js';
-import { createRoute } from '../trails/create.js';
-import { createScaffold } from '../trails/create-scaffold.js';
-import { isInsideProject } from '../trails/project.js';
-import {
-  ontrailsPackageRange,
-  scaffoldDependencyVersions,
-} from '../versions.js';
-
-type Starter = 'empty' | 'entity' | 'hello';
-type Surface = 'cli' | 'http' | 'mcp';
-
-const makeTempProject = (): string =>
-  join(
-    tmpdir(),
-    `trails-create-test-${Date.now()}-${Math.random().toString(36).slice(2)}`
-  );
-
-const readJson = (dir: string, relativePath: string): Record<string, unknown> =>
-  JSON.parse(readFileSync(join(dir, relativePath), 'utf8')) as Record<
-    string,
-    unknown
-  >;
-
-const readText = (dir: string, relativePath: string): string =>
-  readFileSync(join(dir, relativePath), 'utf8');
-
-const expectPaths = (
-  dir: string,
-  relativePaths: readonly string[],
-  expected: boolean
-): void => {
-  for (const relativePath of relativePaths) {
-    expect(existsSync(join(dir, relativePath))).toBe(expected);
-  }
-};
-
-const expectContainsAll = (
-  content: string,
-  snippets: readonly string[]
-): void => {
-  for (const snippet of snippets) {
-    expect(content).toContain(snippet);
-  }
-};
-
-const expectOk = <T>(result: Result<T, Error>): T => {
-  if (result.isErr()) {
-    throw result.error;
-  }
-  return result.value;
-};
-
-const expectErr = <T>(result: Result<T, Error>): Error => {
-  if (result.isOk()) {
-    throw new Error('Expected error result');
-  }
-  return result.error;
-};
-
-const runCross = async (
-  id: string,
-  input: unknown
-): Promise<Result<unknown, Error>> => {
-  switch (id) {
-    case 'create.scaffold': {
-      return await createScaffold.blaze(input as never, {} as never);
-    }
-    case 'add.surface': {
-      return await addSurface.blaze(input as never, {} as never);
-    }
-    case 'add.verify': {
-      return await addVerify.blaze(input as never, {} as never);
-    }
-    default: {
-      return Result.err(new Error(`Unknown cross target: ${id}`));
-    }
-  }
-};
-
-const runCreate = (
-  projectDir: string,
-  overrides?: Partial<{
-    starter: Starter;
-    surfaces: readonly Surface[];
-    verify: boolean;
-  }>
-) =>
-  createRoute.blaze(
-    {
-      dir: dirname(projectDir),
-      name: basename(projectDir),
-      starter: overrides?.starter ?? 'hello',
-      surfaces: [...(overrides?.surfaces ?? ['cli'])],
-      verify: overrides?.verify ?? true,
-    },
-    { cross: runCross } as never
-  );
-
-const setupMinimalProject = (dir: string): void => {
-  mkdirSync(join(dir, 'src'), { recursive: true });
-  mkdirSync(join(dir, '.trails'), { recursive: true });
-  writeFileSync(
-    join(dir, 'src', 'app.ts'),
-    "import { topo } from '@ontrails/core';\nexport const app = topo('test');\n"
-  );
-  writeFileSync(
-    join(dir, 'package.json'),
-    JSON.stringify(
-      {
-        dependencies: { '@ontrails/core': ontrailsPackageRange },
-        name: 'test',
-      },
-      null,
-      2
-    )
-  );
-};
-
-const assertDefaultProjectFiles = (dir: string): void => {
-  expectPaths(
-    dir,
-    [
-      'package.json',
-      'tsconfig.json',
-      '.gitignore',
-      '.oxlintrc.json',
-      '.oxfmtrc.jsonc',
-      'src/app.ts',
-      '.trails',
-      'src/cli.ts',
-      'src/trails/hello.ts',
-      '__tests__/examples.test.ts',
-      'lefthook.yml',
-    ],
-    true
-  );
-};
-
-const assertCliPackage = (dir: string): void => {
-  const pkg = readJson(dir, 'package.json');
-  expect(pkg['name']).toBe(basename(dir));
-
-  const deps = pkg['dependencies'] as Record<string, string>;
-  expect(deps['@ontrails/core']).toBe(ontrailsPackageRange);
-  expect(deps['@ontrails/cli']).toBe(ontrailsPackageRange);
-  expect(deps['commander']).toBe(scaffoldDependencyVersions.commander);
-};
-
-const assertVerifyPackage = (dir: string): void => {
-  const pkg = readJson(dir, 'package.json');
-  const devDeps = pkg['devDependencies'] as Record<string, string>;
-  expect(devDeps['@ontrails/testing']).toBe(ontrailsPackageRange);
-  expect(devDeps['@ontrails/warden']).toBe(ontrailsPackageRange);
-  expect(devDeps['lefthook']).toBe(scaffoldDependencyVersions.lefthook);
-  expect(readText(dir, 'lefthook.yml')).toContain('bunx trails warden');
-  expect(readText(dir, 'lefthook.yml')).not.toContain('--exit-code');
-};
-
-const assertGeneratedToolingDeps = (dir: string): void => {
-  const pkg = readJson(dir, 'package.json');
-  const devDeps = pkg['devDependencies'] as Record<string, string>;
-  expect(devDeps['@types/bun']).toBe(scaffoldDependencyVersions.bunTypes);
-  expect(devDeps['oxlint']).toBe(scaffoldDependencyVersions.oxlint);
-  expect(devDeps['typescript']).toBe(scaffoldDependencyVersions.typescript);
-  expect(devDeps['ultracite']).toBe(scaffoldDependencyVersions.ultracite);
-};
-
-const assertHelloApp = (dir: string): void => {
-  expectContainsAll(readText(dir, 'src/app.ts'), [
-    'topo',
-    `'${basename(dir)}'`,
-    'hello',
-  ]);
-  expectContainsAll(readText(dir, 'src/trails/hello.ts'), [
-    "import { Result, trail } from '@ontrails/core'",
-    'return Result.ok({ message:',
-  ]);
-};
-
-const assertEntityStarter = (dir: string): void => {
-  expectPaths(
-    dir,
-    [
-      'src/trails/entity.ts',
-      'src/trails/search.ts',
-      'src/trails/onboard.ts',
-      'src/signals/entity-signals.ts',
-      'src/store.ts',
-    ],
-    true
-  );
-  expectPaths(dir, ['src/trails/hello.ts'], false);
-  expectContainsAll(readText(dir, 'src/app.ts'), [
-    "import * as entity from './trails/entity.js'",
-    "import * as search from './trails/search.js'",
-    "import * as onboard from './trails/onboard.js'",
-    "import * as entitySignals from './signals/entity-signals.js'",
-  ]);
-  expectContainsAll(readText(dir, 'src/trails/entity.ts'), [
-    "import { Result, trail } from '@ontrails/core'",
-    'return Result.ok({ id: input.id, name:',
-    "return Result.ok({ id: '1', name: input.name })",
-  ]);
-  expectContainsAll(readText(dir, 'src/trails/search.ts'), [
-    "import { Result, trail } from '@ontrails/core'",
-    'return Result.ok({ results: [] })',
-  ]);
-  expectContainsAll(readText(dir, 'src/trails/onboard.ts'), [
-    "import { Result, trail } from '@ontrails/core'",
-    'return Result.ok({ onboarded: true })',
-  ]);
-};
-
-const assertMcpSurface = (dir: string): void => {
-  expectPaths(dir, ['src/mcp.ts'], true);
-  expectPaths(dir, ['src/cli.ts'], false);
-  expectContainsAll(readText(dir, 'src/mcp.ts'), [
-    "import { surface } from '@ontrails/mcp'",
-    'await surface(app)',
-  ]);
-
-  const deps = readJson(dir, 'package.json')['dependencies'] as Record<
-    string,
-    string
-  >;
-  expect(deps['@ontrails/mcp']).toBe(ontrailsPackageRange);
-  expect(deps['@ontrails/cli']).toBeUndefined();
-};
-
-const assertHttpSurface = (dir: string): void => {
-  expectPaths(dir, ['src/http.ts'], true);
-  expectContainsAll(readText(dir, 'src/http.ts'), [
-    "import { surface } from '@ontrails/hono'",
-    'await surface(app, { port: 3000 })',
-  ]);
-
-  const deps = readJson(dir, 'package.json')['dependencies'] as Record<
-    string,
-    string
-  >;
-  expect(deps['@ontrails/hono']).toBe(ontrailsPackageRange);
-  expect(deps['@ontrails/http']).toBe(ontrailsPackageRange);
-};
-
-const assertVerifySkipped = (dir: string): void => {
-  expectPaths(dir, ['__tests__/examples.test.ts', 'lefthook.yml'], false);
-  const devDeps = readJson(dir, 'package.json')['devDependencies'] as Record<
-    string,
-    string
-  >;
-  expect(devDeps['@ontrails/testing']).toBeUndefined();
-  expect(devDeps['@ontrails/warden']).toBeUndefined();
-};
-
-const assertEmptyStarter = (dir: string): void => {
-  expectPaths(dir, ['src/trails/.gitkeep'], true);
-  expectPaths(dir, ['src/trails/hello.ts'], false);
-  const appContent = readText(dir, 'src/app.ts');
-  expect(appContent).toContain(`topo('${basename(dir)}')`);
-  expect(appContent).not.toContain('import * as');
-};
-
-const withTempProject = async (
-  assertion: (dir: string) => Promise<void>
-): Promise<void> => {
-  const dir = makeTempProject();
-  try {
-    await assertion(dir);
-  } finally {
-    rmSync(dir, { force: true, recursive: true });
-  }
-};
-
-describe('trails create', () => {
-  describe('create mode', () => {
-    test('generates project structure with defaults', async () => {
-      await withTempProject(async (dir) => {
-        expectOk(await runCreate(dir));
-        assertDefaultProjectFiles(dir);
-        assertCliPackage(dir);
-        assertVerifyPackage(dir);
-        assertGeneratedToolingDeps(dir);
-        assertHelloApp(dir);
-      });
-    });
-
-    test('generates with entity starter', async () => {
-      await withTempProject(async (dir) => {
-        expectOk(await runCreate(dir, { starter: 'entity' }));
-        assertEntityStarter(dir);
-      });
-    });
-
-    test('generates with MCP surface', async () => {
-      await withTempProject(async (dir) => {
-        expectOk(await runCreate(dir, { surfaces: ['mcp'] }));
-        assertMcpSurface(dir);
-      });
-    });
-
-    test('generates with HTTP surface', async () => {
-      await withTempProject(async (dir) => {
-        expectOk(await runCreate(dir, { surfaces: ['http'] }));
-        assertHttpSurface(dir);
-      });
-    });
-
-    test('skips verification when verify is false', async () => {
-      await withTempProject(async (dir) => {
-        expectOk(await runCreate(dir, { verify: false }));
-        assertVerifySkipped(dir);
-      });
-    });
-
-    test('generates with empty starter', async () => {
-      await withTempProject(async (dir) => {
-        expectOk(await runCreate(dir, { starter: 'empty' }));
-        assertEmptyStarter(dir);
-      });
-    });
-  });
-
-  describe('add-surface mode', () => {
-    test('adds MCP to existing project', async () => {
-      await withTempProject(async (dir) => {
-        setupMinimalProject(dir);
-        const result = expectOk(
-          await addSurface.blaze({ dir, surface: 'mcp' }, {} as never)
-        );
-
-        expect(result.created).toBe('src/mcp.ts');
-        expect(result.dependency).toBe('@ontrails/mcp');
-        expectPaths(dir, ['src/mcp.ts'], true);
-        expectContainsAll(readText(dir, 'src/mcp.ts'), [
-          "import { surface } from '@ontrails/mcp'",
-        ]);
-        const deps = readJson(dir, 'package.json')['dependencies'] as Record<
-          string,
-          string
-        >;
-        expect(deps['@ontrails/mcp']).toBe(ontrailsPackageRange);
-      });
-    });
-
-    test('adds HTTP to existing project', async () => {
-      await withTempProject(async (dir) => {
-        setupMinimalProject(dir);
-        const result = expectOk(
-          await addSurface.blaze({ dir, surface: 'http' }, {} as never)
-        );
-
-        expect(result.created).toBe('src/http.ts');
-        expect(result.dependency).toBe('@ontrails/hono');
-        assertHttpSurface(dir);
-      });
-    });
-
-    test('detects existing surface entrypoint', async () => {
-      await withTempProject(async (dir) => {
-        mkdirSync(join(dir, 'src'), { recursive: true });
-        mkdirSync(join(dir, '.trails'), { recursive: true });
-        writeFileSync(join(dir, 'src', 'mcp.ts'), 'existing content');
-
-        const error = expectErr(
-          await addSurface.blaze({ dir, surface: 'mcp' }, {} as never)
-        );
-        expect(error.message).toBe(
-          'MCP surface already exists. Nothing to do.'
-        );
-      });
-    });
-  });
-});
-
-describe('isInsideProject', () => {
-  test('detects .trails directory', async () => {
-    await withTempProject(async (dir) => {
-      mkdirSync(join(dir, '.trails'), { recursive: true });
-      expect(await isInsideProject(dir)).toBe(true);
-    });
-  });
-
-  test('detects topo in src/', async () => {
-    await withTempProject(async (dir) => {
-      mkdirSync(join(dir, 'src'), { recursive: true });
-      writeFileSync(
-        join(dir, 'src', 'app.ts'),
-        "import { topo } from '@ontrails/core';\nexport const app = topo('app');\n"
-      );
-      expect(await isInsideProject(dir)).toBe(true);
-    });
-  });
-
-  test('returns false for empty directory', async () => {
-    await withTempProject(async (dir) => {
-      mkdirSync(dir, { recursive: true });
-      expect(await isInsideProject(dir)).toBe(false);
-    });
-  });
-});

package/src/__tests__/draft-promote.test.ts

@@ -1,144 +0,0 @@
-import { describe, expect, test } from 'bun:test';
-import {
-  existsSync,
-  mkdirSync,
-  readFileSync,
-  rmSync,
-  writeFileSync,
-} from 'node:fs';
-import { join, resolve } from 'node:path';
-
-import type { Result } from '@ontrails/core';
-import { ValidationError } from '@ontrails/core';
-
-import { draftPromoteTrail } from '../trails/draft-promote.js';
-
-const repoTempDir = (): string =>
-  join(
-    resolve(import.meta.dir, '../..'),
-    '.tmp-tests',
-    `draft-promote-${Date.now()}-${Math.random().toString(36).slice(2)}`
-  );
-
-const expectOk = <T>(result: Result<T, Error>): T => {
-  if (result.isErr()) {
-    throw result.error;
-  }
-  return result.value;
-};
-
-const expectErr = <E extends Error>(result: Result<unknown, E>): E => {
-  if (result.isOk()) {
-    throw new Error('expected result to be an error');
-  }
-  return result.error;
-};
-
-const writeDraftPromoteFixture = (dir: string): void => {
-  mkdirSync(join(dir, 'src'), { recursive: true });
-
-  writeFileSync(
-    join(dir, 'src', 'app.ts'),
-    `import { topo } from '@ontrails/core';
-import { draftPrepare } from './_draft.prepare.js';
-import { exportTrail } from './export.js';
-
-export const app = topo('draft-test', { draftPrepare, exportTrail });
-`
-  );
-
-  writeFileSync(
-    join(dir, 'src', '_draft.prepare.ts'),
-    `import { Result, trail } from '@ontrails/core';
-import { z } from 'zod';
-
-export const draftPrepare = trail('_draft.entity.prepare', {
-  blaze: async () => Result.ok({ ready: true }),
-  input: z.object({}),
-  output: z.object({ ready: z.boolean() }),
-});
-`
-  );
-
-  writeFileSync(
-    join(dir, 'src', 'export.ts'),
-    `import { Result, trail } from '@ontrails/core';
-import { z } from 'zod';
-
-export const exportTrail = trail('entity.export', {
-  blaze: async () => Result.ok({ exported: true }),
-  crosses: ['_draft.entity.prepare'],
-  input: z.object({}),
-  output: z.object({ exported: z.boolean() }),
-});
-`
-  );
-};
-
-const expectDraftPromoteResults = (dir: string): void => {
-  expect(existsSync(join(dir, 'src', '_draft.prepare.ts'))).toBe(false);
-  expect(existsSync(join(dir, 'src', 'prepare.ts'))).toBe(true);
-  expect(readFileSync(join(dir, 'src', 'prepare.ts'), 'utf8')).toContain(
-    "trail('entity.prepare'"
-  );
-  expect(readFileSync(join(dir, 'src', 'export.ts'), 'utf8')).toContain(
-    "crosses: ['entity.prepare']"
-  );
-  expect(readFileSync(join(dir, 'src', 'app.ts'), 'utf8')).toContain(
-    "from './prepare.js'"
-  );
-};
-
-describe('draft.promote', () => {
-  test('promotes draft ids, renames files, and updates imports', async () => {
-    const dir = repoTempDir();
-
-    try {
-      writeDraftPromoteFixture(dir);
-
-      const result = expectOk(
-        await draftPromoteTrail.blaze(
-          {
-            fromId: '_draft.entity.prepare',
-            renameFiles: true,
-            rootDir: dir,
-            toId: 'entity.prepare',
-          },
-          { cwd: dir } as never
-        )
-      );
-
-      expect(result.promotedEstablished).toBe(true);
-      expect(result.remainingDraftIds).toEqual([]);
-      expect(result.updatedFiles).toEqual(
-        expect.arrayContaining(['src/app.ts', 'src/export.ts'])
-      );
-      expect(result.renamedFiles).toEqual([
-        {
-          from: 'src/_draft.prepare.ts',
-          to: 'src/prepare.ts',
-        },
-      ]);
-      expectDraftPromoteResults(dir);
-    } finally {
-      rmSync(dir, { force: true, recursive: true });
-    }
-  });
-
-  test('returns ValidationError when rootDir does not exist', async () => {
-    const error = expectErr(
-      await draftPromoteTrail.blaze(
-        {
-          fromId: '_draft.entity.prepare',
-          renameFiles: true,
-          rootDir: join(repoTempDir(), 'missing'),
-          toId: 'entity.prepare',
-        },
-        { cwd: process.cwd() } as never
-      )
-    );
-
-    expect(error).toBeInstanceOf(ValidationError);
-    expect(error.message).toContain('rootDir does not exist');
-  });
-});

package/src/__tests__/guide.test.ts

@@ -1,96 +0,0 @@
-import { describe, expect, test } from 'bun:test';
-
-import type { AnyTrail } from '@ontrails/core';
-import { ConflictError, trail, topo, Result } from '@ontrails/core';
-import { z } from 'zod';
-
-// ---------------------------------------------------------------------------
-// Test fixtures
-// ---------------------------------------------------------------------------
-
-const helloTrail = trail('hello', {
-  blaze: (input) => {
-    const name = input.name ?? 'world';
-    return Result.ok({ message: `Hello, ${name}!` });
-  },
-  description: 'Say hello',
-  detours: [
-    {
-      on: ConflictError,
-      /* oxlint-disable-next-line require-await -- test stub */
-      recover: async () => Result.ok({ message: 'recovered' }),
-    },
-  ],
-  examples: [
-    {
-      expected: { message: 'Hello, world!' },
-      input: {},
-      name: 'Default greeting',
-    },
-    {
-      expected: { message: 'Hello, Trails!' },
-      input: { name: 'Trails' },
-      name: 'Named greeting',
-    },
-  ],
-  input: z.object({ name: z.string().optional() }),
-  intent: 'read',
-  output: z.object({ message: z.string() }),
-});
-
-const app = topo('test-app', { hello: helloTrail });
-
-// ---------------------------------------------------------------------------
-// Tests
-// ---------------------------------------------------------------------------
-
-describe('trails guide', () => {
-  test('lists trails with descriptions', () => {
-    const items = app.list();
-    expect(items.length).toBe(1);
-
-    const [hello] = items;
-    expect(hello).toBeDefined();
-    expect(hello?.id).toBe('hello');
-
-    expect((hello as AnyTrail).description).toBe('Say hello');
-  });
-
-  test('trail detail includes examples', () => {
-    const item = app.get('hello') as AnyTrail;
-    expect(item).toBeDefined();
-    expect(item.examples).toBeDefined();
-    expect(item.examples?.length).toBe(2);
-    expect(item.examples?.[0]?.name).toBe('Default greeting');
-  });
-
-  test('JSON output for trail is valid', () => {
-    const t = app.get('hello') as AnyTrail;
-    expect(t).toBeDefined();
-
-    const json = JSON.stringify({
-      description: t.description,
-      detours: t.detours,
-      examples: t.examples,
-      id: t.id,
-      kind: t.kind,
-    });
-
-    const parsed = JSON.parse(json) as Record<string, unknown>;
-    expect(parsed['id']).toBe('hello');
-    expect(parsed['kind']).toBe('trail');
-    expect(parsed['description']).toBe('Say hello');
-  });
-
-  test('non-existent trail returns undefined from topo', () => {
-    const item = app.get('does-not-exist');
-    expect(item).toBeUndefined();
-  });
-
-  test('detours are accessible on trail', () => {
-    const t = app.get('hello') as AnyTrail;
-    expect(t).toBeDefined();
-    expect(t.detours).toHaveLength(1);
-    expect(t.detours[0]?.on).toBe(ConflictError);
-  });
-});