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

package/src/__tests__/derive.test.ts

@@ -2,13 +2,45 @@ import { describe, test, expect } from 'bun:test';
 
 import { z } from 'zod';
 
-import { deriveFields } from '../derive.js';
+import { deriveCliPath, deriveFields } from '../derive.js';
 
 // ---------------------------------------------------------------------------
 // Tests
 // ---------------------------------------------------------------------------
 
 describe('derive', () => {
+  describe('cli paths', () => {
+    test('top-level trail IDs derive to a one-segment CLI path', () => {
+      expect(deriveCliPath('search')).toEqual(['search']);
+    });
+
+    test('multi-dot trail IDs derive to the full ordered CLI path', () => {
+      expect(deriveCliPath('topo.pin.remove')).toEqual([
+        'topo',
+        'pin',
+        'remove',
+      ]);
+    });
+
+    test('trail IDs with consecutive dots throw a ValidationError', () => {
+      expect(() => deriveCliPath('topo..pin')).toThrow(
+        'Trail ID "topo..pin" contains an empty segment'
+      );
+    });
+
+    test('trail IDs with a leading dot throw a ValidationError', () => {
+      expect(() => deriveCliPath('.pin')).toThrow(
+        'Trail ID ".pin" contains an empty segment'
+      );
+    });
+
+    test('trail IDs with a trailing dot throw a ValidationError', () => {
+      expect(() => deriveCliPath('pin.')).toThrow(
+        'Trail ID "pin." contains an empty segment'
+      );
+    });
+  });
+
   describe('primitive types', () => {
     test('z.string() derives string field', () => {
       const schema = z.object({ name: z.string() });
@@ -119,6 +151,31 @@ describe('derive', () => {
       expect(fields[0]?.type).toBe('string[]');
       expect(fields[0]?.default).toEqual(['a', 'b']);
     });
+
+    test('z.array(z.object(...)) is omitted when it cannot be represented faithfully', () => {
+      const schema = z.object({
+        files: z.array(
+          z.object({
+            content: z.string(),
+            filename: z.string(),
+          })
+        ),
+      });
+
+      expect(deriveFields(schema)).toEqual([]);
+    });
+  });
+
+  describe('unsupported shapes', () => {
+    test('nested objects are omitted when they cannot be represented faithfully', () => {
+      const schema = z.object({
+        filter: z.object({
+          query: z.string(),
+        }),
+      });
+
+      expect(deriveFields(schema)).toEqual([]);
+    });
   });
 
   describe('modifiers', () => {

package/src/__tests__/errors.test.ts

@@ -15,6 +15,7 @@ import {
   InternalError,
   AuthError,
   CancelledError,
+  RetryExhaustedError,
   exitCodeMap,
   statusCodeMap,
   jsonRpcCodeMap,
@@ -307,3 +308,120 @@ describe('isTrailsError', () => {
     expect(isTrailsError({})).toBe(false);
   });
 });
+
+// ---------------------------------------------------------------------------
+// RetryExhaustedError
+// ---------------------------------------------------------------------------
+
+describe('RetryExhaustedError', () => {
+  describe('category and retryability', () => {
+    test('inherits category from wrapped error', () => {
+      const err = new RetryExhaustedError(new ConflictError('conflict'), {
+        attempts: 1,
+        detour: 'ConflictError',
+      });
+      expect(err.category).toBe('conflict');
+    });
+
+    test('inherits category from retryable error class', () => {
+      const err = new RetryExhaustedError(new TimeoutError('timed out'), {
+        attempts: 3,
+        detour: 'TimeoutError',
+      });
+      expect(err.category).toBe('timeout');
+    });
+
+    test('retryable is always false regardless of wrapped category', () => {
+      const fromTimeout = new RetryExhaustedError(
+        new TimeoutError('timed out'),
+        { attempts: 3, detour: 'TimeoutError' }
+      );
+      expect(fromTimeout.retryable).toBe(false);
+
+      const fromNetwork = new RetryExhaustedError(
+        new NetworkError('disconnected'),
+        { attempts: 2, detour: 'NetworkError' }
+      );
+      expect(fromNetwork.retryable).toBe(false);
+    });
+
+    test('isRetryable returns false even when wrapping a retryable error', () => {
+      const err = new RetryExhaustedError(new TimeoutError('timed out'), {
+        attempts: 3,
+        detour: 'TimeoutError',
+      });
+      expect(isRetryable(err)).toBe(false);
+    });
+  });
+
+  describe('metadata properties', () => {
+    test('cause preserves the original error', () => {
+      const original = new ConflictError('version mismatch');
+      const err = new RetryExhaustedError(original, {
+        attempts: 1,
+        detour: 'ConflictError',
+      });
+      expect(err.cause).toBe(original);
+    });
+
+    test('exposes attempts as a typed readonly property', () => {
+      const err = new RetryExhaustedError(
+        new ConflictError('version mismatch'),
+        { attempts: 3, detour: 'ConflictError' }
+      );
+      expect(err.attempts).toBe(3);
+    });
+
+    test('exposes detour as a typed readonly property', () => {
+      const err = new RetryExhaustedError(new TimeoutError('timed out'), {
+        attempts: 2,
+        detour: 'TimeoutRetry',
+      });
+      expect(err.detour).toBe('TimeoutRetry');
+    });
+
+    test('message includes attempt count and wrapped message', () => {
+      const err = new RetryExhaustedError(
+        new ConflictError('version mismatch'),
+        { attempts: 3, detour: 'ConflictError' }
+      );
+      expect(err.message).toBe(
+        'Recovery exhausted after 3 attempts: version mismatch'
+      );
+    });
+  });
+
+  describe('identity', () => {
+    test('is instanceof InternalError', () => {
+      const err = new RetryExhaustedError(new ConflictError('x'), {
+        attempts: 1,
+        detour: 'ConflictError',
+      });
+      expect(err).toBeInstanceOf(InternalError);
+    });
+
+    test('name is RetryExhaustedError', () => {
+      const err = new RetryExhaustedError(new ConflictError('x'), {
+        attempts: 1,
+        detour: 'ConflictError',
+      });
+      expect(err.name).toBe('RetryExhaustedError');
+    });
+
+    test('is instanceof TrailsError', () => {
+      const err = new RetryExhaustedError(new ConflictError('x'), {
+        attempts: 1,
+        detour: 'ConflictError',
+      });
+      expect(err).toBeInstanceOf(TrailsError);
+    });
+
+    test('is instanceof Error', () => {
+      const err = new RetryExhaustedError(new ConflictError('x'), {
+        attempts: 1,
+        detour: 'ConflictError',
+      });
+      expect(err).toBeInstanceOf(Error);
+    });
+  });
+});