Skip to content

armgit / macro

Public Imported from GitHub
0

Macro is a unified workspace for teams: email, chat, docs, tasks, agents, calls, and CRM — @-linked together with shared AI memory.

11.3 KB
Raw Blame
import '../../database/tests/board-layout';
import { queryClient } from '@queries/client';
import type { CardPosition } from '@service-storage/generated/schemas/cardPosition';
import type { DatabaseView } from '@service-storage/generated/schemas/databaseView';
import type { OpResult } from '@service-storage/generated/schemas/opResult';
import {
  cleanup,
  fireEvent,
  render,
  screen,
  waitFor,
} from '@solidjs/testing-library';
import { QueryClientProvider } from '@tanstack/solid-query';
import { ok, okAsync, ResultAsync } from 'neverthrow';
import { createSignal } from 'solid-js';
import { afterEach, beforeEach, expect, it, vi } from 'vitest';
import type {
  Board,
  Catalog,
  Outcome,
} from '../../../lib/core/database-sql/generated/types';
import { DatabaseBoardView } from '../../database/views/database-board-view';
import { useDatabaseBoardPositions } from './board-positions';
import { databaseViewKeys } from './keys';
import { refreshCardPositions } from './views';

const transport = vi.hoisted(() => ({
  applyDatabaseOps: vi.fn(),
  invalidateDatabase: vi.fn(),
  viewPositions: vi.fn(),
}));
vi.mock('@queries/client', async () => {
  const { QueryClient } = await import('@tanstack/solid-query');
  return {
    queryClient: new QueryClient({
      defaultOptions: { queries: { retry: false } },
    }),
  };
});
vi.mock('@queries/storage/databases', () => transport);
vi.mock('@service-storage/client', () => ({
  storageServiceClient: {
    databases: { viewPositions: transport.viewPositions },
  },
}));

const engine = vi.hoisted(() => ({
  board:
    vi.fn<
      (
        catalog: Catalog,
        view: DatabaseView,
        outcome: Outcome,
        positions: CardPosition[]
      ) => Board
    >(),
  keyBetween: vi.fn<(before: string | null, after: string | null) => string>(),
}));
const toastFailure = vi.hoisted(() => vi.fn());
const loadEngine = vi.hoisted(() =>
  vi.fn(async () => ({
    board: engine.board,
    keyBetween: engine.keyBetween,
  }))
);

vi.mock('../../../lib/core/database-sql/wasm-module', () => ({
  loadDatabaseSqlWasm: loadEngine,
}));
vi.mock('../../../lib/core/component/Toast/Toast', () => ({
  toast: { failure: toastFailure },
}));

// Lanes sit side by side, Done at 0 and To do at 300; each lane's cards stack
// from y = 60, 100 apart and 80 tall.
beforeEach(() => {
  vi.spyOn(window, 'scrollTo').mockImplementation(() => {});
  vi.spyOn(HTMLElement.prototype, 'getBoundingClientRect').mockImplementation(
    function (this: HTMLElement) {
      if (this.hasAttribute('data-kanban-board-viewport'))
        return new DOMRect(0, 0, 880, 500);
      const lane = this.closest('[data-kanban-lane]');
      const x = lane?.getAttribute('aria-label') === 'To do lane' ? 300 : 0;
      const card = this.hasAttribute('data-kanban-card-layout')
        ? this.querySelector('[data-kanban-card]')
        : this;
      const cardIndex = lane
        ? Array.from(lane.querySelectorAll('[data-kanban-card]')).indexOf(card!)
        : 0;
      return this.hasAttribute('data-row-id') ||
        this.hasAttribute('data-kanban-card-layout')
        ? new DOMRect(x + 8, 60 + Math.max(0, cardIndex) * 100, 264, 80)
        : new DOMRect(x, 0, 280, 500);
    }
  );
});
afterEach(() => {
  cleanup();
  queryClient.clear();
  vi.clearAllMocks();
  vi.restoreAllMocks();
  engine.board.mockReset();
  engine.keyBetween.mockReset();
  toastFailure.mockReset();
});

// Reads the lane by its label: a closing dialog still hides the board from role queries.
const cardsIn = (lane: string) =>
  Array.from(
    document.querySelectorAll(
      `[data-kanban-lane][aria-label="${lane} lane"] [data-row-id]`
    ),
    (card) => card.getAttribute('data-row-id')
  );

it.each(['success', 'refusal'] as const)(
  'keeps database move %s on its originating board',
  async (settlement) => {
    const initialView: DatabaseView = {
      id: 'view',
      databaseId: 'database',
      tableId: 'table',
      name: 'Board',
      position: 'a0',
      query: {
        filter: null,
        sort: [],
      },
      layout: {
        kind: 'board',
        title: 'name',
        groupBy: 'stage',
        lanes: [],
        cardFields: [],
        hideEmptyLanes: false,
      },
      createdAt: '2026-09-01T00:00:00Z',
      updatedAt: '2026-09-01T00:00:00Z',
    };
    const [view, setView] = createSignal(initialView);
    const outcome: Outcome = {
      columns: [],
      rows: [],
      rowIds: ['first', 'moving', 'last'],
      readTables: ['table'],
      truncated: false,
      insertedRowIds: [],
      changesApplied: 0,
    };
    engine.board.mockReturnValue({
      lanes: [
        {
          key: { kind: 'option', id: 'done' },
          hidden: false,
          cards: ['first', 'last'],
        },
        {
          key: { kind: 'option', id: 'todo' },
          hidden: false,
          cards: ['moving'],
        },
      ],
    });
    engine.keyBetween.mockReturnValue('a0V');
    const initialPositions: CardPosition[] = [
      { row: 'first', lane: { kind: 'option', id: 'done' }, position: 'a0' },
      { row: 'last', lane: { kind: 'option', id: 'done' }, position: 'a1' },
    ];
    const firstKey = databaseViewKeys.positions('database', 'view').queryKey;
    const secondKey = databaseViewKeys.positions(
      'database',
      'other-view'
    ).queryKey;
    queryClient.setQueryData(firstKey, initialPositions);
    queryClient.setQueryData(secondKey, initialPositions);
    transport.viewPositions.mockResolvedValue(
      ok({ positions: initialPositions })
    );
    const answer = Promise.withResolvers<OpResult[]>();
    transport.applyDatabaseOps.mockReturnValue(
      ResultAsync.fromPromise(answer.promise, () => ({
        code: 'INVALID_OP',
        message: 'Refused',
        refusal: null,
      }))
    );
    function Board() {
      const positions = useDatabaseBoardPositions('database', view, () => true);
      return (
        <DatabaseBoardView
          view={view()}
          source={{
            columns: () => [],
            snapshot: () => undefined,
            read: () => ({ outcome, catalog: { tables: [] }, view: view() }),
            loading: () => false,
            refreshing: () => false,
            error: () => undefined,
            refresh: () => okAsync(undefined),
            write: () => okAsync({ insertedRowIds: [], version: undefined }),
            addOption: () => okAsync(undefined),
            retain: () => {},
          }}
          rows={[
            { rowId: 'first', cells: { name: 'First card', stage: 'Done' } },
            { rowId: 'moving', cells: { name: 'Moving card', stage: 'To do' } },
            { rowId: 'last', cells: { name: 'Last card', stage: 'Done' } },
          ]}
          columns={[
            {
              id: 'name',
              name: 'Name',
              dataType: 'STRING',
              isMultiSelect: false,
              options: [],
              writable: true,
            },
            {
              id: 'stage',
              name: 'Stage',
              dataType: 'SELECT_STRING',
              isMultiSelect: false,
              options: [
                { id: 'done', label: 'Done', color: null },
                { id: 'todo', label: 'To do', color: null },
              ],
              writable: true,
            },
          ]}
          positions={positions}
          canEdit
          onViewChange={vi.fn()}
          rowPending={() => false}
          createPending={() => false}
          createComplete={() => false}
          onOpen={vi.fn()}
          onCreate={vi.fn(async () => true)}
        />
      );
    }
    render(() => (
      <QueryClientProvider client={queryClient}>
        <Board />
      </QueryClientProvider>
    ));
    const card = await screen.findByRole('button', {
      name: 'Open Moving card',
    });
    fireEvent.mouseDown(card, { button: 0, clientX: 560, clientY: 80 });
    fireEvent.mouseMove(document, { clientX: 30, clientY: 150 });
    fireEvent.mouseUp(document, { button: 0, clientX: 30, clientY: 150 });
    await waitFor(() =>
      expect(transport.applyDatabaseOps).toHaveBeenCalledExactlyOnceWith(
        'database',
        [
          {
            kind: 'view',
            table: 'table',
            view: 'view',
            change: {
              kind: 'move_card',
              row: 'moving',
              lane: { kind: 'option', id: 'done' },
              before: 'first',
              after: 'last',
            },
          },
        ]
      )
    );
    expect(cardsIn('Done')).toEqual(['first', 'moving', 'last']);
    // A cache refresh of the same view must preserve its unfinished move.
    setView({ ...initialView, name: 'Renamed board' });
    expect(cardsIn('Done')).toEqual(['first', 'moving', 'last']);
    // Both boards already have rows and positions; no loading state remounts them.
    setView({ ...initialView, id: 'other-view', name: 'Other board' });
    await screen.findByRole('button', { name: 'Open Moving card' });
    const committed: CardPosition = {
      row: 'moving',
      lane: { kind: 'option', id: 'done' },
      position: 'a0W',
    };
    if (settlement === 'success') {
      answer.resolve([
        {
          kind: 'view',
          table: 'table',
          view: 'view',
          tableVersion: 8,
          change: { kind: 'card_moved', positions: [committed] },
        },
      ]);
      await waitFor(() =>
        expect(
          queryClient.getQueryData<CardPosition[]>(firstKey)
        ).toContainEqual(committed)
      );
    } else {
      answer.reject(new Error('Refused'));
      await waitFor(() => expect(toastFailure).toHaveBeenCalled());
    }
    expect(queryClient.getQueryData(secondKey)).toEqual(initialPositions);
    expect(cardsIn('Done')).toEqual(['first', 'last']);
    expect(cardsIn('To do')).toEqual(['moving']);
  }
);

it('keeps cached positions ready when a background refresh fails', async () => {
  const view: DatabaseView = {
    id: 'view',
    databaseId: 'database',
    tableId: 'table',
    name: 'Board',
    position: 'a0',
    query: { filter: null, sort: [] },
    layout: {
      kind: 'board',
      title: 'name',
      groupBy: 'stage',
      lanes: [],
      cardFields: [],
      hideEmptyLanes: false,
    },
    createdAt: '2026-09-01T00:00:00Z',
    updatedAt: '2026-09-01T00:00:00Z',
  };
  const saved: CardPosition[] = [
    { row: 'first', lane: { kind: 'option', id: 'done' }, position: 'a0' },
  ];
  transport.viewPositions
    .mockResolvedValueOnce(ok({ positions: saved }))
    .mockRejectedValueOnce(new Error('Refresh failed'));

  function PositionState() {
    const positions = useDatabaseBoardPositions(
      'database',
      () => view,
      () => true
    );
    return (
      <output aria-label="Board positions">{positions.state().kind}</output>
    );
  }

  render(() => (
    <QueryClientProvider client={queryClient}>
      <PositionState />
    </QueryClientProvider>
  ));

  await waitFor(() =>
    expect(screen.getByLabelText('Board positions').textContent).toBe('ready')
  );
  expect(
    queryClient.getQueryData(
      databaseViewKeys.positions('database', 'view').queryKey
    )
  ).toEqual(saved);

  await refreshCardPositions('database', 'view');

  await waitFor(() => expect(transport.viewPositions).toHaveBeenCalledTimes(2));
  await waitFor(() =>
    expect(screen.getByLabelText('Board positions').textContent).toBe('ready')
  );
  expect(
    queryClient.getQueryData(
      databaseViewKeys.positions('database', 'view').queryKey
    )
  ).toEqual(saved);
});