Skip to content

Beautiful, AI-native markdown IDE and LLM wiki

Backfill the client cache when open attaches it eagerly (#5386)

Andrew Mikofalvycecd71f5a0d9
diff --git a/.changeset/local-cache-after-server-restart.md b/.changeset/local-cache-after-server-restart.md
new file mode 100644
index 000000000..c634fcc99
--- /dev/null
+++ b/.changeset/local-cache-after-server-restart.md
@@ -0,0 +1,5 @@
+---
+"@inkeep/open-knowledge": patch
+---
+
+After the local server restarts, open documents save their full content to the offline cache again once they sync. Previously the cache could keep only edits made after the restart.
diff --git a/packages/app/src/editor/provider-pool.test.ts b/packages/app/src/editor/provider-pool.test.ts
index a53858209..16a192cda 100644
--- a/packages/app/src/editor/provider-pool.test.ts
+++ b/packages/app/src/editor/provider-pool.test.ts
@@ -1724,6 +1724,46 @@ describe('ProviderPool stored-state validation spine', () => {
expect(persistenceFactory).toHaveBeenCalledTimes(1);
});
+ test('a record-present open that attaches eagerly still backfills the cache after its first sync', async () => {
+ const flushSpy = vi.fn(async () => {});
+ const persistenceFactory = vi.fn(
+ () =>
+ ({
+ whenSynced: Promise.resolve(undefined as never),
+ synced: true,
+ destroy: async () => {},
+ clearData: async () => {},
+ flushFullState: flushSpy,
+ }) as unknown as ClientPersistenceProvider,
+ );
+ pool = new ProviderPool(3, DUMMY_WS, {
+ storage: null,
+ persistenceFactory,
+ peekStoredLineageEpoch: async () => null,
+ });
+ const docName = uniqueDocName('pp-eager-backfill');
+
+ const first = pool.open(docName);
+ if (!first) throw new Error('expected first entry');
+ first.provider.document.getMap('lifecycle').set('epoch', 'epoch-x');
+ first.provider.emit('synced', { state: true });
+ pool.close(docName);
+ pool.setExpectedServerInstanceId(TEST_SERVER_INSTANCE_ID);
+
+ const entry = pool.open(docName);
+ if (!entry) throw new Error('expected entry');
+ expect(entry.lineageEpochRecordAtOpen).toBe('epoch-x');
+ expect(entry.persistence).not.toBeNull();
+ expect(persistenceFactory).toHaveBeenCalledTimes(1);
+
+ await wait(20);
+ expect(flushSpy).not.toHaveBeenCalled();
+ entry.provider.document.getMap('lifecycle').set('epoch', 'epoch-x');
+ entry.provider.emit('synced', { state: true });
+ const flushed = await waitFor(() => flushSpy.mock.calls.length === 1, 2_000);
+ expect(flushed).toBe(true);
+ });
+
test('a re-dispatch onto an entry with an in-flight spine run is a no-op (attach ownership)', async () => {
let resolvePeek: (value: string | null) => void = () => {};
const peek = vi.fn(
diff --git a/packages/app/src/editor/provider-pool.ts b/packages/app/src/editor/provider-pool.ts
index bdf900197..d5a66199a 100644
--- a/packages/app/src/editor/provider-pool.ts
+++ b/packages/app/src/editor/provider-pool.ts
@@ -419,15 +419,7 @@ export class ProviderPool {
const persistence = this.buildPersistence(serverInstanceId, docName, entry.provider.document);
entry.persistence = persistence;
this.notify();
- void this.backfillCacheAfterFirstSync(entry, persistence).catch((err: unknown) => {
- this.emitStructuredClientRecoveryEvent({
- event: 'ok-client-persistence-attach-failed',
- ...this.recoveryTelemetryBase(docName),
- phase: 'backfill',
- errorName: err instanceof Error ? err.name : 'non-error-throw',
- errorMessage: err instanceof Error ? err.message : String(err),
- });
- });
+ this.scheduleCacheBackfill(entry, persistence);
} catch (err: unknown) {
this.emitStructuredClientRecoveryEvent({
event: 'ok-client-persistence-attach-failed',
@@ -439,6 +431,21 @@ export class ProviderPool {
}
}
+ private scheduleCacheBackfill(
+ entry: ActivePoolEntry,
+ persistence: ClientPersistenceProvider,
+ ): void {
+ void this.backfillCacheAfterFirstSync(entry, persistence).catch((err: unknown) => {
+ this.emitStructuredClientRecoveryEvent({
+ event: 'ok-client-persistence-attach-failed',
+ ...this.recoveryTelemetryBase(entry.docName),
+ phase: 'backfill',
+ errorName: err instanceof Error ? err.name : 'non-error-throw',
+ errorMessage: err instanceof Error ? err.message : String(err),
+ });
+ });
+ }
+
private async backfillCacheAfterFirstSync(
entry: ActivePoolEntry,
persistence: ClientPersistenceProvider,
@@ -1356,6 +1363,8 @@ export class ProviderPool {
this.touch(docName);
this.notify();
+ if (persistence !== null) this.scheduleCacheBackfill(entry, persistence);
+
if (
persistence === null &&
persistenceServerInstanceId !== null &&