@rsktash/beads-ui 0.1.50 → 0.10.3

package/server/ws.labels.test.js

@@ -1,95 +0,0 @@
-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

@@ -1,95 +0,0 @@
-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

@@ -1,403 +0,0 @@
-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');
-  });
-});