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.

4.3 KB
Raw Blame
import { queryClient } from '@queries/client';
import { databasesKeys } from '@queries/storage/keys';
import type { DatabaseOpsError } from '@service-storage/databases';
import type { DatabaseDetail } from '@service-storage/generated/schemas/databaseDetail';
import type { OpResult } from '@service-storage/generated/schemas/opResult';
import { err, ok, type Result, ResultAsync } from 'neverthrow';
import { afterEach, describe, expect, it, vi } from 'vitest';
import { reorderDatabaseTables } from './reorder-tables';

const storage = vi.hoisted(() => ({
  applyDatabaseOps: vi.fn(),
}));
vi.mock('@service-storage/client', () => ({
  storageServiceClient: {
    databases: {
      applyOps: (input: { id: string; request: { ops: unknown[] } }) =>
        storage
          .applyDatabaseOps(input.id, input.request.ops)
          .map((results: OpResult[]) => ({ results, changes: [] }))
          .mapErr((error: DatabaseOpsError) => [error]),
    },
  },
}));
vi.mock('@queries/client', async () => {
  const { QueryClient } = await import('@tanstack/solid-query');
  return {
    queryClient: new QueryClient({
      defaultOptions: { queries: { retry: false } },
    }),
  };
});

afterEach(() => {
  queryClient.clear();
  vi.resetAllMocks();
});

const detail: DatabaseDetail = {
  database: {
    id: 'db',
    name: 'Party Planner',
    owner_id: 'owner',
    created_at: '',
    trashed_at: null,
    project_id: null,
  },
  grant: 'owner',
  tables: [
    {
      table: {
        id: 'invites',
        database_id: 'db',
        name: 'Invites',
        position: 'a',
        version: 3,
      },
      sql_name: '"Invites"',
      columns: [],
      views: [],
    },
    {
      table: {
        id: 'venues',
        database_id: 'db',
        name: 'Venues',
        position: 'b',
        version: 1,
      },
      sql_name: '"Venues"',
      columns: [],
      views: [],
    },
  ],
};

describe('reordering tables', () => {
  it('puts back only the tab order when the move is refused, keeping a rename made meanwhile', async () => {
    const key = databasesKeys.detail('db').queryKey;
    queryClient.setQueryData(key, detail);
    const { promise: answered, resolve: answer } =
      Promise.withResolvers<Result<OpResult[], DatabaseOpsError>>();
    storage.applyDatabaseOps.mockReturnValue(new ResultAsync(answered));

    const reordered = reorderDatabaseTables({
      databaseId: 'db',
      tableIds: ['venues', 'invites'],
    });
    await vi.waitFor(() =>
      expect(storage.applyDatabaseOps).toHaveBeenCalledExactlyOnceWith('db', [
        { kind: 'reorder_tables', order: ['venues', 'invites'] },
      ])
    );
    queryClient.setQueryData(key, (current: DatabaseDetail | undefined) =>
      current
        ? {
            ...current,
            tables: current.tables.map((entry) =>
              entry.table.id === 'invites'
                ? { ...entry, table: { ...entry.table, name: 'Guests' } }
                : entry
            ),
          }
        : current
    );
    answer(
      err({
        code: 'FORBIDDEN',
        message: 'Owner access required',
        refusal: null,
      })
    );

    expect((await reordered).isErr()).toBe(true);
    expect(
      queryClient
        .getQueryData<DatabaseDetail>(key)
        ?.tables.map((entry) => entry.table.name)
    ).toEqual(['Guests', 'Venues']);
    expect(queryClient.getQueryState(key)?.isInvalidated).toBe(true);
  });

  it('takes each table’s committed version from the answer', async () => {
    const key = databasesKeys.detail('db').queryKey;
    queryClient.setQueryData(key, detail);
    storage.applyDatabaseOps.mockReturnValue(
      new ResultAsync(
        Promise.resolve(
          ok([
            {
              kind: 'reorder_tables',
              tables: [
                { table: 'venues', version: 2 },
                { table: 'invites', version: 4 },
              ],
            },
          ])
        )
      )
    );

    const reordered = await reorderDatabaseTables({
      databaseId: 'db',
      tableIds: ['venues', 'invites'],
    });

    expect(reordered.isOk()).toBe(true);
    expect(
      queryClient
        .getQueryData<DatabaseDetail>(key)
        ?.tables.map((entry) => [entry.table.id, entry.table.version])
    ).toEqual([
      ['venues', 2],
      ['invites', 4],
    ]);
    expect(queryClient.getQueryState(key)?.isInvalidated).toBe(true);
  });
});