@ontrails/warden 1.0.0-beta.2 → 1.0.0-beta.22

package/src/__tests__/drift.test.ts

@@ -1,74 +0,0 @@
-import { describe, expect, test } from 'bun:test';
-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 { hashSurfaceMap, generateSurfaceMap } from '@ontrails/schema';
-import { z } from 'zod';
-
-import { checkDrift } from '../drift.js';
-
-const makeTopo = () => {
-  const t = trail('test.hello', {
-    implementation: () => Result.ok({ greeting: 'hi' }),
-    input: z.object({ name: z.string() }),
-    output: z.object({ greeting: z.string() }),
-  });
-  return topo('test-app', { t });
-};
-
-const createTempDir = (): string => {
-  const dir = join(tmpdir(), `drift-test-${Date.now()}`);
-  mkdirSync(dir, { recursive: true });
-  return dir;
-};
-
-describe('checkDrift', () => {
-  test('returns stale: false when no topo is provided', async () => {
-    const result = await checkDrift('/tmp');
-    expect(result.stale).toBe(false);
-    expect(result.currentHash).toBe('unknown');
-  });
-
-  test('returns stale: false when no lock file exists', async () => {
-    const dir = createTempDir();
-    try {
-      const result = await checkDrift(dir, makeTopo());
-      expect(result.stale).toBe(false);
-      expect(result.committedHash).toBeNull();
-      expect(result.currentHash.length).toBeGreaterThan(0);
-    } 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 = hashSurfaceMap(generateSurfaceMap(tp));
-      writeFileSync(join(dir, 'surface.lock'), `${hash}\n`);
-
-      const result = await checkDrift(dir, tp);
-      expect(result.stale).toBe(false);
-      expect(result.committedHash).toBe(hash);
-      expect(result.currentHash).toBe(hash);
-    } finally {
-      rmSync(dir, { force: true, recursive: true });
-    }
-  });
-
-  test('returns stale: true when lock does not match', async () => {
-    const dir = createTempDir();
-    try {
-      writeFileSync(join(dir, 'surface.lock'), 'outdated-hash\n');
-
-      const result = await checkDrift(dir, makeTopo());
-      expect(result.stale).toBe(true);
-      expect(result.committedHash).toBe('outdated-hash');
-    } finally {
-      rmSync(dir, { force: true, recursive: true });
-    }
-  });
-});

package/src/__tests__/formatters.test.ts

@@ -1,157 +0,0 @@
-import { describe, expect, test } from 'bun:test';
-
-import type { WardenReport } from '../cli.js';
-import {
-  formatGitHubAnnotations,
-  formatJson,
-  formatSummary,
-} from '../formatters.js';
-
-const cleanReport: WardenReport = {
-  diagnostics: [],
-  drift: { committedHash: 'abc', currentHash: 'abc', stale: false },
-  errorCount: 0,
-  passed: true,
-  warnCount: 0,
-};
-
-const reportWithDiagnostics: WardenReport = {
-  diagnostics: [
-    {
-      filePath: 'packages/core/src/result.ts',
-      line: 42,
-      message: 'Throw statement found in trail implementation',
-      rule: 'no-throw-in-implementation',
-      severity: 'error',
-    },
-    {
-      filePath: 'packages/core/src/trails.ts',
-      line: 15,
-      message: 'Trail "entity.show" has no output schema',
-      rule: 'require-output-schema',
-      severity: 'warn',
-    },
-  ],
-  drift: null,
-  errorCount: 1,
-  passed: false,
-  warnCount: 1,
-};
-
-const reportWithDrift: WardenReport = {
-  diagnostics: [],
-  drift: { committedHash: 'abc', currentHash: 'def', stale: true },
-  errorCount: 0,
-  passed: false,
-  warnCount: 0,
-};
-
-describe('formatGitHubAnnotations', () => {
-  test('produces empty string for clean report', () => {
-    expect(formatGitHubAnnotations(cleanReport)).toBe('');
-  });
-
-  test('maps error severity to ::error', () => {
-    const output = formatGitHubAnnotations(reportWithDiagnostics);
-    expect(output).toContain(
-      '::error file=packages/core/src/result.ts,line=42::no-throw-in-implementation:'
-    );
-  });
-
-  test('maps warn severity to ::warning', () => {
-    const output = formatGitHubAnnotations(reportWithDiagnostics);
-    expect(output).toContain(
-      '::warning file=packages/core/src/trails.ts,line=15::require-output-schema:'
-    );
-  });
-
-  test('emits drift as a single ::error annotation', () => {
-    const output = formatGitHubAnnotations(reportWithDrift);
-    expect(output).toContain('::error::drift: surface.lock is stale');
-  });
-
-  test('produces one line per diagnostic', () => {
-    const lines = formatGitHubAnnotations(reportWithDiagnostics)
-      .split('\n')
-      .filter(Boolean);
-    expect(lines).toHaveLength(2);
-  });
-});
-
-describe('formatJson', () => {
-  test('produces valid JSON', () => {
-    const parsed = JSON.parse(formatJson(cleanReport));
-    expect(parsed).toBeDefined();
-  });
-
-  test('includes passed status', () => {
-    const parsed = JSON.parse(formatJson(cleanReport));
-    expect(parsed.passed).toBe(true);
-  });
-
-  test('includes summary counts', () => {
-    const parsed = JSON.parse(formatJson(reportWithDiagnostics));
-    expect(parsed.summary).toEqual({
-      errors: 1,
-      suggestions: 0,
-      warnings: 1,
-    });
-  });
-
-  test('includes diagnostics array', () => {
-    const parsed = JSON.parse(formatJson(reportWithDiagnostics));
-    expect(parsed.diagnostics).toHaveLength(2);
-    expect(parsed.diagnostics[0].rule).toBe('no-throw-in-implementation');
-  });
-
-  test('includes null drift when absent', () => {
-    const parsed = JSON.parse(formatJson(reportWithDiagnostics));
-    expect(parsed.drift).toBeNull();
-  });
-
-  test('includes drift result when present', () => {
-    const parsed = JSON.parse(formatJson(reportWithDrift));
-    expect(parsed.drift.stale).toBe(true);
-  });
-});
-
-describe('formatSummary', () => {
-  test('includes markdown heading', () => {
-    expect(formatSummary(cleanReport)).toContain('## Warden Report');
-  });
-
-  test('shows PASS for clean report', () => {
-    expect(formatSummary(cleanReport)).toContain('**Result: PASS**');
-  });
-
-  test('shows FAIL for failing report', () => {
-    expect(formatSummary(reportWithDiagnostics)).toContain('**Result: FAIL**');
-  });
-
-  test('groups errors under ### Errors heading', () => {
-    const output = formatSummary(reportWithDiagnostics);
-    expect(output).toContain('### Errors');
-    expect(output).toContain('no-throw-in-implementation');
-  });
-
-  test('groups warnings under ### Warnings heading', () => {
-    const output = formatSummary(reportWithDiagnostics);
-    expect(output).toContain('### Warnings');
-    expect(output).toContain('require-output-schema');
-  });
-
-  test('includes file:line in backticks', () => {
-    const output = formatSummary(reportWithDiagnostics);
-    expect(output).toContain('`packages/core/src/result.ts:42`');
-  });
-
-  test('includes drift section when stale', () => {
-    const output = formatSummary(reportWithDrift);
-    expect(output).toContain('### Drift');
-    expect(output).toContain('surface.lock is stale');
-  });
-
-  test('omits drift section when clean', () => {
-    expect(formatSummary(cleanReport)).not.toContain('### Drift');
-  });
-});

package/src/__tests__/implementation-returns-result.test.ts

@@ -1,75 +0,0 @@
-import { describe, expect, test } from 'bun:test';
-
-import { implementationReturnsResult } from '../rules/implementation-returns-result.js';
-
-const TEST_FILE = 'test.ts';
-
-describe('implementation-returns-result', () => {
-  test('flags raw object return in trail implementation', () => {
-    const code = `
-trail("entity.show", {
-  implementation: async (input, ctx) => {
-    return { name: "foo" };
-  }
-})`;
-
-    const diagnostics = implementationReturnsResult.check(code, TEST_FILE);
-
-    expect(diagnostics.length).toBe(1);
-    expect(diagnostics[0]?.rule).toBe('implementation-returns-result');
-    expect(diagnostics[0]?.severity).toBe('error');
-  });
-
-  test('allows Result.ok() and returning ctx.follow() results', () => {
-    const code = `
-hike("entity.onboard", {
-  implementation: async (input, ctx) => {
-    const result = await ctx.follow("entity.create", input);
-    return result;
-  }
-})
-
-trail("entity.create", {
-  implementation: async (input, ctx) => Result.ok({ id: "123" })
-})`;
-
-    const diagnostics = implementationReturnsResult.check(code, TEST_FILE);
-
-    expect(diagnostics.length).toBe(0);
-  });
-
-  test('flags concise raw implementation bodies', () => {
-    const code = `
-trail("entity.create", {
-  implementation: async (input, ctx) => ({ id: "123" })
-})`;
-
-    const diagnostics = implementationReturnsResult.check(code, TEST_FILE);
-
-    expect(diagnostics.length).toBe(1);
-    expect(diagnostics[0]?.message).toContain('entity.create');
-  });
-
-  test('allows returning explicitly Result-typed local helpers', () => {
-    const code = `
-const buildDetail = (trailId: string): Result<object, Error> =>
-  Result.ok({ trailId });
-
-const buildDiff = async (): Promise<Result<object, Error>> =>
-  Result.ok({ breaking: [] });
-
-trail("survey", {
-  implementation: async (input, ctx) => {
-    if (input.diff) {
-      return await buildDiff();
-    }
-
-    return buildDetail(input.trailId);
-  }
-})`;
-
-    const diagnostics = implementationReturnsResult.check(code, TEST_FILE);
-
-    expect(diagnostics.length).toBe(0);
-  });
-});

package/src/__tests__/no-direct-implementation-call.test.ts

@@ -1,83 +0,0 @@
-import { describe, expect, test } from 'bun:test';
-
-import { noDirectImplementationCall } from '../rules/no-direct-implementation-call.js';
-
-describe('no-direct-implementation-call', () => {
-  test('flags direct implementation access in application code', () => {
-    const code = `
-import { trail, Result } from "@ontrails/core";
-
-const entityShow = trail("entity.show", {
-  implementation: async (input, ctx) => Result.ok({ id: input.id }),
-});
-
-async function run() {
-  const result = await entityShow.implementation({ id: "1" }, ctx);
-  return result;
-}`;
-
-    const diagnostics = noDirectImplementationCall.check(code, 'src/app.ts');
-
-    expect(diagnostics).toHaveLength(1);
-    expect(diagnostics[0]?.rule).toBe('no-direct-implementation-call');
-    expect(diagnostics[0]?.severity).toBe('warn');
-    expect(diagnostics[0]?.message).toContain('ctx.follow');
-  });
-
-  test('allows ctx.follow() calls', () => {
-    const code = `
-hike("entity.onboard", {
-  follows: ["entity.create"],
-  implementation: async (input, ctx) => {
-    const result = await ctx.follow("entity.create", input);
-    return Result.ok(result);
-  },
-});
-`;
-
-    const diagnostics = noDirectImplementationCall.check(code, 'src/app.ts');
-
-    expect(diagnostics).toHaveLength(0);
-  });
-
-  test('ignores test files', () => {
-    const code = `
-async function run() {
-  return await entityShow.implementation({ id: "1" }, ctx);
-}`;
-
-    const diagnostics = noDirectImplementationCall.check(
-      code,
-      'src/__tests__/app.test.ts'
-    );
-
-    expect(diagnostics).toHaveLength(0);
-  });
-
-  test('ignores framework internals that intentionally call implementations', () => {
-    const code = `
-export async function run() {
-  return await entityShow.implementation({ id: "1" }, ctx);
-}`;
-
-    const diagnostics = noDirectImplementationCall.check(
-      code,
-      '/repo/packages/testing/src/trail.ts'
-    );
-
-    expect(diagnostics).toHaveLength(0);
-  });
-
-  test('ignores implementation references inside template strings', () => {
-    const code = `
-const generated = \`const result = await entityShow.implementation({ id: "1" }, ctx);\`;
-`;
-
-    const diagnostics = noDirectImplementationCall.check(
-      code,
-      'src/new-trail.ts'
-    );
-
-    expect(diagnostics).toHaveLength(0);
-  });
-});

package/src/__tests__/no-sync-result-assumption.test.ts

@@ -1,85 +0,0 @@
-import { describe, expect, test } from 'bun:test';
-
-import { noSyncResultAssumption } from '../rules/no-sync-result-assumption.js';
-
-describe('no-sync-result-assumption', () => {
-  test('flags direct result access on implementation calls', () => {
-    const code = `
-async function run() {
-  const isOk = entityShow.implementation({ id: "1" }, ctx).isOk();
-  return isOk;
-}`;
-
-    const diagnostics = noSyncResultAssumption.check(code, 'src/app.ts');
-
-    expect(diagnostics).toHaveLength(1);
-    expect(diagnostics[0]?.rule).toBe('no-sync-result-assumption');
-    expect(diagnostics[0]?.severity).toBe('error');
-    expect(diagnostics[0]?.message).toContain('Missing await');
-  });
-
-  test('flags a stored implementation result that is used synchronously', () => {
-    const code = `
-const result = entityShow.implementation({ id: "1" }, ctx);
-
-if (result.isOk()) {
-  console.log("ok");
-}`;
-
-    const diagnostics = noSyncResultAssumption.check(code, 'src/app.ts');
-
-    expect(diagnostics).toHaveLength(1);
-    expect(diagnostics[0]?.line).toBe(4);
-  });
-
-  test('allows awaited implementation calls before result access', () => {
-    const code = `
-async function run() {
-  const result = await entityShow.implementation({ id: "1" }, ctx);
-  return result.isOk();
-}`;
-
-    const diagnostics = noSyncResultAssumption.check(code, 'src/app.ts');
-
-    expect(diagnostics).toHaveLength(0);
-  });
-
-  test('allows awaited implementation calls when the property access is chained', () => {
-    const code = `
-async function run() {
-  return (await entityShow.implementation({ id: "1" }, ctx)).isOk();
-}`;
-
-    const diagnostics = noSyncResultAssumption.check(code, 'src/app.ts');
-
-    expect(diagnostics).toHaveLength(0);
-  });
-
-  test('ignores test files', () => {
-    const code = `
-const result = entityShow.implementation({ id: "1" }, ctx);
-result.isOk();
-`;
-
-    const diagnostics = noSyncResultAssumption.check(
-      code,
-      'src/__tests__/app.test.ts'
-    );
-
-    expect(diagnostics).toHaveLength(0);
-  });
-
-  test('ignores framework internals that intentionally call implementations', () => {
-    const code = `
-const result = entityShow.implementation({ id: "1" }, ctx);
-result.isOk();
-`;
-
-    const diagnostics = noSyncResultAssumption.check(
-      code,
-      '/repo/packages/testing/src/trail.ts'
-    );
-
-    expect(diagnostics).toHaveLength(0);
-  });
-});

package/src/__tests__/no-throw-in-detour-target.test.ts

@@ -1,78 +0,0 @@
-import { describe, expect, test } from 'bun:test';
-
-import { noThrowInDetourTarget } from '../rules/no-throw-in-detour-target.js';
-
-const TEST_FILE = 'test.ts';
-
-describe('no-throw-in-detour-target', () => {
-  test('flags throw inside a detour target implementation', () => {
-    const code = `
-trail("entity.show", {
-  detours: { NotFoundError: ["entity.fallback"] },
-  implementation: async (input, ctx) => Result.ok({ id: "123" })
-})
-
-trail("entity.fallback", {
-  implementation: async (input, ctx) => {
-    throw new Error("boom");
-  }
-})`;
-
-    const diagnostics = noThrowInDetourTarget.check(code, TEST_FILE);
-
-    expect(diagnostics.length).toBe(1);
-    expect(diagnostics[0]?.rule).toBe('no-throw-in-detour-target');
-    expect(diagnostics[0]?.severity).toBe('error');
-  });
-
-  test('allows throw in implementations that are not detour targets', () => {
-    const code = `
-trail("entity.show", {
-  implementation: async (input, ctx) => {
-    throw new Error("boom");
-  }
-})`;
-
-    const diagnostics = noThrowInDetourTarget.check(code, TEST_FILE);
-
-    expect(diagnostics.length).toBe(0);
-  });
-
-  test('flags concise detour target implementations that throw inline', () => {
-    const code = `
-trail("entity.show", {
-  detours: { NotFoundError: ["entity.fallback"] },
-  implementation: async (input, ctx) => Result.ok({ id: "123" })
-})
-
-trail("entity.fallback", {
-  implementation: async (input, ctx) => { throw new Error("boom"); }
-})`;
-
-    const diagnostics = noThrowInDetourTarget.check(code, TEST_FILE);
-
-    expect(diagnostics.length).toBe(1);
-    expect(diagnostics[0]?.message).toContain('entity.fallback');
-  });
-
-  test('uses project context when the detour target is defined in another file', () => {
-    const code = `
-trail("entity.fallback", {
-  implementation: async (input, ctx) => {
-    throw new Error("boom");
-  }
-})`;
-
-    const diagnostics = noThrowInDetourTarget.checkWithContext(
-      code,
-      TEST_FILE,
-      {
-        detourTargetTrailIds: new Set(['entity.fallback']),
-        knownTrailIds: new Set(['entity.show', 'entity.fallback']),
-      }
-    );
-
-    expect(diagnostics).toHaveLength(1);
-    expect(diagnostics[0]?.rule).toBe('no-throw-in-detour-target');
-  });
-});

package/src/__tests__/prefer-schema-inference.test.ts

@@ -1,84 +0,0 @@
-import { describe, expect, test } from 'bun:test';
-
-import { preferSchemaInference } from '../rules/prefer-schema-inference.js';
-
-describe('prefer-schema-inference', () => {
-  test('warns when a fields label only repeats the derived humanized label', () => {
-    const code = `
-trail("entity.show", {
-  input: z.object({ firstName: z.string() }),
-  fields: {
-    firstName: { label: "First Name" },
-  },
-  implementation: (input) => Result.ok(input),
-})`;
-
-    const diagnostics = preferSchemaInference.check(code, 'src/entity.ts');
-
-    expect(diagnostics).toHaveLength(1);
-    expect(diagnostics[0]?.rule).toBe('prefer-schema-inference');
-    expect(diagnostics[0]?.message).toContain('firstName');
-  });
-
-  test('warns when enum options only repeat schema-derived values', () => {
-    const code = `
-trail("entity.paint", {
-  input: z.object({
-    color: z.enum(["red", "green"]),
-  }),
-  fields: {
-    color: {
-      options: [{ value: "red" }, { value: "green" }],
-    },
-  },
-  implementation: (input) => Result.ok(input),
-})`;
-
-    const diagnostics = preferSchemaInference.check(code, 'src/entity.ts');
-
-    expect(diagnostics).toHaveLength(1);
-    expect(diagnostics[0]?.message).toContain('schema-derived options');
-  });
-
-  test('allows custom labels and enriched enum options', () => {
-    const code = `
-trail("entity.paint", {
-  input: z.object({
-    color: z.enum(["red", "green"]),
-    displayName: z.string().describe("Display name"),
-  }),
-  fields: {
-    color: {
-      options: [
-        { value: "red", label: "Red" },
-        { value: "green", hint: "Safe default" },
-      ],
-    },
-    displayName: { label: "Public name" },
-  },
-  implementation: (input) => Result.ok(input),
-})`;
-
-    const diagnostics = preferSchemaInference.check(code, 'src/entity.ts');
-
-    expect(diagnostics).toHaveLength(0);
-  });
-
-  test('does not warn when the override carries other field metadata', () => {
-    const code = `
-trail("entity.show", {
-  input: z.object({ firstName: z.string() }),
-  fields: {
-    firstName: {
-      label: "First Name",
-      message: "Who should we greet?",
-    },
-  },
-  implementation: (input) => Result.ok(input),
-})`;
-
-    const diagnostics = preferSchemaInference.check(code, 'src/entity.ts');
-
-    expect(diagnostics).toHaveLength(0);
-  });
-});