From 07bbfc0779198dd326b99bfd889eeec00f7c95f3 Mon Sep 17 00:00:00 2001 From: Jonas Date: Wed, 18 Nov 2026 10:03:12 +0100 Subject: [PATCH 1/7] fix(sync): clear hasConnectionIssue when the server rejects the session A typo set `hasConnectionIssues` instead of `hasConnectionIssue`. After a connection issue, a push rejected with 403 kept showing "The document could not be loaded" instead of "You've been disconnected from the server". With the flag cleared, the connection issue watcher made the editor editable again 200 ms later, although the rejected session had switched it to read-only. The watcher now only re-enables editing in edit mode. This also keeps documents that were opened read-only from becoming editable after a connection issue. A sync answered after the rejection could set the connection issue flag again and bring back the old message. The status card now shows the disconnected state first. Signed-off-by: Jonas Assisted-by: ClaudeCode:claude-opus-5-5 --- .../session-rejected-offline.spec.ts | 77 +++++++++++++++++++ src/components/CollaborativeEditor.vue | 4 +- .../Editor/DocumentStatus/SyncStatus.vue | 16 ++-- src/tests/components/SyncStatus.spec.js | 7 ++ 4 files changed, 94 insertions(+), 10 deletions(-) create mode 100644 playwright/e2e/synchronize-content/session-rejected-offline.spec.ts diff --git a/playwright/e2e/synchronize-content/session-rejected-offline.spec.ts b/playwright/e2e/synchronize-content/session-rejected-offline.spec.ts new file mode 100644 index 00000000000..b9bb4c02e11 --- /dev/null +++ b/playwright/e2e/synchronize-content/session-rejected-offline.spec.ts @@ -0,0 +1,77 @@ +/** + * SPDX-FileCopyrightText: 2026 Nextcloud GmbH and Nextcloud contributors + * SPDX-License-Identifier: AGPL-3.0-or-later + */ + +import type { Route } from '@playwright/test' + +import { expect, mergeTests } from '@playwright/test' +import { test as editorTest } from '../../support/fixtures/editor.ts' +import { test as uploadFileTest } from '../../support/fixtures/upload-file.ts' + +const test = mergeTests(editorTest, uploadFileTest) + +const PUSH = /\/apps\/text\/session\/\d+\/push$/ +const SESSION_REQUESTS = /\/apps\/text\/session\/\d+\/(sync|push)$/ + +test.beforeEach(async ({ open }) => { + await open() +}) + +test('stays read-only when the session is rejected after a connection issue', async ({ + editor, + page, +}) => { + test.slow() + await page.clock.install() + const status = page.locator('.document-status') + const content = editor.el.locator('.ProseMirror') + await expect(content).toHaveAttribute('contenteditable', 'true') + + // One handler for the whole test, so no request slips through while switching. + let network: 'online' | 'offline' | 'rejected' = 'online' + let releaseSyncs = () => {} + const syncsReleased = new Promise((resolve) => { + releaseSyncs = resolve + }) + await page.route(SESSION_REQUESTS, async (route: Route) => { + if (network === 'online') { + return route.continue() + } + if (network === 'offline') { + return route.abort('internetdisconnected') + } + if (PUSH.test(route.request().url())) { + // Answer like SessionMiddleware does for a session it no longer knows. + return route.fulfill({ status: 403, contentType: 'application/json', body: '[]' }) + } + // Hold the syncs so that only the rejected push changes the state. + await syncsReleased + return route.abort('internetdisconnected') + }) + + network = 'offline' + const failedPush = page.waitForEvent('requestfailed', (request) => PUSH.test(request.url())) + await editor.type('Hello') + // The connection issue only starts counting once the push failed. + await failedPush + const delay = await page.evaluate(() => window.OCP.InitialState.loadState('text', 'offline_readonly_delay') as number) + await page.clock.fastForward(delay * 1000 + 1000) + await expect(status).toContainText('The document could not be loaded.') + await expect(content).toHaveAttribute('contenteditable', 'false') + + network = 'rejected' + // The autosave retries the push, which is rejected. + await page.clock.fastForward(60_000) + await expect(status).toContainText("You've been disconnected from the server.") + // Clearing the connection issue takes effect after 200 ms. + await page.waitForTimeout(1000) + await expect(content).toHaveAttribute('contenteditable', 'false') + + network = 'online' + releaseSyncs() + await status.getByRole('button', { name: 'Reconnect' }).click() + await expect(status).not.toContainText("You've been disconnected from the server.") + await expect(content).toHaveAttribute('contenteditable', 'true') + await expect(editor.content).toContainText('Hello') +}) diff --git a/src/components/CollaborativeEditor.vue b/src/components/CollaborativeEditor.vue index a921b62354f..8b74a7a2654 100644 --- a/src/components/CollaborativeEditor.vue +++ b/src/components/CollaborativeEditor.vue @@ -473,7 +473,7 @@ export default defineComponent({ if (val) { this.$emit('syncService:error') } - this.setEditable(!val) // TODO: can we remove this now with indexed DB? + this.setEditable(!val && this.editMode) // TODO: can we remove this now with indexed DB? }, async hasOutdatedDocument(val) { @@ -737,7 +737,7 @@ export default defineComponent({ // Server rejected the session. Behave like an idle disconnect: // read-only editor with a permanent status card offering to reconnect. this.idle = true - this.hasConnectionIssues = false + this.hasConnectionIssue = false this.readOnly = true this.editMode = false this.setEditable(this.editMode) diff --git a/src/components/Editor/DocumentStatus/SyncStatus.vue b/src/components/Editor/DocumentStatus/SyncStatus.vue index 083a6fc37ec..ae60e58f2fe 100644 --- a/src/components/Editor/DocumentStatus/SyncStatus.vue +++ b/src/components/Editor/DocumentStatus/SyncStatus.vue @@ -75,6 +75,14 @@ export default { ), } } + if (this.idle) { + return { + type: 'info', + message: t('text', "You've been disconnected from the server."), + action: this.reconnect, + actionLabel: t('text', 'Reconnect'), + } + } if (this.hasConnectionIssue) { return { message: t( @@ -86,14 +94,6 @@ export default { actionLabel: t('text', 'Reconnect'), } } - if (this.idle) { - return { - type: 'info', - message: t('text', "You've been disconnected from the server."), - action: this.reconnect, - actionLabel: t('text', 'Reconnect'), - } - } return {} }, diff --git a/src/tests/components/SyncStatus.spec.js b/src/tests/components/SyncStatus.spec.js index 04daa40538f..9a338c4fa92 100644 --- a/src/tests/components/SyncStatus.spec.js +++ b/src/tests/components/SyncStatus.spec.js @@ -33,6 +33,13 @@ FLAGS.forEach((flag) => { }) }) +test('shows the disconnected state despite a connection issue', () => { + const wrapper = shallowMount(SyncStatus, { + propsData: { idle: true, hasConnectionIssue: true }, + }) + expect(wrapper.text()).toContain("You've been disconnected from the server.") +}) + Object.values(ERROR_TYPE).forEach((type) => { test(`renders sync error ${type}`, () => { const data = { From 1f14c93ddd8c1a824b9a967fe643ad20da6f1fc4 Mon Sep 17 00:00:00 2001 From: Jonas Date: Wed, 18 Nov 2026 10:07:52 +0100 Subject: [PATCH 2/7] fix(indexedDB): close the database when the editor closes Every opened document left its IndexedDB connection and awareness interval open after the editor was closed. Navigating between pages piled up dangling connections and timers. Destroy the ydoc in `close()`. Its destroy event closes the IndexedDB connection and stops the awareness interval. Skip reading from the database once the ydoc is destroyed. Signed-off-by: Jonas Assisted-by: ClaudeCode:claude-opus-5-5 --- src/components/CollaborativeEditor.vue | 2 ++ src/composables/useIndexedDbProvider.ts | 9 ++++++++- 2 files changed, 10 insertions(+), 1 deletion(-) diff --git a/src/components/CollaborativeEditor.vue b/src/components/CollaborativeEditor.vue index 8b74a7a2654..0d63b9f10e2 100644 --- a/src/components/CollaborativeEditor.vue +++ b/src/components/CollaborativeEditor.vue @@ -844,6 +844,8 @@ export default defineComponent({ logger.warn('Failed to destroy editor', { error }) } } + // Also close the IndexedDB connection and stop the awareness interval + this.ydoc.destroy() // Update the file in Files with the latest size, mtime, the lock state if (this.fileNode) { diff --git a/src/composables/useIndexedDbProvider.ts b/src/composables/useIndexedDbProvider.ts index e178192f396..abd67794c06 100644 --- a/src/composables/useIndexedDbProvider.ts +++ b/src/composables/useIndexedDbProvider.ts @@ -27,12 +27,19 @@ export function useIndexedDbProvider( const indexedDbProvider = new IndexeddbPersistence(name, ydoc) const dirty = ref(false) let isDestroyed = false + // The provider closes its database when the ydoc is destroyed + ydoc.on('destroy', () => { + isDestroyed = true + }) const whenSynced: Promise = indexedDbProvider.whenSynced.then(async () => { + if (isDestroyed) { + return + } const val = await indexedDbProvider.get('dirty') dirty.value = Boolean(val) logger.info('synced from indexeddb', { dirty: val, - baseVersionEtag: await indexedDbProvider.get('baseVersionEtag'), + baseVersionEtag: await getBaseVersionEtag(), }) }) From 37f021d437ed782227ab211fe6068ae03015e4e0 Mon Sep 17 00:00:00 2001 From: Jonas Date: Wed, 18 Nov 2026 12:56:21 +0100 Subject: [PATCH 3/7] fix(sync): do not push steps twice or drop the autosave after reconnecting When coming back online, the sync response retried the push while the save was still pushing the same steps. The server stored them twice, so the save only covered the first copy. The autosave scheduled for the second one was then cancelled when the save finished, leaving the document at "Unsaved changes". - SyncService: sendStepsNow joins a push in flight instead of sending the outbox again. sendRemainingSteps waits for it and pushes any steps that remain, so saving and closing still send everything. - SaveService: clear the pending autosave before emitting the save event, and only when the save succeeded. - useSaveService: after a save, schedule an autosave if newer changes were pushed in the meantime. Fixes the flaky autosave e2e test "saves after being disconnected for 2 minutes". Signed-off-by: Jonas Assisted-by: ClaudeCode:claude-opus-5-5 --- src/composables/useSaveService.ts | 18 +++++++++++---- src/services/SaveService.ts | 8 +++++-- src/services/SyncService.ts | 23 ++++++++++++++------ src/tests/composables/useSaveService.spec.ts | 12 ++++++++++ src/tests/services/SyncService.spec.ts | 22 +++++++++++++++++++ 5 files changed, 70 insertions(+), 13 deletions(-) diff --git a/src/composables/useSaveService.ts b/src/composables/useSaveService.ts index 61d6cd9e2f8..8583a830753 100644 --- a/src/composables/useSaveService.ts +++ b/src/composables/useSaveService.ts @@ -93,6 +93,17 @@ export function provideSaveService( }) const versionWithChanges = ref(0) + + /** + * Schedule an autosave unless all pushed changes are saved. + * Retried pushes and pushes during a save are not followed by an editor update that triggers it. + */ + function autosaveUnsavedChanges() { + if ((document.value?.lastSavedVersion ?? 0) < versionWithChanges.value && !saveService.autosave.isPending) { + saveService.autosave() + } + } + /** * Update the tracked version based on the one in the event * @@ -101,14 +112,13 @@ export function provideSaveService( */ function updateVersionWithChanges(event: { version: number }) { versionWithChanges.value = Math.max(event.version, versionWithChanges.value) - // Retried pushes are not preceded by an editor update that triggers the autosave - if ((document.value?.lastSavedVersion ?? 0) < event.version && !saveService.autosave.isPending) { - saveService.autosave() - } + autosaveUnsavedChanges() } syncService.bus.on('changesPushed', updateVersionWithChanges) + saveService.bus.on('save', autosaveUnsavedChanges) onUnmounted(() => { syncService.bus.off('changesPushed', updateVersionWithChanges) + saveService.bus.off('save', autosaveUnsavedChanges) }) const hasPendingChanges = ref(false) diff --git a/src/services/SaveService.ts b/src/services/SaveService.ts index 08c17cde574..e7a17853aa0 100644 --- a/src/services/SaveService.ts +++ b/src/services/SaveService.ts @@ -81,14 +81,18 @@ class SaveService { force, manualSave, }) + const saved = response.data.document.lastSavedVersion >= data.version + // Before emitting, so listeners can schedule an autosave for newer changes + if (saved) { + this.clearAutosave() + } // update the document - even if the save was throttled this.bus.emit('save', response.data) - if (response.data.document.lastSavedVersion < data.version) { + if (!saved) { logger.debug('[SaveService] Server throttled save request.', { response }) return false } logger.debug('[SaveService] saved', { response }) - this.clearAutosave() return true } catch (e) { logger.error('Failed to save document.', { error: e }) diff --git a/src/services/SyncService.ts b/src/services/SyncService.ts index 90d79288c0c..f2f0d7e06fd 100644 --- a/src/services/SyncService.ts +++ b/src/services/SyncService.ts @@ -95,7 +95,7 @@ class SyncService { bus = mitt() #openConnection: () => Promise #lastStepPush = Date.now() - #sending = false + #pushing?: Promise constructor({ connection, @@ -173,19 +173,28 @@ class SyncService { return } this.#sendIntervalId = setInterval(() => { - if (this.connection.value && !this.#sending) { + if (this.connection.value && !this.#pushing) { this.sendStepsNow().catch((err) => logger.error(err)) } }, 200) } - async sendStepsNow() { - this.#sending = true + /** + * Push the outbox to the server. + * Joins a push that is still in flight, as it would otherwise send the same steps twice. + */ + sendStepsNow(): Promise { + this.#pushing ??= this.#push().finally(() => { + this.#pushing = undefined + }) + return this.#pushing + } + + async #push() { clearInterval(this.#sendIntervalId) this.#sendIntervalId = undefined const hadUpdate = this.#outbox.hasUpdate if (!this.hasActiveConnection()) { - this.#sending = false return } const sendable = this.#outbox.getDataToSend() @@ -204,7 +213,6 @@ class SyncService { this.#emitDocumentStateStep(documentState, version) } this.pushError = 0 - this.#sending = false if (steps?.length > 0) { this.receiveSteps({ steps }) if (hadUpdate) { @@ -216,7 +224,6 @@ class SyncService { }) .catch((err) => { const { response, code } = err - this.#sending = false this.pushError++ logger.error('Failed to push the steps to the server', err) if (!response || code === 'ECONNABORTED') { @@ -279,6 +286,8 @@ class SyncService { } async sendRemainingSteps() { + // A push in flight may fail or miss steps added since it started + await this.#pushing?.catch(() => {}) if (!this.#outbox.hasUpdate) { return } diff --git a/src/tests/composables/useSaveService.spec.ts b/src/tests/composables/useSaveService.spec.ts index 65c6e48cb95..29804aa9913 100644 --- a/src/tests/composables/useSaveService.spec.ts +++ b/src/tests/composables/useSaveService.spec.ts @@ -90,6 +90,18 @@ describe('provideSaveService', () => { expect(saveApi.save).toHaveBeenCalledWith(connection.value, expect.objectContaining({ version: 2 })) }) + it('autosaves changes pushed while saving', async () => { + const { syncService, saveService } = setup() + vi.mocked(saveApi.save).mockImplementationOnce(async () => { + syncService.version = 3 + syncService.bus.emit('changesPushed', { version: 3 }) + return { data: { document: { lastSavedVersion: 2, lastSavedVersionTime: 0 } } } as Awaited> + }) + await saveService.save() + await vi.advanceTimersByTimeAsync(11_000) + expect(saveApi.save).toHaveBeenLastCalledWith(connection.value, expect.objectContaining({ version: 3 })) + }) + it('does not autosave pushed changes that are already saved', async () => { const { syncService } = setup() syncService.bus.emit('changesPushed', { version: 1 }) diff --git a/src/tests/services/SyncService.spec.ts b/src/tests/services/SyncService.spec.ts index dc630ce9860..16e86e5d823 100644 --- a/src/tests/services/SyncService.spec.ts +++ b/src/tests/services/SyncService.spec.ts @@ -92,5 +92,27 @@ describe('Sync service', () => { await expect(service.sendStepsNow()).rejects.toThrow() expect(onPendingChanges).toHaveBeenCalledExactlyOnceWith({ pending: true }) }) + + it('are pushed once while a push is in flight', async () => { + const service = new SyncService({ connection: shallowRef(connection), openConnection: vi.fn() }) + vi.mocked(sync.push).mockClear() + vi.mocked(sync.push).mockResolvedValue({ data: { steps: [], documentState: '', version: 1 } }) + service.sendStep(update) + await Promise.all([service.sendStepsNow(), service.sendStepsNow()]) + expect(sync.push).toHaveBeenCalledOnce() + }) + + it('are pushed again if they remain after a push in flight', async () => { + const service = new SyncService({ connection: shallowRef(connection), openConnection: vi.fn() }) + vi.mocked(sync.push).mockClear() + vi.mocked(sync.push) + .mockRejectedValueOnce({ code: 'ECONNABORTED' }) + .mockResolvedValue({ data: { steps: [], documentState: '', version: 1 } }) + service.sendStep(update) + const inFlight = service.sendStepsNow() + await service.sendRemainingSteps() + await expect(inFlight).rejects.toThrow() + expect(sync.push).toHaveBeenCalledTimes(2) + }) }) }) From f92c923978e51de6752ba295d0d4ea8223498c6c Mon Sep 17 00:00:00 2001 From: Jonas Date: Wed, 18 Nov 2026 13:33:09 +0100 Subject: [PATCH 4/7] fix(sync): stop the send interval and unload listener of a closed editor Destroying the sync provider on close sends a last awareness step after the connection was already cleared. It started the 200 ms send interval, which only stopped after a push, so every closed editor left an interval running that kept the sync service reachable. The interval now stops once there is no connection; the next step after reconnecting starts a new one. The beforeunload listener stayed registered if the editor was closed with unsaved changes, because only the dirty watcher removed it and watchers no longer run after unmounting. Signed-off-by: Jonas Assisted-by: ClaudeCode:claude-opus-5-5 --- src/components/CollaborativeEditor.vue | 2 ++ src/services/SyncService.ts | 8 +++++++- src/tests/services/SyncService.spec.ts | 11 +++++++++++ 3 files changed, 20 insertions(+), 1 deletion(-) diff --git a/src/components/CollaborativeEditor.vue b/src/components/CollaborativeEditor.vue index 0d63b9f10e2..2751b9fed0b 100644 --- a/src/components/CollaborativeEditor.vue +++ b/src/components/CollaborativeEditor.vue @@ -549,6 +549,8 @@ export default defineComponent({ const timeout = new Promise((resolve) => setTimeout(resolve, 2000)) await Promise.any([timeout, this.saveWhenDirty()]) await this.close() + // The dirty watcher that removes it no longer runs after unmounting + window.removeEventListener('beforeunload', this.saveBeforeUnload) removeFromDebugging(this) }, diff --git a/src/services/SyncService.ts b/src/services/SyncService.ts index f2f0d7e06fd..69e3d952007 100644 --- a/src/services/SyncService.ts +++ b/src/services/SyncService.ts @@ -173,7 +173,13 @@ class SyncService { return } this.#sendIntervalId = setInterval(() => { - if (this.connection.value && !this.#pushing) { + if (!this.connection.value) { + // Closed or rejected: the next step after reconnecting starts a new interval + clearInterval(this.#sendIntervalId) + this.#sendIntervalId = undefined + return + } + if (!this.#pushing) { this.sendStepsNow().catch((err) => logger.error(err)) } }, 200) diff --git a/src/tests/services/SyncService.spec.ts b/src/tests/services/SyncService.spec.ts index 16e86e5d823..5aa078bd11a 100644 --- a/src/tests/services/SyncService.spec.ts +++ b/src/tests/services/SyncService.spec.ts @@ -102,6 +102,17 @@ describe('Sync service', () => { expect(sync.push).toHaveBeenCalledOnce() }) + it('stop the send interval once the connection is closed', async () => { + vi.useFakeTimers() + const service = new SyncService({ connection: shallowRef(connection), openConnection: vi.fn() }) + vi.mocked(connect.close).mockResolvedValue({} as Awaited>) + await service.close() + service.sendStep(update) + await vi.advanceTimersByTimeAsync(200) + expect(vi.getTimerCount()).toBe(0) + vi.useRealTimers() + }) + it('are pushed again if they remain after a push in flight', async () => { const service = new SyncService({ connection: shallowRef(connection), openConnection: vi.fn() }) vi.mocked(sync.push).mockClear() From ee849bda87ede028bdf3ff0b57c651ddf70688a1 Mon Sep 17 00:00:00 2001 From: Jonas Date: Wed, 18 Nov 2026 13:39:43 +0100 Subject: [PATCH 5/7] refactor(indexedDB): rely on ydoc.isDestroyed instead of a destroy listener Yjs sets `Doc.isDestroyed` before it emits `destroy`, so the composable no longer tracks the destroyed ydoc in its own flag. The local flag now only records that the data was cleared, which also closes the database while the ydoc stays alive. The early return in `whenSynced` could not run: y-indexeddb never emits `synced` once it is destroyed, so `whenSynced` does not settle for a ydoc destroyed before the initial load. Signed-off-by: Jonas Assisted-by: ClaudeCode:claude-opus-5-5 --- src/composables/useIndexedDbProvider.ts | 19 ++--- .../composables/useIndexedDbProvider.spec.ts | 70 +++++++++++++++++++ 2 files changed, 77 insertions(+), 12 deletions(-) create mode 100644 src/tests/composables/useIndexedDbProvider.spec.ts diff --git a/src/composables/useIndexedDbProvider.ts b/src/composables/useIndexedDbProvider.ts index abd67794c06..fb0fa8c11f7 100644 --- a/src/composables/useIndexedDbProvider.ts +++ b/src/composables/useIndexedDbProvider.ts @@ -26,15 +26,10 @@ export function useIndexedDbProvider( const name = `text-${props.context.type}-${props.context.id}` const indexedDbProvider = new IndexeddbPersistence(name, ydoc) const dirty = ref(false) - let isDestroyed = false - // The provider closes its database when the ydoc is destroyed - ydoc.on('destroy', () => { - isDestroyed = true - }) + let isCleared = false + // The provider also closes its database when the ydoc is destroyed + const isClosed = () => isCleared || ydoc.isDestroyed const whenSynced: Promise = indexedDbProvider.whenSynced.then(async () => { - if (isDestroyed) { - return - } const val = await indexedDbProvider.get('dirty') dirty.value = Boolean(val) logger.info('synced from indexeddb', { @@ -50,7 +45,7 @@ export function useIndexedDbProvider( */ function setDirty(val: boolean) { dirty.value = Boolean(val) - if (isDestroyed) { + if (isClosed()) { logger.debug('IndexedDB already destroyed, skipping setDirty') return Promise.resolve() } @@ -61,7 +56,7 @@ export function useIndexedDbProvider( * Get the base version etag the document had when it was edited last. */ function getBaseVersionEtag(): Promise { - if (isDestroyed) { + if (isClosed()) { logger.debug('IndexedDB already destroyed, skipping getBaseVersionEtag') return Promise.resolve(undefined) } @@ -74,7 +69,7 @@ export function useIndexedDbProvider( * @param val the base version etag as returned by open. */ function setBaseVersionEtag(val: string) { - if (isDestroyed) { + if (isClosed()) { logger.debug('IndexedDB already destroyed, skipping setBaseVersionEtag') return Promise.resolve(undefined) } @@ -87,7 +82,7 @@ export function useIndexedDbProvider( */ function clearIndexedDb() { logger.info('clearing indexeddb') - isDestroyed = true + isCleared = true return indexedDbProvider.clearData() } diff --git a/src/tests/composables/useIndexedDbProvider.spec.ts b/src/tests/composables/useIndexedDbProvider.spec.ts new file mode 100644 index 00000000000..4b6357086ed --- /dev/null +++ b/src/tests/composables/useIndexedDbProvider.spec.ts @@ -0,0 +1,70 @@ +/** + * SPDX-FileCopyrightText: 2026 Nextcloud GmbH and Nextcloud contributors + * SPDX-License-Identifier: AGPL-3.0-or-later + */ + +import { beforeEach, describe, expect, it, vi } from 'vitest' +import { Doc } from 'yjs' +import { useIndexedDbProvider } from '../../composables/useIndexedDbProvider.ts' + +const provider = vi.hoisted(() => ({ + whenSynced: new Promise(() => {}), + get: vi.fn(async () => undefined), + set: vi.fn(async () => undefined), + clearData: vi.fn(async () => undefined), +})) + +vi.mock('y-indexeddb', () => ({ + IndexeddbPersistence: class { + constructor() { + return provider + } + }, +})) + +/** + * Set up the composable for a new ydoc. + */ +function setup() { + const ydoc = new Doc() + const indexedDb = useIndexedDbProvider({ context: { type: 'file', id: 123 } }, ydoc) + return { ydoc, ...indexedDb } +} + +describe('useIndexedDbProvider', () => { + beforeEach(() => { + vi.clearAllMocks() + }) + + it('stores the dirty state and base version etag', async () => { + const { setDirty, setBaseVersionEtag, getBaseVersionEtag } = setup() + await setDirty(true) + await setBaseVersionEtag('etag') + await getBaseVersionEtag() + expect(provider.set).toHaveBeenCalledWith('dirty', 1) + expect(provider.set).toHaveBeenCalledWith('baseVersionEtag', 'etag') + expect(provider.get).toHaveBeenCalledWith('baseVersionEtag') + }) + + it('stops using the database once the ydoc is destroyed', async () => { + const { ydoc, dirty, setDirty, setBaseVersionEtag, getBaseVersionEtag } = setup() + ydoc.destroy() + await setDirty(true) + await setBaseVersionEtag('etag') + expect(await getBaseVersionEtag()).toBeUndefined() + expect(dirty.value).toBe(true) + expect(provider.set).not.toHaveBeenCalled() + expect(provider.get).not.toHaveBeenCalled() + }) + + it('stops using the database once it was cleared', async () => { + const { clearIndexedDb, setDirty, setBaseVersionEtag, getBaseVersionEtag } = setup() + await clearIndexedDb() + await setDirty(true) + await setBaseVersionEtag('etag') + expect(await getBaseVersionEtag()).toBeUndefined() + expect(provider.clearData).toHaveBeenCalledOnce() + expect(provider.set).not.toHaveBeenCalled() + expect(provider.get).not.toHaveBeenCalled() + }) +}) From 928427aa5b0359069bd227f7faffd45f269be475 Mon Sep 17 00:00:00 2001 From: Jonas Date: Wed, 18 Nov 2026 13:44:36 +0100 Subject: [PATCH 6/7] fix(save): do not save if pushing the changes invalidated the session Saving pushes the local changes first. If the server rejects that push, the session is invalidated and the connection cleared, but the save went ahead with it and failed with "Cannot read properties of undefined (reading 'shareToken')". Check the connection after pushing instead. Signed-off-by: Jonas Assisted-by: ClaudeCode:claude-opus-5-5 --- src/services/SaveService.ts | 5 +++-- src/tests/services/SaveService.spec.ts | 16 ++++++++++++++++ 2 files changed, 19 insertions(+), 2 deletions(-) diff --git a/src/services/SaveService.ts b/src/services/SaveService.ts index e7a17853aa0..0b50e894e49 100644 --- a/src/services/SaveService.ts +++ b/src/services/SaveService.ts @@ -67,12 +67,13 @@ class SaveService { */ async save({ force = false, manualSave = true } = {}) { logger.debug('[SaveService] saving', { force, manualSave }) + // Save the version that includes the local changes + await this.pushChanges() + // Pushing may have invalidated the session if (!this.connection.value) { logger.warn('Could not save due to missing connection') return } - // Save the version that includes the local changes - await this.pushChanges() const data = this.getSaveData() try { this.lastSaveAttempt = Date.now() diff --git a/src/tests/services/SaveService.spec.ts b/src/tests/services/SaveService.spec.ts index e3d56bacbf0..baf7c4b1d65 100644 --- a/src/tests/services/SaveService.spec.ts +++ b/src/tests/services/SaveService.spec.ts @@ -45,6 +45,22 @@ describe('SaveService', () => { }) }) + it('does not save if pushing the changes invalidated the session', async () => { + vi.mocked(saveApi.save).mockClear() + const sessionConnection = shallowRef(connection.value) + const saveService = new SaveService({ + connection: sessionConnection, + getSaveData, + pushChanges: async () => { + sessionConnection.value = undefined + }, + }) + + await expect(saveService.save()).resolves.toBeUndefined() + + expect(saveApi.save).not.toHaveBeenCalled() + }) + it('pushes changes before saving', async () => { vi.mocked(saveApi.save).mockResolvedValue({ data: { document: { lastSavedVersion: 2 } }, From 17bb036d273ee85dd0fe9b38b22788e71ec851c2 Mon Sep 17 00:00:00 2001 From: Jonas Date: Wed, 18 Nov 2026 13:51:34 +0100 Subject: [PATCH 7/7] fix(a11y): announce document status changes to screen readers The status cards for connection issues, a rejected session or a conflict are added and removed as the state changes and use role="note", so screen readers did not announce them. The always rendered status wrapper is now a polite live region. Signed-off-by: Jonas Assisted-by: ClaudeCode:claude-opus-5-5 --- src/components/Editor/DocumentStatus.vue | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/components/Editor/DocumentStatus.vue b/src/components/Editor/DocumentStatus.vue index 5c416dfe034..f8e567c61ce 100644 --- a/src/components/Editor/DocumentStatus.vue +++ b/src/components/Editor/DocumentStatus.vue @@ -5,7 +5,7 @@