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
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.tsxindex 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.tsxindex 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.tsxindex 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.tsxindex 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.tsindex 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.tsindex 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.tsindex 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.tsindex 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.tsdeleted file mode 100644index 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.tsindex 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.tsindex 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.tsdeleted file mode 100644index 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.tsdeleted file mode 100644index 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.tsdeleted file mode 100644index 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.tsdeleted file mode 100644index 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.tsindex 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.tsindex 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.tsxindex 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.tsindex 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.tsindex 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.tsindex 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.tsindex 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.mdindex 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. Movingor 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.