@rsktash/beads-ui 0.1.51 → 0.10.3

package/server/ws.mutation-window.test.js

@@ -1,147 +0,0 @@
-import { createServer } from 'node:http';
-import { beforeEach, describe, expect, test, vi } from 'vitest';
-import { runBd } from './bd.js';
-import { fetchListForSubscription } from './list-adapters.js';
-import { attachWsServer, handleMessage, scheduleListRefresh } from './ws.js';
-
-vi.mock('./bd.js', () => ({ runBdJson: vi.fn(), runBd: vi.fn() }));
-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();
-});
-
-function makeSocket() {
-  return {
-    sent: /** @type {string[]} */ ([]),
-    readyState: 1,
-    OPEN: 1,
-    /** @param {string} msg */
-    send(msg) {
-      this.sent.push(String(msg));
-    }
-  };
-}
-
-/**
- * @param {import('ws').WebSocketServer} wss
- */
-async function subscribeTwoLists(wss) {
-  const a = makeSocket();
-  const b = makeSocket();
-  wss.clients.add(/** @type {any} */ (a));
-  wss.clients.add(/** @type {any} */ (b));
-  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' }
-      })
-    )
-  );
-}
-
-describe('mutation window gating', () => {
-  test('watcher-first resolves gate and refreshes once', async () => {
-    const server = createServer();
-    const { wss } = attachWsServer(server, {
-      path: '/ws',
-      refresh_debounce_ms: 50
-    });
-
-    await subscribeTwoLists(wss);
-
-    // Clear any refresh calls from initial subscriptions
-    const mFetch = /** @type {import('vitest').Mock} */ (
-      fetchListForSubscription
-    );
-    mFetch.mockClear();
-
-    // Prepare mutation stubs
-    const mRun = /** @type {import('vitest').Mock} */ (runBd);
-    mRun.mockResolvedValueOnce({ code: 0, stdout: 'UI-99', stderr: '' });
-
-    // Fire a mutation
-    const ws = makeSocket();
-    await handleMessage(
-      /** @type {any} */ (ws),
-      Buffer.from(
-        JSON.stringify({
-          id: 'create1',
-          type: /** @type {any} */ ('create-issue'),
-          payload: { title: 'X' }
-        })
-      )
-    );
-
-    // Simulate watcher event arriving before timeout
-    scheduleListRefresh();
-
-    // Allow pending promises and microtasks to flush
-    await vi.advanceTimersByTimeAsync(0);
-    await Promise.resolve();
-
-    // Exactly one refresh pass over active specs
-    expect(mFetch.mock.calls.length).toBe(2);
-  });
-
-  test('timeout-first triggers refresh after 500ms', async () => {
-    const server = createServer();
-    const { wss } = attachWsServer(server, {
-      path: '/ws',
-      refresh_debounce_ms: 50
-    });
-
-    await subscribeTwoLists(wss);
-
-    const mFetch = /** @type {import('vitest').Mock} */ (
-      fetchListForSubscription
-    );
-    mFetch.mockClear();
-
-    const mRun = /** @type {import('vitest').Mock} */ (runBd);
-    mRun.mockResolvedValueOnce({ code: 0, stdout: 'UI-100', stderr: '' });
-
-    const ws = makeSocket();
-    await handleMessage(
-      /** @type {any} */ (ws),
-      Buffer.from(
-        JSON.stringify({
-          id: 'create2',
-          type: /** @type {any} */ ('create-issue'),
-          payload: { title: 'Y' }
-        })
-      )
-    );
-
-    // Before timeout, no refreshes triggered
-    await vi.advanceTimersByTimeAsync(499);
-    expect(mFetch.mock.calls.length).toBe(0);
-
-    // After timeout, one refresh per active spec
-    await vi.advanceTimersByTimeAsync(1);
-    expect(mFetch.mock.calls.length).toBe(2);
-  });
-});

package/server/ws.mutations.test.js

@@ -1,389 +0,0 @@
-import { beforeEach, describe, expect, test, vi } from 'vitest';
-import { runBd, runBdJson } from './bd.js';
-import { handleMessage } from './ws.js';
-
-vi.mock('./bd.js', () => ({ runBdJson: vi.fn(), runBd: vi.fn() }));
-
-// Ensure clean mock state for each test
-beforeEach(() => {
-  /** @type {import('vitest').Mock} */ (runBd).mockReset();
-  /** @type {import('vitest').Mock} */ (runBdJson).mockReset();
-});
-
-function makeStubSocket() {
-  return {
-    sent: /** @type {string[]} */ ([]),
-    readyState: 1,
-    OPEN: 1,
-    /** @param {string} msg */
-    send(msg) {
-      this.sent.push(String(msg));
-    }
-  };
-}
-
-describe('ws mutation handlers', () => {
-  test('update-status validates and returns updated issue', async () => {
-    const mRun = /** @type {import('vitest').Mock} */ (runBd);
-    const mJson = /** @type {import('vitest').Mock} */ (runBdJson);
-    mRun.mockResolvedValueOnce({ code: 0, stdout: '', stderr: '' });
-    mJson.mockResolvedValueOnce({
-      code: 0,
-      stdoutJson: { id: 'UI-7', status: 'in_progress' }
-    });
-    const ws = makeStubSocket();
-    const req = {
-      id: 'r1',
-      type: 'update-status',
-      payload: { id: 'UI-7', status: 'in_progress' }
-    };
-    await handleMessage(
-      /** @type {any} */ (ws),
-      Buffer.from(JSON.stringify(req))
-    );
-    const obj = JSON.parse(ws.sent[ws.sent.length - 1]);
-    expect(obj.ok).toBe(true);
-    expect(obj.payload.status).toBe('in_progress');
-  });
-
-  test('update-status bd fallback hydrates parent context in response payload', async () => {
-    const mRun = /** @type {import('vitest').Mock} */ (runBd);
-    const mJson = /** @type {import('vitest').Mock} */ (runBdJson);
-    mRun.mockResolvedValueOnce({ code: 0, stdout: '', stderr: '' });
-    mJson
-      .mockResolvedValueOnce({
-        code: 0,
-        stdoutJson: {
-          id: 'UI-7',
-          status: 'in_progress',
-          parent: 'EP-1',
-          updated_at: '2024-01-01T00:00:00.000Z'
-        }
-      })
-      .mockResolvedValueOnce({
-        code: 0,
-        stdoutJson: {
-          id: 'EP-1',
-          title: 'Parent epic',
-          status: 'open',
-          issue_type: 'epic'
-        }
-      });
-
-    const ws = makeStubSocket();
-    const req = {
-      id: 'r1-parent',
-      type: 'update-status',
-      payload: { id: 'UI-7', status: 'in_progress' }
-    };
-    await handleMessage(
-      /** @type {any} */ (ws),
-      Buffer.from(JSON.stringify(req))
-    );
-
-    const obj = JSON.parse(ws.sent[ws.sent.length - 1]);
-    expect(obj.ok).toBe(true);
-    expect(obj.payload).toMatchObject({
-      id: 'UI-7',
-      parent: 'EP-1',
-      parent_id: 'EP-1',
-      parent_title: 'Parent epic',
-      parent_status: 'open',
-      parent_type: 'epic'
-    });
-  });
-
-  test('update-status invalid payload yields bad_request', async () => {
-    const ws = makeStubSocket();
-    const req = {
-      id: 'r2',
-      type: 'update-status',
-      payload: { id: 'UI-7', status: 'bogus' }
-    };
-    await handleMessage(
-      /** @type {any} */ (ws),
-      Buffer.from(JSON.stringify(req))
-    );
-    const obj = JSON.parse(ws.sent[ws.sent.length - 1]);
-    expect(obj.ok).toBe(false);
-    expect(obj.error.code).toBe('bad_request');
-  });
-
-  test('update-priority success path', async () => {
-    const mRun = /** @type {import('vitest').Mock} */ (runBd);
-    const mJson = /** @type {import('vitest').Mock} */ (runBdJson);
-    mRun.mockResolvedValueOnce({ code: 0, stdout: '', stderr: '' });
-    mJson.mockResolvedValueOnce({
-      code: 0,
-      stdoutJson: { id: 'UI-7', priority: 1 }
-    });
-    const ws = makeStubSocket();
-    const req = {
-      id: 'r3',
-      type: 'update-priority',
-      payload: { id: 'UI-7', priority: 1 }
-    };
-    await handleMessage(
-      /** @type {any} */ (ws),
-      Buffer.from(JSON.stringify(req))
-    );
-    const obj = JSON.parse(ws.sent[ws.sent.length - 1]);
-    expect(obj.ok).toBe(true);
-    expect(obj.payload.priority).toBe(1);
-  });
-
-  test('update-priority invalid payload yields bad_request', async () => {
-    const ws = makeStubSocket();
-    const req = {
-      id: 'r3bad',
-      type: 'update-priority',
-      payload: { id: 'UI-7', priority: 9 }
-    };
-    await handleMessage(
-      /** @type {any} */ (ws),
-      Buffer.from(JSON.stringify(req))
-    );
-    const obj = JSON.parse(ws.sent[ws.sent.length - 1]);
-    expect(obj.ok).toBe(false);
-    expect(obj.error && obj.error.code).toBe('bad_request');
-  });
-
-  test('edit-text title success', async () => {
-    const mRun = /** @type {import('vitest').Mock} */ (runBd);
-    const mJson = /** @type {import('vitest').Mock} */ (runBdJson);
-    mRun.mockResolvedValueOnce({ code: 0, stdout: '', stderr: '' });
-    mJson.mockResolvedValueOnce({
-      code: 0,
-      stdoutJson: { id: 'UI-7', title: 'New' }
-    });
-    const ws = makeStubSocket();
-    const req = {
-      id: 'r4',
-      type: 'edit-text',
-      payload: { id: 'UI-7', field: 'title', value: 'New' }
-    };
-    await handleMessage(
-      /** @type {any} */ (ws),
-      Buffer.from(JSON.stringify(req))
-    );
-    const obj = JSON.parse(ws.sent[ws.sent.length - 1]);
-    expect(obj.ok).toBe(true);
-    expect(obj.payload.title).toBe('New');
-  });
-
-  // update-type removed; no server handler remains
-
-  test('update-assignee validates and returns updated issue', async () => {
-    const mRun = /** @type {import('vitest').Mock} */ (runBd);
-    const mJson = /** @type {import('vitest').Mock} */ (runBdJson);
-    mRun.mockResolvedValueOnce({ code: 0, stdout: '', stderr: '' });
-    mJson.mockResolvedValueOnce({ code: 0, stdoutJson: { id: 'UI-2' } });
-    const ws = makeStubSocket();
-    const req = {
-      id: 'rua',
-      type: /** @type {any} */ ('update-assignee'),
-      payload: { id: 'UI-2', assignee: 'max' }
-    };
-    await handleMessage(
-      /** @type {any} */ (ws),
-      Buffer.from(JSON.stringify(req))
-    );
-    const call = mRun.mock.calls[mRun.mock.calls.length - 1];
-    expect(call[0][0]).toBe('update');
-    expect(call[0].includes('--assignee')).toBe(true);
-    const obj = JSON.parse(ws.sent[ws.sent.length - 1]);
-    expect(obj.ok).toBe(true);
-    expect(obj.payload.id).toBe('UI-2');
-  });
-
-  test('update-assignee allows clearing with empty string', async () => {
-    const mRun = /** @type {import('vitest').Mock} */ (runBd);
-    const mJson = /** @type {import('vitest').Mock} */ (runBdJson);
-    mRun.mockResolvedValueOnce({ code: 0, stdout: '', stderr: '' });
-    mJson.mockResolvedValueOnce({ code: 0, stdoutJson: { id: 'UI-31' } });
-    const ws = makeStubSocket();
-    const req = {
-      id: 'rua2',
-      type: /** @type {any} */ ('update-assignee'),
-      payload: { id: 'UI-31', assignee: '' }
-    };
-    await handleMessage(
-      /** @type {any} */ (ws),
-      Buffer.from(JSON.stringify(req))
-    );
-    const call = mRun.mock.calls[mRun.mock.calls.length - 1];
-    expect(call[0]).toEqual(['update', 'UI-31', '--assignee', '']);
-    const obj = JSON.parse(ws.sent[ws.sent.length - 1]);
-    expect(obj.ok).toBe(true);
-    expect(obj.payload.id).toBe('UI-31');
-  });
-
-  test('edit-text acceptance success', async () => {
-    const mRun = /** @type {import('vitest').Mock} */ (runBd);
-    const mJson = /** @type {import('vitest').Mock} */ (runBdJson);
-    mRun.mockResolvedValueOnce({ code: 0, stdout: '', stderr: '' });
-    mJson.mockResolvedValueOnce({
-      code: 0,
-      stdoutJson: { id: 'UI-7', acceptance: 'Done when...' }
-    });
-    const ws = makeStubSocket();
-    const req = {
-      id: 'r4a',
-      type: 'edit-text',
-      payload: { id: 'UI-7', field: 'acceptance', value: 'Done when...' }
-    };
-    await handleMessage(
-      /** @type {any} */ (ws),
-      Buffer.from(JSON.stringify(req))
-    );
-    const obj = JSON.parse(ws.sent[ws.sent.length - 1]);
-    expect(obj.ok).toBe(true);
-    expect(obj.payload.acceptance).toBe('Done when...');
-    // Verify correct flag mapping for acceptance
-    expect(mRun.mock.calls[0][0]).toEqual([
-      'update',
-      'UI-7',
-      '--acceptance-criteria',
-      'Done when...'
-    ]);
-  });
-
-  test('edit-text notes success', async () => {
-    const mRun = /** @type {import('vitest').Mock} */ (runBd);
-    const mJson = /** @type {import('vitest').Mock} */ (runBdJson);
-    mRun.mockResolvedValueOnce({ code: 0, stdout: '', stderr: '' });
-    mJson.mockResolvedValueOnce({
-      code: 0,
-      stdoutJson: { id: 'UI-12', notes: 'Some note' }
-    });
-    const ws = makeStubSocket();
-    const req = {
-      id: 'r4n',
-      type: 'edit-text',
-      payload: { id: 'UI-12', field: 'notes', value: 'Some note' }
-    };
-    await handleMessage(
-      /** @type {any} */ (ws),
-      Buffer.from(JSON.stringify(req))
-    );
-    const obj = JSON.parse(ws.sent[ws.sent.length - 1]);
-    expect(obj.ok).toBe(true);
-    expect(obj.payload.notes).toBe('Some note');
-    // Verify correct flag mapping for notes
-    expect(mRun.mock.calls[0][0]).toEqual([
-      'update',
-      'UI-12',
-      '--notes',
-      'Some note'
-    ]);
-  });
-
-  test('edit-text description success and flag mapping', async () => {
-    const mRun = /** @type {import('vitest').Mock} */ (runBd);
-    const mJson = /** @type {import('vitest').Mock} */ (runBdJson);
-    mRun.mockResolvedValueOnce({ code: 0, stdout: '', stderr: '' });
-    mJson.mockResolvedValueOnce({
-      code: 0,
-      stdoutJson: { id: 'UI-7', description: 'New desc' }
-    });
-    const ws = makeStubSocket();
-    const req = {
-      id: 'r4b',
-      type: 'edit-text',
-      payload: { id: 'UI-7', field: 'description', value: 'New desc' }
-    };
-    await handleMessage(
-      /** @type {any} */ (ws),
-      Buffer.from(JSON.stringify(req))
-    );
-    // Verify bd call flag mapping
-    const call = mRun.mock.calls[mRun.mock.calls.length - 1][0];
-    expect(call).toEqual(['update', 'UI-7', '--description', 'New desc']);
-    const obj = JSON.parse(ws.sent[ws.sent.length - 1]);
-    expect(obj.ok).toBe(true);
-    expect(obj.payload.description).toBe('New desc');
-  });
-
-  test('edit-text design success and flag mapping', async () => {
-    const mRun = /** @type {import('vitest').Mock} */ (runBd);
-    const mJson = /** @type {import('vitest').Mock} */ (runBdJson);
-    mRun.mockResolvedValueOnce({ code: 0, stdout: '', stderr: '' });
-    mJson.mockResolvedValueOnce({
-      code: 0,
-      stdoutJson: { id: 'UI-8', design: 'New design' }
-    });
-    const ws = makeStubSocket();
-    const req = {
-      id: 'r4d',
-      type: 'edit-text',
-      payload: { id: 'UI-8', field: 'design', value: 'New design' }
-    };
-    await handleMessage(
-      /** @type {any} */ (ws),
-      Buffer.from(JSON.stringify(req))
-    );
-    const call = mRun.mock.calls[mRun.mock.calls.length - 1][0];
-    expect(call).toEqual(['update', 'UI-8', '--design', 'New design']);
-    const obj = JSON.parse(ws.sent[ws.sent.length - 1]);
-    expect(obj.ok).toBe(true);
-    expect(obj.payload.design).toBe('New design');
-  });
-
-  test('dep-add returns updated issue (view_id)', async () => {
-    const mRun = /** @type {import('vitest').Mock} */ (runBd);
-    const mJson = /** @type {import('vitest').Mock} */ (runBdJson);
-    mRun.mockResolvedValueOnce({ code: 0, stdout: '', stderr: '' });
-    mJson.mockResolvedValueOnce({
-      code: 0,
-      stdoutJson: { id: 'UI-7', dependencies: [] }
-    });
-    const ws = makeStubSocket();
-    const req = {
-      id: 'r5',
-      type: 'dep-add',
-      payload: { a: 'UI-7', b: 'UI-1', view_id: 'UI-7' }
-    };
-    await handleMessage(
-      /** @type {any} */ (ws),
-      Buffer.from(JSON.stringify(req))
-    );
-    const obj = JSON.parse(ws.sent[ws.sent.length - 1]);
-    expect(obj.ok).toBe(true);
-    expect(obj.payload.id).toBe('UI-7');
-  });
-
-  test('dep-remove bad payload yields bad_request', async () => {
-    const ws = makeStubSocket();
-    const req = { id: 'r6', type: 'dep-remove', payload: { a: '' } };
-    await handleMessage(
-      /** @type {any} */ (ws),
-      Buffer.from(JSON.stringify(req))
-    );
-    const obj = JSON.parse(ws.sent[ws.sent.length - 1]);
-    expect(obj.ok).toBe(false);
-    expect(obj.error.code).toBe('bad_request');
-  });
-
-  test('create-issue acks on success', async () => {
-    const mRun = /** @type {import('vitest').Mock} */ (runBd);
-    mRun.mockResolvedValueOnce({ code: 0, stdout: 'UI-99', stderr: '' });
-    const ws = makeStubSocket();
-    const req = {
-      id: 'r7',
-      type: 'create-issue',
-      payload: {
-        title: 'New item',
-        type: 'task',
-        priority: 2,
-        description: 'x'
-      }
-    };
-    await handleMessage(
-      /** @type {any} */ (ws),
-      Buffer.from(JSON.stringify(req))
-    );
-    const obj = JSON.parse(ws.sent[ws.sent.length - 1]);
-    expect(obj.ok).toBe(true);
-    expect(obj.payload && obj.payload.created).toBe(true);
-  });
-});

package/server/ws.test.js

@@ -1,52 +0,0 @@
-import { describe, expect, test, vi } from 'vitest';
-import { handleMessage } from './ws.js';
-
-/** @returns {any} */
-function makeStubSocket() {
-  return {
-    sent: /** @type {string[]} */ ([]),
-    readyState: 1,
-    OPEN: 1,
-    /** @param {string} msg */
-    send(msg) {
-      this.sent.push(String(msg));
-    },
-    ping: vi.fn(),
-    terminate: vi.fn()
-  };
-}
-
-describe('ws message handling', () => {
-  test('invalid JSON yields bad_json error', () => {
-    const ws = makeStubSocket();
-    handleMessage(/** @type {any} */ (ws), Buffer.from('{oops'));
-    expect(ws.sent.length).toBe(1);
-    const obj = JSON.parse(ws.sent[0]);
-    expect(obj.ok).toBe(false);
-    expect(obj.error.code).toBe('bad_json');
-  });
-
-  test('invalid envelope yields bad_request', () => {
-    const ws = makeStubSocket();
-    handleMessage(
-      /** @type {any} */ (ws),
-      Buffer.from(JSON.stringify({ not: 'a request' }))
-    );
-    const last = ws.sent[ws.sent.length - 1];
-    const obj = JSON.parse(last);
-    expect(obj.ok).toBe(false);
-    expect(obj.error.code).toBe('bad_request');
-  });
-
-  test('unknown message type returns unknown_type error', () => {
-    const ws = makeStubSocket();
-    const req = { id: '1', type: 'some-unknown', payload: {} };
-    handleMessage(/** @type {any} */ (ws), Buffer.from(JSON.stringify(req)));
-    const last = ws.sent[ws.sent.length - 1];
-    const obj = JSON.parse(last);
-    expect(obj.ok).toBe(false);
-    expect(obj.error.code).toBe('unknown_type');
-  });
-});
-
-// Note: broadcast behavior is integration-tested later when a full server can run.