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.

fix(databases): consolidate UI ops and synchronize created schema (#7392)

Wolf Mermelsteinb2f752bf3bd2
diff --git a/apps/web/src/features/block-database/component/AddColumnMenu.test.tsx b/apps/web/src/features/block-database/component/AddColumnMenu.test.tsx
index 0789a35419..8e79904b2f 100644
--- a/apps/web/src/features/block-database/component/AddColumnMenu.test.tsx
+++ b/apps/web/src/features/block-database/component/AddColumnMenu.test.tsx
@@ -67,7 +67,7 @@ describe('immediate column creation', () => {
const [[, [op]]] = storage.applyDatabaseOps.mock.calls;
assert(op.kind === 'column');
expect(created).toHaveBeenCalledExactlyOnceWith(op.column);
- expect(storage.invalidateDatabase).toHaveBeenCalledExactlyOnceWith('db');
+ expect(storage.invalidateDatabase).not.toHaveBeenCalled();
expect(screen.queryByRole('dialog')).toBeNull();
});
it('prevents repeated clicks during creation and preserves errors', async () => {
diff --git a/apps/web/src/features/block-database/component/DatabaseGrid.tsx b/apps/web/src/features/block-database/component/DatabaseGrid.tsx
index 58e88320be..34db578123 100644
--- a/apps/web/src/features/block-database/component/DatabaseGrid.tsx
+++ b/apps/web/src/features/block-database/component/DatabaseGrid.tsx
@@ -13,6 +13,7 @@ import {
} from '@queries/storage/databases-sync';
import type { DatabaseView } from '@service-storage/generated/schemas/databaseView';
import type { TableDetail } from '@service-storage/generated/schemas/tableDetail';
+import { ResultAsync } from 'neverthrow';
import {
createMemo,
createSignal,
@@ -42,15 +43,15 @@ import {
} from '../database-mentions';
import type { BoardPositionsState } from '../primitives/board-layout';
import { createColumnCasts } from '../queries/column-casts';
-import { updateDatabaseColumns } from '../queries/column-schema';
+import { opColumnKind } from '../queries/column-schema';
import {
addDatabaseColumnOptions,
convertDatabaseColumn,
} from '../queries/columns';
import { createDatabaseRelations } from '../queries/database-relations';
import { useRelatedDatabaseSync } from '../queries/database-relations-sync';
+import { patchTable } from '../queries/detail-cache';
import { deleteDatabaseOption, updateDatabaseOption } from '../queries/options';
-import { renameDatabaseColumn } from '../queries/rename-column';
import { tableChangesOf } from '../queries/table-changes';
import { createDatabaseRowsSource, toViewColumn } from '../queries/table-rows';
import {
@@ -285,16 +286,6 @@ function TableAdapter(props: DatabaseGridProps & { tableId: string }) {
tableId: props.tableId,
version: () => table().table.version,
});
- const changeColumns = (
- mutation: Parameters<typeof updateDatabaseColumns>[0]['mutation'],
- baseVersion = table().table.version
- ) =>
- updateDatabaseColumns({
- databaseId,
- tableId: props.tableId,
- baseVersion,
- mutation,
- });
return (
<>
<For each={relatedDatabases()}>
@@ -340,10 +331,21 @@ function TableAdapter(props: DatabaseGridProps & { tableId: string }) {
onChangeColumnType={(columnId, change) =>
// Checked against the version the menu's dry run read, so a
// change made since is not converted blind.
- changeColumns(
- { kind: 'type', columnId, change },
- change.baseVersion
- )
+ applyDatabaseOps(
+ databaseId,
+ [
+ {
+ kind: 'column',
+ table: props.tableId,
+ column: columnId,
+ change: {
+ kind: 'change_type',
+ to: opColumnKind(databaseId, change.to),
+ },
+ },
+ ],
+ { [props.tableId]: change.baseVersion ?? table().table.version }
+ ).map(() => undefined)
}
onConvertColumn={(columnId, conversion) =>
convertDatabaseColumn({
@@ -358,27 +360,102 @@ function TableAdapter(props: DatabaseGridProps & { tableId: string }) {
),
})
}
- onDeleteColumn={(columnId) =>
- changeColumns({ kind: 'delete', columnId })
- }
- onReorderColumns={(columnIds) =>
- changeColumns({
- kind: 'order',
- columnIds: mergeDatabaseColumnOrder(
- table().columns.map(({ column }) => column.id),
- columnIds
- ),
- })
- }
- onRenameColumn={(columnId, name, previousName) =>
- renameDatabaseColumn({
- databaseId,
- tableId: props.tableId,
- columnId,
- name,
- previousName,
- })
- }
+ onDeleteColumn={(columnId) => {
+ const tableId = props.tableId;
+ const version = table().table.version;
+ return ResultAsync.fromSafePromise(
+ patchTable(databaseId, tableId, (entry) => ({
+ ...entry,
+ columns: entry.columns.filter(
+ ({ column }) => column.id !== columnId
+ ),
+ }))
+ )
+ .andThen((rollback) =>
+ applyDatabaseOps(
+ databaseId,
+ [
+ {
+ kind: 'column',
+ table: tableId,
+ column: columnId,
+ change: { kind: 'delete' },
+ },
+ ],
+ { [tableId]: version }
+ ).mapErr((error) => {
+ rollback();
+ return error;
+ })
+ )
+ .map(() => undefined);
+ }}
+ onReorderColumns={(columnIds) => {
+ const tableId = props.tableId;
+ const version = table().table.version;
+ const order = mergeDatabaseColumnOrder(
+ table().columns.map(({ column }) => column.id),
+ columnIds
+ );
+ const rank = new Map(order.map((id, i) => [id, i]));
+ return ResultAsync.fromSafePromise(
+ patchTable(databaseId, tableId, (entry) => ({
+ ...entry,
+ columns: entry.columns.toSorted(
+ (a, b) =>
+ (rank.get(a.column.id) ?? Infinity) -
+ (rank.get(b.column.id) ?? Infinity)
+ ),
+ }))
+ )
+ .andThen((rollback) =>
+ applyDatabaseOps(
+ databaseId,
+ [
+ {
+ kind: 'table',
+ table: tableId,
+ change: { kind: 'reorder_columns', order },
+ },
+ ],
+ { [tableId]: version }
+ ).mapErr((error) => {
+ rollback();
+ return error;
+ })
+ )
+ .map(() => undefined);
+ }}
+ onRenameColumn={(columnId, name, previousName) => {
+ const tableId = props.tableId;
+ return ResultAsync.fromSafePromise(
+ patchTable(databaseId, tableId, (entry) => ({
+ ...entry,
+ columns: entry.columns.map((column) =>
+ column.column.id === columnId
+ ? {
+ ...column,
+ column: { ...column.column, display_name: name },
+ }
+ : column
+ ),
+ }))
+ )
+ .andThen((rollback) =>
+ applyDatabaseOps(databaseId, [
+ {
+ kind: 'column',
+ table: tableId,
+ column: columnId,
+ change: { kind: 'rename', name, previousName },
+ },
+ ]).mapErr((error) => {
+ rollback();
+ return error;
+ })
+ )
+ .map(() => undefined);
+ }}
actionsRef={props.actionsRef}
renderToolbar={props.renderToolbar}
createColumn={() =>
diff --git a/apps/web/src/features/block-database/component/TableTabs.test.tsx b/apps/web/src/features/block-database/component/TableTabs.test.tsx
index 3b8a76adeb..5fda84e000 100644
--- a/apps/web/src/features/block-database/component/TableTabs.test.tsx
+++ b/apps/web/src/features/block-database/component/TableTabs.test.tsx
@@ -10,6 +10,7 @@ import {
screen,
waitFor,
} from '@solidjs/testing-library';
+import { QueryObserver } from '@tanstack/solid-query';
import { err, ok } from 'neverthrow';
import { createSignal, onCleanup } from 'solid-js';
import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
@@ -262,7 +263,7 @@ describe('deleting a table', () => {
results: [
{ kind: 'table', table: 'budget', change: { kind: 'deleted' } },
],
- changes: [],
+ changes: [{ table: 'budget', version: 2, change: 1 }],
})
);
renderTabs();
@@ -302,3 +303,106 @@ describe('deleting a table', () => {
expect(fetch).not.toHaveBeenCalled();
});
});
+
+it('shows a rename before commit and cancels an older schema read', async () => {
+ let releaseRead!: (value: DatabaseDetail) => void;
+ const staleRead = queryClient.fetchQuery({
+ queryKey: key,
+ queryFn: () =>
+ new Promise<DatabaseDetail>((resolve) => {
+ releaseRead = resolve;
+ }),
+ staleTime: 0,
+ });
+ const settled = Promise.allSettled([staleRead]);
+ let releaseWrite!: () => void;
+ fetch.mockImplementationOnce(async () => {
+ await new Promise<void>((resolve) => {
+ releaseWrite = resolve;
+ });
+ return ok({
+ results: [
+ {
+ kind: 'table',
+ table: 'guests',
+ tableVersion: 4,
+ change: { kind: 'renamed' },
+ },
+ ],
+ changes: [],
+ });
+ });
+ renderTabs();
+ fireEvent.dblClick(screen.getByRole('tab', { name: 'Guests' }));
+ const input = screen.getByRole('textbox', { name: 'Table name' });
+ fireEvent.input(input, { target: { value: 'Attendees' } });
+ fireEvent.keyDown(input, { key: 'Enter' });
+ await waitFor(() => expect(fetch).toHaveBeenCalledOnce());
+ expect(
+ queryClient.getQueryData<DatabaseDetail>(key)?.tables[0].table.name
+ ).toBe('Attendees');
+ releaseWrite();
+ await screen.findByRole('tab', { name: 'Attendees' });
+ releaseRead(detail);
+ await settled;
+ expect(
+ queryClient.getQueryData<DatabaseDetail>(key)?.tables[0].table.name
+ ).toBe('Attendees');
+});
+
+it('refreshes a refused optimistic rename back to server state', async () => {
+ const observer = new QueryObserver(queryClient, {
+ queryKey: key,
+ queryFn: async () => detail,
+ staleTime: Infinity,
+ });
+ const unsubscribe = observer.subscribe(() => {});
+ try {
+ fetch.mockResolvedValue(
+ err([{ code: 'CONFLICT', message: 'The table changed.' }])
+ );
+ renderTabs();
+ fireEvent.dblClick(screen.getByRole('tab', { name: 'Guests' }));
+ const input = screen.getByRole('textbox', { name: 'Table name' });
+ fireEvent.input(input, { target: { value: 'Attendees' } });
+ fireEvent.keyDown(input, { key: 'Enter' });
+ await waitFor(() => expect(fetch).toHaveBeenCalledOnce());
+ await waitFor(() =>
+ expect(
+ queryClient.getQueryData<DatabaseDetail>(key)?.tables[0].table.name
+ ).toBe('Guests')
+ );
+ } finally {
+ unsubscribe();
+ }
+});
+
+it('restores a refused deletion even when its recovery read fails', async () => {
+ const observer = new QueryObserver(queryClient, {
+ queryKey: key,
+ queryFn: async (): Promise<DatabaseDetail> => {
+ throw new Error('Offline');
+ },
+ staleTime: Infinity,
+ retry: false,
+ });
+ const unsubscribe = observer.subscribe(() => {});
+ try {
+ fetch.mockResolvedValue(
+ err([{ code: 'UNKNOWN_ERROR', message: 'Offline' }])
+ );
+ renderTabs();
+ await chooseMenuItem('Budget', 'Delete table');
+ await screen.findByRole('dialog');
+ fireEvent.click(screen.getByRole('button', { name: 'Delete table' }));
+ await waitFor(() => expect(toast.failure).toHaveBeenCalledOnce());
+ await waitFor(() =>
+ expect(tabNames()).toEqual(['Guests', 'Budget', 'Venues'])
+ );
+ await waitFor(() =>
+ expect(queryClient.getQueryState(key)?.status).toBe('error')
+ );
+ } finally {
+ unsubscribe();
+ }
+});
diff --git a/apps/web/src/features/block-database/component/TableTabs.tsx b/apps/web/src/features/block-database/component/TableTabs.tsx
index 2527712fca..09c695aa6f 100644
--- a/apps/web/src/features/block-database/component/TableTabs.tsx
+++ b/apps/web/src/features/block-database/component/TableTabs.tsx
@@ -1,10 +1,11 @@
import { toast } from '@core/component/Toast/Toast';
+import { applyDatabaseOps } from '@queries/storage/databases';
import type { TableDetail } from '@service-storage/generated/schemas/tableDetail';
+import { ResultAsync } from 'neverthrow';
import { TableNavigation } from '../components/table-navigation';
import { tableDeleteMessage, tableOrderMessage } from '../core/column-schema';
import { createTableWithName } from '../queries/create-table';
-import { deleteDatabaseTable } from '../queries/delete-table';
-import { renameDatabaseTable } from '../queries/rename-table';
+import { patchDetail, patchTable } from '../queries/detail-cache';
import { reorderDatabaseTables } from '../queries/reorder-tables';
export function TableTabs(props: {
@@ -24,12 +25,25 @@ export function TableTabs(props: {
canCreate={props.canEdit}
onSelect={props.onSelect}
onRename={(tableId, name, previousName) =>
- renameDatabaseTable({
- databaseId: props.databaseId,
- tableId,
- name,
- previousName,
- })
+ ResultAsync.fromSafePromise(
+ patchTable(props.databaseId, tableId, (entry) => ({
+ ...entry,
+ table: { ...entry.table, name },
+ }))
+ )
+ .andThen((rollback) =>
+ applyDatabaseOps(props.databaseId, [
+ {
+ kind: 'table',
+ table: tableId,
+ change: { kind: 'rename', name, previousName },
+ },
+ ]).mapErr((error) => {
+ rollback();
+ return error;
+ })
+ )
+ .map(() => undefined)
}
onReorder={(tableIds) =>
void reorderDatabaseTables({
@@ -38,10 +52,21 @@ export function TableTabs(props: {
}).mapErr((errors) => toast.failure(tableOrderMessage(errors)))
}
onDelete={(tableId) =>
- void deleteDatabaseTable({
- databaseId: props.databaseId,
- tableId,
- }).mapErr((error) => toast.failure(tableDeleteMessage(error)))
+ void ResultAsync.fromSafePromise(
+ patchDetail(props.databaseId, (detail) => ({
+ ...detail,
+ tables: detail.tables.filter((entry) => entry.table.id !== tableId),
+ }))
+ )
+ .andThen((rollback) =>
+ applyDatabaseOps(props.databaseId, [
+ { kind: 'table', table: tableId, change: { kind: 'delete' } },
+ ]).mapErr((error) => {
+ rollback();
+ return error;
+ })
+ )
+ .mapErr((error) => toast.failure(tableDeleteMessage(error)))
}
onCreate={(name, existingTableId) =>
createTableWithName({
diff --git a/apps/web/src/features/block-database/queries/column-schema.test.ts b/apps/web/src/features/block-database/queries/column-schema.test.ts
index 0438b79c6a..e7fa2a6d31 100644
--- a/apps/web/src/features/block-database/queries/column-schema.test.ts
+++ b/apps/web/src/features/block-database/queries/column-schema.test.ts
@@ -1,168 +1,12 @@
-import { okAsync } from 'neverthrow';
-import { afterEach, describe, expect, it, vi } from 'vitest';
-import { updateDatabaseColumns } from './column-schema';
+import { describe, expect, it } from 'vitest';
+import { opColumnKind } from './column-schema';
-const storage = vi.hoisted(() => ({ applyDatabaseOps: vi.fn() }));
-vi.mock('@queries/storage/databases', () => storage);
-vi.mock('@queries/client', async () => {
- const { QueryClient } = await import('@tanstack/solid-query');
- return {
- queryClient: new QueryClient({
- defaultOptions: { queries: { retry: false } },
- }),
- };
-});
-
-afterEach(() => {
- vi.resetAllMocks();
-});
-
-describe('column schema changes', () => {
- it('sends a type change, with nothing but its type, against the table version it was made at', async () => {
- storage.applyDatabaseOps.mockReturnValue(
- okAsync([
- {
- kind: 'column',
- table: 'tasks',
- column: 'price',
- tableVersion: 5,
- change: { kind: 'type_changed' },
- },
- ])
- );
-
- const changed = await updateDatabaseColumns({
- databaseId: 'db',
- tableId: 'tasks',
- baseVersion: 4,
- mutation: {
- kind: 'type',
- columnId: 'price',
- change: { to: { type: 'number' }, baseVersion: 4 },
- },
+describe('column kind translation', () => {
+ it('qualifies relation targets with the owning database', () => {
+ expect(opColumnKind('db', { type: 'relation', table: 'people' })).toEqual({
+ type: 'relation',
+ database: 'db',
+ table: 'people',
});
-
- expect(changed.isOk()).toBe(true);
- expect(storage.applyDatabaseOps).toHaveBeenCalledExactlyOnceWith(
- 'db',
- [
- {
- kind: 'column',
- table: 'tasks',
- column: 'price',
- change: { kind: 'change_type', to: { type: 'number' } },
- },
- ],
- { tasks: 4 }
- );
- const [[, [op]]] = storage.applyDatabaseOps.mock.calls;
- expect(op).not.toHaveProperty('clearInvalid');
- });
-
- it('names this database as a relation target', async () => {
- storage.applyDatabaseOps.mockReturnValue(
- okAsync([
- {
- kind: 'column',
- table: 'tasks',
- column: 'owner',
- tableVersion: 5,
- change: { kind: 'type_changed' },
- },
- ])
- );
-
- await updateDatabaseColumns({
- databaseId: 'db',
- tableId: 'tasks',
- baseVersion: 4,
- mutation: {
- kind: 'type',
- columnId: 'owner',
- change: { to: { type: 'relation', table: 'people' } },
- },
- });
-
- expect(storage.applyDatabaseOps).toHaveBeenCalledExactlyOnceWith(
- 'db',
- [
- {
- kind: 'column',
- table: 'tasks',
- column: 'owner',
- change: {
- kind: 'change_type',
- to: { type: 'relation', database: 'db', table: 'people' },
- },
- },
- ],
- { tasks: 4 }
- );
- });
-
- it('deletes a column against the table version', async () => {
- storage.applyDatabaseOps.mockReturnValue(
- okAsync([
- {
- kind: 'column',
- table: 'tasks',
- column: 'notes',
- tableVersion: 8,
- change: { kind: 'deleted' },
- },
- ])
- );
-
- await updateDatabaseColumns({
- databaseId: 'db',
- tableId: 'tasks',
- baseVersion: 7,
- mutation: { kind: 'delete', columnId: 'notes' },
- });
-
- expect(storage.applyDatabaseOps).toHaveBeenCalledExactlyOnceWith(
- 'db',
- [
- {
- kind: 'column',
- table: 'tasks',
- column: 'notes',
- change: { kind: 'delete' },
- },
- ],
- { tasks: 7 }
- );
- });
-
- it('reorders columns against the table version', async () => {
- storage.applyDatabaseOps.mockReturnValue(
- okAsync([
- {
- kind: 'table',
- table: 'tasks',
- tableVersion: 9,
- change: { kind: 'columns_reordered' },
- },
- ])
- );
-
- await updateDatabaseColumns({
- databaseId: 'db',
- tableId: 'tasks',
- baseVersion: 8,
- mutation: { kind: 'order', columnIds: ['title', 'status'] },
- });
-
- expect(storage.applyDatabaseOps).toHaveBeenCalledExactlyOnceWith(
- 'db',
- [
- {
- kind: 'table',
- table: 'tasks',
- change: { kind: 'reorder_columns', order: ['title', 'status'] },
- },
- ],
- { tasks: 8 }
- );
});
});
diff --git a/apps/web/src/features/block-database/queries/column-schema.ts b/apps/web/src/features/block-database/queries/column-schema.ts
index ada539979d..debb8c8836 100644
--- a/apps/web/src/features/block-database/queries/column-schema.ts
+++ b/apps/web/src/features/block-database/queries/column-schema.ts
@@ -1,22 +1,5 @@
-import type {
- DatabaseOp,
- OpColumnKind,
-} from '@core/database-sql/generated/types';
-import { queryClient } from '@queries/client';
-import { applyDatabaseOps } from '@queries/storage/databases';
-import { databasesKeys } from '@queries/storage/keys';
-import { ResultAsync } from 'neverthrow';
-import { match } from 'ts-pattern';
-import type {
- DatabaseColumnKind,
- DatabaseColumnTypeChange,
- DatabaseSchemaChange,
-} from '../core/column-schema';
-
-type ColumnMutation =
- | { kind: 'type'; columnId: string; change: DatabaseColumnTypeChange }
- | { kind: 'delete'; columnId: string }
- | { kind: 'order'; columnIds: string[] };
+import type { OpColumnKind } from '@core/database-sql/generated/types';
+import type { DatabaseColumnKind } from '../core/column-schema';
/** The op's spelling of a kind; a relation's rows live in this database. */
export function opColumnKind(
@@ -27,52 +10,3 @@ export function opColumnKind(
? { type: 'relation', database: databaseId, table: kind.table }
: kind;
}
-
-/**
- * Refused if the table moved past `baseVersion`; schema and rows refresh
- * whatever the outcome, and a destructive change is never replayed.
- */
-export function updateDatabaseColumns(params: {
- databaseId: string;
- tableId: string;
- baseVersion: number;
- mutation: ColumnMutation;
-}): DatabaseSchemaChange {
- const table = params.tableId;
- const op = match(params.mutation)
- .returnType<DatabaseOp>()
- .with({ kind: 'type' }, ({ columnId, change }) => ({
- kind: 'column',
- table,
- column: columnId,
- change: {
- kind: 'change_type',
- to: opColumnKind(params.databaseId, change.to),
- },
- }))
- .with({ kind: 'delete' }, ({ columnId }) => ({
- kind: 'column',
- table,
- column: columnId,
- change: { kind: 'delete' },
- }))
- .with({ kind: 'order' }, ({ columnIds }) => ({
- kind: 'table',
- table,
- change: { kind: 'reorder_columns', order: columnIds },
- }))
- .exhaustive();
- const applied = applyDatabaseOps(params.databaseId, [op], {
- [table]: params.baseVersion,
- });
- // Open reads rerun against the refreshed schema, whatever the outcome.
- const refreshed = async () => {
- const result = await applied;
- await queryClient.invalidateQueries(
- { queryKey: databasesKeys.detail(params.databaseId).queryKey },
- { throwOnError: false }
- );
- return result.map(() => undefined);
- };
- return new ResultAsync(refreshed());
-}
diff --git a/apps/web/src/features/block-database/queries/columns.test.ts b/apps/web/src/features/block-database/queries/columns.test.ts
index 46f4fa858a..445d259991 100644
--- a/apps/web/src/features/block-database/queries/columns.test.ts
+++ b/apps/web/src/features/block-database/queries/columns.test.ts
@@ -72,7 +72,6 @@ describe('adding columns and options', () => {
];
expect(new Set(ids).size).toBe(3);
expect(created._unsafeUnwrap()).toBe(op.column);
- expect(storage.invalidateDatabase).toHaveBeenCalledExactlyOnceWith('db');
});
it('adds options to a column under minted ids and reads the schema again', async () => {
@@ -107,7 +106,6 @@ describe('adding columns and options', () => {
},
},
]);
- expect(storage.invalidateDatabase).toHaveBeenCalledExactlyOnceWith('db');
});
it('converts into a new column after the original in one batch, against the version the conversion read', async () => {
@@ -219,7 +217,6 @@ describe('adding columns and options', () => {
);
expect(new Set([created.column, high.id, low.id]).size).toBe(3);
expect(converted._unsafeUnwrap()).toBe(created.column);
- expect(storage.invalidateDatabase).toHaveBeenCalledExactlyOnceWith('db');
});
it('creates only the new column when no value converts', async () => {
diff --git a/apps/web/src/features/block-database/queries/columns.ts b/apps/web/src/features/block-database/queries/columns.ts
index b1d3259ce1..01a7b2da40 100644
--- a/apps/web/src/features/block-database/queries/columns.ts
+++ b/apps/web/src/features/block-database/queries/columns.ts
@@ -3,10 +3,7 @@ import type {
DatabaseOp,
OpColumnKind,
} from '@core/database-sql/generated/types';
-import {
- applyDatabaseOps,
- invalidateDatabase,
-} from '@queries/storage/databases';
+import { applyDatabaseOps } from '@queries/storage/databases';
import { storageServiceClient } from '@service-storage/client';
import { v7 as uuidv7 } from 'uuid';
import type {
@@ -47,10 +44,7 @@ export function createDatabaseColumn(params: {
},
},
},
- ]).map(async () => {
- await invalidateDatabase(params.databaseId);
- return id;
- });
+ ]).map(() => id);
}
/** Add select options to a column; labels it already has are left out. */
@@ -70,9 +64,7 @@ export function addDatabaseColumnOptions(params: {
options: params.labels.map((label) => ({ id: uuidv7(), label })),
},
},
- ]).map(async () => {
- await invalidateDatabase(params.databaseId);
- });
+ ]).map(() => undefined);
}
/**
@@ -137,9 +129,6 @@ export function convertDatabaseColumn(params: {
});
return applyDatabaseOps(params.databaseId, ops, {
[table]: conversion.tableVersion,
- }).map(async () => {
- await invalidateDatabase(params.databaseId);
- return id;
- });
+ }).map(() => id);
});
}
diff --git a/apps/web/src/features/block-database/queries/delete-table.ts b/apps/web/src/features/block-database/queries/delete-table.ts
deleted file mode 100644
index 1fdcd62bb6..0000000000
--- a/apps/web/src/features/block-database/queries/delete-table.ts
+++ /dev/null
@@ -1,34 +0,0 @@
-import { queryClient } from '@queries/client';
-import { applyDatabaseOps } from '@queries/storage/databases';
-import { databasesKeys } from '@queries/storage/keys';
-import type { DatabaseDetail } from '@service-storage/generated/schemas/databaseDetail';
-import type { DatabaseSchemaChange } from '../core/column-schema';
-
-/** Delete a table with its columns, rows and views; the service keeps a database's last table. */
-export function deleteDatabaseTable(params: {
- databaseId: string;
- tableId: string;
-}): DatabaseSchemaChange {
- return applyDatabaseOps(params.databaseId, [
- { kind: 'table', table: params.tableId, change: { kind: 'delete' } },
- ]).map(async () => {
- const key = databasesKeys.detail(params.databaseId).queryKey;
- // An older read must not bring the deleted tab back.
- await queryClient.cancelQueries({ queryKey: key });
- queryClient.setQueryData(
- key,
- (previous: DatabaseDetail | undefined) =>
- previous && {
- ...previous,
- tables: previous.tables.filter(
- (entry) => entry.table.id !== params.tableId
- ),
- }
- );
- // Relations to the table went with it, so every catalog reads again.
- await queryClient.invalidateQueries(
- { queryKey: databasesKeys.detail._def },
- { throwOnError: false }
- );
- });
-}
diff --git a/apps/web/src/features/block-database/queries/detail-cache.ts b/apps/web/src/features/block-database/queries/detail-cache.ts
index 3e4f965e58..9a8b144c94 100644
--- a/apps/web/src/features/block-database/queries/detail-cache.ts
+++ b/apps/web/src/features/block-database/queries/detail-cache.ts
@@ -1,16 +1,13 @@
/** The cached database detail, patched as schema, option and view ops are sent and read again when one is refused. */
import type { DatabaseOp } from '@core/database-sql/generated/types';
import { queryClient } from '@queries/client';
-import {
- applyDatabaseOps,
- applyDatabaseTableVersions,
- invalidateDatabase,
-} from '@queries/storage/databases';
+import { applyDatabaseOps } from '@queries/storage/databases';
import { databasesKeys } from '@queries/storage/keys';
import type { ColumnDetail } from '@service-storage/generated/schemas/columnDetail';
import type { DatabaseDetail } from '@service-storage/generated/schemas/databaseDetail';
import type { DatabaseView } from '@service-storage/generated/schemas/databaseView';
import type { OpResult } from '@service-storage/generated/schemas/opResult';
+import type { TableDetail } from '@service-storage/generated/schemas/tableDetail';
import type { QueryClient } from '@tanstack/solid-query';
import { errAsync, okAsync, type ResultAsync } from 'neverthrow';
import type { DatabaseOpFailure } from '../core/write-failure';
@@ -23,22 +20,43 @@ import type { DatabaseOpFailure } from '../core/write-failure';
export async function patchDetail(
databaseId: string,
change: (detail: DatabaseDetail) => DatabaseDetail
-): Promise<void> {
+): Promise<() => void> {
const queryKey = databasesKeys.detail(databaseId).queryKey;
await queryClient.cancelQueries({ queryKey, exact: true });
- queryClient.setQueryData(
+ const previous = queryClient.getQueryData<DatabaseDetail>(queryKey);
+ const optimistic = queryClient.setQueryData<DatabaseDetail>(
queryKey,
- (previous: DatabaseDetail | undefined) => previous && change(previous)
+ (current) => current && change(current)
);
+ return () => {
+ // Never restore a snapshot over a newer edit or server read.
+ if (previous && queryClient.getQueryData(queryKey) === optimistic)
+ queryClient.setQueryData(queryKey, previous);
+ void queryClient.invalidateQueries({ queryKey });
+ };
+}
+
+/** Optimistically change one table before sending its operation. */
+export function patchTable(
+ databaseId: string,
+ tableId: string,
+ change: (table: TableDetail) => TableDetail
+): Promise<() => void> {
+ return patchDetail(databaseId, (detail) => ({
+ ...detail,
+ tables: detail.tables.map((table) =>
+ table.table.id === tableId ? change(table) : table
+ ),
+ }));
}
/** Change one table's cached views. */
-export function patchViews(
+export async function patchViews(
databaseId: string,
tableId: string,
change: (views: DatabaseView[]) => DatabaseView[]
): Promise<void> {
- return patchDetail(databaseId, (detail) => ({
+ await patchDetail(databaseId, (detail) => ({
...detail,
tables: detail.tables.map((table) =>
table.table.id === tableId
@@ -133,7 +151,6 @@ export function applyOp<
Change extends ResultChanges[Kind],
>(
databaseId: string,
- tableId: string,
op: DatabaseOp,
expected: { kind: Kind; change: Change }
): ResultAsync<ResultOf<Kind, Change>, DatabaseOpFailure> {
@@ -145,14 +162,6 @@ export function applyOp<
return errAsync<ResultOf<Kind, Change>, DatabaseOpFailure>({
kind: 'unexpected-result',
});
- if (result.tableVersion !== undefined)
- applyDatabaseTableVersions(databaseId, {
- [tableId]: result.tableVersion,
- });
return okAsync(result);
- })
- .orElse((failure) => {
- void invalidateDatabase(databaseId);
- return errAsync(failure);
});
}
diff --git a/apps/web/src/features/block-database/queries/options.ts b/apps/web/src/features/block-database/queries/options.ts
index e34b0e8493..522464d0d1 100644
--- a/apps/web/src/features/block-database/queries/options.ts
+++ b/apps/web/src/features/block-database/queries/options.ts
@@ -28,11 +28,11 @@ function definitionOf(
}
/** Every column bound to the target's definition, with its options changed. */
-function patchOptions(
+async function patchOptions(
target: OptionTarget,
change: (options: PropertyOption[]) => PropertyOption[]
): Promise<void> {
- return patchDetail(target.databaseId, (detail) => {
+ await patchDetail(target.databaseId, (detail) => {
const definition = definitionOf(detail, target);
return {
...detail,
@@ -111,7 +111,6 @@ export function updateDatabaseOption(
.andThen(() =>
applyOp(
target.databaseId,
- target.tableId,
{
kind: 'column',
table: target.tableId,
@@ -136,7 +135,6 @@ export function deleteDatabaseOption(
.andThen(() =>
applyOp(
target.databaseId,
- target.tableId,
{
kind: 'column',
table: target.tableId,
diff --git a/apps/web/src/features/block-database/queries/rename-column.test.ts b/apps/web/src/features/block-database/queries/rename-column.test.ts
deleted file mode 100644
index 1f50003658..0000000000
--- a/apps/web/src/features/block-database/queries/rename-column.test.ts
+++ /dev/null
@@ -1,239 +0,0 @@
-import { queryClient } from '@queries/client';
-import { databasesKeys } from '@queries/storage/keys';
-import type { DatabaseOpsError } from '@service-storage/databases';
-import type { ApplyOpsResponse } from '@service-storage/generated/schemas/applyOpsResponse';
-import type { ColumnDetail } from '@service-storage/generated/schemas/columnDetail';
-import type { DatabaseDetail } from '@service-storage/generated/schemas/databaseDetail';
-import { QueryObserver } from '@tanstack/solid-query';
-import {
- err,
- errAsync,
- ok,
- okAsync,
- type Result,
- ResultAsync,
-} from 'neverthrow';
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
-import { toQuerySchema } from '../../database-query/queries/query-source';
-import { renameDatabaseColumn } from './rename-column';
-import { toViewColumn } from './table-rows';
-
-const transport = vi.hoisted(() => ({ applyOps: vi.fn() }));
-vi.mock('@service-storage/client', () => ({
- storageServiceClient: { databases: transport },
-}));
-vi.mock('@queries/client', async () => {
- const { QueryClient } = await import('@tanstack/solid-query');
- return {
- queryClient: new QueryClient({
- defaultOptions: { queries: { retry: false } },
- }),
- };
-});
-const column: ColumnDetail = {
- shared_outside_database: false,
- column: {
- id: 'title',
- table_id: 'tasks',
- property_definition_id: 'definition',
- position: 'a',
- config: null,
- display_name: null,
- infer_type: false,
- },
- sql_name: 'name',
- writable: true,
- definition: {
- definition: {
- id: 'definition',
- owner: { scope: 'database', database_id: 'db' },
- display_name: 'Name',
- data_type: 'STRING',
- is_multi_select: false,
- specific_entity_type: null,
- created_at: '',
- updated_at: '',
- is_system: false,
- is_metadata: false,
- },
- property_options: [],
- },
-};
-const detail: DatabaseDetail = {
- database: {
- id: 'db',
- name: 'Planning',
- owner_id: 'owner',
- created_at: '',
- trashed_at: null,
- },
- grant: 'owner',
- tables: [
- {
- views: [],
- table: {
- id: 'tasks',
- database_id: 'db',
- name: 'Tasks',
- position: 'a',
- version: 5,
- },
- sql_name: 'tasks',
- columns: [column],
- },
- ],
-};
-const answer: ApplyOpsResponse = {
- results: [
- {
- kind: 'column',
- table: 'tasks',
- column: 'title',
- tableVersion: 6,
- change: { kind: 'renamed' },
- },
- ],
- changes: [],
-};
-const params = {
- databaseId: 'db',
- tableId: 'tasks',
- columnId: 'title',
- name: 'Task',
- previousName: 'Name',
-};
-const key = databasesKeys.detail('db').queryKey;
-beforeEach(() => {
- vi.resetAllMocks();
- queryClient.setQueryData(key, detail);
- transport.applyOps.mockImplementation(() => okAsync(answer));
-});
-afterEach(() => queryClient.clear());
-
-describe('column rename cache and labels', () => {
- it('updates only the placement label and version, preserves SQL, and supplies the new label to grid and AI', async () => {
- const otherKey = databasesKeys.detail('other').queryKey;
- queryClient.setQueryData(otherKey, detail);
- expect(await renameDatabaseColumn(params)).toEqual(ok(undefined));
- expect(transport.applyOps).toHaveBeenCalledExactlyOnceWith({
- id: 'db',
- request: {
- ops: [
- {
- kind: 'column',
- table: 'tasks',
- column: 'title',
- change: { kind: 'rename', name: 'Task', previousName: 'Name' },
- },
- ],
- },
- });
- const updated = queryClient.getQueryData<DatabaseDetail>(key)!;
- expect(updated.tables[0].table.version).toBe(6);
- expect(updated.tables[0].columns[0]).toEqual({
- ...column,
- column: { ...column.column, display_name: 'Task' },
- });
- expect(toViewColumn(updated.tables[0].columns[0]).name).toBe('Task');
- expect(toQuerySchema(updated).tables[0].columns[0]).toMatchObject({
- name: 'Task',
- sqlName: 'name',
- });
- expect(toQuerySchema(detail).tables[0].columns[0]).toMatchObject({
- name: 'Name',
- sqlName: 'name',
- });
- expect(queryClient.getQueryState(key)?.isInvalidated).toBe(true);
- expect(queryClient.getQueryState(otherKey)?.isInvalidated).toBe(false);
- });
- it('retains the server validation reason without changing a failed rename in cache', async () => {
- const refused: DatabaseOpsError = {
- code: 'INVALID_OP',
- message: 'A column with this name already exists. Choose another name.',
- refusal: {
- message: 'A column with this name already exists. Choose another name.',
- op: 0,
- row: null,
- column: 'title',
- taken: null,
- },
- };
- transport.applyOps.mockImplementation(() => errAsync([refused]));
- expect(await renameDatabaseColumn(params)).toEqual(err(refused));
- expect(queryClient.getQueryData(key)).toEqual(detail);
- expect(queryClient.getQueryState(key)?.isInvalidated).toBe(true);
- });
- it('keeps a committed rename successful when schema refresh fails', async () => {
- const refresh = vi.fn(async (): Promise<DatabaseDetail> => {
- throw new Error('Offline');
- });
- const observer = new QueryObserver(queryClient, {
- queryKey: key,
- queryFn: refresh,
- staleTime: Infinity,
- retry: false,
- });
- const unsubscribe = observer.subscribe(() => {});
- try {
- expect(await renameDatabaseColumn(params)).toEqual(ok(undefined));
- expect(refresh).toHaveBeenCalledTimes(1);
- expect(
- queryClient.getQueryData<DatabaseDetail>(key)?.tables[0].columns[0]
- .column.display_name
- ).toBe('Task');
- expect(queryClient.getQueryState(key)?.status).toBe('error');
- } finally {
- unsubscribe();
- }
- });
- it('does not overwrite a newer label/version with a delayed rename response', async () => {
- let resolve!: (value: Result<ApplyOpsResponse, never>) => void;
- transport.applyOps.mockImplementation(
- () =>
- new ResultAsync(
- new Promise<Result<ApplyOpsResponse, never>>((complete) => {
- resolve = complete;
- })
- )
- );
- const pending = renameDatabaseColumn(params);
- const newer = {
- ...detail,
- tables: [
- {
- ...detail.tables[0],
- table: { ...detail.tables[0].table, version: 7 },
- columns: [
- {
- ...column,
- column: { ...column.column, display_name: 'Work item' },
- },
- ],
- },
- ],
- };
- queryClient.setQueryData(key, newer);
- resolve(ok(answer));
- await pending;
- expect(queryClient.getQueryData(key)).toEqual(newer);
- });
- it('cancels an older inactive schema fetch so it cannot undo the committed label', async () => {
- let resolve!: (value: DatabaseDetail) => void;
- const fetched = queryClient.fetchQuery({
- queryKey: key,
- queryFn: () =>
- new Promise<DatabaseDetail>((complete) => {
- resolve = complete;
- }),
- staleTime: 0,
- });
- const settled = Promise.allSettled([fetched]);
- await renameDatabaseColumn(params);
- resolve(detail);
- await settled;
- expect(
- queryClient.getQueryData<DatabaseDetail>(key)?.tables[0].columns[0].column
- .display_name
- ).toBe('Task');
- });
-});
diff --git a/apps/web/src/features/block-database/queries/rename-column.ts b/apps/web/src/features/block-database/queries/rename-column.ts
deleted file mode 100644
index ffff4f3d4e..0000000000
--- a/apps/web/src/features/block-database/queries/rename-column.ts
+++ /dev/null
@@ -1,53 +0,0 @@
-import { queryClient } from '@queries/client';
-import { applyDatabaseOps } from '@queries/storage/databases';
-import { databasesKeys } from '@queries/storage/keys';
-import type { DatabaseSchemaChange } from '../core/column-schema';
-import { isResult, patchTableColumn } from './detail-cache';
-
-/** Change the placement label while preserving column IDs and stored SQL. */
-export function renameDatabaseColumn(params: {
- databaseId: string;
- tableId: string;
- columnId: string;
- name: string;
- previousName: string;
-}): DatabaseSchemaChange {
- const queryKey = databasesKeys.detail(params.databaseId).queryKey;
- return applyDatabaseOps(params.databaseId, [
- {
- kind: 'column',
- table: params.tableId,
- column: params.columnId,
- change: {
- kind: 'rename',
- name: params.name,
- previousName: params.previousName,
- },
- },
- ])
- .mapErr((error) => {
- void queryClient.invalidateQueries({ queryKey });
- return error;
- })
- .map(async ([result]) => {
- // A newer version may contain another rename, so a delayed response
- // must not replace it.
- if (isResult(result, 'column', 'renamed'))
- await patchTableColumn(queryClient, {
- databaseId: params.databaseId,
- tableId: params.tableId,
- columnId: params.columnId,
- tableVersion: result.tableVersion,
- change: (column) => ({
- ...column,
- column: { ...column.column, display_name: params.name },
- }),
- });
- // Open reads rerun against the refreshed schema. The refresh may not report
- // an already-committed rename as a failed write.
- await queryClient.invalidateQueries(
- { queryKey },
- { throwOnError: false }
- );
- });
-}
diff --git a/apps/web/src/features/block-database/queries/rename-table.test.ts b/apps/web/src/features/block-database/queries/rename-table.test.ts
deleted file mode 100644
index 6fcef6c191..0000000000
--- a/apps/web/src/features/block-database/queries/rename-table.test.ts
+++ /dev/null
@@ -1,194 +0,0 @@
-import { queryClient } from '@queries/client';
-import { databasesKeys } from '@queries/storage/keys';
-import type { ApplyOpsResponse } from '@service-storage/generated/schemas/applyOpsResponse';
-import type { DatabaseDetail } from '@service-storage/generated/schemas/databaseDetail';
-import type { Table } from '@service-storage/generated/schemas/table';
-import { QueryObserver } from '@tanstack/solid-query';
-import { errAsync, ok, okAsync, type Result, ResultAsync } from 'neverthrow';
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
-import { tableRenameMessage } from '../core/column-schema';
-import { renameDatabaseTable } from './rename-table';
-
-const transport = vi.hoisted(() => ({ applyOps: vi.fn() }));
-vi.mock('@service-storage/client', () => ({
- storageServiceClient: { databases: transport },
-}));
-vi.mock('@queries/client', async () => {
- const { QueryClient } = await import('@tanstack/solid-query');
- return {
- queryClient: new QueryClient({
- defaultOptions: { queries: { retry: false } },
- }),
- };
-});
-
-const original: Table = {
- id: 'guests',
- database_id: 'db',
- name: 'Guests',
- position: 'a',
- version: 5,
-};
-const renamed: Table = { ...original, name: 'Attendees', version: 6 };
-const answer: ApplyOpsResponse = {
- results: [
- {
- kind: 'table',
- table: 'guests',
- tableVersion: 6,
- change: { kind: 'renamed' },
- },
- ],
- changes: [],
-};
-const detail: DatabaseDetail = {
- database: {
- id: 'db',
- name: 'Planning',
- owner_id: 'owner',
- created_at: '',
- trashed_at: null,
- },
- grant: 'owner',
- tables: [
- {
- views: [],
- table: original,
- sql_name: 'guests',
- columns: [],
- },
- {
- views: [],
- table: { ...original, id: 'other', name: 'Other' },
- sql_name: 'other',
- columns: [],
- },
- ],
-};
-const parameters = {
- databaseId: 'db',
- tableId: 'guests',
- name: 'Attendees',
- previousName: 'Guests',
-};
-const key = databasesKeys.detail('db').queryKey;
-
-beforeEach(() => {
- vi.resetAllMocks();
- queryClient.setQueryData(key, detail);
- transport.applyOps.mockImplementation(() => okAsync(answer));
-});
-afterEach(() => queryClient.clear());
-
-describe('table rename cache', () => {
- it('passes compare-and-swap identity, updates the named table, and invalidates other catalog schemas', async () => {
- const otherKey = databasesKeys.detail('other-db').queryKey;
- queryClient.setQueryData(otherKey, {
- ...detail,
- database: { ...detail.database, id: 'other-db' },
- });
- expect(await renameDatabaseTable(parameters)).toEqual(ok(undefined));
- expect(transport.applyOps).toHaveBeenCalledExactlyOnceWith({
- id: 'db',
- request: {
- ops: [
- {
- kind: 'table',
- table: 'guests',
- change: {
- kind: 'rename',
- name: 'Attendees',
- previousName: 'Guests',
- },
- },
- ],
- },
- });
- const updated = queryClient.getQueryData<DatabaseDetail>(key)!;
- expect(updated.tables[0]).toEqual({ ...detail.tables[0], table: renamed });
- expect(updated.tables[1]).toEqual(detail.tables[1]);
- expect(queryClient.getQueryState(key)?.isInvalidated).toBe(true);
- expect(queryClient.getQueryState(otherKey)?.isInvalidated).toBe(true);
- });
-
- it('preserves the cache after a rejected rename and refreshes its database for recovery', async () => {
- const otherKey = databasesKeys.detail('other-db').queryKey;
- queryClient.setQueryData(otherKey, detail);
- transport.applyOps.mockImplementation(() =>
- errAsync([{ code: 'HTTP_ERROR', message: 'Name changed', refusal: null }])
- );
- const result = await renameDatabaseTable(parameters);
- expect(result.isErr() && tableRenameMessage(result.error)).toContain(
- 'reopen Rename table'
- );
- expect(queryClient.getQueryData(key)).toEqual(detail);
- expect(queryClient.getQueryState(key)?.isInvalidated).toBe(true);
- expect(queryClient.getQueryState(otherKey)?.isInvalidated).toBe(false);
- });
-
- it('keeps a committed rename successful when the follow-up schema refresh fails', async () => {
- const refresh = vi.fn(async (): Promise<DatabaseDetail> => {
- throw new Error('Connection lost');
- });
- const observer = new QueryObserver(queryClient, {
- queryKey: key,
- queryFn: refresh,
- staleTime: Infinity,
- retry: false,
- });
- const unsubscribe = observer.subscribe(() => {});
- try {
- expect(await renameDatabaseTable(parameters)).toEqual(ok(undefined));
- expect(refresh).toHaveBeenCalledTimes(1);
- expect(
- queryClient.getQueryData<DatabaseDetail>(key)?.tables[0].table
- ).toEqual(renamed);
- expect(queryClient.getQueryState(key)?.status).toBe('error');
- } finally {
- unsubscribe();
- }
- });
-
- it('does not replace a newer cached table with a delayed rename acknowledgment', async () => {
- let complete!: (value: Result<ApplyOpsResponse, never>) => void;
- transport.applyOps.mockImplementation(
- () =>
- new ResultAsync(
- new Promise<Result<ApplyOpsResponse, never>>((resolve) => {
- complete = resolve;
- })
- )
- );
- const pending = renameDatabaseTable(parameters);
- const newer = { ...renamed, name: 'Team attendees', version: 7 };
- queryClient.setQueryData(key, {
- ...detail,
- tables: [{ ...detail.tables[0], table: newer }, detail.tables[1]],
- });
- complete(ok(answer));
- await pending;
- expect(
- queryClient.getQueryData<DatabaseDetail>(key)?.tables[0].table
- ).toEqual(newer);
- });
-
- it('does not let an older in-flight schema overwrite a successful rename after navigation', async () => {
- let complete!: (value: DatabaseDetail) => void;
- const previousFetch = queryClient
- .fetchQuery({
- queryKey: key,
- queryFn: () =>
- new Promise<DatabaseDetail>((resolve) => {
- complete = resolve;
- }),
- staleTime: 0,
- })
- .catch(() => undefined);
- await renameDatabaseTable(parameters);
- complete(detail);
- await previousFetch;
- expect(
- queryClient.getQueryData<DatabaseDetail>(key)?.tables[0].table
- ).toEqual(renamed);
- });
-});
diff --git a/apps/web/src/features/block-database/queries/rename-table.ts b/apps/web/src/features/block-database/queries/rename-table.ts
deleted file mode 100644
index 6f6347d554..0000000000
--- a/apps/web/src/features/block-database/queries/rename-table.ts
+++ /dev/null
@@ -1,63 +0,0 @@
-import { queryClient } from '@queries/client';
-import {
- applyDatabaseOps,
- invalidateDatabase,
-} from '@queries/storage/databases';
-import { databasesKeys } from '@queries/storage/keys';
-import type { DatabaseDetail } from '@service-storage/generated/schemas/databaseDetail';
-import type { DatabaseSchemaChange } from '../core/column-schema';
-import { isResult } from './detail-cache';
-
-export function renameDatabaseTable(params: {
- databaseId: string;
- tableId: string;
- name: string;
- previousName: string;
-}): DatabaseSchemaChange {
- return applyDatabaseOps(params.databaseId, [
- {
- kind: 'table',
- table: params.tableId,
- change: {
- kind: 'rename',
- name: params.name,
- previousName: params.previousName,
- },
- },
- ])
- .mapErr((error) => {
- void invalidateDatabase(params.databaseId);
- return error;
- })
- .map(async ([result]) => {
- // An older request must not overwrite the committed name after navigation.
- await queryClient.cancelQueries({ queryKey: databasesKeys.detail._def });
- const version = isResult(result, 'table', 'renamed')
- ? result.tableVersion
- : undefined;
- if (version !== undefined) {
- queryClient.setQueryData(
- databasesKeys.detail(params.databaseId).queryKey,
- (previous: DatabaseDetail | undefined) =>
- previous && {
- ...previous,
- tables: previous.tables.map((entry) =>
- entry.table.id === params.tableId &&
- entry.table.version <= version
- ? {
- ...entry,
- table: { ...entry.table, name: params.name, version },
- }
- : entry
- ),
- }
- );
- }
- // SQL names can change throughout the catalog; open reads rerun against it.
- // A refresh failure does not turn the committed rename into a failed write.
- await queryClient.invalidateQueries(
- { queryKey: databasesKeys.detail._def },
- { throwOnError: false }
- );
- });
-}
diff --git a/apps/web/src/features/block-database/queries/reorder-tables.test.ts b/apps/web/src/features/block-database/queries/reorder-tables.test.ts
index b1209bf8be..d8d02c8318 100644
--- a/apps/web/src/features/block-database/queries/reorder-tables.test.ts
+++ b/apps/web/src/features/block-database/queries/reorder-tables.test.ts
@@ -9,9 +9,18 @@ import { reorderDatabaseTables } from './reorder-tables';
const storage = vi.hoisted(() => ({
applyDatabaseOps: vi.fn(),
- invalidateDatabase: vi.fn(),
}));
-vi.mock('@queries/storage/databases', () => storage);
+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 {
@@ -106,7 +115,7 @@ describe('reordering tables', () => {
.getQueryData<DatabaseDetail>(key)
?.tables.map((entry) => entry.table.name)
).toEqual(['Guests', 'Venues']);
- expect(storage.invalidateDatabase).toHaveBeenCalledExactlyOnceWith('db');
+ expect(queryClient.getQueryState(key)?.isInvalidated).toBe(true);
});
it('takes each table’s committed version from the answer', async () => {
@@ -142,6 +151,6 @@ describe('reordering tables', () => {
['venues', 2],
['invites', 4],
]);
- expect(storage.invalidateDatabase).not.toHaveBeenCalled();
+ expect(queryClient.getQueryState(key)?.isInvalidated).toBe(true);
});
});
diff --git a/apps/web/src/features/block-database/queries/reorder-tables.ts b/apps/web/src/features/block-database/queries/reorder-tables.ts
index bd79d2f876..d1bc66f674 100644
--- a/apps/web/src/features/block-database/queries/reorder-tables.ts
+++ b/apps/web/src/features/block-database/queries/reorder-tables.ts
@@ -5,7 +5,6 @@ import {
} from '@queries/storage/databases';
import { databasesKeys } from '@queries/storage/keys';
import type { DatabaseDetail } from '@service-storage/generated/schemas/databaseDetail';
-import type { VersionedTable } from '@service-storage/generated/schemas/versionedTable';
import { ResultAsync } from 'neverthrow';
import type { DatabaseSchemaChange } from '../core/column-schema';
import { createKeyedSerializer } from '../core/keyed-serializer';
@@ -81,32 +80,11 @@ export function reorderDatabaseTables(params: {
? withTableOrder(current, previousOrder)
: current
);
+ // setQueryData during rollback marks the cache fresh; reconcile after it.
void invalidateDatabase(params.databaseId);
return result.map(() => undefined);
}
- const [reordered] = result.value;
- if (reordered?.kind === 'reorder_tables') commit(key, reordered.tables);
return result.map(() => undefined);
};
return new ResultAsync(reorder());
}
-
-/** Each table's committed version; a cached table already past it keeps its own. */
-function commit(key: readonly unknown[], tables: VersionedTable[]) {
- const committed = new Map(
- tables.map(({ table, version }) => [table, version])
- );
- queryClient.setQueryData(key, (current: DatabaseDetail | undefined) =>
- current
- ? {
- ...current,
- tables: current.tables.map((entry) => {
- const version = committed.get(entry.table.id);
- return version !== undefined && entry.table.version <= version
- ? { ...entry, table: { ...entry.table, version } }
- : entry;
- }),
- }
- : current
- );
-}
diff --git a/apps/web/src/features/block-database/queries/table-rows.test.tsx b/apps/web/src/features/block-database/queries/table-rows.test.tsx
index 795feb48d4..dd58391a3c 100644
--- a/apps/web/src/features/block-database/queries/table-rows.test.tsx
+++ b/apps/web/src/features/block-database/queries/table-rows.test.tsx
@@ -10,6 +10,7 @@ import type { CacheHost } from '@graphql-cache/host/types';
import { queryClient } from '@queries/client';
import type { DatabaseSqlQueryCapabilities } from '@queries/database-sql/create-database-sql-query';
import {
+ applyDatabaseOps,
applyDatabaseTableVersions,
onDatabaseBatchCommitted,
onDatabaseTableAdvanced,
@@ -34,7 +35,28 @@ import { allRecordsView } from '../core/views';
import { createDraftRows } from '../primitives/draft-rows';
import { createTableController } from '../primitives/table-controller';
import { createDatabaseColumn } from './columns';
-import { renameDatabaseColumn } from './rename-column';
+
+function renameDatabaseColumn(params: {
+ databaseId: string;
+ tableId: string;
+ columnId: string;
+ name: string;
+ previousName: string;
+}) {
+ return applyDatabaseOps(params.databaseId, [
+ {
+ kind: 'column',
+ table: params.tableId,
+ column: params.columnId,
+ change: {
+ kind: 'rename',
+ name: params.name,
+ previousName: params.previousName,
+ },
+ },
+ ]).map(() => undefined);
+}
+
import { createDatabaseRowsSource } from './table-rows';
const transport = vi.hoisted(() => ({
diff --git a/apps/web/src/features/block-database/queries/views.test.ts b/apps/web/src/features/block-database/queries/views.test.ts
index 84a223a758..d3b808ec87 100644
--- a/apps/web/src/features/block-database/queries/views.test.ts
+++ b/apps/web/src/features/block-database/queries/views.test.ts
@@ -212,9 +212,6 @@ describe('reordering a table’s views', () => {
change: { kind: 'reorder_views', order: ['second', 'first'] },
},
]);
- expect(transport.applyDatabaseTableVersions).toHaveBeenCalledWith('db', {
- invites: 4,
- });
expect(cachedViews()).toEqual([
['second', 'Zz'],
['first', 'a0'],
@@ -239,7 +236,6 @@ describe('reordering a table’s views', () => {
const reordered = await reorderDatabaseViews('db', 'invites', ['second']);
expect(reordered.isErr()).toBe(true);
- expect(transport.invalidateDatabase).toHaveBeenCalledExactlyOnceWith('db');
});
});
diff --git a/apps/web/src/features/block-database/queries/views.ts b/apps/web/src/features/block-database/queries/views.ts
index 46aeb53c9a..183e3f16c5 100644
--- a/apps/web/src/features/block-database/queries/views.ts
+++ b/apps/web/src/features/block-database/queries/views.ts
@@ -5,7 +5,6 @@ import { throwOnErr } from '@core/util/result';
import { queryClient } from '@queries/client';
import {
applyDatabaseOps,
- applyDatabaseTableVersions,
invalidateDatabase,
} from '@queries/storage/databases';
import { storageServiceClient } from '@service-storage/client';
@@ -56,7 +55,6 @@ export function createDatabaseView(
return inOrder(viewListKey(tableId), () =>
applyOp(
databaseId,
- tableId,
{
kind: 'view',
table: tableId,
@@ -102,9 +100,6 @@ function applyColumnAndView(
return errAsync<DatabaseView, DatabaseOpFailure>({
kind: 'unexpected-result',
});
- applyDatabaseTableVersions(databaseId, {
- [tableId]: result.tableVersion,
- });
return okAsync(result.change.view);
})
.orElse((failure) => {
@@ -117,7 +112,6 @@ function applyColumnAndView(
? views.map((existing) => (existing.id === view.id ? view : existing))
: [...views, view]
);
- await invalidateDatabase(databaseId);
return view;
});
}
@@ -190,7 +184,6 @@ export function updateDatabaseView(
optimistic.andThen(() =>
applyOp(
view.databaseId,
- view.tableId,
{
kind: 'view',
table: view.tableId,
@@ -229,7 +222,6 @@ export function deleteDatabaseView(
inOrder(view.id, () =>
applyOp(
view.databaseId,
- view.tableId,
{
kind: 'view',
table: view.tableId,
@@ -256,7 +248,6 @@ export function reorderDatabaseViews(
inOrder(viewListKey(tableId), () =>
applyOp(
databaseId,
- tableId,
{
kind: 'table',
table: tableId,
@@ -332,7 +323,6 @@ export function moveDatabaseCard(
return inOrder(view.id, () =>
applyOp(
view.databaseId,
- view.tableId,
{
kind: 'view',
table: view.tableId,
diff --git a/apps/web/src/lib/queries/storage/databases.test.ts b/apps/web/src/lib/queries/storage/databases.test.ts
index 064128df9e..68262b246a 100644
--- a/apps/web/src/lib/queries/storage/databases.test.ts
+++ b/apps/web/src/lib/queries/storage/databases.test.ts
@@ -1,3 +1,4 @@
+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 } from 'neverthrow';
@@ -7,6 +8,7 @@ import {
applyDatabaseTableVersions,
createDatabase,
fetchViewerDatabases,
+ onDatabaseBatchCommitted,
} from './databases';
import { databasesKeys } from './keys';
@@ -312,3 +314,308 @@ describe('reading every viewer database once', () => {
]);
});
});
+
+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('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();
+ }
+});
diff --git a/apps/web/src/lib/queries/storage/databases.ts b/apps/web/src/lib/queries/storage/databases.ts
index a8f229140b..2976770073 100644
--- a/apps/web/src/lib/queries/storage/databases.ts
+++ b/apps/web/src/lib/queries/storage/databases.ts
@@ -181,7 +181,7 @@ export function applyDatabaseOps(
id: databaseId,
request: baseVersions ? { ops, baseVersions } : { ops },
})
- .map((response) => {
+ .map(async (response) => {
const tableVersions = committedTableVersions(
response.results,
response.changes
@@ -193,10 +193,49 @@ export function applyDatabaseOps(
changes: response.changes,
tableVersions,
});
+ applyDatabaseTableVersions(databaseId, tableVersions);
+ // Schema-only creation waits for data callers need to focus or patch views.
+ // A row edit that mints options keeps the write queue moving.
+ const createsColumnData = ops.some(
+ (op) =>
+ op.kind === 'column' &&
+ (op.change.kind === 'create' ||
+ (op.change.kind === 'add_options' &&
+ !ops.some((item) => item.kind === 'rows')))
+ );
+ if (
+ ops.some(
+ (op) =>
+ op.kind === 'column' ||
+ (op.kind === 'table' && op.change.kind !== 'reorder_views') ||
+ op.kind === 'reorder_tables'
+ )
+ ) {
+ const global = ops.some(
+ (op) =>
+ op.kind === 'table' &&
+ ['rename', 'delete'].includes(op.change.kind)
+ );
+ const refresh = queryClient.invalidateQueries(
+ {
+ queryKey: global
+ ? databasesKeys.detail._def
+ : databasesKeys.detail(databaseId).queryKey,
+ refetchType: createsColumnData ? 'all' : 'active',
+ },
+ // A failed read must not report an already committed write as failed.
+ { throwOnError: false }
+ );
+ if (createsColumnData) await refresh;
+ else void refresh;
+ }
return response.results;
})
// A refused batch is one error: the first op the service could not apply.
- .mapErr(([refusal]) => refusal)
+ .mapErr(([refusal]) => {
+ void invalidateDatabase(databaseId);
+ return refusal;
+ })
);
}
diff --git a/docs/AGENT_GUIDE/databases.md b/docs/AGENT_GUIDE/databases.md
index d669dc11e4..22eac10c72 100644
--- a/docs/AGENT_GUIDE/databases.md
+++ b/docs/AGENT_GUIDE/databases.md
@@ -461,3 +461,8 @@ in as the same user: each should show the other tab's selection and name. Moving
or leaving one peer must not overwrite or remove another peer's selection.
Refresh failures emit a `database.rows.read_refresh` span with the database ID,
table ID, and failure kind, plus a `database rows could not be refreshed` log.
+
+Schema edits update their UI optimistically and finish after the write commits;
+they do not wait for the background catalog refresh. A refused edit rolls back
+its optimistic state when no newer cache update has replaced it, then refreshes.
+A slow or failed refresh is not a reason to resend a successful mutation.