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 { loadDatabase } from '@app/features/block-database/queries/load-database';
import type { DatabaseOp } from '@core/database-sql/generated/types';
import { queryClient } from '@queries/client';
import type { DatabaseDetail } from '@service-storage/generated/schemas/databaseDetail';
import { errAsync, okAsync, ResultAsync } from 'neverthrow';
import { afterEach, describe, expect, it, vi } from 'vitest';
import {
applyDatabaseOps,
applyDatabaseTableVersions,
createDatabase,
databaseDetailQueryOptions,
fetchViewerDatabases,
onDatabaseBatchCommitted,
} from './databases';
import { databasesKeys } from './keys';
const mock = vi.hoisted(() => ({
applyOps: vi.fn(),
create: vi.fn(),
list: vi.fn(),
get: vi.fn(),
track: vi.fn(),
}));
vi.mock('@app/lib/analytics', () => ({ analytics: { track: mock.track } }));
vi.mock('@service-storage/client', () => ({
storageServiceClient: {
databases: {
applyOps: mock.applyOps,
create: mock.create,
list: mock.list,
get: mock.get,
},
},
}));
vi.mock('@queries/client', async () => {
const { QueryClient } = await import('@tanstack/solid-query');
return {
queryClient: new QueryClient({
defaultOptions: { queries: { retry: false } },
}),
};
});
const detail: DatabaseDetail = {
database: {
id: 'db',
name: 'Planning',
owner_id: 'owner',
created_at: '',
trashed_at: null,
project_id: null,
},
grant: 'owner',
tables: [
{
views: [],
table: {
id: 'tasks',
database_id: 'db',
name: 'Tasks',
position: 'a',
version: 5,
},
sql_name: 'tasks',
columns: [],
},
{
views: [],
table: {
id: 'people',
database_id: 'db',
name: 'People',
position: 'b',
version: 3,
},
sql_name: 'people',
columns: [],
},
],
};
const key = databasesKeys.detail('db').queryKey;
afterEach(() => {
queryClient.clear();
vi.clearAllMocks();
});
describe('database write version acknowledgments', () => {
it('preserves a newer schema refresh when an older write response arrives later', async () => {
queryClient.setQueryData(key, detail);
let acknowledge!: (versions: Record<string, number>) => void;
const response = new Promise<Record<string, number>>((resolve) => {
acknowledge = resolve;
});
const pendingWrite = (async () => {
applyDatabaseTableVersions('db', await response);
})();
// A concurrent rename is already visible before our own write responds.
const refreshed: DatabaseDetail = {
...detail,
tables: detail.tables.map((entry) =>
entry.table.id === 'tasks'
? {
...entry,
table: { ...entry.table, name: 'Roadmap', version: 8 },
sql_name: 'roadmap',
}
: entry
),
};
queryClient.setQueryData(key, refreshed);
acknowledge({ tasks: 7 });
await pendingWrite;
expect(queryClient.getQueryData(key)).toEqual(refreshed);
});
it('advances only the acknowledged table', () => {
queryClient.setQueryData(key, detail);
applyDatabaseTableVersions('db', { tasks: 6, unknown: 10 });
const updated = queryClient.getQueryData<DatabaseDetail>(key)!;
expect(updated.tables[0]).toEqual({
...detail.tables[0],
table: { ...detail.tables[0].table, version: 6 },
});
expect(updated.tables[1]).toEqual(detail.tables[1]);
});
});
describe('applying ops', () => {
it('sends the base versions with the batch and returns its results', async () => {
mock.applyOps.mockReturnValue(
okAsync({
results: [
{
kind: 'column',
table: 'tasks',
column: 'status',
tableVersion: 6,
change: { kind: 'deleted' },
},
],
changes: [],
})
);
const applied = await applyDatabaseOps(
'db',
[
{
kind: 'column',
table: 'tasks',
column: 'status',
change: { kind: 'delete' },
},
],
{ tasks: 5 }
);
expect(applied._unsafeUnwrap()).toEqual([
{
kind: 'column',
table: 'tasks',
column: 'status',
tableVersion: 6,
change: { kind: 'deleted' },
},
]);
expect(mock.applyOps).toHaveBeenCalledExactlyOnceWith({
id: 'db',
request: {
ops: [
{
kind: 'column',
table: 'tasks',
column: 'status',
change: { kind: 'delete' },
},
],
baseVersions: { tasks: 5 },
},
});
});
it('hands back the first refusal of a refused batch', async () => {
mock.applyOps.mockReturnValue(
errAsync([
{
code: 'CONFLICT',
message: 'The table changed.',
refusal: null,
},
])
);
const applied = await applyDatabaseOps('db', [
{ kind: 'table', table: 'tasks', change: { kind: 'delete' } },
]);
expect(applied._unsafeUnwrapErr()).toEqual({
code: 'CONFLICT',
message: 'The table changed.',
refusal: null,
});
expect(mock.applyOps).toHaveBeenCalledExactlyOnceWith({
id: 'db',
request: {
ops: [{ kind: 'table', table: 'tasks', change: { kind: 'delete' } }],
},
});
});
});
describe('creating a database', () => {
it('asks the service once and returns the new id', async () => {
mock.create.mockReturnValue(
okAsync({
id: 'db',
name: 'Untitled database',
owner_id: 'owner',
created_at: '',
trashed_at: null,
})
);
const created = await createDatabase({
name: 'Untitled database',
source: 'launcher',
});
expect(created._unsafeUnwrap()).toBe('db');
expect(mock.create).toHaveBeenCalledWith({ name: 'Untitled database' });
expect(mock.get).not.toHaveBeenCalled();
expect(mock.track).toHaveBeenCalledWith('create_entity', {
entityType: 'database',
entityId: 'db',
source: 'launcher',
});
});
it('returns the committed id while database discovery is still refreshing', async () => {
mock.create.mockReturnValue(okAsync({ ...detail.database, id: 'new-db' }));
let finish!: () => void;
const invalidating = vi
.spyOn(queryClient, 'invalidateQueries')
.mockImplementationOnce(
() =>
new Promise<void>((resolve) => {
finish = resolve;
})
);
try {
const created = await createDatabase({
name: 'Untitled database',
source: 'slash-menu',
});
expect(created._unsafeUnwrap()).toBe('new-db');
expect(invalidating).toHaveBeenCalledWith({
queryKey: databasesKeys.list.queryKey,
});
} finally {
finish?.();
invalidating.mockRestore();
}
});
it('hands a refusal back to the caller', async () => {
mock.create.mockReturnValue(
errAsync([{ code: 'INVALID_SCHEMA', message: 'name is empty' }])
);
const created = await createDatabase({ name: '' });
expect(created._unsafeUnwrapErr()).toEqual([
{ code: 'INVALID_SCHEMA', message: 'name is empty' },
]);
expect(mock.track).not.toHaveBeenCalled();
});
});
describe('reading every viewer database once', () => {
it('reads each live database and skips the trashed', async () => {
mock.list.mockReturnValue(
okAsync([
{
database: {
id: 'db',
name: 'Planning',
owner_id: 'owner',
created_at: '',
trashed_at: null,
},
grant: 'owner',
tables: [],
},
{
database: {
id: 'old',
name: 'Archive',
owner_id: 'owner',
created_at: '',
trashed_at: '2026-09-01T00:00:00Z',
},
grant: 'owner',
tables: [],
},
])
);
mock.get.mockReturnValue(okAsync(detail));
const databases = await fetchViewerDatabases();
expect(databases._unsafeUnwrap()).toEqual([detail]);
expect(mock.get).toHaveBeenCalledWith({ id: 'db' });
expect(mock.get).toHaveBeenCalledTimes(1);
});
it('returns the failure a detail read gave', async () => {
mock.list.mockReturnValue(
okAsync([
{
database: {
id: 'db',
name: 'Planning',
owner_id: 'owner',
created_at: '',
trashed_at: null,
},
grant: 'owner',
tables: [],
},
])
);
mock.get.mockReturnValue(
errAsync([{ code: 'FORBIDDEN', message: 'no access' }])
);
const databases = await fetchViewerDatabases();
expect(databases._unsafeUnwrapErr()).toEqual([
{ code: 'FORBIDDEN', message: 'no access' },
]);
});
});
describe('shared ops cache effects', () => {
it('publishes versions and refreshes schema without replaying ops into the cache', async () => {
queryClient.setQueryData(key, detail);
mock.applyOps.mockReturnValue(
okAsync({
results: [
{
kind: 'table',
table: 'tasks',
tableVersion: 6,
change: { kind: 'renamed' },
},
{
kind: 'table',
table: 'tasks',
tableVersion: 6,
change: { kind: 'renamed' },
},
],
changes: [],
})
);
await applyDatabaseOps('db', [
{
kind: 'table',
table: 'tasks',
change: { kind: 'rename', name: 'First', previousName: 'Tasks' },
},
{
kind: 'table',
table: 'tasks',
change: { kind: 'rename', name: 'Final', previousName: 'First' },
},
]);
expect(
queryClient.getQueryData<DatabaseDetail>(key)?.tables[0].table
).toMatchObject({ name: 'Tasks', version: 6 });
expect(queryClient.getQueryState(key)?.isInvalidated).toBe(true);
});
it('invalidates dependent catalogs for table deletion without replaying it', async () => {
queryClient.setQueryData(key, detail);
const other = databasesKeys.detail('other').queryKey;
queryClient.setQueryData(other, detail);
mock.applyOps.mockReturnValue(
okAsync({
results: [
{
kind: 'table',
table: 'tasks',
change: { kind: 'deleted' },
},
],
changes: [{ table: 'tasks', version: 6, change: 1 }],
})
);
await applyDatabaseOps('db', [
{ kind: 'table', table: 'tasks', change: { kind: 'delete' } },
]);
expect(
queryClient
.getQueryData<DatabaseDetail>(key)
?.tables.map(({ table }) => table.id)
).toEqual(['tasks', 'people']);
expect(queryClient.getQueryState(other)?.isInvalidated).toBe(true);
});
it('advances ordinary row writes without refetching the schema for each cell', async () => {
queryClient.setQueryData(key, detail);
mock.applyOps.mockReturnValue(
okAsync({
results: [],
changes: [{ table: 'tasks', version: 6, change: 1 }],
})
);
await applyDatabaseOps('db', [
{
kind: 'rows',
table: 'tasks',
change: { kind: 'delete', rows: ['row'] },
},
]);
expect(
queryClient.getQueryData<DatabaseDetail>(key)?.tables[0].table.version
).toBe(6);
expect(queryClient.getQueryState(key)?.isInvalidated).toBe(false);
});
it('reports committed row writes by kind without cell contents', async () => {
mock.applyOps.mockReturnValue(okAsync({ results: [], changes: [] }));
await applyDatabaseOps('db', [
{
kind: 'rows',
table: 'tasks',
change: { kind: 'insert', rows: [[], []] },
},
{
kind: 'rows',
table: 'tasks',
change: {
kind: 'update',
changes: { kind: 'uniform', rows: ['a', 'b', 'c'], cells: [] },
},
},
{ kind: 'table', table: 'tasks', change: { kind: 'delete' } },
]);
expect(mock.track).toHaveBeenCalledExactlyOnceWith('database_rows_edited', {
databaseId: 'db',
insertedRows: 2,
updatedRows: 3,
deletedRows: 0,
});
});
it('does not report schema-only or refused batches as row edits', async () => {
mock.applyOps.mockReturnValueOnce(okAsync({ results: [], changes: [] }));
await applyDatabaseOps('db', [
{ kind: 'table', table: 'tasks', change: { kind: 'delete' } },
]);
mock.applyOps.mockReturnValueOnce(
errAsync([{ code: 'CONFLICT', message: 'Changed.', refusal: null }])
);
await applyDatabaseOps('db', [
{
kind: 'rows',
table: 'tasks',
change: { kind: 'delete', rows: ['row'] },
},
]);
expect(mock.track).not.toHaveBeenCalled();
});
it('does not report the cells a column type conversion copies as row edits', async () => {
mock.applyOps.mockReturnValue(okAsync({ results: [], changes: [] }));
await applyDatabaseOps('db', [
{
kind: 'column',
table: 'tasks',
column: 'status-as-select',
change: {
kind: 'create',
definition: {
source: 'new',
name: 'Status',
type: { type: 'select', multi: false },
options: [],
},
after: 'status',
},
},
{
kind: 'rows',
table: 'tasks',
change: {
kind: 'update',
changes: {
kind: 'per_row',
rows: [
{ row: 'a', cells: [] },
{ row: 'b', cells: [] },
],
},
},
},
]);
expect(mock.track).not.toHaveBeenCalled();
});
it('invalidates optimistic state after a refused batch', async () => {
queryClient.setQueryData(key, detail);
mock.applyOps.mockReturnValue(
errAsync([{ code: 'CONFLICT', message: 'Changed', refusal: null }])
);
const result = await applyDatabaseOps('db', [
{ kind: 'table', table: 'tasks', change: { kind: 'delete' } },
]);
expect(result.isErr()).toBe(true);
expect(queryClient.getQueryData(key)).toEqual(detail);
expect(queryClient.getQueryState(key)?.isInvalidated).toBe(true);
});
});
it('returns and announces schema commits without waiting for a slow refresh', async () => {
const events: number[] = [];
const unsubscribe = onDatabaseBatchCommitted((batch) =>
events.push(batch.changes[0].change)
);
let release!: () => void;
const refresh = new Promise<void>((resolve) => {
release = resolve;
});
const invalidation = vi
.spyOn(queryClient, 'invalidateQueries')
.mockImplementationOnce(() => refresh);
mock.applyOps
.mockReturnValueOnce(
okAsync({
results: [],
changes: [{ table: 'tasks', version: 6, change: 10 }],
})
)
.mockReturnValueOnce(
okAsync({
results: [],
changes: [{ table: 'tasks', version: 7, change: 11 }],
})
);
try {
const schema = applyDatabaseOps('db', [
{
kind: 'table',
table: 'tasks',
change: { kind: 'rename', name: 'Renamed', previousName: 'Tasks' },
},
]);
await vi.waitFor(() => expect(invalidation).toHaveBeenCalled());
await applyDatabaseOps('db', [
{
kind: 'rows',
table: 'tasks',
change: { kind: 'delete', rows: ['row'] },
},
]);
expect(events).toEqual([10, 11]);
expect((await schema).isOk()).toBe(true);
release();
} finally {
release();
unsubscribe();
invalidation.mockRestore();
}
});
it.each<DatabaseOp>([
{
kind: 'column',
table: 'tasks',
column: 'status',
change: {
kind: 'create',
definition: {
source: 'new',
name: 'Status',
type: { type: 'select', multi: false },
},
},
},
{
kind: 'column',
table: 'tasks',
column: 'status',
change: { kind: 'add_options', options: [{ id: 'done', label: 'Done' }] },
},
])(
'loads created column data before a caller can cancel its refresh: %j',
async (op) => {
let release!: (value: DatabaseDetail) => void;
const refreshed = {
...detail,
tables: [{ ...detail.tables[0], sql_name: 'refreshed schema' }],
};
const read = vi
.fn()
.mockResolvedValueOnce(detail)
.mockImplementationOnce(
() =>
new Promise<DatabaseDetail>((resolve) => {
release = resolve;
})
);
// An inactive but previously loaded catalog must also be reconciled.
await queryClient.fetchQuery({ queryKey: key, queryFn: read });
mock.applyOps.mockReturnValue(okAsync({ results: [], changes: [] }));
let continued = false;
const write = applyDatabaseOps('db', [op]).map(async () => {
// View patches cancel pending reads. This used to discard the only read
// containing the newly created Status column.
continued = true;
await queryClient.cancelQueries({ queryKey: key, exact: true });
expect(queryClient.getQueryData(key)).toEqual(refreshed);
});
await vi.waitFor(() => expect(read).toHaveBeenCalledTimes(2));
expect(continued).toBe(false);
release(refreshed);
expect((await write).isOk()).toBe(true);
expect(continued).toBe(true);
}
);
it('keeps a column creation successful when its catalog refresh fails', async () => {
const read = vi
.fn()
.mockResolvedValueOnce(detail)
.mockRejectedValueOnce(new Error('Offline'));
await queryClient.fetchQuery({ queryKey: key, queryFn: read });
mock.applyOps.mockReturnValue(okAsync({ results: [], changes: [] }));
const result = await applyDatabaseOps('db', [
{
kind: 'column',
table: 'tasks',
column: 'status',
change: {
kind: 'create',
definition: { source: 'new', name: 'Status', type: { type: 'text' } },
},
},
]);
expect(read).toHaveBeenCalledTimes(2);
expect(result.isOk()).toBe(true);
expect(mock.applyOps).toHaveBeenCalledOnce();
expect(queryClient.getQueryState(key)?.isInvalidated).toBe(true);
});
it('does not refresh the catalog for board card or view order changes', async () => {
const invalidate = vi.spyOn(queryClient, 'invalidateQueries');
mock.applyOps.mockReturnValue(okAsync({ results: [], changes: [] }));
const result = await applyDatabaseOps('db', [
{
kind: 'view',
table: 'tasks',
view: 'board',
change: {
kind: 'move_card',
row: 'row',
lane: { kind: 'none' },
before: null,
after: null,
},
},
]);
await applyDatabaseOps('db', [
{
kind: 'table',
table: 'tasks',
change: { kind: 'reorder_views', order: ['board'] },
},
]);
expect(result.isOk()).toBe(true);
expect(invalidate).not.toHaveBeenCalled();
invalidate.mockRestore();
});
it('does not hold a cell write while refreshing a newly minted option', async () => {
let release!: () => void;
const refresh = new Promise<void>((resolve) => {
release = resolve;
});
const invalidate = vi
.spyOn(queryClient, 'invalidateQueries')
.mockReturnValue(refresh);
mock.applyOps.mockReturnValue(okAsync({ results: [], changes: [] }));
try {
const result = await applyDatabaseOps('db', [
{
kind: 'column',
table: 'tasks',
column: 'status',
change: {
kind: 'add_options',
options: [{ id: 'done', label: 'Done' }],
},
},
{
kind: 'rows',
table: 'tasks',
change: {
kind: 'update',
changes: {
kind: 'uniform',
rows: ['row'],
cells: [
{
column: 'status',
value: { type: 'options', value: [{ label: 'Done' }] },
},
],
},
},
},
]);
expect(result.isOk()).toBe(true);
expect(invalidate).toHaveBeenCalledOnce();
} finally {
release();
invalidate.mockRestore();
}
});
it('shares the block loader schema read with the mounted database view', async () => {
mock.get.mockReturnValue(okAsync(detail));
const loaded = await loadDatabase('db');
expect(loaded.isOk()).toBe(true);
const mounted = await queryClient.fetchQuery(
databaseDetailQueryOptions('db')
);
expect(mounted).toEqual(detail);
expect(mock.get).toHaveBeenCalledOnce();
});
it('deduplicates a block load with an in-flight schema read and reuses it on reopen', async () => {
let finish!: (value: DatabaseDetail) => void;
mock.get.mockReturnValue(
ResultAsync.fromSafePromise(
new Promise<DatabaseDetail>((resolve) => {
finish = resolve;
})
)
);
const mounted = queryClient.fetchQuery(databaseDetailQueryOptions('db'));
const loaded = loadDatabase('db');
expect(mock.get).toHaveBeenCalledOnce();
finish(detail);
await mounted;
expect((await loaded).isOk()).toBe(true);
expect((await loadDatabase('db')).isOk()).toBe(true);
expect(mock.get).toHaveBeenCalledOnce();
});
it('propagates a refused database load without seeding its schema cache', async () => {
const errors = [{ code: 'FORBIDDEN', message: 'Access denied' }];
mock.get.mockReturnValue(errAsync(errors));
const loaded = await loadDatabase('db');
expect(loaded.isErr()).toBe(true);
expect(loaded._unsafeUnwrapErr()).toEqual(errors);
expect(queryClient.getQueryData(key)).toBeUndefined();
});