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

package/src/__tests__/build.test.ts

@@ -1,610 +0,0 @@
-import { describe, expect, test } from 'bun:test';
-
-import {
-  InternalError,
-  NotFoundError,
-  Result,
-  TRAILHEAD_KEY,
-  resource,
-  signal,
-  ValidationError,
-  trail,
-  topo,
-} from '@ontrails/core';
-import type { Layer, TrailContext } from '@ontrails/core';
-import { z } from 'zod';
-
-import { deriveHttpRoutes } from '../build.js';
-
-// ---------------------------------------------------------------------------
-// Test trails
-// ---------------------------------------------------------------------------
-
-const echoTrail = trail('echo', {
-  blaze: (input) => Result.ok({ reply: input.message }),
-  description: 'Echo a message back',
-  input: z.object({ message: z.string() }),
-  intent: 'read',
-  output: z.object({ reply: z.string() }),
-});
-
-const createTrail = trail('item.create', {
-  blaze: (input) => Result.ok({ id: '123', name: input.name }),
-  description: 'Create an item',
-  input: z.object({ name: z.string() }),
-  output: z.object({ id: z.string(), name: z.string() }),
-});
-
-const deleteTrail = trail('item.delete', {
-  blaze: (_input) => Result.ok({ deleted: true }),
-  description: 'Delete an item',
-  input: z.object({ id: z.string() }),
-  intent: 'destroy',
-});
-
-const notFoundTrail = trail('item.get', {
-  blaze: (_input) => Result.err(new NotFoundError('Item not found')),
-  description: 'Get an item that does not exist',
-  input: z.object({ id: z.string() }),
-  intent: 'read',
-});
-
-const internalTrail = trail('crash', {
-  blaze: () => Result.err(new InternalError('Something broke')),
-  description: 'Always fails with internal error',
-  input: z.object({}),
-});
-
-const internalVisibilityTrail = trail('secret', {
-  blaze: () => Result.ok({ ok: true }),
-  description: 'Internal trail that should be skipped',
-  input: z.object({}),
-  visibility: 'internal',
-});
-
-const dbResource = resource('db.main', {
-  create: () =>
-    Result.ok({
-      source: 'factory',
-    }),
-});
-
-const orderPlaced = signal('order.placed', {
-  payload: z.object({ orderId: z.string() }),
-});
-
-const requireFire = (fire: TrailContext['fire']) => {
-  if (!fire) {
-    throw new Error('Expected ctx.fire to be bound');
-  }
-  return fire;
-};
-
-// ---------------------------------------------------------------------------
-// Tests
-// ---------------------------------------------------------------------------
-
-describe('deriveHttpRoutes', () => {
-  describe('method derivation', () => {
-    test('intent: read maps to GET', () => {
-      const app = topo('testapp', { echoTrail });
-      const result = deriveHttpRoutes(app);
-
-      expect(result.isOk()).toBe(true);
-      const routes = result.value;
-      expect(routes).toHaveLength(1);
-      expect(routes[0]?.method).toBe('GET');
-    });
-
-    test('intent: destroy maps to DELETE', () => {
-      const app = topo('testapp', { deleteTrail });
-      const result = deriveHttpRoutes(app);
-
-      expect(result.isOk()).toBe(true);
-      const routes = result.value;
-      expect(routes).toHaveLength(1);
-      expect(routes[0]?.method).toBe('DELETE');
-    });
-
-    test('default intent (write) maps to POST', () => {
-      const app = topo('testapp', { createTrail });
-      const result = deriveHttpRoutes(app);
-
-      expect(result.isOk()).toBe(true);
-      const routes = result.value;
-      expect(routes).toHaveLength(1);
-      expect(routes[0]?.method).toBe('POST');
-    });
-  });
-
-  describe('path derivation', () => {
-    test('dotted ID becomes slashed path', () => {
-      const app = topo('testapp', { createTrail });
-      const result = deriveHttpRoutes(app);
-
-      expect(result.isOk()).toBe(true);
-      expect(result.value[0]?.path).toBe('/item/create');
-    });
-
-    test('simple ID becomes /id', () => {
-      const app = topo('testapp', { echoTrail });
-      const result = deriveHttpRoutes(app);
-
-      expect(result.isOk()).toBe(true);
-      expect(result.value[0]?.path).toBe('/echo');
-    });
-
-    test('basePath is prepended', () => {
-      const app = topo('testapp', { echoTrail });
-      const result = deriveHttpRoutes(app, { basePath: '/api/v1' });
-
-      expect(result.isOk()).toBe(true);
-      expect(result.value[0]?.path).toBe('/api/v1/echo');
-    });
-
-    test('basePath trailing slash is normalized', () => {
-      const app = topo('testapp', { echoTrail });
-      const result = deriveHttpRoutes(app, { basePath: '/api/v1/' });
-
-      expect(result.isOk()).toBe(true);
-      expect(result.value[0]?.path).toBe('/api/v1/echo');
-    });
-  });
-
-  describe('input source derivation', () => {
-    test('GET routes use query input source', () => {
-      const app = topo('testapp', { echoTrail });
-      const result = deriveHttpRoutes(app);
-
-      expect(result.isOk()).toBe(true);
-      expect(result.value[0]?.inputSource).toBe('query');
-    });
-
-    test('POST routes use body input source', () => {
-      const app = topo('testapp', { createTrail });
-      const result = deriveHttpRoutes(app);
-
-      expect(result.isOk()).toBe(true);
-      expect(result.value[0]?.inputSource).toBe('body');
-    });
-
-    test('DELETE routes use body input source', () => {
-      const app = topo('testapp', { deleteTrail });
-      const result = deriveHttpRoutes(app);
-
-      expect(result.isOk()).toBe(true);
-      expect(result.value[0]?.inputSource).toBe('body');
-    });
-  });
-
-  describe('filtering', () => {
-    test('internal trails are skipped', () => {
-      const app = topo('testapp', { echoTrail, internalVisibilityTrail });
-      const result = deriveHttpRoutes(app);
-
-      expect(result.isOk()).toBe(true);
-      const routes = result.value;
-      expect(routes).toHaveLength(1);
-      expect(routes[0]?.trailId).toBe('echo');
-    });
-
-    test('exact include can expose an internal trail', () => {
-      const app = topo('testapp', { echoTrail, internalVisibilityTrail });
-      const result = deriveHttpRoutes(app, { include: ['secret'] });
-
-      expect(result.isOk()).toBe(true);
-      const routes = result.value;
-      expect(routes).toHaveLength(1);
-      expect(routes[0]?.trailId).toBe('secret');
-    });
-
-    test('wildcard include does not expose internal trails', () => {
-      const app = topo('testapp', { echoTrail, internalVisibilityTrail });
-      const result = deriveHttpRoutes(app, { include: ['**'] });
-
-      expect(result.isOk()).toBe(true);
-      const routes = result.value;
-      expect(routes).toHaveLength(1);
-      expect(routes[0]?.trailId).toBe('echo');
-    });
-
-    test('exclude patterns win before include narrowing', () => {
-      const app = topo('testapp', { deleteTrail, echoTrail });
-      const result = deriveHttpRoutes(app, {
-        exclude: ['item.**'],
-        include: ['echo', 'item.delete'],
-      });
-
-      expect(result.isOk()).toBe(true);
-      expect(result.value.map((route) => route.trailId)).toEqual(['echo']);
-    });
-
-    test('intent filters narrow the route table', () => {
-      const app = topo('testapp', { deleteTrail, echoTrail });
-      const result = deriveHttpRoutes(app, { intent: ['read'] });
-
-      expect(result.isOk()).toBe(true);
-      expect(result.value.map((route) => route.trailId)).toEqual(['echo']);
-    });
-
-    test('intent filters compose with include patterns using AND logic', () => {
-      const app = topo('testapp', { deleteTrail, echoTrail });
-      const result = deriveHttpRoutes(app, {
-        include: ['item.*', 'echo'],
-        intent: ['destroy'],
-      });
-
-      expect(result.isOk()).toBe(true);
-      expect(result.value.map((route) => route.trailId)).toEqual([
-        'item.delete',
-      ]);
-    });
-
-    test('consumer trails (on: [...]) are skipped', () => {
-      const consumerTrail = trail('notify.email', {
-        blaze: (input: { orderId: string }) =>
-          Result.ok({ delivered: true, orderId: input.orderId }),
-        description: 'Send email on order placed',
-        input: z.object({ orderId: z.string() }),
-        on: ['order.placed'],
-      });
-      const app = topo('testapp', { consumerTrail, echoTrail, orderPlaced });
-      const result = deriveHttpRoutes(app);
-
-      expect(result.isOk()).toBe(true);
-      const routes = result.value;
-      expect(routes).toHaveLength(1);
-      expect(routes[0]?.trailId).toBe('echo');
-    });
-  });
-
-  describe('route definition shape', () => {
-    test('includes trail reference', () => {
-      const app = topo('testapp', { echoTrail });
-      const result = deriveHttpRoutes(app);
-
-      expect(result.isOk()).toBe(true);
-      expect(result.value[0]?.trail).toBe(echoTrail);
-    });
-
-    test('execute is a function', () => {
-      const app = topo('testapp', { echoTrail });
-      const result = deriveHttpRoutes(app);
-
-      expect(result.isOk()).toBe(true);
-      expect(typeof result.value[0]?.execute).toBe('function');
-    });
-  });
-
-  describe('execute', () => {
-    test('returns ok Result on valid input', async () => {
-      const app = topo('testapp', { echoTrail });
-      const buildResult = deriveHttpRoutes(app);
-
-      expect(buildResult.isOk()).toBe(true);
-      const [route] = buildResult.value;
-
-      const result = await route?.execute({ message: 'hello' });
-      expect(result?.isOk()).toBe(true);
-      expect(result?.value).toEqual({ reply: 'hello' });
-    });
-
-    test('returns err Result on invalid input', async () => {
-      const app = topo('testapp', { echoTrail });
-      const buildResult = deriveHttpRoutes(app);
-
-      expect(buildResult.isOk()).toBe(true);
-      const [route] = buildResult.value;
-
-      const result = await route?.execute({});
-      expect(result?.isErr()).toBe(true);
-    });
-
-    test('returns err Result from trail error', async () => {
-      const app = topo('testapp', { notFoundTrail });
-      const buildResult = deriveHttpRoutes(app);
-
-      expect(buildResult.isOk()).toBe(true);
-      const [route] = buildResult.value;
-
-      const result = await route?.execute({ id: 'missing' });
-      expect(result?.isErr()).toBe(true);
-      expect(result?.error?.message).toBe('Item not found');
-    });
-
-    test('returns err Result from internal error', async () => {
-      const app = topo('testapp', { internalTrail });
-      const buildResult = deriveHttpRoutes(app);
-
-      expect(buildResult.isOk()).toBe(true);
-      const [route] = buildResult.value;
-
-      const result = await route?.execute({});
-      expect(result?.isErr()).toBe(true);
-      expect(result?.error?.message).toBe('Something broke');
-    });
-
-    test('returns err Result when run function throws', async () => {
-      const throwingTrail = trail('throwing', {
-        blaze: () => {
-          throw new Error('unexpected throw');
-        },
-        input: z.object({}),
-      });
-      const app = topo('testapp', { throwingTrail });
-      const buildResult = deriveHttpRoutes(app);
-
-      expect(buildResult.isOk()).toBe(true);
-      const [route] = buildResult.value;
-
-      const result = await route?.execute({});
-      expect(result?.isErr()).toBe(true);
-      expect(result?.error).toBeInstanceOf(InternalError);
-      expect(result?.error?.message).toBe('unexpected throw');
-    });
-
-    test('returns err Result when createContext throws', async () => {
-      const app = topo('testapp', { echoTrail });
-      const buildResult = deriveHttpRoutes(app, {
-        createContext: () => {
-          throw new Error('context creation failed');
-        },
-      });
-
-      expect(buildResult.isOk()).toBe(true);
-      const [route] = buildResult.value;
-
-      const result = await route?.execute({ message: 'hi' });
-      expect(result?.isErr()).toBe(true);
-      expect(result?.error).toBeInstanceOf(InternalError);
-      expect(result?.error?.message).toBe('context creation failed');
-    });
-
-    test('passes topo to executeTrail so HTTP-invoked producers can fan out', async () => {
-      const captured: string[] = [];
-      const consumer = trail('notify.email', {
-        blaze: (input: { orderId: string }) => {
-          captured.push(input.orderId);
-          return Result.ok({ delivered: true });
-        },
-        input: z.object({ orderId: z.string() }),
-        on: ['order.placed'],
-      });
-      const producer = trail('order.create', {
-        blaze: async (input: { orderId: string }, ctx) => {
-          const fired = await requireFire(ctx.fire)('order.placed', {
-            orderId: input.orderId,
-          });
-          return fired.match({
-            err: (error) => Result.err(error),
-            ok: () => Result.ok({ ok: true }),
-          });
-        },
-        fires: ['order.placed'],
-        input: z.object({ orderId: z.string() }),
-      });
-      const app = topo('signal-http', { consumer, orderPlaced, producer });
-      const buildResult = deriveHttpRoutes(app);
-
-      expect(buildResult.isOk()).toBe(true);
-      const [route] = buildResult.value;
-
-      const result = await route?.execute({ orderId: 'o-http' });
-
-      expect(result?.isOk()).toBe(true);
-      expect(captured).toEqual(['o-http']);
-    });
-
-    test('passes requestId to context', async () => {
-      let capturedRequestId: string | undefined;
-
-      const ctxTrail = trail('ctx.check', {
-        blaze: (_input, ctx) => {
-          capturedRequestId = ctx.requestId;
-          return Result.ok({ ok: true });
-        },
-        input: z.object({}),
-        intent: 'read',
-      });
-
-      const app = topo('testapp', { ctxTrail });
-      const buildResult = deriveHttpRoutes(app);
-
-      expect(buildResult.isOk()).toBe(true);
-      const [route] = buildResult.value;
-
-      await route?.execute({}, 'custom-req-123');
-      expect(capturedRequestId).toBe('custom-req-123');
-    });
-
-    test('uses default requestId when none provided', async () => {
-      let capturedRequestId: string | undefined;
-
-      const ctxTrail = trail('ctx.default', {
-        blaze: (_input, ctx) => {
-          capturedRequestId = ctx.requestId;
-          return Result.ok({ ok: true });
-        },
-        input: z.object({}),
-        intent: 'read',
-      });
-
-      const app = topo('testapp', { ctxTrail });
-      const buildResult = deriveHttpRoutes(app);
-
-      expect(buildResult.isOk()).toBe(true);
-      const [route] = buildResult.value;
-
-      await route?.execute({});
-      expect(capturedRequestId).toBeDefined();
-      expect(capturedRequestId).not.toBe('');
-    });
-
-    test('forwards resource overrides into executeTrail', async () => {
-      const resourceTrail = trail('resource.check', {
-        blaze: (_input, ctx) =>
-          Result.ok({ source: dbResource.from(ctx).source as string }),
-        input: z.object({}),
-        output: z.object({ source: z.string() }),
-        resources: [dbResource],
-      });
-
-      const app = topo('testapp', { dbResource, resourceTrail });
-      const buildResult = deriveHttpRoutes(app, {
-        resources: { 'db.main': { source: 'override' } },
-      });
-
-      expect(buildResult.isOk()).toBe(true);
-      const [route] = buildResult.value;
-
-      const result = await route?.execute({});
-      expect(result?.isOk()).toBe(true);
-      expect(result?.value).toEqual({ source: 'override' });
-    });
-  });
-
-  describe('layers', () => {
-    test('layers compose around trail execution', async () => {
-      const calls: string[] = [];
-
-      const testGate: Layer = {
-        name: 'test-layer',
-        wrap(_trail, impl) {
-          return async (input, ctx) => {
-            calls.push('before');
-            const result = await impl(input, ctx);
-            calls.push('after');
-            return result;
-          };
-        },
-      };
-
-      const app = topo('testapp', { echoTrail });
-      const buildResult = deriveHttpRoutes(app, { layers: [testGate] });
-
-      expect(buildResult.isOk()).toBe(true);
-      const [route] = buildResult.value;
-
-      const result = await route?.execute({ message: 'hi' });
-      expect(result?.isOk()).toBe(true);
-      expect(calls).toEqual(['before', 'after']);
-    });
-  });
-
-  describe('custom createContext', () => {
-    test('custom createContext is used when provided', async () => {
-      const contextState = { custom: false, trailheadMarker: false };
-
-      const ctxTrail = trail('ctx.custom', {
-        blaze: (_input, ctx) => {
-          contextState.custom = ctx.extensions?.['custom'] === true;
-          contextState.trailheadMarker =
-            ctx.extensions?.[TRAILHEAD_KEY] === 'http';
-          return Result.ok({ ok: true });
-        },
-        input: z.object({}),
-        intent: 'read',
-      });
-
-      const app = topo('testapp', { ctxTrail });
-      const buildResult = deriveHttpRoutes(app, {
-        createContext: () => ({
-          abortSignal: new AbortController().signal,
-          extensions: { custom: true },
-          requestId: 'test-id',
-        }),
-      });
-
-      expect(buildResult.isOk()).toBe(true);
-      const [route] = buildResult.value;
-
-      const result = await route?.execute({});
-      expect(result?.isOk()).toBe(true);
-      expect(contextState.custom).toBe(true);
-      expect(contextState.trailheadMarker).toBe(true);
-    });
-  });
-
-  describe('collision detection', () => {
-    test('returns err on duplicate (path, method) pair', () => {
-      // "entity.show" derives path /entity/show (dots become slashes)
-      // "entity/show" derives path /entity/show (slashes are preserved)
-      // Both have intent: read -> GET, so they collide on GET /entity/show
-      const dotTrail = trail('entity.show', {
-        blaze: () => Result.ok({ dot: true }),
-        description: 'Show entity (dot notation)',
-        input: z.object({}),
-        intent: 'read',
-      });
-      const slashTrail = trail('entity/show', {
-        blaze: () => Result.ok({ slash: true }),
-        description: 'Show entity (slash notation)',
-        input: z.object({}),
-        intent: 'read',
-      });
-      const app = topo('testapp', { dotTrail, slashTrail });
-      const result = deriveHttpRoutes(app);
-
-      expect(result.isErr()).toBe(true);
-      expect(result.error).toBeInstanceOf(ValidationError);
-      expect(result.error?.message).toContain('GET /entity/show');
-    });
-
-    test('same path with different methods is allowed', () => {
-      // "item.resource" derives GET /item/resource (intent: read)
-      // "item/resource" derives POST /item/resource (default intent: write)
-      // Same path, different methods — no collision
-      const getItem = trail('item.resource', {
-        blaze: () => Result.ok({ get: true }),
-        description: 'Get item',
-        input: z.object({}),
-        intent: 'read',
-      });
-      const createItem = trail('item/resource', {
-        blaze: () => Result.ok({ created: true }),
-        description: 'Create item',
-        input: z.object({ name: z.string() }),
-      });
-      const app = topo('testapp', { createItem, getItem });
-      const result = deriveHttpRoutes(app);
-
-      expect(result.isOk()).toBe(true);
-      expect(result.value).toHaveLength(2);
-    });
-
-    test('collision error message identifies both trail IDs', () => {
-      const dotTrail = trail('entity.show', {
-        blaze: () => Result.ok({ one: true }),
-        description: 'Trail one',
-        input: z.object({}),
-        intent: 'read',
-      });
-      const slashTrail = trail('entity/show', {
-        blaze: () => Result.ok({ two: true }),
-        description: 'Trail two',
-        input: z.object({}),
-        intent: 'read',
-      });
-      const app = topo('testapp', { dotTrail, slashTrail });
-      const result = deriveHttpRoutes(app);
-
-      expect(result.isErr()).toBe(true);
-      expect(result.error?.message).toContain('entity');
-    });
-  });
-
-  describe('established graph enforcement', () => {
-    test('returns err when draft contamination remains', () => {
-      const draftTrail = trail('entity.export', {
-        blaze: () => Result.ok({ ok: true }),
-        crosses: ['_draft.entity.prepare'],
-        input: z.object({}),
-      });
-
-      const result = deriveHttpRoutes(topo('testapp', { draftTrail }));
-
-      expect(result.isErr()).toBe(true);
-      expect(result.error?.message).toMatch(/draft/i);
-    });
-  });
-});

package/src/__tests__/derive.test.ts

@@ -1,31 +0,0 @@
-import { describe, expect, test } from 'bun:test';
-
-import { Result, trail, topo } from '@ontrails/core';
-import { z } from 'zod';
-
-import { deriveHttpRoutes } from '../build.js';
-
-const unwrapOk = <T>(result: Result<T, Error>): T =>
-  result.match({
-    err: (error) => {
-      throw error;
-    },
-    ok: (value) => value,
-  });
-
-describe('deriveHttpRoutes', () => {
-  test('aliases the HTTP projection API', () => {
-    const graph = topo('testapp', {
-      echo: trail('echo', {
-        blaze: (input: { message: string }) =>
-          Result.ok({ reply: input.message }),
-        input: z.object({ message: z.string() }),
-        intent: 'read',
-        output: z.object({ reply: z.string() }),
-      }),
-    });
-
-    const routes = unwrapOk(deriveHttpRoutes(graph));
-    expect(routes[0]?.path).toBe('/echo');
-  });
-});

package/tsconfig.json

@@ -1,9 +0,0 @@
-{
-  "extends": "../../tsconfig.json",
-  "compilerOptions": {
-    "outDir": "dist",
-    "rootDir": "src"
-  },
-  "include": ["src"],
-  "exclude": ["**/__tests__/**", "**/*.test.ts", "dist"]
-}

package/tsconfig.tests.json

@@ -1,10 +0,0 @@
-{
-  "extends": "./tsconfig.json",
-  "compilerOptions": {
-    "noEmit": true,
-    "rootDir": "./src",
-    "types": ["bun"]
-  },
-  "include": ["src/**/*.test.ts", "src/__tests__/**/*.ts"],
-  "exclude": []
-}

package/tsconfig.tsbuildinfo

@@ -1 +0,0 @@
-{"root":["./src/build.ts","./src/index.ts"],"version":"5.9.3"}