@rsktash/beads-ui 0.1.0

package/server/ws.labels.test.js

@@ -0,0 +1,95 @@
+import { describe, expect, test, vi } from 'vitest';
+import { runBd, runBdJson } from './bd.js';
+import { handleMessage } from './ws.js';
+
+vi.mock('./bd.js', () => ({
+  runBd: vi.fn(),
+  runBdJson: vi.fn()
+}));
+
+function makeStubSocket() {
+  return {
+    sent: /** @type {string[]} */ ([]),
+    readyState: 1,
+    OPEN: 1,
+    /** @param {string} msg */
+    send(msg) {
+      this.sent.push(String(msg));
+    }
+  };
+}
+
+describe('ws labels handlers', () => {
+  test('label-add validates payload', async () => {
+    const ws = makeStubSocket();
+    await handleMessage(
+      /** @type {any} */ (ws),
+      Buffer.from(
+        JSON.stringify({
+          id: 'x',
+          type: /** @type {any} */ ('label-add'),
+          payload: {}
+        })
+      )
+    );
+    const obj = JSON.parse(ws.sent[0]);
+    expect(obj.ok).toBe(false);
+    expect(obj.error.code).toBe('bad_request');
+  });
+
+  test('label-add runs bd and replies with show', async () => {
+    const rb = /** @type {import('vitest').Mock} */ (runBd);
+    const rj = /** @type {import('vitest').Mock} */ (runBdJson);
+    rb.mockResolvedValueOnce({ code: 0, stdout: '', stderr: '' });
+    rj.mockResolvedValueOnce({
+      code: 0,
+      stdoutJson: { id: 'UI-1', labels: ['frontend'] }
+    });
+
+    const ws = makeStubSocket();
+    await handleMessage(
+      /** @type {any} */ (ws),
+      Buffer.from(
+        JSON.stringify({
+          id: 'a',
+          type: /** @type {any} */ ('label-add'),
+          payload: { id: 'UI-1', label: 'frontend' }
+        })
+      )
+    );
+
+    const call = rb.mock.calls[0][0];
+    expect(call.slice(0, 3)).toEqual(['label', 'add', 'UI-1']);
+    const obj = JSON.parse(ws.sent[ws.sent.length - 1]);
+    expect(obj.ok).toBe(true);
+    expect(obj.payload && obj.payload.id).toBe('UI-1');
+  });
+
+  test('label-remove runs bd and replies with show', async () => {
+    const rb = /** @type {import('vitest').Mock} */ (runBd);
+    const rj = /** @type {import('vitest').Mock} */ (runBdJson);
+    rb.mockResolvedValueOnce({ code: 0, stdout: '', stderr: '' });
+    rj.mockResolvedValueOnce({
+      code: 0,
+      stdoutJson: { id: 'UI-1', labels: [] }
+    });
+
+    const ws = makeStubSocket();
+    await handleMessage(
+      /** @type {any} */ (ws),
+      Buffer.from(
+        JSON.stringify({
+          id: 'b',
+          type: /** @type {any} */ ('label-remove'),
+          payload: { id: 'UI-1', label: 'frontend' }
+        })
+      )
+    );
+
+    const call = rb.mock.calls[rb.mock.calls.length - 1][0];
+    expect(call.slice(0, 3)).toEqual(['label', 'remove', 'UI-1']);
+    const obj = JSON.parse(ws.sent[ws.sent.length - 1]);
+    expect(obj.ok).toBe(true);
+    expect(obj.payload && obj.payload.id).toBe('UI-1');
+  });
+});

package/server/ws.list-refresh.coalesce.test.js

@@ -0,0 +1,95 @@
+import { createServer } from 'node:http';
+import { beforeEach, describe, expect, test, vi } from 'vitest';
+import { fetchListForSubscription } from './list-adapters.js';
+import { attachWsServer, handleMessage, scheduleListRefresh } from './ws.js';
+
+vi.mock('./list-adapters.js', () => ({
+  fetchListForSubscription: vi.fn(async () => {
+    return {
+      ok: true,
+      items: [
+        { id: 'A', updated_at: 1, closed_at: null },
+        { id: 'B', updated_at: 1, closed_at: null }
+      ]
+    };
+  })
+}));
+
+beforeEach(() => {
+  vi.useFakeTimers();
+});
+
+describe('ws list refresh coalescing', () => {
+  test('schedules one refresh per burst for active specs', async () => {
+    const server = createServer();
+    const { wss } = attachWsServer(server, {
+      path: '/ws',
+      heartbeat_ms: 10000,
+      refresh_debounce_ms: 50
+    });
+
+    // Two connected clients
+    const a = {
+      sent: /** @type {string[]} */ ([]),
+      readyState: 1,
+      OPEN: 1,
+      /** @param {string} msg */
+      send(msg) {
+        this.sent.push(String(msg));
+      }
+    };
+    const b = {
+      sent: /** @type {string[]} */ ([]),
+      readyState: 1,
+      OPEN: 1,
+      /** @param {string} msg */
+      send(msg) {
+        this.sent.push(String(msg));
+      }
+    };
+    wss.clients.add(/** @type {any} */ (a));
+    wss.clients.add(/** @type {any} */ (b));
+
+    // Subscribe to two different lists
+    await handleMessage(
+      /** @type {any} */ (a),
+      Buffer.from(
+        JSON.stringify({
+          id: 'l1',
+          type: /** @type {any} */ ('subscribe-list'),
+          payload: { id: 'c1', type: 'all-issues' }
+        })
+      )
+    );
+    await handleMessage(
+      /** @type {any} */ (b),
+      Buffer.from(
+        JSON.stringify({
+          id: 'l2',
+          type: /** @type {any} */ ('subscribe-list'),
+          payload: { id: 'c2', type: 'in-progress-issues' }
+        })
+      )
+    );
+
+    // Clear initial refresh calls from subscribe-list
+    const mock = /** @type {import('vitest').Mock} */ (
+      fetchListForSubscription
+    );
+    mock.mockClear();
+
+    // Simulate a burst of DB change events
+    scheduleListRefresh();
+    scheduleListRefresh();
+    scheduleListRefresh();
+
+    // Before debounce, nothing ran
+    expect(mock.mock.calls.length).toBe(0);
+    await vi.advanceTimersByTimeAsync(49);
+    expect(mock.mock.calls.length).toBe(0);
+
+    // After debounce window, one refresh per active spec
+    await vi.advanceTimersByTimeAsync(1);
+    expect(mock.mock.calls.length).toBe(2);
+  });
+});

package/server/ws.list-subscriptions.test.js

@@ -0,0 +1,403 @@
+import { createServer } from 'node:http';
+import { describe, expect, test, vi } from 'vitest';
+import { fetchListForSubscription } from './list-adapters.js';
+import { keyOf, registry } from './subscriptions.js';
+import { attachWsServer, handleMessage, scheduleListRefresh } from './ws.js';
+
+// Mock adapters BEFORE importing ws.js to ensure the mock is applied
+vi.mock('./list-adapters.js', () => ({
+  fetchListForSubscription: vi.fn(async () => {
+    // Return a simple, deterministic list for any spec
+    return {
+      ok: true,
+      items: [
+        { id: 'A', updated_at: 1, closed_at: null },
+        { id: 'B', updated_at: 1, closed_at: null }
+      ]
+    };
+  })
+}));
+
+describe('ws list subscriptions', () => {
+  test('refresh emits upsert/delete after subscribe', async () => {
+    vi.useFakeTimers();
+    const server = createServer();
+    const { wss } = attachWsServer(server, {
+      path: '/ws',
+      heartbeat_ms: 10000,
+      refresh_debounce_ms: 50
+    });
+    const sock = {
+      sent: /** @type {string[]} */ ([]),
+      readyState: 1,
+      OPEN: 1,
+      /** @param {string} msg */
+      send(msg) {
+        this.sent.push(String(msg));
+      }
+    };
+    wss.clients.add(/** @type {any} */ (sock));
+
+    // Initial subscribe
+    await handleMessage(
+      /** @type {any} */ (sock),
+      Buffer.from(
+        JSON.stringify({
+          id: 'sub-2',
+          type: /** @type {any} */ ('subscribe-list'),
+          payload: { id: 'c2', type: 'all-issues' }
+        })
+      )
+    );
+
+    // Clear initial snapshot
+    sock.sent = [];
+
+    // Change adapter to simulate one added, one updated, one removed
+    const mock = /** @type {import('vitest').Mock} */ (
+      fetchListForSubscription
+    );
+    mock.mockResolvedValueOnce({
+      ok: true,
+      items: [
+        { id: 'A', updated_at: 2, closed_at: null }, // updated
+        { id: 'C', updated_at: 1, closed_at: null } // added
+      ]
+    });
+
+    // Trigger refresh
+    scheduleListRefresh();
+    await vi.advanceTimersByTimeAsync(60);
+
+    const events = sock.sent
+      .map((m) => {
+        try {
+          return JSON.parse(m);
+        } catch {
+          return null;
+        }
+      })
+      .filter(Boolean);
+    const upserts = events.filter((e) => e && e.type === 'upsert');
+    const deletes = events.filter((e) => e && e.type === 'delete');
+    expect(upserts.length).toBeGreaterThan(0);
+    expect(deletes.length).toBeGreaterThan(0);
+    vi.useRealTimers();
+  });
+  test('subscribe-list attaches and publishes initial snapshot', async () => {
+    const sock = {
+      sent: /** @type {string[]} */ ([]),
+      readyState: 1,
+      OPEN: 1,
+      /** @param {string} msg */
+      send(msg) {
+        this.sent.push(String(msg));
+      }
+    };
+
+    const req = {
+      id: 'sub-1',
+      type: /** @type {any} */ ('subscribe-list'),
+      payload: { id: 'c1', type: 'in-progress-issues' }
+    };
+    await handleMessage(
+      /** @type {any} */ (sock),
+      Buffer.from(JSON.stringify(req))
+    );
+
+    // Expect an OK reply for subscribe-list
+    const last = sock.sent[sock.sent.length - 1];
+    const reply = JSON.parse(last);
+    expect(reply && reply.ok).toBe(true);
+    expect(reply && reply.type).toBe('subscribe-list');
+
+    // Expect a snapshot event was sent containing issues
+    const snapshot_envelope = sock.sent
+      .map((m) => {
+        try {
+          return JSON.parse(m);
+        } catch {
+          return null;
+        }
+      })
+      .find((o) => o && o.type === 'snapshot');
+    expect(!!snapshot_envelope).toBe(true);
+    expect(snapshot_envelope.payload && snapshot_envelope.payload.id).toBe(
+      'c1'
+    );
+    expect(Array.isArray(snapshot_envelope.payload.issues)).toBe(true);
+    expect(snapshot_envelope.payload.issues.length).toBeGreaterThan(0);
+
+    const key = keyOf({ type: 'in-progress-issues' });
+    const entry = registry.get(key);
+    const before_size = entry ? entry.subscribers.size : 0;
+    expect(before_size).toBeGreaterThanOrEqual(1);
+  });
+
+  test('subscribe-list returns bd_error payload when adapter fails', async () => {
+    const mock = /** @type {import('vitest').Mock} */ (
+      fetchListForSubscription
+    );
+    mock.mockResolvedValueOnce({
+      ok: false,
+      error: {
+        code: 'bd_error',
+        message: 'bd failed: out of sync',
+        details: { exit_code: 1 }
+      }
+    });
+
+    const sock = {
+      sent: /** @type {string[]} */ ([]),
+      readyState: 1,
+      OPEN: 1,
+      /** @param {string} msg */
+      send(msg) {
+        this.sent.push(String(msg));
+      }
+    };
+
+    const req = {
+      id: 'sub-error',
+      type: /** @type {any} */ ('subscribe-list'),
+      payload: { id: 'c-err', type: 'all-issues' }
+    };
+
+    await handleMessage(
+      /** @type {any} */ (sock),
+      Buffer.from(JSON.stringify(req))
+    );
+
+    const last = sock.sent[sock.sent.length - 1];
+    const reply = JSON.parse(last);
+    expect(reply && reply.ok).toBe(false);
+    expect(reply && reply.error && reply.error.code).toBe('bd_error');
+    expect(reply && reply.error && reply.error.message).toContain(
+      'out of sync'
+    );
+    expect(reply && reply.error && reply.error.details.exit_code).toBe(1);
+  });
+
+  test('unsubscribe-list detaches and disconnect sweep evicts entry', async () => {
+    const sock = {
+      sent: /** @type {string[]} */ ([]),
+      readyState: 1,
+      OPEN: 1,
+      /** @param {string} msg */
+      send(msg) {
+        this.sent.push(String(msg));
+      }
+    };
+
+    // Subscribe first
+    await handleMessage(
+      /** @type {any} */ (sock),
+      Buffer.from(
+        JSON.stringify({
+          id: 'sub-1',
+          type: /** @type {any} */ ('subscribe-list'),
+          payload: { id: 'c1', type: 'all-issues' }
+        })
+      )
+    );
+
+    const key = keyOf({ type: 'all-issues' });
+    const entry = registry.get(key);
+    const before = entry ? entry.subscribers.size : 0;
+    expect(before).toBeGreaterThanOrEqual(1);
+
+    // Now unsubscribe
+    await handleMessage(
+      /** @type {any} */ (sock),
+      Buffer.from(
+        JSON.stringify({
+          id: 'unsub-1',
+          type: /** @type {any} */ ('unsubscribe-list'),
+          payload: { id: 'c1' }
+        })
+      )
+    );
+
+    const entry2 = registry.get(key);
+    const after_size = entry2 ? entry2.subscribers.size : 0;
+    expect(after_size).toBeLessThan(before);
+
+    // Do not assert full eviction here due to global registry used across tests
+  });
+
+  test('closed-issues pre-filter applies before diff', async () => {
+    const now = Date.now();
+    // Configure adapter mock for this test case
+    const mock = /** @type {import('vitest').Mock} */ (
+      fetchListForSubscription
+    );
+    mock.mockResolvedValueOnce({
+      ok: true,
+      items: [
+        { id: 'old', updated_at: now - 3000, closed_at: now - 2000 },
+        { id: 'recent', updated_at: now - 100, closed_at: now - 100 },
+        { id: 'open', updated_at: now - 50, closed_at: null }
+      ]
+    });
+
+    const sock = {
+      sent: /** @type {string[]} */ ([]),
+      readyState: 1,
+      OPEN: 1,
+      /** @param {string} msg */
+      send(msg) {
+        this.sent.push(String(msg));
+      }
+    };
+
+    const since = now - 1000;
+    await handleMessage(
+      /** @type {any} */ (sock),
+      Buffer.from(
+        JSON.stringify({
+          id: 'sub-closed',
+          type: /** @type {any} */ ('subscribe-list'),
+          payload: { id: 'c-closed', type: 'closed-issues', params: { since } }
+        })
+      )
+    );
+
+    const key = keyOf({ type: 'closed-issues', params: { since } });
+    const entry = registry.get(key);
+    const ids = entry ? Array.from(entry.itemsById.keys()).sort() : [];
+    expect(ids).toEqual(['recent']);
+  });
+
+  test('subscribe-list rejects unknown subscription type', async () => {
+    const sock = {
+      sent: /** @type {string[]} */ ([]),
+      readyState: 1,
+      OPEN: 1,
+      /** @param {string} msg */
+      send(msg) {
+        this.sent.push(String(msg));
+      }
+    };
+
+    await handleMessage(
+      /** @type {any} */ (sock),
+      Buffer.from(
+        JSON.stringify({
+          id: 'bad-sub',
+          type: /** @type {any} */ ('subscribe-list'),
+          payload: { id: 'c-bad', type: 'not-supported' }
+        })
+      )
+    );
+
+    const last = sock.sent[sock.sent.length - 1];
+    const reply = JSON.parse(last);
+    expect(reply && reply.ok).toBe(false);
+    expect(reply && reply.error && reply.error.code).toBe('bad_request');
+  });
+
+  test('subscribe-list accepts issue-detail with id and publishes snapshot', async () => {
+    const sock = {
+      sent: /** @type {string[]} */ ([]),
+      readyState: 1,
+      OPEN: 1,
+      /** @param {string} msg */
+      send(msg) {
+        this.sent.push(String(msg));
+      }
+    };
+
+    await handleMessage(
+      /** @type {any} */ (sock),
+      Buffer.from(
+        JSON.stringify({
+          id: 'sub-detail-1',
+          type: /** @type {any} */ ('subscribe-list'),
+          payload: {
+            id: 'detail:UI-1',
+            type: 'issue-detail',
+            params: { id: 'UI-1' }
+          }
+        })
+      )
+    );
+
+    const last = sock.sent[sock.sent.length - 1];
+    const reply = JSON.parse(last);
+    expect(reply && reply.ok).toBe(true);
+    expect(reply && reply.type).toBe('subscribe-list');
+
+    const snapshot_envelope = sock.sent
+      .map((m) => {
+        try {
+          return JSON.parse(m);
+        } catch {
+          return null;
+        }
+      })
+      .find((o) => o && o.type === 'snapshot');
+    expect(!!snapshot_envelope).toBe(true);
+    expect(snapshot_envelope.payload && snapshot_envelope.payload.id).toBe(
+      'detail:UI-1'
+    );
+    expect(Array.isArray(snapshot_envelope.payload.issues)).toBe(true);
+  });
+
+  test('subscribe-list issue-detail enforces id', async () => {
+    const sock = {
+      sent: /** @type {string[]} */ ([]),
+      readyState: 1,
+      OPEN: 1,
+      /** @param {string} msg */
+      send(msg) {
+        this.sent.push(String(msg));
+      }
+    };
+
+    await handleMessage(
+      /** @type {any} */ (sock),
+      Buffer.from(
+        JSON.stringify({
+          id: 'bad-detail',
+          type: /** @type {any} */ ('subscribe-list'),
+          payload: { id: 'detail:UI-X', type: 'issue-detail' }
+        })
+      )
+    );
+    const last = sock.sent[sock.sent.length - 1];
+    const reply = JSON.parse(last);
+    expect(reply && reply.ok).toBe(false);
+    expect(reply && reply.error && reply.error.code).toBe('bad_request');
+  });
+
+  test('subscribe-list closed-issues validates since param', async () => {
+    const sock = {
+      sent: /** @type {string[]} */ ([]),
+      readyState: 1,
+      OPEN: 1,
+      /** @param {string} msg */
+      send(msg) {
+        this.sent.push(String(msg));
+      }
+    };
+
+    await handleMessage(
+      /** @type {any} */ (sock),
+      Buffer.from(
+        JSON.stringify({
+          id: 'bad-since',
+          type: /** @type {any} */ ('subscribe-list'),
+          payload: {
+            id: 'c-closed',
+            type: 'closed-issues',
+            params: { since: 'yesterday' }
+          }
+        })
+      )
+    );
+    const last = sock.sent[sock.sent.length - 1];
+    const reply = JSON.parse(last);
+    expect(reply && reply.ok).toBe(false);
+    expect(reply && reply.error && reply.error.code).toBe('bad_request');
+  });
+});