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

package/src/__tests__/drift.test.ts

@@ -3,8 +3,17 @@ import { mkdirSync, rmSync, writeFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { tmpdir } from 'node:os';
 
-import { trail, topo, Result } from '@ontrails/core';
-import { hashTrailheadMap, generateTrailheadMap } from '@ontrails/schema';
+import { createTopoStore, trail, topo, Result } from '@ontrails/core';
+import { createTopoSnapshot } from '@ontrails/core/internal/topo-store';
+import {
+  openWriteTrailsDb,
+  deriveTrailsDir,
+} from '@ontrails/core/internal/trails-db';
+import {
+  deriveSurfaceMapHash,
+  deriveSurfaceMap,
+  writeSurfaceLock,
+} from '@ontrails/schema';
 import { z } from 'zod';
 
 import { checkDrift } from '../drift.js';
@@ -24,6 +33,28 @@ const createTempDir = (): string => {
   return dir;
 };
 
+const committedLockDir = (dir: string): string => {
+  const trailsDir = deriveTrailsDir({ rootDir: dir });
+  mkdirSync(trailsDir, { recursive: true });
+  return trailsDir;
+};
+
+const seedSavedTopo = (dir: string): string | undefined => {
+  const db = openWriteTrailsDb({ rootDir: dir });
+  try {
+    const result = createTopoSnapshot(db, makeTopo(), {
+      createdAt: '2026-04-03T15:00:00.000Z',
+    });
+    if (result.isErr()) {
+      throw result.error;
+    }
+  } finally {
+    db.close();
+  }
+
+  return createTopoStore({ rootDir: dir }).exports.get()?.surfaceHash;
+};
+
 describe('checkDrift', () => {
   test('returns stale: false when no topo is provided', async () => {
     const result = await checkDrift('/tmp');
@@ -43,12 +74,28 @@ describe('checkDrift', () => {
     }
   });
 
+  test('uses the latest saved topo hash when no live topo is provided', async () => {
+    const dir = createTempDir();
+    try {
+      const expectedHash = seedSavedTopo(dir);
+      const result = await checkDrift(dir);
+
+      expect(result.stale).toBe(false);
+      expect(result.currentHash).toBe(expectedHash);
+    } finally {
+      rmSync(dir, { force: true, recursive: true });
+    }
+  });
+
   test('returns stale: false when lock matches current hash', async () => {
     const dir = createTempDir();
     try {
       const tp = makeTopo();
-      const hash = hashTrailheadMap(generateTrailheadMap(tp));
-      writeFileSync(join(dir, 'trailhead.lock'), `${hash}\n`);
+      const hash = deriveSurfaceMapHash(deriveSurfaceMap(tp));
+      await writeSurfaceLock(
+        { hash, version: 1 },
+        { dir: committedLockDir(dir) }
+      );
 
       const result = await checkDrift(dir, tp);
       expect(result.stale).toBe(false);
@@ -62,7 +109,10 @@ describe('checkDrift', () => {
   test('returns stale: true when lock does not match', async () => {
     const dir = createTempDir();
     try {
-      writeFileSync(join(dir, 'trailhead.lock'), 'outdated-hash\n');
+      writeFileSync(
+        join(committedLockDir(dir), 'trails.lock'),
+        'outdated-hash\n'
+      );
 
       const result = await checkDrift(dir, makeTopo());
       expect(result.stale).toBe(true);
@@ -71,4 +121,24 @@ describe('checkDrift', () => {
       rmSync(dir, { force: true, recursive: true });
     }
   });
+
+  test('blocks drift calculation when draft state remains in the topo', async () => {
+    const dir = createTempDir();
+    try {
+      const draftTrail = trail('test.hello', {
+        blaze: () => Result.ok({ greeting: 'hi' }),
+        crosses: ['_draft.test.prepare'],
+        input: z.object({ name: z.string() }),
+        output: z.object({ greeting: z.string() }),
+      });
+
+      const result = await checkDrift(dir, topo('test-app', { draftTrail }));
+
+      expect(result.stale).toBe(true);
+      expect(result.blockedReason).toContain('draft');
+      expect(result.currentHash).toBe('blocked');
+    } finally {
+      rmSync(dir, { force: true, recursive: true });
+    }
+  });
 });

package/src/__tests__/error-mapping-completeness.test.ts

@@ -0,0 +1,56 @@
+import { describe, expect, test } from 'bun:test';
+
+import { errorMappingCompleteness } from '../rules/error-mapping-completeness.js';
+
+const TEST_FILE = 'transport-error-map.ts';
+
+describe('error-mapping-completeness', () => {
+  test('passes complete mapper registrations', () => {
+    const code = `
+import { createTransportErrorMapper } from '@ontrails/core';
+
+const cliMapper = createTransportErrorMapper({
+  auth: 9,
+  cancelled: 130,
+  conflict: 3,
+  internal: 8,
+  network: 7,
+  not_found: 2,
+  permission: 4,
+  rate_limit: 6,
+  timeout: 5,
+  validation: 1,
+});
+`;
+
+    const diagnostics = errorMappingCompleteness.check(code, TEST_FILE);
+
+    expect(diagnostics).toHaveLength(0);
+  });
+
+  test('catches incomplete mapper registrations resolved through object properties', () => {
+    const code = `
+import { createTransportErrorMapper } from '@ontrails/core';
+
+const transportErrorMap = {
+  cli: {
+    conflict: 3,
+    internal: 8,
+    not_found: 2,
+    validation: 1,
+  },
+};
+
+const cliMapper = createTransportErrorMapper(transportErrorMap.cli);
+`;
+
+    const diagnostics = errorMappingCompleteness.check(code, TEST_FILE);
+
+    expect(diagnostics).toHaveLength(1);
+    expect(diagnostics[0]?.rule).toBe('error-mapping-completeness');
+    expect(diagnostics[0]?.severity).toBe('error');
+    expect(diagnostics[0]?.message).toContain('auth');
+    expect(diagnostics[0]?.message).toContain('cancelled');
+    expect(diagnostics[0]?.line).toBeGreaterThan(0);
+  });
+});

package/src/__tests__/example-valid.test.ts

@@ -0,0 +1,101 @@
+import { describe, expect, test } from 'bun:test';
+
+import { exampleValid } from '../rules/example-valid.js';
+
+const TEST_FILE = 'contours.ts';
+
+describe('example-valid', () => {
+  test('passes when contour examples match the schema', () => {
+    const code = `
+import { contour } from '@ontrails/core';
+import { z } from 'zod';
+
+const user = contour('user', {
+  id: z.string().uuid(),
+  name: z.string(),
+}, {
+  examples: [{
+    id: '550e8400-e29b-41d4-a716-446655440000',
+    name: 'Ada',
+  }],
+  identity: 'id',
+});
+`;
+
+    expect(exampleValid.check(code, TEST_FILE)).toEqual([]);
+  });
+
+  test('flags invalid contour examples', () => {
+    const code = `
+import { contour } from '@ontrails/core';
+import { z } from 'zod';
+
+const user = contour('user', {
+  id: z.string().uuid(),
+  name: z.string(),
+}, {
+  examples: [{
+    id: 'not-a-uuid',
+    name: 42,
+  }],
+  identity: 'id',
+});
+`;
+
+    const diagnostics = exampleValid.check(code, TEST_FILE);
+
+    expect(diagnostics).toHaveLength(1);
+    expect(diagnostics[0]?.rule).toBe('example-valid');
+    expect(diagnostics[0]?.message).toContain('example 0 is invalid');
+  });
+
+  test('skips unsupported example expressions instead of guessing', () => {
+    const code = `
+import { contour } from '@ontrails/core';
+import { z } from 'zod';
+
+const buildExample = () => ({
+  id: '550e8400-e29b-41d4-a716-446655440000',
+  name: 'Ada',
+});
+
+const user = contour('user', {
+  id: z.string().uuid(),
+  name: z.string(),
+}, {
+  examples: [buildExample()],
+  identity: 'id',
+});
+`;
+
+    expect(exampleValid.check(code, TEST_FILE)).toEqual([]);
+  });
+
+  test('keeps dependent contour validation alive when base contours omit options', () => {
+    const code = `
+import { contour } from '@ontrails/core';
+import { z } from 'zod';
+
+const base = contour('base', {
+  id: z.string().uuid(),
+});
+
+const child = contour('child', {
+  id: z.string().uuid(),
+  baseId: base.id(),
+}, {
+  examples: [{
+    id: '550e8400-e29b-41d4-a716-446655440000',
+    baseId: 'not-a-uuid',
+  }],
+  identity: 'id',
+});
+`;
+
+    const diagnostics = exampleValid.check(code, TEST_FILE);
+
+    expect(diagnostics).toHaveLength(1);
+    expect(diagnostics[0]?.rule).toBe('example-valid');
+    expect(diagnostics[0]?.message).toContain('child');
+  });
+});

package/src/__tests__/fires-declarations-param-destructure.test.ts

@@ -0,0 +1,54 @@
+import { describe, expect, test } from 'bun:test';
+
+import { firesDeclarations } from '../rules/fires-declarations.js';
+
+const TEST_FILE = 'test.ts';
+
+describe('fires-declarations — parameter-level destructure', () => {
+  test('parameter-level { fire } destructure is tracked (clean)', () => {
+    const code = `
+trail('paramDestructure', {
+  fires: ['entity.created'],
+  blaze: async (input, { fire }) => {
+    await fire('entity.created', { name: input.name });
+    return Result.ok({});
+  },
+});
+`;
+
+    const diagnostics = firesDeclarations.check(code, TEST_FILE);
+    expect(diagnostics.length).toBe(0);
+  });
+
+  test('parameter-level { fire } destructure flags undeclared signal', () => {
+    const code = `
+trail('paramDestructureUndeclared', {
+  blaze: async (input, { fire }) => {
+    await fire('undeclared.signal', { name: input.name });
+    return Result.ok({});
+  },
+});
+`;
+
+    const diagnostics = firesDeclarations.check(code, TEST_FILE);
+    expect(diagnostics.length).toBe(1);
+    expect(diagnostics[0]?.severity).toBe('error');
+    expect(diagnostics[0]?.message).toContain("'undeclared.signal'");
+  });
+
+  test('parameter-level { fire: emit } rename is tracked', () => {
+    const code = `
+trail('paramRename', {
+  blaze: async (input, { fire: emit }) => {
+    await emit('undeclared.renamed', { name: input.name });
+    return Result.ok({});
+  },
+});
+`;
+
+    const diagnostics = firesDeclarations.check(code, TEST_FILE);
+    expect(diagnostics.length).toBe(1);
+    expect(diagnostics[0]?.severity).toBe('error');
+    expect(diagnostics[0]?.message).toContain("'undeclared.renamed'");
+  });
+});