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

package/src/__tests__/missing-reconcile.test.ts

@@ -0,0 +1,154 @@
+import { describe, expect, test } from 'bun:test';
+
+import { missingReconcile } from '../rules/missing-reconcile.js';
+
+const TEST_FILE = 'store.ts';
+
+describe('missing-reconcile', () => {
+  test('warns when a versioned store table is used with crud() but no reconcile() trail exists', () => {
+    const code = `
+import { Result, resource } from '@ontrails/core';
+import { store } from '@ontrails/store';
+import { crud } from '@ontrails/store/trails';
+import { z } from 'zod';
+
+const definition = store({
+  notes: {
+    identity: 'id',
+    schema: z.object({
+      id: z.string(),
+      title: z.string(),
+    }),
+    versioned: true,
+  },
+});
+
+const notesResource = resource('db.notes', {
+  create: () => Result.ok({}),
+  mock: () => ({}),
+});
+
+const noteTrails = crud(definition.tables.notes, notesResource);
+`;
+
+    const diagnostics = missingReconcile.check(code, TEST_FILE);
+
+    expect(diagnostics).toHaveLength(1);
+    expect(diagnostics[0]?.rule).toBe('missing-reconcile');
+    expect(diagnostics[0]?.severity).toBe('warn');
+    expect(diagnostics[0]?.message).toContain('notes');
+    expect(diagnostics[0]?.message).toContain('reconcile');
+  });
+
+  test('stays quiet when reconcile() is present for the versioned table', () => {
+    const code = `
+import { Result, resource } from '@ontrails/core';
+import { store } from '@ontrails/store';
+import { crud, reconcile } from '@ontrails/store/trails';
+import { z } from 'zod';
+
+const definition = store({
+  notes: {
+    identity: 'id',
+    schema: z.object({
+      id: z.string(),
+      title: z.string(),
+    }),
+    versioned: true,
+  },
+});
+
+const notesResource = resource('db.notes', {
+  create: () => Result.ok({}),
+  mock: () => ({}),
+});
+
+const noteTrails = crud(definition.tables.notes, notesResource);
+const reconcileNote = reconcile({
+  resource: notesResource,
+  table: definition.tables.notes,
+});
+`;
+
+    expect(missingReconcile.check(code, TEST_FILE)).toEqual([]);
+  });
+
+  test('tracks two stores with colliding table names independently', () => {
+    const code = `
+import { Result, resource } from '@ontrails/core';
+import { store } from '@ontrails/store';
+import { crud, reconcile } from '@ontrails/store/trails';
+import { z } from 'zod';
+
+const primary = store({
+  notes: {
+    identity: 'id',
+    schema: z.object({ id: z.string(), title: z.string() }),
+    versioned: true,
+  },
+});
+
+const archive = store({
+  notes: {
+    identity: 'id',
+    schema: z.object({ id: z.string(), title: z.string() }),
+    versioned: true,
+  },
+});
+
+const primaryResource = resource('db.primary', {
+  create: () => Result.ok({}),
+  mock: () => ({}),
+});
+const archiveResource = resource('db.archive', {
+  create: () => Result.ok({}),
+  mock: () => ({}),
+});
+
+// primary gets both crud and reconcile — should be quiet
+const primaryCrud = crud(primary.tables.notes, primaryResource);
+const primaryReconcile = reconcile({
+  resource: primaryResource,
+  table: primary.tables.notes,
+});
+
+// archive only gets crud — should warn ONCE for archive (not primary)
+const archiveCrud = crud(archive.tables.notes, archiveResource);
+`;
+
+    const diagnostics = missingReconcile.check(code, TEST_FILE);
+
+    // Only archive should warn; primary's reconcile is correctly paired.
+    expect(diagnostics).toHaveLength(1);
+    expect(diagnostics[0]?.rule).toBe('missing-reconcile');
+    expect(diagnostics[0]?.message).toContain('notes');
+  });
+
+  test('stays quiet for non-versioned tables even when crud() is present', () => {
+    const code = `
+import { Result, resource } from '@ontrails/core';
+import { store } from '@ontrails/store';
+import { crud } from '@ontrails/store/trails';
+import { z } from 'zod';
+
+const definition = store({
+  notes: {
+    identity: 'id',
+    schema: z.object({
+      id: z.string(),
+      title: z.string(),
+    }),
+  },
+});
+
+const notesResource = resource('db.notes', {
+  create: () => Result.ok({}),
+  mock: () => ({}),
+});
+
+const noteTrails = crud(definition.tables.notes, notesResource);
+`;
+
+    expect(missingReconcile.check(code, TEST_FILE)).toEqual([]);
+  });
+});

package/src/__tests__/missing-visibility.test.ts

@@ -0,0 +1,108 @@
+import { describe, expect, test } from 'bun:test';
+
+import { missingVisibility } from '../rules/missing-visibility.js';
+
+const TEST_FILE = 'entity.ts';
+
+describe('missing-visibility', () => {
+  test('warns when a crossed trail has required crossInput but remains public', () => {
+    const code = `
+trail('entity.resolve', {
+  crossInput: z.object({ forkedFrom: z.string() }),
+  blaze: async () => Result.ok({}),
+});
+`;
+
+    const diagnostics = missingVisibility.checkWithContext(code, TEST_FILE, {
+      crossTargetTrailIds: new Set(['entity.resolve']),
+      knownTrailIds: new Set(['entity.resolve']),
+    });
+
+    expect(diagnostics).toHaveLength(1);
+    expect(diagnostics[0]?.rule).toBe('missing-visibility');
+    expect(diagnostics[0]?.severity).toBe('warn');
+    expect(diagnostics[0]?.message).toContain('entity.resolve');
+    expect(diagnostics[0]?.message).toContain("visibility: 'internal'");
+  });
+
+  describe('hasLegacyMetaInternal detection', () => {
+    test('treats trail with meta: { internal: true } as internal', () => {
+      const code = `
+trail('entity.resolve', {
+  meta: { internal: true },
+  crossInput: z.object({ forkedFrom: z.string() }),
+  blaze: async () => Result.ok({}),
+});
+`;
+
+      expect(
+        missingVisibility.checkWithContext(code, TEST_FILE, {
+          crossTargetTrailIds: new Set(['entity.resolve']),
+          knownTrailIds: new Set(['entity.resolve']),
+        })
+      ).toEqual([]);
+    });
+
+    test('does not false-positive on string values containing "internal: true"', () => {
+      const code = `
+trail('entity.resolve', {
+  meta: { description: "this has internal: true in it" },
+  crossInput: z.object({ forkedFrom: z.string() }),
+  blaze: async () => Result.ok({}),
+});
+`;
+
+      const diagnostics = missingVisibility.checkWithContext(code, TEST_FILE, {
+        crossTargetTrailIds: new Set(['entity.resolve']),
+        knownTrailIds: new Set(['entity.resolve']),
+      });
+
+      expect(diagnostics).toHaveLength(1);
+      expect(diagnostics[0]?.rule).toBe('missing-visibility');
+    });
+  });
+
+  test('stays quiet when the crossed trail is already internal', () => {
+    const code = `
+trail('entity.resolve', {
+  visibility: 'internal',
+  crossInput: z.object({ forkedFrom: z.string() }),
+  blaze: async () => Result.ok({}),
+});
+`;
+
+    expect(
+      missingVisibility.checkWithContext(code, TEST_FILE, {
+        crossTargetTrailIds: new Set(['entity.resolve']),
+        knownTrailIds: new Set(['entity.resolve']),
+      })
+    ).toEqual([]);
+  });
+
+  test('stays quiet when crossInput fields are optional', () => {
+    const code = `
+trail('entity.resolve', {
+  crossInput: z.object({ forkedFrom: z.string().optional() }),
+  blaze: async () => Result.ok({}),
+});
+`;
+
+    expect(
+      missingVisibility.checkWithContext(code, TEST_FILE, {
+        crossTargetTrailIds: new Set(['entity.resolve']),
+        knownTrailIds: new Set(['entity.resolve']),
+      })
+    ).toEqual([]);
+  });
+
+  test('stays quiet when the trail is not crossed', () => {
+    const code = `
+trail('entity.resolve', {
+  crossInput: z.object({ forkedFrom: z.string() }),
+  blaze: async () => Result.ok({}),
+});
+`;
+
+    expect(missingVisibility.check(code, TEST_FILE)).toEqual([]);
+  });
+});