Macro is a unified workspace for teams: email, chat, docs, tasks, agents, calls, and CRM — @-linked together with shared AI memory.
TypeScript agentaiai-agentsall-in-onecrmcrm-systememaillinearmcpmessagingnotesnotionofficerustslackslack-alternativestartupstartup-toolstypescriptworkspace
import type { ResultError } from '@core/util/result';
import { errAsync, okAsync } from 'neverthrow';
import { createRoot, createSignal } from 'solid-js';
import { afterEach, beforeEach, expect, it, vi } from 'vitest';
import {
type LocalDatabaseAwareness,
useDatabaseAwareness,
useDatabaseMetadataChanges,
useDatabaseTableChanges,
} from './databases-sync';
it('reads metadata pings without exposing a name or accepting malformed payloads', () => {
const changed = vi.fn();
createRoot((dispose) => {
useDatabaseMetadataChanges(changed);
mock.event?.({ type: 'database_changed', data: { databaseId: 'db' } });
mock.event?.({ type: 'database_changed', data: '{"databaseId":"other"}' });
mock.event?.({ type: 'database_changed', data: { name: 'Private name' } });
mock.event?.({ type: 'form_changed', data: { databaseId: 'db' } });
expect(changed.mock.calls).toEqual([
[{ databaseId: 'db' }],
[{ databaseId: 'other' }],
]);
dispose();
});
});
const mock = vi.hoisted(() => ({
event: undefined as
| ((message: { type: string; data: unknown }) => void)
| undefined,
shareAwareness: vi.fn(
(_request: { id: string; state: Record<string, unknown> }) =>
okAsync<Record<string, never>, ResultError[]>({})
),
warn: vi.fn(),
}));
vi.mock('@service-connection/websocket', () => ({
createConnectionWebsocketEffect: (handler: typeof mock.event) => {
mock.event = handler;
},
}));
vi.mock('@core/context/user', () => ({ useUserId: () => () => 'me' }));
vi.mock('@service-storage/client', () => ({
storageServiceClient: { databases: { shareAwareness: mock.shareAwareness } },
}));
vi.mock('@macro-inc/observability', () => ({
Telemetry: { warn: mock.warn },
}));
vi.mock('./databases', () => ({
invalidateDatabase: vi.fn(),
}));
function relay(
userId: string,
state: Record<string, unknown>,
relayedAt: number,
databaseId = 'db'
) {
mock.event?.({
type: 'database_awareness',
data: JSON.stringify({ databaseId, userId, state, relayedAt }),
});
}
beforeEach(() => {
vi.useFakeTimers();
vi.setSystemTime(new Date('2026-09-30T10:00:00Z'));
});
afterEach(() => {
vi.useRealTimers();
mock.shareAwareness.mockClear();
mock.warn.mockClear();
});
it('sends the local state debounced, heartbeats it, and announces leaving on dispose', () => {
const [local, setLocal] = createSignal<LocalDatabaseAwareness | undefined>({
tableId: 'tasks',
rowId: 'row-1',
columnId: 'name',
});
const dispose = createRoot((dispose) => {
useDatabaseAwareness(() => 'db', local);
return dispose;
});
expect(mock.shareAwareness).not.toHaveBeenCalled();
setLocal({ tableId: 'tasks', rowId: 'row-1', columnId: 'notes' });
setLocal({
tableId: 'tasks',
rowId: 'row-1',
columnId: 'notes',
endRowId: 'row-3',
endColumnId: 'status',
editing: true,
});
vi.advanceTimersByTime(150);
expect(mock.shareAwareness).toHaveBeenCalledTimes(1);
expect(mock.shareAwareness).toHaveBeenCalledWith({
id: 'db',
state: {
peerId: expect.any(String),
tableId: 'tasks',
rowId: 'row-1',
columnId: 'notes',
endRowId: 'row-3',
endColumnId: 'status',
editing: true,
},
});
vi.advanceTimersByTime(20_000);
expect(mock.shareAwareness).toHaveBeenCalledTimes(2);
expect(mock.shareAwareness).toHaveBeenLastCalledWith({
id: 'db',
state: {
peerId: expect.any(String),
tableId: 'tasks',
rowId: 'row-1',
columnId: 'notes',
endRowId: 'row-3',
endColumnId: 'status',
editing: true,
},
});
setLocal({ tableId: 'tasks' });
vi.advanceTimersByTime(150);
expect(mock.shareAwareness).toHaveBeenLastCalledWith({
id: 'db',
state: {
peerId: expect.any(String),
tableId: 'tasks',
},
});
dispose();
expect(mock.shareAwareness).toHaveBeenLastCalledWith({
id: 'db',
state: {
peerId: expect.any(String),
tableId: 'tasks',
left: true,
},
});
expect(mock.shareAwareness).toHaveBeenCalledTimes(4);
});
it('merges legacy states per user, drops stale relays, itself, other databases, leavers, and silent viewers', () => {
const { remote, dispose } = createRoot((dispose) => ({
remote: useDatabaseAwareness(
() => 'db',
() => ({ tableId: 'tasks' })
).remote,
dispose,
}));
relay('alex', { tableId: 'tasks', rowId: 'row-1', columnId: 'name' }, 100);
relay('me', { tableId: 'tasks', rowId: 'row-2', columnId: 'name' }, 101);
relay(
'sam',
{ tableId: 'tasks', rowId: 'row-3', columnId: 'name' },
102,
'other-db'
);
// A server that predates view-only presence stamps no access: an editor.
expect(remote()).toEqual([
{
userId: 'alex',
canEdit: true,
tableId: 'tasks',
rowId: 'row-1',
columnId: 'name',
editing: false,
},
]);
// An older relay arriving late never rewinds a viewer.
relay('alex', { tableId: 'tasks', rowId: 'row-9', columnId: 'name' }, 99);
expect(remote()[0].rowId).toBe('row-1');
relay(
'alex',
{
tableId: 'tasks',
rowId: 'row-1',
columnId: 'notes',
endRowId: 'row-3',
endColumnId: 'status',
editing: true,
},
103
);
expect(remote()[0]).toMatchObject({
columnId: 'notes',
endRowId: 'row-3',
endColumnId: 'status',
editing: true,
});
relay('sam', { tableId: 'people' }, 104);
expect(remote().map((user) => user.userId)).toEqual(['alex', 'sam']);
relay('sam', { tableId: 'people', left: true }, 105);
expect(remote().map((user) => user.userId)).toEqual(['alex']);
vi.advanceTimersByTime(30_000);
relay('sam', { tableId: 'people' }, 106);
vi.advanceTimersByTime(20_000);
// Alex went quiet for 50 s; Sam refreshed 20 s ago.
expect(remote().map((user) => user.userId)).toEqual(['sam']);
dispose();
});
it('reports an awareness update the service refused', async () => {
mock.shareAwareness.mockReturnValueOnce(
errAsync([{ code: 'FORBIDDEN', message: 'no access' } as ResultError])
);
const dispose = createRoot((dispose) => {
useDatabaseAwareness(
() => 'db',
() => ({ tableId: 'tasks' })
);
return dispose;
});
vi.advanceTimersByTime(150);
await vi.waitFor(() =>
expect(mock.warn).toHaveBeenCalledWith(
'database awareness was not shared',
{
databaseId: 'db',
errors: JSON.stringify([{ code: 'FORBIDDEN', message: 'no access' }]),
}
)
);
dispose();
});
it('reports table changes the gateway announces and drops a payload that does not fit', () => {
const onChange = vi.fn();
const dispose = createRoot((dispose) => {
useDatabaseTableChanges(onChange);
return dispose;
});
mock.event?.({
type: 'database_table_changed',
data: JSON.stringify({ databaseId: 'db', tableId: 'tasks', version: 7 }),
});
expect(onChange).toHaveBeenCalledExactlyOnceWith({
databaseId: 'db',
tableId: 'tasks',
version: 7,
});
mock.event?.({
type: 'database_table_changed',
data: { databaseId: 'db', tableId: 'tasks', version: '8' },
});
expect(onChange).toHaveBeenCalledTimes(1);
expect(mock.warn).toHaveBeenCalledWith(
'gateway payload did not match its schema',
{
type: 'database_table_changed',
issues: JSON.stringify([
{
expected: 'number',
code: 'invalid_type',
path: ['version'],
message: 'Invalid input: expected number, received string',
},
]),
}
);
dispose();
});
it('drops an awareness relay without its relay time', () => {
const { remote, dispose } = createRoot((dispose) => ({
remote: useDatabaseAwareness(
() => 'db',
() => ({ tableId: 'tasks' })
).remote,
dispose,
}));
mock.event?.({
type: 'database_awareness',
data: JSON.stringify({
databaseId: 'db',
userId: 'alex',
state: { tableId: 'tasks' },
ts: 100,
}),
});
expect(remote()).toEqual([]);
expect(mock.warn).toHaveBeenCalledWith(
'gateway payload did not match its schema',
{
type: 'database_awareness',
issues: JSON.stringify([
{
expected: 'number',
code: 'invalid_type',
path: ['relayedAt'],
message: 'Invalid input: expected number, received undefined',
},
]),
}
);
dispose();
});
it('keeps same-user tabs separate, suppresses only this peer, and leaves one peer at a time', () => {
const { remote, dispose } = createRoot((dispose) => ({
remote: useDatabaseAwareness(
() => 'db',
() => ({ tableId: 'tasks' })
).remote,
dispose,
}));
vi.advanceTimersByTime(150);
const peerId = mock.shareAwareness.mock.calls.at(-1)![0].state.peerId;
const first = crypto.randomUUID();
const second = crypto.randomUUID();
relay('me', { peerId, tableId: 'tasks', rowId: 'local' }, 100);
relay('me', { peerId: first, tableId: 'tasks', rowId: 'one' }, 101);
relay('me', { peerId: second, tableId: 'tasks', rowId: 'two' }, 102);
expect(remote().map((state) => [state.userId, state.rowId])).toEqual([
['me', 'one'],
['me', 'two'],
]);
relay('me', { peerId: first, tableId: 'tasks', left: true }, 103);
expect(remote().map((state) => state.rowId)).toEqual(['two']);
relay('me', { peerId: first, tableId: 'tasks', rowId: 'stale' }, 102);
expect(remote().map((state) => state.rowId)).toEqual(['two']);
// Peer ids do not replace the authenticated identity or collide across users.
relay('alex', { peerId: second, tableId: 'tasks', rowId: 'alex' }, 104);
expect(remote().map((state) => state.userId)).toEqual(['me', 'alex']);
dispose();
});
it('marks a view-only viewer from the access the server stamped', () => {
const { remote, dispose } = createRoot((dispose) => ({
remote: useDatabaseAwareness(
() => 'db',
() => ({ tableId: 'tasks' })
).remote,
dispose,
}));
mock.event?.({
type: 'database_awareness',
data: JSON.stringify({
databaseId: 'db',
userId: 'pat',
canEdit: false,
state: { tableId: 'tasks', rowId: 'row-1', columnId: 'name' },
relayedAt: 100,
}),
});
expect(remote()).toEqual([
{
userId: 'pat',
canEdit: false,
tableId: 'tasks',
rowId: 'row-1',
columnId: 'name',
editing: false,
},
]);
dispose();
});
it('forgets peers when switching databases', () => {
const [database, setDatabase] = createSignal('db');
const { remote, dispose } = createRoot((dispose) => ({
remote: useDatabaseAwareness(database, () => ({ tableId: 'tasks' })).remote,
dispose,
}));
relay('alex', { peerId: crypto.randomUUID(), tableId: 'tasks' }, 100);
expect(remote()).toHaveLength(1);
setDatabase('other');
expect(remote()).toEqual([]);
dispose();
});