@ontrails/core 1.0.0-beta.2 → 1.0.0-beta.21

package/src/__tests__/derive.test.ts

@@ -1,159 +0,0 @@
-import { describe, test, expect } from 'bun:test';
-
-import { z } from 'zod';
-
-import { deriveFields } from '../derive.js';
-
-// ---------------------------------------------------------------------------
-// Tests
-// ---------------------------------------------------------------------------
-
-describe('derive', () => {
-  describe('primitive types', () => {
-    test('z.string() derives string field', () => {
-      const schema = z.object({ name: z.string() });
-      const fields = deriveFields(schema);
-      expect(fields).toHaveLength(1);
-      expect(fields[0]).toMatchObject({
-        label: 'Name',
-        name: 'name',
-        required: true,
-        type: 'string',
-      });
-    });
-
-    test('z.number() derives number field', () => {
-      const schema = z.object({ count: z.number() });
-      const fields = deriveFields(schema);
-      expect(fields[0]).toMatchObject({
-        name: 'count',
-        required: true,
-        type: 'number',
-      });
-    });
-
-    test('z.boolean() derives boolean field', () => {
-      const schema = z.object({ verbose: z.boolean() });
-      const fields = deriveFields(schema);
-      expect(fields[0]).toMatchObject({
-        name: 'verbose',
-        required: true,
-        type: 'boolean',
-      });
-    });
-  });
-
-  describe('enum and multiselect', () => {
-    test('z.enum() derives enum field with options', () => {
-      const schema = z.object({ color: z.enum(['red', 'green', 'blue']) });
-      const fields = deriveFields(schema);
-      expect(fields[0]).toMatchObject({
-        name: 'color',
-        required: true,
-        type: 'enum',
-      });
-      expect(fields[0]?.options).toEqual([
-        { value: 'red' },
-        { value: 'green' },
-        { value: 'blue' },
-      ]);
-    });
-
-    test('z.array(z.enum()) derives multiselect field', () => {
-      const schema = z.object({
-        tags: z.array(z.enum(['a', 'b', 'c'])),
-      });
-      const fields = deriveFields(schema);
-      expect(fields[0]).toMatchObject({
-        name: 'tags',
-        required: true,
-        type: 'multiselect',
-      });
-      expect(fields[0]?.options).toEqual([
-        { value: 'a' },
-        { value: 'b' },
-        { value: 'c' },
-      ]);
-    });
-  });
-
-  describe('modifiers', () => {
-    test('.describe() sets label', () => {
-      const schema = z.object({
-        name: z.string().describe('Your full name'),
-      });
-      const fields = deriveFields(schema);
-      expect(fields[0]?.label).toBe('Your full name');
-    });
-
-    test('.default() sets default and marks not required', () => {
-      const schema = z.object({
-        port: z.number().default(3000),
-      });
-      const fields = deriveFields(schema);
-      expect(fields[0]?.required).toBe(false);
-      expect(fields[0]?.default).toBe(3000);
-    });
-
-    test('.optional() marks not required', () => {
-      const schema = z.object({
-        nickname: z.string().optional(),
-      });
-      const fields = deriveFields(schema);
-      expect(fields[0]?.required).toBe(false);
-    });
-  });
-
-  describe('overrides', () => {
-    test('override label replaces derived label', () => {
-      const schema = z.object({
-        name: z.string().describe('Derived label'),
-      });
-      const fields = deriveFields(schema, {
-        name: { label: 'Override label' },
-      });
-      expect(fields[0]?.label).toBe('Override label');
-    });
-
-    test('override options enrich enum values with labels and hints', () => {
-      const schema = z.object({
-        color: z.enum(['red', 'green', 'blue']),
-      });
-      const fields = deriveFields(schema, {
-        color: {
-          options: [
-            { hint: 'Hot color', label: 'Red', value: 'red' },
-            { label: 'Green', value: 'green' },
-          ],
-        },
-      });
-      expect(fields[0]?.options).toEqual([
-        { hint: 'Hot color', label: 'Red', value: 'red' },
-        { label: 'Green', value: 'green' },
-        { value: 'blue' },
-      ]);
-    });
-  });
-
-  describe('sorting and edge cases', () => {
-    test('returns fields sorted by name', () => {
-      const schema = z.object({
-        alpha: z.string(),
-        middle: z.string(),
-        zebra: z.string(),
-      });
-      const fields = deriveFields(schema);
-      expect(fields.map((f) => f.name)).toEqual(['alpha', 'middle', 'zebra']);
-    });
-
-    test('returns empty array for non-object schema', () => {
-      expect(deriveFields(z.string())).toEqual([]);
-    });
-
-    test('humanizes camelCase field names', () => {
-      const schema = z.object({ firstName: z.string() });
-      const fields = deriveFields(schema);
-      expect(fields[0]?.label).toBe('First Name');
-    });
-  });
-});

package/src/__tests__/errors.test.ts

@@ -1,309 +0,0 @@
-import { describe, test, expect } from 'bun:test';
-
-import {
-  TrailsError,
-  ValidationError,
-  AmbiguousError,
-  AssertionError,
-  NotFoundError,
-  AlreadyExistsError,
-  ConflictError,
-  PermissionError,
-  TimeoutError,
-  RateLimitError,
-  NetworkError,
-  InternalError,
-  AuthError,
-  CancelledError,
-  exitCodeMap,
-  statusCodeMap,
-  jsonRpcCodeMap,
-  retryableMap,
-  isRetryable,
-  isTrailsError,
-} from '../errors.js';
-import type { ErrorCategory } from '../errors.js';
-
-// ---------------------------------------------------------------------------
-// Error class matrix
-// ---------------------------------------------------------------------------
-
-const errorMatrix: readonly {
-  Class: new (
-    message: string,
-    options?: { cause?: Error; context?: Record<string, unknown> }
-  ) => TrailsError;
-  category: ErrorCategory;
-  retryable: boolean;
-  name: string;
-}[] = [
-  {
-    Class: ValidationError,
-    category: 'validation',
-    name: 'ValidationError',
-    retryable: false,
-  },
-  {
-    Class: AmbiguousError,
-    category: 'validation',
-    name: 'AmbiguousError',
-    retryable: false,
-  },
-  {
-    Class: AssertionError,
-    category: 'internal',
-    name: 'AssertionError',
-    retryable: false,
-  },
-  {
-    Class: NotFoundError,
-    category: 'not_found',
-    name: 'NotFoundError',
-    retryable: false,
-  },
-  {
-    Class: AlreadyExistsError,
-    category: 'conflict',
-    name: 'AlreadyExistsError',
-    retryable: false,
-  },
-  {
-    Class: ConflictError,
-    category: 'conflict',
-    name: 'ConflictError',
-    retryable: false,
-  },
-  {
-    Class: PermissionError,
-    category: 'permission',
-    name: 'PermissionError',
-    retryable: false,
-  },
-  {
-    Class: TimeoutError,
-    category: 'timeout',
-    name: 'TimeoutError',
-    retryable: true,
-  },
-  {
-    Class: RateLimitError,
-    category: 'rate_limit',
-    name: 'RateLimitError',
-    retryable: true,
-  },
-  {
-    Class: NetworkError,
-    category: 'network',
-    name: 'NetworkError',
-    retryable: true,
-  },
-  {
-    Class: InternalError,
-    category: 'internal',
-    name: 'InternalError',
-    retryable: false,
-  },
-  { Class: AuthError, category: 'auth', name: 'AuthError', retryable: false },
-  {
-    Class: CancelledError,
-    category: 'cancelled',
-    name: 'CancelledError',
-    retryable: false,
-  },
-];
-
-describe('error classes', () => {
-  // oxlint-disable-next-line prefer-each -- describe.each loses type safety on heterogeneous class matrix
-  for (const { Class, category, retryable, name } of errorMatrix) {
-    describe(name, () => {
-      test('sets correct category', () => {
-        const err = new Class('test');
-        expect(err.category).toBe(category);
-      });
-
-      test('sets correct retryable', () => {
-        const err = new Class('test');
-        expect(err.retryable).toBe(retryable);
-      });
-
-      test('sets message', () => {
-        const err = new Class('something went wrong');
-        expect(err.message).toBe('something went wrong');
-      });
-
-      test('sets name to constructor name', () => {
-        const err = new Class('test');
-        expect(err.name).toBe(name);
-      });
-
-      test('sets cause when provided', () => {
-        const cause = new Error('root cause');
-        const err = new Class('test', { cause });
-        expect(err.cause).toBe(cause);
-      });
-
-      test('sets context when provided', () => {
-        const ctx = { action: 'delete', userId: 'u_123' };
-        const err = new Class('test', { context: ctx });
-        expect(err.context).toEqual(ctx);
-      });
-
-      test('context is undefined when not provided', () => {
-        const err = new Class('test');
-        expect(err.context).toBeUndefined();
-      });
-
-      test('is instanceof TrailsError', () => {
-        const err = new Class('test');
-        expect(err).toBeInstanceOf(TrailsError);
-      });
-
-      test('is instanceof Error', () => {
-        const err = new Class('test');
-        expect(err).toBeInstanceOf(Error);
-      });
-
-      test('is instanceof its own class', () => {
-        const err = new Class('test');
-        expect(err).toBeInstanceOf(Class);
-      });
-    });
-  }
-});
-
-// ---------------------------------------------------------------------------
-// RateLimitError.retryAfter
-// ---------------------------------------------------------------------------
-
-describe('RateLimitError.retryAfter', () => {
-  test('stores retryAfter when provided', () => {
-    const err = new RateLimitError('slow down', { retryAfter: 30 });
-    expect(err.retryAfter).toBe(30);
-  });
-
-  test('retryAfter is undefined when not provided', () => {
-    const err = new RateLimitError('slow down');
-    expect(err.retryAfter).toBeUndefined();
-  });
-
-  test('retryAfter coexists with cause and context', () => {
-    const cause = new Error('upstream');
-    const err = new RateLimitError('slow down', {
-      cause,
-      context: { endpoint: '/api' },
-      retryAfter: 60,
-    });
-    expect(err.retryAfter).toBe(60);
-    expect(err.cause).toBe(cause);
-    expect(err.context).toEqual({ endpoint: '/api' });
-  });
-});
-
-// ---------------------------------------------------------------------------
-// Taxonomy maps
-// ---------------------------------------------------------------------------
-
-describe('exitCodeMap', () => {
-  test('maps all categories to expected exit codes', () => {
-    expect(exitCodeMap.validation).toBe(1);
-    expect(exitCodeMap.not_found).toBe(2);
-    expect(exitCodeMap.conflict).toBe(3);
-    expect(exitCodeMap.permission).toBe(4);
-    expect(exitCodeMap.timeout).toBe(5);
-    expect(exitCodeMap.rate_limit).toBe(6);
-    expect(exitCodeMap.network).toBe(7);
-    expect(exitCodeMap.internal).toBe(8);
-    expect(exitCodeMap.auth).toBe(9);
-    expect(exitCodeMap.cancelled).toBe(130);
-  });
-});
-
-describe('statusCodeMap', () => {
-  test('maps all categories to expected HTTP status codes', () => {
-    expect(statusCodeMap.validation).toBe(400);
-    expect(statusCodeMap.not_found).toBe(404);
-    expect(statusCodeMap.conflict).toBe(409);
-    expect(statusCodeMap.permission).toBe(403);
-    expect(statusCodeMap.timeout).toBe(504);
-    expect(statusCodeMap.rate_limit).toBe(429);
-    expect(statusCodeMap.network).toBe(502);
-    expect(statusCodeMap.internal).toBe(500);
-    expect(statusCodeMap.auth).toBe(401);
-    expect(statusCodeMap.cancelled).toBe(499);
-  });
-});
-
-describe('jsonRpcCodeMap', () => {
-  test('maps all categories to expected JSON-RPC codes', () => {
-    expect(jsonRpcCodeMap.validation).toBe(-32_602);
-    expect(jsonRpcCodeMap.not_found).toBe(-32_601);
-    expect(jsonRpcCodeMap.conflict).toBe(-32_603);
-    expect(jsonRpcCodeMap.permission).toBe(-32_600);
-    expect(jsonRpcCodeMap.timeout).toBe(-32_603);
-    expect(jsonRpcCodeMap.rate_limit).toBe(-32_603);
-    expect(jsonRpcCodeMap.network).toBe(-32_603);
-    expect(jsonRpcCodeMap.internal).toBe(-32_603);
-    expect(jsonRpcCodeMap.auth).toBe(-32_600);
-    expect(jsonRpcCodeMap.cancelled).toBe(-32_603);
-  });
-});
-
-describe('retryableMap', () => {
-  test('only timeout, rate_limit, and network are retryable', () => {
-    expect(retryableMap.timeout).toBe(true);
-    expect(retryableMap.rate_limit).toBe(true);
-    expect(retryableMap.network).toBe(true);
-
-    expect(retryableMap.validation).toBe(false);
-    expect(retryableMap.not_found).toBe(false);
-    expect(retryableMap.conflict).toBe(false);
-    expect(retryableMap.permission).toBe(false);
-    expect(retryableMap.internal).toBe(false);
-    expect(retryableMap.auth).toBe(false);
-    expect(retryableMap.cancelled).toBe(false);
-  });
-});
-
-// ---------------------------------------------------------------------------
-// Helper functions
-// ---------------------------------------------------------------------------
-
-describe('isRetryable', () => {
-  test('returns true for retryable errors', () => {
-    expect(isRetryable(new TimeoutError('timed out'))).toBe(true);
-    expect(isRetryable(new RateLimitError('too fast'))).toBe(true);
-    expect(isRetryable(new NetworkError('disconnected'))).toBe(true);
-  });
-
-  test('returns false for non-retryable errors', () => {
-    expect(isRetryable(new ValidationError('bad input'))).toBe(false);
-    expect(isRetryable(new NotFoundError('missing'))).toBe(false);
-    expect(isRetryable(new AuthError('unauthorized'))).toBe(false);
-    expect(isRetryable(new InternalError('oops'))).toBe(false);
-    expect(isRetryable(new CancelledError('aborted'))).toBe(false);
-  });
-
-  test('returns false for plain Error', () => {
-    expect(isRetryable(new Error('generic'))).toBe(false);
-  });
-});
-
-describe('isTrailsError', () => {
-  test('returns true for TrailsError subclasses', () => {
-    expect(isTrailsError(new ValidationError('bad'))).toBe(true);
-    expect(isTrailsError(new NetworkError('down'))).toBe(true);
-    expect(isTrailsError(new CancelledError('stop'))).toBe(true);
-  });
-
-  test('returns false for plain Error', () => {
-    expect(isTrailsError(new Error('nope'))).toBe(false);
-  });
-
-  test('returns false for non-error values', () => {
-    expect(isTrailsError(null)).toBe(false);
-    expect(isTrailsError()).toBe(false);
-    expect(isTrailsError('string')).toBe(false);
-    expect(isTrailsError(42)).toBe(false);
-    expect(isTrailsError({})).toBe(false);
-  });
-});

package/src/__tests__/event.test.ts

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