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.

16.8 KB
Raw Blame
import { err, errAsync, okAsync, type Result, ResultAsync } from 'neverthrow';
import { createRoot, createSignal } from 'solid-js';
import { afterEach, describe, expect, it, vi } from 'vitest';
import type {
  DatabaseRowsSnapshot,
  DatabaseRowsSource,
  DatabaseWriteResult,
} from '../context/table-source';
import { type DatabaseRowMutation, optimisticRows } from '../core/table';
import type { DatabaseWriteFailure } from '../core/write-failure';

import { createDraftRows } from './draft-rows';
import { createTableController } from './table-controller';

/** What the fake table holds; it retains no rows beyond the view's. */
type StoredTable = Omit<DatabaseRowsSnapshot, 'retained'>;

const offline: DatabaseWriteFailure = {
  kind: 'ops',
  error: { code: 'NETWORK_ERROR', message: 'Offline', refusal: null },
};

const disposers: (() => void)[] = [];
afterEach(() => {
  disposers.splice(0).forEach((dispose) => dispose());
});
function fixture() {
  return createRoot((dispose) => {
    disposers.push(dispose);
    const [snapshot, setSnapshot] = createSignal<StoredTable>({
      version: 1,
      rows: [],
    });
    let database: StoredTable = { version: 1, rows: [] };
    let sequence = 0;
    const persisted: DatabaseRowMutation[] = [];
    const persist = (
      mutation: DatabaseRowMutation,
      version: number | undefined
    ): DatabaseWriteResult => {
      expect(version).toBe(database.version);
      persisted.push(structuredClone(mutation));
      const insertedRowIds =
        mutation.kind === 'create' ? [`server-${++sequence}`] : [];
      database = {
        version: (database.version ?? 0) + 1,
        rows:
          mutation.kind === 'create'
            ? [
                ...database.rows,
                { rowId: insertedRowIds[0], cells: { ...mutation.values } },
              ]
            : optimisticRows(database.rows, [mutation]),
      };
      return { version: database.version, insertedRowIds };
    };
    const source: DatabaseRowsSource = {
      columns: () => [],
      snapshot: () => ({ ...snapshot(), retained: [] }),
      read: () => undefined,
      loading: () => false,
      refreshing: () => false,
      error: () => undefined,
      write: vi.fn<DatabaseRowsSource['write']>((mutation, version) =>
        okAsync(persist(mutation, version))
      ),
      refresh: vi.fn<DatabaseRowsSource['refresh']>(() => {
        setSnapshot(database);
        return okAsync(undefined);
      }),
      addOption: vi.fn<DatabaseRowsSource['addOption']>(() => {
        database = { ...database, version: (database.version ?? 0) + 1 };
        return okAsync(undefined);
      }),
      retain: () => {},
    };
    const controller = createTableController(source);
    const drafts = createDraftRows(controller);
    return {
      source,
      controller,
      drafts,
      persist,
      persisted,
      database: () => database,
      dispose,
    };
  });
}

describe('editable blank row', () => {
  it('preserves an uncertain draft without inserting it twice after refresh, retry, dismissal, or more typing', async () => {
    const { source, controller, drafts, persist, database } = fixture();
    vi.mocked(source.write).mockImplementationOnce((mutation, version) => {
      persist(mutation, version);
      return errAsync({ kind: 'outcome-unknown' });
    });
    const id = drafts.blankId();
    expect(await drafts.write(id, 'name', 'Saved once')).toBe(false);
    expect(controller.failure()?.failure).toEqual({ kind: 'outcome-unknown' });
    expect(controller.rows()).toEqual(database().rows);
    expect(drafts.project(controller.rows())).toContainEqual({
      rowId: id,
      cells: { name: 'Saved once' },
    });
    await controller.retry();
    expect(await drafts.retry(id)).toBe(false);
    controller.dismissFailure();
    expect(await drafts.write(id, 'notes', 'Keep this unsaved note')).toBe(
      false
    );
    await controller.save(
      { kind: 'create', values: { name: 'Saved once' } },
      { label: 'new record', createIntentId: id }
    );
    expect(source.write).toHaveBeenCalledOnce();
    expect(database().rows).toHaveLength(1);
    expect(drafts.project(controller.rows())).toContainEqual({
      rowId: id,
      cells: { name: 'Saved once', notes: 'Keep this unsaved note' },
    });
    drafts.discardUncertain(id);
    expect(drafts.has(id)).toBe(false);
    expect(database().rows).toHaveLength(1);
    expect(drafts.project(controller.rows())).toContainEqual(
      database().rows[0]
    );
  });

  it('finishes accepted fields against the original row after its owner is disposed', async () => {
    const {
      source,
      controller,
      drafts,
      persist,
      persisted,
      database,
      dispose,
    } = fixture();
    let release!: () => void;
    vi.mocked(source.write).mockImplementationOnce((mutation, version) =>
      ResultAsync.fromSafePromise(
        new Promise<void>((resolve) => {
          release = resolve;
        })
      ).map(() => persist(mutation, version))
    );
    const id = drafts.blankId();
    const name = drafts.write(id, 'name', 'First table record');
    const notes = drafts.write(id, 'notes', 'Keep these accepted notes');
    await vi.waitFor(() => expect(source.write).toHaveBeenCalledOnce());
    dispose();

    expect(await drafts.write(id, 'notes', 'Too late')).toBe(false);
    expect(await drafts.retry(id)).toBe(false);
    expect(
      await controller.save({ kind: 'create', values: { name: 'Too late' } })
    ).toEqual(err({ kind: 'unmounted' }));
    expect(await controller.addGroup('status', 'Too late')).toEqual(
      err({
        code: 'UNKNOWN_ERROR',
        message: 'The table was closed before the group was added.',
        refusal: null,
      })
    );
    expect(source.addOption).not.toHaveBeenCalled();

    release();
    expect(await Promise.all([name, notes])).toEqual([true, true]);
    expect(persisted).toEqual([
      { kind: 'create', values: { name: 'First table record' } },
      {
        kind: 'cell',
        rowId: 'server-1',
        columnId: 'notes',
        value: 'Keep these accepted notes',
      },
    ]);
    expect(database().rows).toEqual([
      {
        rowId: 'server-1',
        cells: {
          name: 'First table record',
          notes: 'Keep these accepted notes',
        },
      },
    ]);
    expect(
      vi.mocked(source.write).mock.calls.map(([, version]) => version)
    ).toEqual([1, 2]);
  });

  it('finishes an accepted new option and its field after the create owner is disposed', async () => {
    const { source, drafts, persist, database, dispose } = fixture();
    let release!: () => void;
    vi.mocked(source.write).mockImplementationOnce((mutation, version) =>
      ResultAsync.fromSafePromise(
        new Promise<void>((resolve) => {
          release = resolve;
        })
      ).map(() => persist(mutation, version))
    );
    const id = drafts.blankId();
    const name = drafts.write(id, 'name', 'Accepted record');
    const status = drafts.write(id, 'status', 'In review', 'In review');
    await vi.waitFor(() => expect(source.write).toHaveBeenCalledOnce());
    dispose();
    release();
    expect(await Promise.all([name, status])).toEqual([true, true]);
    // The field's write creates the option it names.
    expect(source.addOption).not.toHaveBeenCalled();
    expect(database().rows).toEqual([
      {
        rowId: 'server-1',
        cells: { name: 'Accepted record', status: 'In review' },
      },
    ]);
    expect(
      vi
        .mocked(source.write)
        .mock.calls.map(([, version, createOptions]) => [
          version,
          createOptions,
        ])
    ).toEqual([
      [1, false],
      [2, true],
    ]);
    expect(database().version).toBe(3);
  });

  it('drops a failed mention type when its draft is replaced with plain text', async () => {
    const { source, drafts, persisted, database } = fixture();
    vi.mocked(source.write).mockImplementationOnce(() =>
      errAsync({
        kind: 'type-refused',
        errors: [
          {
            code: 'INVALID_SCHEMA',
            message: 'Could not infer the column type',
          },
        ],
      })
    );
    const id = drafts.blankId();
    expect(
      await drafts.write(id, 'owner', 'macro|[email protected]', undefined, {
        dataType: 'ENTITY',
        entityType: 'USER',
      })
    ).toBe(false);
    expect(drafts.project([])[0].cells.owner).toBe('macro|[email protected]');

    expect(await drafts.write(id, 'owner', 'A plain text value')).toBe(true);
    expect(persisted).toEqual([
      { kind: 'create', values: { owner: 'A plain text value' } },
    ]);
    expect(database().rows).toEqual([
      { rowId: 'server-1', cells: { owner: 'A plain text value' } },
    ]);
  });

  it('carries a mention type through creation and queued field writes', async () => {
    const { source, drafts, persist, persisted } = fixture();
    let release!: () => void;
    vi.mocked(source.write).mockImplementationOnce((mutation, version) =>
      ResultAsync.fromSafePromise(
        new Promise<void>((resolve) => {
          release = resolve;
        })
      ).map(() => persist(mutation, version))
    );
    const id = drafts.blankId();
    const first = drafts.write(
      id,
      'owner',
      'macro|[email protected]',
      undefined,
      { dataType: 'ENTITY', entityType: 'USER' }
    );
    const second = drafts.write(id, 'reference', 'document-id', undefined, {
      dataType: 'ENTITY',
      entityType: 'DOCUMENT',
    });
    await vi.waitFor(() => expect(source.write).toHaveBeenCalledOnce());
    release();
    expect(await Promise.all([first, second])).toEqual([true, true]);
    expect(persisted[0]).toMatchObject({
      kind: 'create',
      columnTypes: { owner: { dataType: 'ENTITY', entityType: 'USER' } },
    });
    expect(persisted[1]).toMatchObject({
      kind: 'cell',
      columnId: 'reference',
      columnTypes: {
        reference: { dataType: 'ENTITY', entityType: 'DOCUMENT' },
      },
    });
  });

  it('names a row to the server by its saved id, and an unsaved draft not at all', async () => {
    const { drafts } = fixture();
    const id = drafts.blankId();

    expect(drafts.savedRowId(id)).toBeUndefined();
    expect(drafts.savedRowId('server-7')).toBe('server-7');

    await drafts.write(id, 'name', 'Ada');

    expect(drafts.savedRowId(id)).toBe('server-1');
    expect(drafts.savedRowId(drafts.blankId())).toBeUndefined();
  });

  it('keeps one empty row local without creating records for empty commits', async () => {
    const { source, controller, drafts } = fixture();
    const id = drafts.blankId();
    await drafts.write(id, 'name', null);
    await drafts.write(id, 'notes', '');
    expect(drafts.project(controller.rows())).toEqual([
      { rowId: id, cells: {} },
    ]);
    expect(controller.rows()).toEqual([]);
    expect(source.write).not.toHaveBeenCalled();
  });

  it('creates once while rapid multi-field edits wait, preserving the UI row ID and every latest value', async () => {
    const { source, controller, drafts, persist, database, persisted } =
      fixture();
    let release!: () => void;
    vi.mocked(source.write).mockImplementationOnce((mutation, version) =>
      ResultAsync.fromSafePromise(
        new Promise<void>((resolve) => {
          release = resolve;
        })
      ).map(() => persist(mutation, version))
    );
    const id = drafts.blankId();
    const first = drafts.write(id, 'name', 'First name');
    const second = drafts.write(id, 'notes', 'Typed while saving');
    const third = drafts.write(id, 'name', 'Final name');
    await vi.waitFor(() => expect(source.write).toHaveBeenCalledTimes(1));
    const rows = drafts.project(controller.rows());
    expect(rows).toHaveLength(2);
    expect(rows[0]).toEqual({
      rowId: id,
      cells: { name: 'Final name', notes: 'Typed while saving' },
    });
    expect(rows[1].cells).toEqual({});
    release();
    expect(await Promise.all([first, second, third])).toEqual([
      true,
      true,
      true,
    ]);
    expect(
      persisted.filter((mutation) => mutation.kind === 'create')
    ).toHaveLength(1);
    expect(database().rows).toEqual([
      {
        rowId: 'server-1',
        cells: { name: 'Final name', notes: 'Typed while saving' },
      },
    ]);
    expect(drafts.project(controller.rows())[0].rowId).toBe(id);
    expect(drafts.project(controller.rows())).toHaveLength(2);
  });

  it('retries a failed creation with all fields typed since its first request', async () => {
    const { source, controller, drafts, database } = fixture();
    let reject!: () => void;
    vi.mocked(source.write).mockImplementationOnce(
      () =>
        new ResultAsync(
          new Promise<Result<DatabaseWriteResult, DatabaseWriteFailure>>(
            (resolve) => {
              reject = () => resolve(err(offline));
            }
          )
        )
    );
    const id = drafts.blankId();
    const first = drafts.write(id, 'name', 'Old name');
    const next = drafts.write(id, 'notes', 'Keep these notes');
    const revised = drafts.write(id, 'name', 'Revised name');
    await vi.waitFor(() => expect(source.write).toHaveBeenCalledOnce());
    reject();
    expect(await Promise.all([first, next, revised])).toEqual([
      false,
      false,
      false,
    ]);
    expect(database().rows).toEqual([]);
    expect(drafts.retryTarget(controller.failure()!)).toBe(id);
    expect(await drafts.retry(id)).toBe(true);
    expect(source.write).toHaveBeenCalledTimes(2);
    expect(database().rows).toEqual([
      {
        rowId: 'server-1',
        cells: { name: 'Revised name', notes: 'Keep these notes' },
      },
    ]);
    expect(controller.failure()).toBeUndefined();
    expect(drafts.error()).toBeUndefined();
  });

  it('does not insert twice after an acknowledged create whose refresh fails', async () => {
    const { source, controller, drafts, database, persisted } = fixture();
    vi.mocked(source.refresh).mockImplementationOnce(() =>
      errAsync({ kind: 'fetch', message: 'Read offline' })
    );
    const id = drafts.blankId();
    expect(await drafts.write(id, 'name', 'Saved record')).toBe(true);
    expect(controller.refreshWarning()).toBe(true);
    expect(drafts.project(controller.rows())[0]).toEqual({
      rowId: id,
      cells: { name: 'Saved record' },
    });
    expect(await drafts.write(id, 'notes', 'Still editable')).toBe(true);
    expect(await drafts.retry(id)).toBe(true);
    expect(
      persisted.filter((mutation) => mutation.kind === 'create')
    ).toHaveLength(1);
    expect(database().rows[0].cells).toEqual({
      name: 'Saved record',
      notes: 'Still editable',
    });
    expect(drafts.project(controller.rows())[0].rowId).toBe(id);
  });

  it('keeps a focused promoted row through filtering, then reconciles when focus leaves', async () => {
    const { controller, drafts } = fixture();
    const id = drafts.blankId();
    drafts.setActive(id);
    await drafts.write(id, 'name', 'Outside the filter');
    expect(drafts.project([])[0]).toEqual({
      rowId: id,
      cells: { name: 'Outside the filter' },
    });
    drafts.setActive(undefined);
    expect(drafts.project([])).toEqual([
      { rowId: drafts.blankId(), cells: {} },
    ]);
    expect(controller.rows()).toHaveLength(1);
  });

  it('retains a new option and row when the write creating them fails, and retries them together', async () => {
    const { source, drafts, database } = fixture();
    vi.mocked(source.write).mockImplementationOnce(() => errAsync(offline));
    const id = drafts.blankId();
    expect(await drafts.write(id, 'status', 'In review', 'In review')).toBe(
      false
    );
    expect(drafts.error()?.failure).toEqual(offline);
    expect(drafts.error()?.error).toBe(
      'Your change could not be sent. Check your connection.'
    );
    expect(await drafts.retry(id)).toBe(true);
    expect(source.addOption).not.toHaveBeenCalled();
    expect(vi.mocked(source.write).mock.calls).toEqual([
      [{ kind: 'create', values: { status: 'In review' } }, 1, true],
      [{ kind: 'create', values: { status: 'In review' } }, 1, true],
    ]);
    expect(database().rows).toEqual([
      { rowId: 'server-1', cells: { status: 'In review' } },
    ]);
  });

  it('retries the same failed cell with its latest text and does not resurrect deleted rows', async () => {
    const { source, controller, drafts, database } = fixture();
    const id = drafts.blankId();
    await drafts.write(id, 'name', 'New record');
    vi.mocked(source.write).mockImplementationOnce(() => errAsync(offline));
    expect(await drafts.write(id, 'notes', 'Old draft')).toBe(false);
    expect(await drafts.write(id, 'notes', 'Updated draft')).toBe(true);
    expect(controller.failure()).toBeUndefined();
    expect(database().rows[0].cells.notes).toBe('Updated draft');
    await controller.save({ kind: 'delete', rowId: drafts.serverId(id)! });
    expect(database().rows).toEqual([]);
    expect(drafts.project(controller.rows())).toEqual([
      { rowId: drafts.blankId(), cells: {} },
    ]);
  });
});