Protect bounded remote activity across app lifecycle

src/modules/core/ModuleReplicator.ts

@@ -133,33 +133,41 @@ Even if you choose to clean up, you will see this option again if you exit Obsid
                 await this.core.rebuilder.$performRebuildDB("localOnly");
             }
             if (ret == CHOICE_CLEAN) {
-                const replicator = this.services.replicator.getActiveReplicator();
-                if (!(replicator instanceof LiveSyncCouchDBReplicator)) return;
-                const remoteDB = await replicator.connectRemoteCouchDBWithSetting(
-                    this.settings,
-                    this.services.API.isMobile(),
-                    true
-                );
-                if (typeof remoteDB == "string") {
-                    Logger(remoteDB, LOG_LEVEL_NOTICE);
-                    return false;
-                }
+                await this.services.replicator.runBoundedRemoteActivity(
+                    async () => {
+                        const replicator = this.services.replicator.getActiveReplicator();
+                        if (!(replicator instanceof LiveSyncCouchDBReplicator)) return;
+                        const remoteDB = await replicator.connectRemoteCouchDBWithSetting(
+                            this.settings,
+                            this.services.API.isMobile(),
+                            true
+                        );
+                        if (typeof remoteDB == "string") {
+                            Logger(remoteDB, LOG_LEVEL_NOTICE);
+                            return false;
+                        }
 
-                await purgeUnreferencedChunks(this.localDatabase.localDatabase, false);
-                this.localDatabase.clearCaches();
-                // Perform the synchronisation once.
-                if (await this.core.replicator.openReplication(this.settings, false, showMessage, true)) {
-                    await balanceChunkPurgedDBs(this.localDatabase.localDatabase, remoteDB.db);
-                    await purgeUnreferencedChunks(this.localDatabase.localDatabase, false);
-                    this.localDatabase.clearCaches();
-                    await this.services.replicator.getActiveReplicator()?.markRemoteResolved(this.settings);
-                    Logger("The local database has been cleaned up.", showMessage ? LOG_LEVEL_NOTICE : LOG_LEVEL_INFO);
-                } else {
-                    Logger(
-                        "Replication has been cancelled. Please try it again.",
-                        showMessage ? LOG_LEVEL_NOTICE : LOG_LEVEL_INFO
-                    );
-                }
+                        await purgeUnreferencedChunks(this.localDatabase.localDatabase, false);
+                        this.localDatabase.clearCaches();
+                        // Perform the synchronisation once.
+                        if (await this.core.replicator.openReplication(this.settings, false, showMessage, true)) {
+                            await balanceChunkPurgedDBs(this.localDatabase.localDatabase, remoteDB.db);
+                            await purgeUnreferencedChunks(this.localDatabase.localDatabase, false);
+                            this.localDatabase.clearCaches();
+                            await this.services.replicator.getActiveReplicator()?.markRemoteResolved(this.settings);
+                            Logger(
+                                "The local database has been cleaned up.",
+                                showMessage ? LOG_LEVEL_NOTICE : LOG_LEVEL_INFO
+                            );
+                        } else {
+                            Logger(
+                                "Replication has been cancelled. Please try it again.",
+                                showMessage ? LOG_LEVEL_NOTICE : LOG_LEVEL_INFO
+                            );
+                        }
+                    },
+                    { label: "database-cleanup" }
+                );
             }
         });
     }

src/modules/core/ModuleReplicator.unit.spec.ts

@@ -1,4 +1,16 @@
 import { describe, expect, it, vi } from "vitest";
+
+const chunkMocks = vi.hoisted(() => ({
+    purgeUnreferencedChunks: vi.fn(async (_db: unknown, countOnly: boolean) => (countOnly ? 2 : 0)),
+    balanceChunkPurgedDBs: vi.fn(async () => undefined),
+}));
+
+vi.mock("@lib/pouchdb/chunks", () => chunkMocks);
+vi.mock("@lib/replication/couchdb/LiveSyncReplicator", () => ({
+    LiveSyncCouchDBReplicator: class {},
+}));
+
+import { LiveSyncCouchDBReplicator } from "@lib/replication/couchdb/LiveSyncReplicator";
 import { ModuleReplicator } from "./ModuleReplicator";
 
 describe("ModuleReplicator", () => {
@@ -46,3 +58,61 @@ describe("ModuleReplicator", () => {
         expect(ensurePBKDF2Salt).toHaveBeenCalledWith({}, false, false);
     });
 });
+
+describe("ModuleReplicator legacy cleanup", () => {
+    it("keeps its finite replication and balancing work inside the shared activity boundary", async () => {
+        const activityFinished = vi.fn();
+        const runBoundedRemoteActivity = vi.fn(async (task: () => unknown) => {
+            try {
+                return await task();
+            } finally {
+                activityFinished();
+            }
+        });
+        const openReplication = vi.fn(async () => true);
+        const activeReplicator = Object.assign(new LiveSyncCouchDBReplicator({} as any), {
+            connectRemoteCouchDBWithSetting: vi.fn(async () => ({ db: {} })),
+            markRemoteResolved: vi.fn(async () => undefined),
+        });
+        const services = {
+            API: {
+                addLog: vi.fn(),
+                addCommand: vi.fn(),
+                registerWindow: vi.fn(),
+                addRibbonIcon: vi.fn(),
+                registerProtocolHandler: vi.fn(),
+                isMobile: vi.fn(() => false),
+            },
+            setting: { saveSettingData: vi.fn(async () => undefined) },
+            appLifecycle: {
+                getUnresolvedMessages: { addHandler: vi.fn() },
+            },
+            replicator: {
+                getActiveReplicator: vi.fn(() => activeReplicator),
+                runBoundedRemoteActivity,
+            },
+        };
+        const localDatabase = {
+            localDatabase: {},
+            clearCaches: vi.fn(),
+        };
+        const core = {
+            _services: services,
+            services,
+            settings: {},
+            localDatabase,
+            confirm: { confirmWithMessage: vi.fn(async () => "Cleanup") },
+            replicator: { openReplication },
+        } as any;
+        const module = new ModuleReplicator(core);
+
+        await module.cleaned(true);
+
+        expect(runBoundedRemoteActivity).toHaveBeenCalledWith(expect.any(Function), {
+            label: "database-cleanup",
+        });
+        expect(openReplication).toHaveBeenCalledOnce();
+        expect(openReplication.mock.invocationCallOrder[0]).toBeLessThan(activityFinished.mock.invocationCallOrder[0]);
+        expect(chunkMocks.balanceChunkPurgedDBs).toHaveBeenCalledOnce();
+    });
+});

src/modules/core/ModuleReplicatorCouchDB.ts

@@ -28,7 +28,15 @@ export class ModuleReplicatorCouchDB extends AbstractModule {
                 fireAndForget(async () => {
                     const canReplicate = await this.services.replication.isReplicationReady(false);
                     if (!canReplicate) return;
-                    void this.core.replicator.openReplication(this.settings, continuous, false, false);
+                    const openReplication = () =>
+                        this.core.replicator.openReplication(this.settings, continuous, false, false);
+                    if (continuous) {
+                        void openReplication();
+                    } else {
+                        await this.services.replicator.runBoundedRemoteActivity(openReplication, {
+                            label: "replication",
+                        });
+                    }
                 });
             }
         }

src/modules/core/ModuleReplicatorCouchDB.unit.spec.ts

@@ -0,0 +1,89 @@
+import { describe, expect, it, vi } from "vitest";
+import { ModuleReplicatorCouchDB } from "./ModuleReplicatorCouchDB.ts";
+
+function createModule(settings: { liveSync: boolean; syncOnStart: boolean }, isReplicationReady = true) {
+    const openReplication = vi.fn(async () => true);
+    const runBoundedRemoteActivity = vi.fn(async (task: () => unknown) => await task());
+    const services = {
+        API: {
+            addLog: vi.fn(),
+            addCommand: vi.fn(),
+            registerWindow: vi.fn(),
+            addRibbonIcon: vi.fn(),
+            registerProtocolHandler: vi.fn(),
+        },
+        appLifecycle: {
+            isSuspended: vi.fn(() => false),
+            isReady: vi.fn(() => true),
+        },
+        replication: {
+            isReplicationReady: vi.fn(async () => isReplicationReady),
+        },
+        replicator: {
+            runBoundedRemoteActivity,
+        },
+        setting: {
+            saveSettingData: vi.fn(async () => undefined),
+        },
+    };
+    const core = {
+        _services: services,
+        services,
+        settings: {
+            remoteType: "",
+            ...settings,
+        },
+        replicator: { openReplication },
+    } as any;
+    return {
+        module: new ModuleReplicatorCouchDB(core),
+        openReplication,
+        runBoundedRemoteActivity,
+    };
+}
+
+describe("ModuleReplicatorCouchDB resume replication activity", () => {
+    it("runs start-up one-shot replication through bounded remote activity", async () => {
+        const { module, openReplication, runBoundedRemoteActivity } = createModule({
+            liveSync: false,
+            syncOnStart: true,
+        });
+
+        await module._everyAfterResumeProcess();
+
+        await vi.waitFor(() => expect(openReplication).toHaveBeenCalledOnce());
+        expect(runBoundedRemoteActivity).toHaveBeenCalledWith(expect.any(Function), {
+            label: "replication",
+        });
+        expect(openReplication).toHaveBeenCalledWith(expect.any(Object), false, false, false);
+    });
+
+    it("does not treat continuous replication as bounded activity", async () => {
+        const { module, openReplication, runBoundedRemoteActivity } = createModule({
+            liveSync: true,
+            syncOnStart: false,
+        });
+
+        await module._everyAfterResumeProcess();
+
+        await vi.waitFor(() => expect(openReplication).toHaveBeenCalledOnce());
+        expect(runBoundedRemoteActivity).not.toHaveBeenCalled();
+        expect(openReplication).toHaveBeenCalledWith(expect.any(Object), true, false, false);
+    });
+
+    it("does not start a one-shot activity when start-up readiness fails", async () => {
+        const { module, openReplication, runBoundedRemoteActivity } = createModule(
+            {
+                liveSync: false,
+                syncOnStart: true,
+            },
+            false
+        );
+
+        await module._everyAfterResumeProcess();
+        await new Promise((resolve) => setTimeout(resolve, 0));
+
+        expect(runBoundedRemoteActivity).not.toHaveBeenCalled();
+        expect(openReplication).not.toHaveBeenCalled();
+    });
+});