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

package/src/__tests__/branded.test.ts

@@ -1,148 +0,0 @@
-import { describe, test, expect } from 'bun:test';
-
-import {
-  brand,
-  unbrand,
-  uuid,
-  email,
-  nonEmptyString,
-  positiveInt,
-  shortId,
-  deriveIdHash,
-} from '../branded';
-
-describe('branded', () => {
-  describe('brand / unbrand', () => {
-    test('brand wraps and unbrand unwraps', () => {
-      const branded = brand('Tag', 'hello');
-      expect(unbrand(branded)).toBe('hello');
-    });
-
-    test('branded value is still usable as base type at runtime', () => {
-      const branded = brand('PositiveInt', 42);
-      expect(branded + 1).toBe(43);
-    });
-  });
-
-  describe('uuid()', () => {
-    test('accepts a valid v4 UUID', () => {
-      const result = uuid('550e8400-e29b-41d4-a716-446655440000');
-      expect(result.isOk()).toBe(true);
-      const value: string = unbrand(result.unwrap());
-      expect(value).toBe('550e8400-e29b-41d4-a716-446655440000');
-    });
-
-    test('rejects an empty string', () => {
-      const result = uuid('');
-      expect(result.isErr()).toBe(true);
-    });
-
-    test('rejects a malformed UUID', () => {
-      const result = uuid('not-a-uuid');
-      expect(result.isErr()).toBe(true);
-    });
-
-    test('rejects UUID missing hyphens', () => {
-      const result = uuid('550e8400e29b41d4a716446655440000');
-      expect(result.isErr()).toBe(true);
-    });
-  });
-
-  describe('email()', () => {
-    test('accepts a simple email', () => {
-      const result = email('test@example.com');
-      expect(result.isOk()).toBe(true);
-    });
-
-    test('rejects missing @', () => {
-      const result = email('testexample.com');
-      expect(result.isErr()).toBe(true);
-    });
-
-    test('rejects missing domain', () => {
-      const result = email('test@');
-      expect(result.isErr()).toBe(true);
-    });
-
-    test('rejects empty string', () => {
-      const result = email('');
-      expect(result.isErr()).toBe(true);
-    });
-  });
-
-  describe('nonEmptyString()', () => {
-    test('accepts a non-empty string', () => {
-      const result = nonEmptyString('hello');
-      expect(result.isOk()).toBe(true);
-    });
-
-    test('rejects an empty string', () => {
-      const result = nonEmptyString('');
-      expect(result.isErr()).toBe(true);
-    });
-  });
-
-  describe('positiveInt()', () => {
-    test('accepts 1', () => {
-      const result = positiveInt(1);
-      expect(result.isOk()).toBe(true);
-    });
-
-    test('accepts a large integer', () => {
-      const result = positiveInt(1_000_000);
-      expect(result.isOk()).toBe(true);
-    });
-
-    test('rejects 0', () => {
-      const result = positiveInt(0);
-      expect(result.isErr()).toBe(true);
-    });
-
-    test('rejects negative numbers', () => {
-      const result = positiveInt(-5);
-      expect(result.isErr()).toBe(true);
-    });
-
-    test('rejects non-integers', () => {
-      const result = positiveInt(1.5);
-      expect(result.isErr()).toBe(true);
-    });
-  });
-
-  describe('shortId()', () => {
-    test('returns a string of default length 8', () => {
-      const id = shortId();
-      expect(id).toHaveLength(8);
-    });
-
-    test('respects custom length', () => {
-      const id = shortId(16);
-      expect(id).toHaveLength(16);
-    });
-
-    test('contains only alphanumeric characters', () => {
-      const id = shortId(100);
-      expect(id).toMatch(/^[A-Za-z0-9]+$/);
-    });
-
-    test('produces unique values', () => {
-      const ids = new Set(Array.from({ length: 50 }, () => shortId()));
-      expect(ids.size).toBe(50);
-    });
-  });
-
-  describe('deriveIdHash()', () => {
-    test('returns a hex string', () => {
-      const id = deriveIdHash('test');
-      expect(id).toMatch(/^[0-9a-f]{8}$/);
-    });
-
-    test('is deterministic', () => {
-      expect(deriveIdHash('hello')).toBe(deriveIdHash('hello'));
-    });
-
-    test('different inputs produce different outputs', () => {
-      expect(deriveIdHash('a')).not.toBe(deriveIdHash('b'));
-    });
-  });
-});

package/src/__tests__/collections.test.ts

@@ -1,126 +0,0 @@
-import { describe, test, expect } from 'bun:test';
-
-import {
-  chunk,
-  dedupe,
-  groupBy,
-  sortBy,
-  isNonEmptyArray,
-} from '../collections';
-
-describe('collections', () => {
-  describe('chunk()', () => {
-    test('splits into even chunks', () => {
-      expect(chunk([1, 2, 3, 4], 2)).toEqual([
-        [1, 2],
-        [3, 4],
-      ]);
-    });
-
-    test('handles remainder', () => {
-      expect(chunk([1, 2, 3, 4, 5], 2)).toEqual([[1, 2], [3, 4], [5]]);
-    });
-
-    test('returns empty array for empty input', () => {
-      expect(chunk([], 3)).toEqual([]);
-    });
-
-    test('single-element chunks', () => {
-      expect(chunk([1, 2, 3], 1)).toEqual([[1], [2], [3]]);
-    });
-
-    test('chunk size larger than array', () => {
-      expect(chunk([1, 2], 10)).toEqual([[1, 2]]);
-    });
-
-    test('throws on size < 1', () => {
-      expect(() => chunk([1], 0)).toThrow(RangeError);
-    });
-  });
-
-  describe('dedupe()', () => {
-    test('removes primitive duplicates', () => {
-      expect(dedupe([1, 2, 2, 3, 1])).toEqual([1, 2, 3]);
-    });
-
-    test('dedupes by key function', () => {
-      const items = [
-        { id: 1, name: 'a' },
-        { id: 2, name: 'b' },
-        { id: 1, name: 'c' },
-      ];
-      const result = dedupe(items, (i) => i.id);
-      expect(result).toEqual([
-        { id: 1, name: 'a' },
-        { id: 2, name: 'b' },
-      ]);
-    });
-
-    test('preserves order', () => {
-      expect(dedupe([3, 1, 2, 1, 3])).toEqual([3, 1, 2]);
-    });
-
-    test('handles empty array', () => {
-      expect(dedupe([])).toEqual([]);
-    });
-  });
-
-  describe('groupBy()', () => {
-    test('groups by key', () => {
-      const items = [
-        { type: 'a', value: 1 },
-        { type: 'b', value: 2 },
-        { type: 'a', value: 3 },
-      ];
-      const groups = groupBy(items, (i) => i.type);
-      expect(groups).toEqual({
-        a: [
-          { type: 'a', value: 1 },
-          { type: 'a', value: 3 },
-        ],
-        b: [{ type: 'b', value: 2 }],
-      });
-    });
-
-    test('returns empty object for empty array', () => {
-      expect(groupBy([], () => 'key')).toEqual({});
-    });
-  });
-
-  describe('sortBy()', () => {
-    test('sorts by numeric key ascending', () => {
-      const items = [{ n: 3 }, { n: 1 }, { n: 2 }];
-      expect(sortBy(items, (i) => i.n)).toEqual([{ n: 1 }, { n: 2 }, { n: 3 }]);
-    });
-
-    test('sorts by string key alphabetically', () => {
-      const items = [{ name: 'charlie' }, { name: 'alice' }, { name: 'bob' }];
-      expect(sortBy(items, (i) => i.name)).toEqual([
-        { name: 'alice' },
-        { name: 'bob' },
-        { name: 'charlie' },
-      ]);
-    });
-
-    test('does not mutate the original array', () => {
-      const original = [{ n: 3 }, { n: 1 }];
-      sortBy(original, (i) => i.n);
-      expect(original[0]?.n).toBe(3);
-    });
-
-    test('returns empty array for empty input', () => {
-      expect(sortBy([], () => 0)).toEqual([]);
-    });
-  });
-
-  describe('isNonEmptyArray()', () => {
-    test('returns true for arrays with elements', () => {
-      expect(isNonEmptyArray([1])).toBe(true);
-      expect(isNonEmptyArray([1, 2, 3])).toBe(true);
-    });
-
-    test('returns false for empty array', () => {
-      expect(isNonEmptyArray([])).toBe(false);
-    });
-  });
-});

package/src/__tests__/context.test.ts

@@ -1,77 +0,0 @@
-import { describe, test, expect } from 'bun:test';
-
-import { createTrailContext } from '../context.js';
-import type { TrailContext } from '../types.js';
-
-const UUID_RE =
-  /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
-
-describe('createTrailContext', () => {
-  test('generates a requestId in UUID format', () => {
-    const ctx = createTrailContext();
-    expect(ctx.requestId).toMatch(UUID_RE);
-  });
-
-  test('defaults cwd to process.cwd()', () => {
-    const ctx = createTrailContext();
-    expect(ctx.cwd).toBe(process.cwd());
-  });
-
-  test('defaults env to process.env', () => {
-    const ctx = createTrailContext();
-    expect(ctx.env).toBeTruthy();
-    expect(ctx.env).toBe(process.env);
-  });
-
-  test('provides a non-aborted abortSignal by default', () => {
-    const ctx = createTrailContext();
-    expect(ctx.abortSignal).toBeInstanceOf(AbortSignal);
-    expect(ctx.abortSignal.aborted).toBe(false);
-  });
-
-  test('override values take precedence', () => {
-    const ac = new AbortController();
-    ac.abort();
-
-    const ctx = createTrailContext({
-      abortSignal: ac.signal,
-      cwd: '/custom/dir',
-      env: { CUSTOM: 'yes' },
-      requestId: 'custom-id',
-      workspaceRoot: '/tmp',
-    });
-
-    expect(ctx.cwd).toBe('/custom/dir');
-    expect(ctx.env).toEqual({ CUSTOM: 'yes' });
-    expect(ctx.requestId).toBe('custom-id');
-    expect(ctx.abortSignal.aborted).toBe(true);
-    expect(ctx.workspaceRoot).toBe('/tmp');
-  });
-
-  test('TrailContext supports extensions for custom fields', () => {
-    const ctx: TrailContext = createTrailContext({
-      extensions: { customField: 42, nested: { key: 'value' } },
-    });
-
-    expect(ctx.extensions?.['customField']).toBe(42);
-    expect(ctx.extensions?.['nested']).toEqual({ key: 'value' });
-  });
-
-  test('provides a resource accessor backed by extensions', () => {
-    const widget = { id: 'widget-1' };
-    const ctx = createTrailContext({
-      extensions: { 'widget.main': widget },
-    });
-
-    expect(ctx.resource('widget.main')).toBe(widget);
-    expect(ctx.resource<{ id: string }>({ id: 'widget.main' }).id).toBe(
-      'widget-1'
-    );
-  });
-
-  test('each call generates a unique requestId', () => {
-    const a = createTrailContext();
-    const b = createTrailContext();
-    expect(a.requestId).not.toBe(b.requestId);
-  });
-});

package/src/__tests__/contour.test.ts

@@ -1,263 +0,0 @@
-import { describe, expect, test } from 'bun:test';
-
-import { z } from 'zod';
-
-import {
-  contour,
-  getContourIdMetadata,
-  getContourReferences,
-} from '../contour.js';
-
-const user = contour(
-  'user',
-  {
-    email: z.string().email(),
-    id: z.string().uuid(),
-    name: z.string(),
-  },
-  {
-    examples: [
-      {
-        email: 'ada@example.com',
-        id: '550e8400-e29b-41d4-a716-446655440000',
-        name: 'Ada',
-      },
-    ],
-    identity: 'id',
-  }
-);
-
-const gist = contour(
-  'gist',
-  {
-    id: z.string().uuid(),
-    ownerId: user.id(),
-    title: z.string(),
-  },
-  { identity: 'id' }
-);
-
-type UserId = z.infer<ReturnType<typeof user.id>>;
-type GistId = z.infer<ReturnType<typeof gist.id>>;
-
-const _ownerId: z.infer<typeof gist.shape.ownerId> = {} as UserId;
-// @ts-expect-error distinct contour ids should not be assignable
-const _mixedIds: UserId = {} as GistId;
-
-describe('contour()', () => {
-  describe('basics', () => {
-    test("returns kind 'contour'", () => {
-      expect(user.kind).toBe('contour');
-    });
-
-    test('preserves the contour name', () => {
-      expect(user.name).toBe('user');
-    });
-
-    test('preserves schema behavior', () => {
-      const parsed = user.safeParse({
-        email: 'ada@example.com',
-        id: '550e8400-e29b-41d4-a716-446655440000',
-        name: 'Ada',
-      });
-
-      expect(parsed.success).toBe(true);
-    });
-  });
-
-  describe('identity', () => {
-    test('stores the identity field name', () => {
-      expect(user.identity).toBe('id');
-    });
-
-    test('exposes the identity field schema', () => {
-      expect(user.identitySchema).toBe(user.shape.id);
-    });
-
-    test('returns a branded identity schema', () => {
-      const schema = user.id();
-      expect(
-        schema.safeParse('550e8400-e29b-41d4-a716-446655440000').success
-      ).toBe(true);
-      expect(schema).toBe(user.id());
-    });
-
-    test('attaches contour metadata to branded identity schemas', () => {
-      expect(getContourIdMetadata(user.id())).toEqual({
-        contour: 'user',
-        identity: 'id',
-      });
-    });
-
-    test('preserves first-write metadata when identity schemas are shared', () => {
-      const baseUser = contour(
-        'user',
-        { id: z.string().uuid(), name: z.string() },
-        { identity: 'id' }
-      );
-      const admin = contour(
-        'admin',
-        { id: baseUser.shape.id, role: z.string() },
-        { identity: 'id' }
-      );
-
-      // The first contour to brand the schema wins — user, not admin.
-      expect(getContourIdMetadata(baseUser.id())).toEqual({
-        contour: 'user',
-        identity: 'id',
-      });
-      // admin still has its own id() accessor
-      expect(admin.id()).toBeDefined();
-
-      // Neither contour should emit its own identity as a cross-contour reference
-      expect(getContourReferences(baseUser)).toEqual([]);
-      expect(getContourReferences(admin)).toEqual([]);
-    });
-
-    test('rejects identity keys that are not in the shape', () => {
-      expect(() =>
-        contour(
-          'broken',
-          {
-            id: z.string(),
-          },
-          { identity: 'missing' as 'id' }
-        )
-      ).toThrow('identity "missing" must match a declared field');
-    });
-  });
-
-  describe('examples', () => {
-    test('stores examples as a frozen array', () => {
-      expect(user.examples).toHaveLength(1);
-      expect(Object.isFrozen(user.examples)).toBe(true);
-    });
-
-    test('validates examples against the contour schema', () => {
-      expect(() =>
-        contour(
-          'broken',
-          {
-            id: z.string().uuid(),
-            name: z.string(),
-          },
-          {
-            examples: [{ id: 'not-a-uuid', name: 42 as never }],
-            identity: 'id',
-          }
-        )
-      ).toThrow('example 0 is invalid');
-    });
-  });
-
-  describe('zod forwarding', () => {
-    test('supports .pick()', () => {
-      const schema = user.pick({ name: true });
-      expect(schema.safeParse({ name: 'Ada' }).success).toBe(true);
-      expect(schema.safeParse({ email: 'ada@example.com' }).success).toBe(
-        false
-      );
-    });
-
-    test('supports .extend()', () => {
-      const schema = user.extend({ active: z.boolean() });
-      expect(
-        schema.safeParse({
-          active: true,
-          email: 'ada@example.com',
-          id: '550e8400-e29b-41d4-a716-446655440000',
-          name: 'Ada',
-        }).success
-      ).toBe(true);
-    });
-
-    test('supports .array()', () => {
-      const schema = user.array();
-      expect(
-        schema.safeParse([
-          {
-            email: 'ada@example.com',
-            id: '550e8400-e29b-41d4-a716-446655440000',
-            name: 'Ada',
-          },
-        ]).success
-      ).toBe(true);
-    });
-
-    test('supports cross-contour references via .id()', () => {
-      expect(
-        gist.safeParse({
-          id: '0f31f6ba-6ff0-41ce-9f6b-8d132b6c4b81',
-          ownerId: '550e8400-e29b-41d4-a716-446655440000',
-          title: 'Hello',
-        }).success
-      ).toBe(true);
-      expect(getContourIdMetadata(gist.shape.ownerId)).toEqual({
-        contour: 'user',
-        identity: 'id',
-      });
-    });
-
-    test('lists declared contour references', () => {
-      expect(getContourReferences(gist)).toEqual([
-        {
-          contour: 'user',
-          field: 'ownerId',
-          identity: 'id',
-        },
-      ]);
-    });
-  });
-
-  describe('wrapper unwrapping', () => {
-    test('resolves .optional() contour id metadata', () => {
-      expect(getContourIdMetadata(user.id().optional())).toEqual({
-        contour: 'user',
-        identity: 'id',
-      });
-    });
-
-    test('resolves .nullable() contour id metadata', () => {
-      expect(getContourIdMetadata(user.id().nullable())).toEqual({
-        contour: 'user',
-        identity: 'id',
-      });
-    });
-
-    test('resolves .nullish() contour id metadata (two-level wrapper)', () => {
-      expect(getContourIdMetadata(user.id().nullish())).toEqual({
-        contour: 'user',
-        identity: 'id',
-      });
-    });
-
-    test('resolves deeply nested wrappers', () => {
-      expect(
-        getContourIdMetadata(user.id().nullable().optional().default(null))
-      ).toEqual({
-        contour: 'user',
-        identity: 'id',
-      });
-    });
-
-    test('detects references through .nullish() wrappers in contour shapes', () => {
-      const comment = contour(
-        'comment',
-        {
-          authorId: user.id().nullish(),
-          id: z.string().uuid(),
-          text: z.string(),
-        },
-        { identity: 'id' }
-      );
-
-      expect(getContourReferences(comment)).toEqual([
-        {
-          contour: 'user',
-          field: 'authorId',
-          identity: 'id',
-        },
-      ]);
-    });
-  });
-});