@vrtmrz/livesync-commonlib 0.1.13 → 0.1.14-canary.0

package/README.md

@@ -20,6 +20,8 @@ Treat every `compat/*` subpath as a migration-only interface. A source-directory
 
 The package is ESM-only and declares Node 20 or later. Browser entry points are built with browser conditions, but the host remains responsible for checking the availability of browser capabilities such as the File System Access API.
 
+Every non-root module entry is available both without an extension and with an explicit `.js` suffix. For example, `@vrtmrz/livesync-commonlib/context` and `@vrtmrz/livesync-commonlib/context.js` resolve to the same runtime module and declaration file. Existing extensionless imports remain supported; consumers and review tools which require explicit JavaScript specifiers may use the `.js` form.
+
 ## Package entry points
 
 | Entry point                                        | Intended use                                                                      | Current contract status                                                                     |

package/dist/replication/couchdb/LiveSyncReplicator.d.ts

@@ -33,6 +33,7 @@ export declare class LiveSyncCouchDBReplicator extends LiveSyncAbstractReplicato
     sendChunks(setting: RemoteDBSettings, remoteDB: PouchDB.Database<EntryDoc> | undefined, showResult: boolean, fromSeq?: number | string): Promise<boolean>;
     openOneShotReplication(setting: RemoteDBSettings, showResult: boolean, retrying: boolean, syncMode: "sync" | "pullOnly" | "pushOnly", ignoreCleanLock?: boolean): Promise<boolean>;
     private closeRemoteDatabase;
+    private withRemoteDatabase;
     replicateAllToServer(setting: RemoteDBSettings, showingNotice?: boolean): Promise<boolean>;
     replicateAllFromServer(setting: RemoteDBSettings, showingNotice?: boolean): Promise<boolean>;
     checkReplicationConnectivity(setting: RemoteDBSettings, keepAlive: boolean, skipCheck: boolean, showResult: boolean, ignoreCleanLock?: boolean): Promise<false | {

package/dist/replication/couchdb/LiveSyncReplicator.js

@@ -379,9 +379,12 @@ class LiveSyncCouchDBReplicator extends LiveSyncAbstractReplicator {
         );
         return false;
       }
-      remoteDB = d.db;
+      return await this.withRemoteDatabase(d.db, async (db) => this.sendChunks(setting, db, showResult, fromSeq));
+    }
+    const connectivity = await this.checkReplicationConnectivity(setting, false, false, false, false);
+    if (connectivity !== false) {
+      await this.closeRemoteDatabase(connectivity.db);
     }
-    await this.checkReplicationConnectivity(setting, false, false, false, false);
     Logger(`Bulk sending chunks to remote database...`, showResult ? LOG_LEVEL_NOTICE : LOG_LEVEL_INFO, "fetch");
     const remoteMilestone = await remoteDB.get(MILESTONE_DOCID);
     const remoteID = remoteMilestone?.created ?? 0;
@@ -628,6 +631,13 @@ ${sendingDocs}/(${sentDocsCount} done)`,
       Logger(ex, LOG_LEVEL_VERBOSE, "sync");
     }
   }
+  async withRemoteDatabase(db, task) {
+    try {
+      return await task(db);
+    } finally {
+      await this.closeRemoteDatabase(db);
+    }
+  }
   replicateAllToServer(setting, showingNotice) {
     return this.openOneShotReplication(setting, showingNotice ?? false, false, "pushOnly");
   }
@@ -763,58 +773,62 @@ ${sendingDocs}/(${sentDocsCount} done)`,
           Logger(this.translate("liveSyncReplicator.checkingLastSyncPoint"), LOG_LEVEL_NOTICE, "sync");
         }
         const { db, syncOption } = ret;
-        this.syncStatus = "STARTED";
-        this.maxPullSeq = Number(`${ret.info.update_seq}`.split("-")[0]);
-        this.maxPushSeq = Number(`${(await localDB.info()).update_seq}`.split("-")[0]);
-        this.updateInfo();
-        const docArrivedOnStart = this.docArrived;
-        const docSentOnStart = this.docSent;
-        if (!retrying) {
-          this.originalSetting = setting;
-        }
-        this.terminateSync();
-        const syncHandler = localDB.sync(db, {
-          ...syncOption
-        });
-        const syncMode = "sync";
-        const syncResult = await this.processSync(
-          syncHandler,
-          showResult,
-          docSentOnStart,
-          docArrivedOnStart,
-          syncMode,
-          retrying
-        );
-        if (syncResult == "DONE") {
-          return true;
-        }
-        if (syncResult == "FAILED") {
-          return false;
-        }
-        if (syncResult == "NEED_RESURRECT") {
+        try {
+          this.syncStatus = "STARTED";
+          this.maxPullSeq = Number(`${ret.info.update_seq}`.split("-")[0]);
+          this.maxPushSeq = Number(`${(await localDB.info()).update_seq}`.split("-")[0]);
+          this.updateInfo();
+          const docArrivedOnStart = this.docArrived;
+          const docSentOnStart = this.docSent;
+          if (!retrying) {
+            this.originalSetting = setting;
+          }
           this.terminateSync();
-          return async () => await this.openContinuousReplication(this.originalSetting, showResult, false);
-        }
-        if (syncResult == "NEED_RETRY") {
-          const tempSetting = JSON.parse(JSON.stringify(setting));
-          tempSetting.batch_size = Math.ceil(tempSetting.batch_size / 2) + 2;
-          tempSetting.batches_limit = Math.ceil(tempSetting.batches_limit / 2) + 2;
-          if (tempSetting.batch_size <= 5 && tempSetting.batches_limit <= 5) {
-            Logger(
-              this.translate("liveSyncReplicator.cantReplicateLowerValue"),
-              showResult ? LOG_LEVEL_NOTICE : LOG_LEVEL_INFO
-            );
+          const syncHandler = localDB.sync(db, {
+            ...syncOption
+          });
+          const syncMode = "sync";
+          const syncResult = await this.processSync(
+            syncHandler,
+            showResult,
+            docSentOnStart,
+            docArrivedOnStart,
+            syncMode,
+            retrying
+          );
+          if (syncResult == "DONE") {
+            return true;
+          }
+          if (syncResult == "FAILED") {
             return false;
-          } else {
-            Logger(
-              this.translate("liveSyncReplicator.retryLowerBatchSize", {
-                batch_size: tempSetting.batch_size.toString(),
-                batches_limit: tempSetting.batches_limit.toString()
-              }),
-              showResult ? LOG_LEVEL_NOTICE : LOG_LEVEL_INFO
-            );
-            return async () => await this.openContinuousReplication(tempSetting, showResult, true);
           }
+          if (syncResult == "NEED_RESURRECT") {
+            this.terminateSync();
+            return async () => await this.openContinuousReplication(this.originalSetting, showResult, false);
+          }
+          if (syncResult == "NEED_RETRY") {
+            const tempSetting = JSON.parse(JSON.stringify(setting));
+            tempSetting.batch_size = Math.ceil(tempSetting.batch_size / 2) + 2;
+            tempSetting.batches_limit = Math.ceil(tempSetting.batches_limit / 2) + 2;
+            if (tempSetting.batch_size <= 5 && tempSetting.batches_limit <= 5) {
+              Logger(
+                this.translate("liveSyncReplicator.cantReplicateLowerValue"),
+                showResult ? LOG_LEVEL_NOTICE : LOG_LEVEL_INFO
+              );
+              return false;
+            } else {
+              Logger(
+                this.translate("liveSyncReplicator.retryLowerBatchSize", {
+                  batch_size: tempSetting.batch_size.toString(),
+                  batches_limit: tempSetting.batches_limit.toString()
+                }),
+                showResult ? LOG_LEVEL_NOTICE : LOG_LEVEL_INFO
+              );
+              return async () => await this.openContinuousReplication(tempSetting, showResult, true);
+            }
+          }
+        } finally {
+          await this.closeRemoteDatabase(db);
         }
       }
       return false;
@@ -839,12 +853,16 @@ ${sendingDocs}/(${sentDocsCount} done)`,
     const con = await this.connectRemoteCouchDBWithSetting(setting, this.isMobile(), true);
     if (typeof con == "string") return;
     try {
-      await con.db.destroy();
-      Logger(this.translate("liveSyncReplicator.remoteDbDestroyed"), LOG_LEVEL_NOTICE);
-      await this.tryCreateRemoteDatabase(setting);
-    } catch (ex) {
-      Logger(this.translate("liveSyncReplicator.remoteDbDestroyError"), LOG_LEVEL_NOTICE);
-      Logger(ex, LOG_LEVEL_NOTICE);
+      try {
+        await con.db.destroy();
+        Logger(this.translate("liveSyncReplicator.remoteDbDestroyed"), LOG_LEVEL_NOTICE);
+        await this.tryCreateRemoteDatabase(setting);
+      } catch (ex) {
+        Logger(this.translate("liveSyncReplicator.remoteDbDestroyError"), LOG_LEVEL_NOTICE);
+        Logger(ex, LOG_LEVEL_NOTICE);
+      }
+    } finally {
+      await this.closeRemoteDatabase(con.db);
     }
     clearHandlers();
     await this.ensurePBKDF2Salt(setting, true, false);
@@ -853,6 +871,7 @@ ${sendingDocs}/(${sentDocsCount} done)`,
     this.closeReplication();
     const con2 = await this.connectRemoteCouchDBWithSetting(setting, this.isMobile(), true);
     if (typeof con2 === "string") return;
+    await this.closeRemoteDatabase(con2.db);
     clearHandlers();
     await this.ensurePBKDF2Salt(setting, true, false);
     Logger(this.translate("liveSyncReplicator.remoteDbCreatedOrConnected"), LOG_LEVEL_NOTICE);
@@ -864,35 +883,37 @@ ${sendingDocs}/(${sentDocsCount} done)`,
       Logger(this.translate("liveSyncReplicator.couldNotConnectToURI", { uri, dbRet }), LOG_LEVEL_NOTICE);
       return;
     }
-    if (!await checkRemoteVersion(dbRet.db, this.migrate.bind(this), VER)) {
-      Logger(this.translate("liveSyncReplicator.remoteDbCorrupted"), LOG_LEVEL_NOTICE);
-      return;
-    }
-    const defInitPoint = {
-      _id: MILESTONE_DOCID,
-      type: "milestoneinfo",
-      created: Date.now(),
-      locked,
-      cleaned: lockByClean,
-      accepted_nodes: [this.nodeid],
-      node_chunk_info: { [this.nodeid]: currentVersionRange },
-      node_info: {},
-      tweak_values: {}
-    };
-    const remoteMilestone = {
-      ...defInitPoint,
-      ...await resolveWithIgnoreKnownError(dbRet.db.get(MILESTONE_DOCID), defInitPoint)
-    };
-    remoteMilestone.node_chunk_info = { ...defInitPoint.node_chunk_info, ...remoteMilestone.node_chunk_info };
-    remoteMilestone.accepted_nodes = [this.nodeid];
-    remoteMilestone.locked = locked;
-    remoteMilestone.cleaned = remoteMilestone.cleaned || lockByClean;
-    if (locked) {
-      Logger(this.translate("liveSyncReplicator.lockRemoteDb"), LOG_LEVEL_NOTICE);
-    } else {
-      Logger(this.translate("liveSyncReplicator.unlockRemoteDb"), LOG_LEVEL_NOTICE);
-    }
-    await dbRet.db.put(remoteMilestone);
+    await this.withRemoteDatabase(dbRet.db, async (db) => {
+      if (!await checkRemoteVersion(db, this.migrate.bind(this), VER)) {
+        Logger(this.translate("liveSyncReplicator.remoteDbCorrupted"), LOG_LEVEL_NOTICE);
+        return;
+      }
+      const defInitPoint = {
+        _id: MILESTONE_DOCID,
+        type: "milestoneinfo",
+        created: Date.now(),
+        locked,
+        cleaned: lockByClean,
+        accepted_nodes: [this.nodeid],
+        node_chunk_info: { [this.nodeid]: currentVersionRange },
+        node_info: {},
+        tweak_values: {}
+      };
+      const remoteMilestone = {
+        ...defInitPoint,
+        ...await resolveWithIgnoreKnownError(db.get(MILESTONE_DOCID), defInitPoint)
+      };
+      remoteMilestone.node_chunk_info = { ...defInitPoint.node_chunk_info, ...remoteMilestone.node_chunk_info };
+      remoteMilestone.accepted_nodes = [this.nodeid];
+      remoteMilestone.locked = locked;
+      remoteMilestone.cleaned = remoteMilestone.cleaned || lockByClean;
+      if (locked) {
+        Logger(this.translate("liveSyncReplicator.lockRemoteDb"), LOG_LEVEL_NOTICE);
+      } else {
+        Logger(this.translate("liveSyncReplicator.unlockRemoteDb"), LOG_LEVEL_NOTICE);
+      }
+      await db.put(remoteMilestone);
+    });
   }
   async markRemoteResolved(setting) {
     const uri = setting.couchDB_URI.replace(/\/+$/, "") + (setting.couchDB_DBNAME == "" ? "" : "/" + setting.couchDB_DBNAME);
@@ -901,33 +922,35 @@ ${sendingDocs}/(${sentDocsCount} done)`,
       Logger(this.translate("liveSyncReplicator.couldNotConnectToURI", { uri, dbRet }), LOG_LEVEL_NOTICE);
       return;
     }
-    if (!await checkRemoteVersion(dbRet.db, this.migrate.bind(this), VER)) {
-      Logger(this.translate("liveSyncReplicator.remoteDbCorrupted"), LOG_LEVEL_NOTICE);
-      return;
-    }
-    const defInitPoint = {
-      _id: MILESTONE_DOCID,
-      type: "milestoneinfo",
-      created: Date.now(),
-      locked: false,
-      accepted_nodes: [this.nodeid],
-      node_info: {},
-      node_chunk_info: { [this.nodeid]: currentVersionRange },
-      tweak_values: {}
-    };
-    const remoteMilestone = {
-      ...defInitPoint,
-      ...await resolveWithIgnoreKnownError(dbRet.db.get(MILESTONE_DOCID), defInitPoint)
-    };
-    remoteMilestone.node_chunk_info = { ...defInitPoint.node_chunk_info, ...remoteMilestone.node_chunk_info };
-    remoteMilestone.accepted_nodes = Array.from(/* @__PURE__ */ new Set([...remoteMilestone.accepted_nodes, this.nodeid]));
-    Logger(this.translate("liveSyncReplicator.markDeviceResolved"), LOG_LEVEL_NOTICE);
-    const result = await dbRet.db.put(remoteMilestone);
-    if (result.ok) {
-      Logger(this.translate("liveSyncReplicator.remoteDbMarkedResolved"), LOG_LEVEL_VERBOSE);
-    } else {
-      Logger(this.translate("liveSyncReplicator.couldNotMarkResolveRemoteDb"), LOG_LEVEL_NOTICE);
-    }
+    await this.withRemoteDatabase(dbRet.db, async (db) => {
+      if (!await checkRemoteVersion(db, this.migrate.bind(this), VER)) {
+        Logger(this.translate("liveSyncReplicator.remoteDbCorrupted"), LOG_LEVEL_NOTICE);
+        return;
+      }
+      const defInitPoint = {
+        _id: MILESTONE_DOCID,
+        type: "milestoneinfo",
+        created: Date.now(),
+        locked: false,
+        accepted_nodes: [this.nodeid],
+        node_info: {},
+        node_chunk_info: { [this.nodeid]: currentVersionRange },
+        tweak_values: {}
+      };
+      const remoteMilestone = {
+        ...defInitPoint,
+        ...await resolveWithIgnoreKnownError(db.get(MILESTONE_DOCID), defInitPoint)
+      };
+      remoteMilestone.node_chunk_info = { ...defInitPoint.node_chunk_info, ...remoteMilestone.node_chunk_info };
+      remoteMilestone.accepted_nodes = Array.from(/* @__PURE__ */ new Set([...remoteMilestone.accepted_nodes, this.nodeid]));
+      Logger(this.translate("liveSyncReplicator.markDeviceResolved"), LOG_LEVEL_NOTICE);
+      const result = await db.put(remoteMilestone);
+      if (result.ok) {
+        Logger(this.translate("liveSyncReplicator.remoteDbMarkedResolved"), LOG_LEVEL_VERBOSE);
+      } else {
+        Logger(this.translate("liveSyncReplicator.couldNotMarkResolveRemoteDb"), LOG_LEVEL_NOTICE);
+      }
+    });
   }
   connectRemoteCouchDBWithSetting(settings, isMobile, performSetup = false, skipInfo = false) {
     if (settings.encrypt && settings.passphrase == "" && !settings.permitEmptyPassphrase) {
@@ -976,14 +999,19 @@ ${sendingDocs}/(${sentDocsCount} done)`,
    * @throws {Error} Other errors that may occur during the fetch operation.
    */
   async fetchRemoteDocument(settings, id, db) {
+    const ownsConnection = db === void 0;
+    const connDB = db ?? await this._ensureConnection(settings);
     try {
-      const connDB = db ?? await this._ensureConnection(settings);
       return await connDB.get(id);
     } catch (ex) {
       if (ex && ex.status == 404) {
         return false;
       }
       throw ex;
+    } finally {
+      if (ownsConnection) {
+        await this.closeRemoteDatabase(connDB);
+      }
     }
   }
   /**
@@ -995,8 +1023,15 @@ ${sendingDocs}/(${sentDocsCount} done)`,
    * @throws {Error} If the document could not be put.
    */
   async putRemoteDocument(settings, doc, db) {
+    const ownsConnection = db === void 0;
     const connDB = db ?? await this._ensureConnection(settings, true);
-    return await connDB.put(doc);
+    try {
+      return await connDB.put(doc);
+    } finally {
+      if (ownsConnection) {
+        await this.closeRemoteDatabase(connDB);
+      }
+    }
   }
   async fetchRemoteChunks(missingChunks, showResult) {
     const ret = await this.connectRemoteCouchDBWithSetting(this.currentSettings, this.isMobile(), false, true);
@@ -1008,19 +1043,23 @@ ${sendingDocs}/(${sentDocsCount} done)`,
       );
       return false;
     }
-    const remoteChunks = await ret.db.allDocs({ keys: missingChunks, include_docs: true });
-    const errorRows = remoteChunks.rows.filter((e) => "error" in e);
-    if (errorRows.length > 0) {
-      Logger(
-        `Some requested chunks were not found in the remote database.`,
-        showResult ? LOG_LEVEL_NOTICE : LOG_LEVEL_INFO,
-        "fetch"
-      );
-      Logger(`Requested chunks: ${missingChunks.join(",")}`, LOG_LEVEL_VERBOSE);
-      Logger(`Error chunks: ${errorRows.map((e) => e.key).join(",")}`, LOG_LEVEL_VERBOSE);
-    }
-    const remoteChunkItems = remoteChunks.rows.filter((e) => !("error" in e)).map((e) => e.doc).filter((e) => e !== void 0);
-    return remoteChunkItems;
+    return await this.withRemoteDatabase(ret.db, async (db) => {
+      const remoteChunks = await db.allDocs({ keys: missingChunks, include_docs: true });
+      const errorRows = remoteChunks.rows.filter((e) => "error" in e);
+      if (errorRows.length > 0) {
+        Logger(
+          `Some requested chunks were not found in the remote database.`,
+          showResult ? LOG_LEVEL_NOTICE : LOG_LEVEL_INFO,
+          "fetch"
+        );
+        Logger(`Requested chunks: ${missingChunks.join(",")}`, LOG_LEVEL_VERBOSE);
+        Logger(
+          `Error chunks: ${errorRows.map((e) => e.key).join(",")}`,
+          LOG_LEVEL_VERBOSE
+        );
+      }
+      return remoteChunks.rows.filter((e) => !("error" in e)).map((e) => e.doc).filter((e) => e !== void 0);
+    });
   }
   async tryConnectRemote(setting, showResult = true) {
     const db = await this.connectRemoteCouchDBWithSetting(setting, this.isMobile(), true);
@@ -1035,8 +1074,10 @@ ${sendingDocs}/(${sentDocsCount} done)`,
       );
       return false;
     }
-    Logger(`Connected to ${db.info.db_name} successfully`, LOG_LEVEL_NOTICE);
-    return true;
+    return await this.withRemoteDatabase(db.db, async () => {
+      Logger(`Connected to ${db.info.db_name} successfully`, LOG_LEVEL_NOTICE);
+      return true;
+    });
   }
   async resetRemoteTweakSettings(setting) {
     const uri = setting.couchDB_URI.replace(/\/+$/, "") + (setting.couchDB_DBNAME == "" ? "" : "/" + setting.couchDB_DBNAME);
@@ -1045,19 +1086,21 @@ ${sendingDocs}/(${sentDocsCount} done)`,
       Logger(this.translate("liveSyncReplicator.couldNotConnectToURI", { uri, dbRet }), LOG_LEVEL_NOTICE);
       return;
     }
-    if (!await checkRemoteVersion(dbRet.db, this.migrate.bind(this), VER)) {
-      Logger(this.translate("liveSyncReplicator.remoteDbCorrupted"), LOG_LEVEL_NOTICE);
-      return;
-    }
-    try {
-      const remoteMilestone = await dbRet.db.get(MILESTONE_DOCID);
-      remoteMilestone.tweak_values = {};
-      await dbRet.db.put(remoteMilestone);
-      Logger(`tweak values on the remote database have been cleared`, LOG_LEVEL_VERBOSE);
-    } catch (ex) {
-      Logger(`Could not retrieve remote milestone`, LOG_LEVEL_NOTICE);
-      throw ex;
-    }
+    await this.withRemoteDatabase(dbRet.db, async (db) => {
+      if (!await checkRemoteVersion(db, this.migrate.bind(this), VER)) {
+        Logger(this.translate("liveSyncReplicator.remoteDbCorrupted"), LOG_LEVEL_NOTICE);
+        return;
+      }
+      try {
+        const remoteMilestone = await db.get(MILESTONE_DOCID);
+        remoteMilestone.tweak_values = {};
+        await db.put(remoteMilestone);
+        Logger(`tweak values on the remote database have been cleared`, LOG_LEVEL_VERBOSE);
+      } catch (ex) {
+        Logger(`Could not retrieve remote milestone`, LOG_LEVEL_NOTICE);
+        throw ex;
+      }
+    });
   }
   async setPreferredRemoteTweakSettings(setting) {
     const uri = setting.couchDB_URI.replace(/\/+$/, "") + (setting.couchDB_DBNAME == "" ? "" : "/" + setting.couchDB_DBNAME);
@@ -1066,19 +1109,21 @@ ${sendingDocs}/(${sentDocsCount} done)`,
       Logger(this.translate("liveSyncReplicator.couldNotConnectToURI", { uri, dbRet }), LOG_LEVEL_NOTICE);
       return;
     }
-    if (!await checkRemoteVersion(dbRet.db, this.migrate.bind(this), VER)) {
-      Logger(this.translate("liveSyncReplicator.remoteDbCorrupted"), LOG_LEVEL_NOTICE);
-      return;
-    }
-    try {
-      const remoteMilestone = await dbRet.db.get(MILESTONE_DOCID);
-      remoteMilestone.tweak_values[DEVICE_ID_PREFERRED] = extractObject(TweakValuesTemplate, { ...setting });
-      await dbRet.db.put(remoteMilestone);
-      Logger(`Preferred tweak values has been registered`, LOG_LEVEL_VERBOSE);
-    } catch (ex) {
-      Logger(`Could not retrieve remote milestone`, LOG_LEVEL_NOTICE);
-      throw ex;
-    }
+    await this.withRemoteDatabase(dbRet.db, async (db) => {
+      if (!await checkRemoteVersion(db, this.migrate.bind(this), VER)) {
+        Logger(this.translate("liveSyncReplicator.remoteDbCorrupted"), LOG_LEVEL_NOTICE);
+        return;
+      }
+      try {
+        const remoteMilestone = await db.get(MILESTONE_DOCID);
+        remoteMilestone.tweak_values[DEVICE_ID_PREFERRED] = extractObject(TweakValuesTemplate, { ...setting });
+        await db.put(remoteMilestone);
+        Logger(`Preferred tweak values has been registered`, LOG_LEVEL_VERBOSE);
+      } catch (ex) {
+        Logger(`Could not retrieve remote milestone`, LOG_LEVEL_NOTICE);
+        throw ex;
+      }
+    });
   }
   async getRemotePreferredTweakValues(setting) {
     const uri = setting.couchDB_URI.replace(/\/+$/, "") + (setting.couchDB_DBNAME == "" ? "" : "/" + setting.couchDB_DBNAME);
@@ -1100,56 +1145,58 @@ ${sendingDocs}/(${sentDocsCount} done)`,
         error: new Error(dbRet)
       };
     }
-    try {
-      if (!await checkRemoteVersion(dbRet.db, this.migrate.bind(this), VER)) {
-        const error = new Error("The remote database version is not compatible");
-        Logger(this.translate("liveSyncReplicator.remoteDbCorrupted"), LOG_LEVEL_NOTICE);
+    return await this.withRemoteDatabase(dbRet.db, async (db) => {
+      try {
+        if (!await checkRemoteVersion(db, this.migrate.bind(this), VER)) {
+          const error = new Error("The remote database version is not compatible");
+          Logger(this.translate("liveSyncReplicator.remoteDbCorrupted"), LOG_LEVEL_NOTICE);
+          return {
+            status: RemotePreferredTweakStatuses.UNAVAILABLE,
+            error
+          };
+        }
+      } catch (ex) {
+        Logger(`Could not check the remote database version`, LOG_LEVEL_NOTICE);
+        Logger(ex, LOG_LEVEL_VERBOSE);
         return {
           status: RemotePreferredTweakStatuses.UNAVAILABLE,
-          error
+          error: ex
         };
       }
-    } catch (ex) {
-      Logger(`Could not check the remote database version`, LOG_LEVEL_NOTICE);
-      Logger(ex, LOG_LEVEL_VERBOSE);
-      return {
-        status: RemotePreferredTweakStatuses.UNAVAILABLE,
-        error: ex
-      };
-    }
-    try {
-      const remoteMilestone = await dbRet.db.get(MILESTONE_DOCID);
-      if (!remoteMilestone) {
-        return {
-          status: RemotePreferredTweakStatuses.NOT_CONFIGURED,
-          reason: RemotePreferredTweakNotConfiguredReasons.MILESTONE_MISSING
-        };
-      }
-      const preferred = remoteMilestone.tweak_values?.[DEVICE_ID_PREFERRED];
-      if (!preferred) {
+      try {
+        const remoteMilestone = await db.get(MILESTONE_DOCID);
+        if (!remoteMilestone) {
+          return {
+            status: RemotePreferredTweakStatuses.NOT_CONFIGURED,
+            reason: RemotePreferredTweakNotConfiguredReasons.MILESTONE_MISSING
+          };
+        }
+        const preferred = remoteMilestone.tweak_values?.[DEVICE_ID_PREFERRED];
+        if (!preferred) {
+          return {
+            status: RemotePreferredTweakStatuses.NOT_CONFIGURED,
+            reason: RemotePreferredTweakNotConfiguredReasons.PREFERRED_VALUES_MISSING
+          };
+        }
         return {
-          status: RemotePreferredTweakStatuses.NOT_CONFIGURED,
-          reason: RemotePreferredTweakNotConfiguredReasons.PREFERRED_VALUES_MISSING
+          status: RemotePreferredTweakStatuses.AVAILABLE,
+          values: preferred
         };
-      }
-      return {
-        status: RemotePreferredTweakStatuses.AVAILABLE,
-        values: preferred
-      };
-    } catch (ex) {
-      if (isErrorOfMissingDoc(ex)) {
+      } catch (ex) {
+        if (isErrorOfMissingDoc(ex)) {
+          return {
+            status: RemotePreferredTweakStatuses.NOT_CONFIGURED,
+            reason: RemotePreferredTweakNotConfiguredReasons.MILESTONE_MISSING
+          };
+        }
+        Logger(`Could not retrieve remote milestone`, LOG_LEVEL_NOTICE);
+        Logger(ex, LOG_LEVEL_VERBOSE);
         return {
-          status: RemotePreferredTweakStatuses.NOT_CONFIGURED,
-          reason: RemotePreferredTweakNotConfiguredReasons.MILESTONE_MISSING
+          status: RemotePreferredTweakStatuses.UNAVAILABLE,
+          error: ex
         };
       }
-      Logger(`Could not retrieve remote milestone`, LOG_LEVEL_NOTICE);
-      Logger(ex, LOG_LEVEL_VERBOSE);
-      return {
-        status: RemotePreferredTweakStatuses.UNAVAILABLE,
-        error: ex
-      };
-    }
+    });
   }
   async compactRemote(setting) {
     const uri = setting.couchDB_URI.replace(/\/+$/, "") + (setting.couchDB_DBNAME == "" ? "" : "/" + setting.couchDB_DBNAME);
@@ -1158,8 +1205,7 @@ ${sendingDocs}/(${sentDocsCount} done)`,
       Logger(this.translate("liveSyncReplicator.couldNotConnectToURI", { uri, dbRet }), LOG_LEVEL_NOTICE);
       return false;
     }
-    const ret = await dbRet.db.compact({ interval: 1e3 });
-    return ret.ok;
+    return await this.withRemoteDatabase(dbRet.db, async (db) => (await db.compact({ interval: 1e3 })).ok);
   }
   async getRemoteStatus(setting) {
     const dbRet = await this.connectRemoteCouchDBWithSetting(setting, this.isMobile(), true);
@@ -1168,11 +1214,13 @@ ${sendingDocs}/(${sentDocsCount} done)`,
       Logger(this.translate("liveSyncReplicator.couldNotConnectToURI", { uri, dbRet }), LOG_LEVEL_NOTICE);
       return false;
     }
-    const info = await dbRet.db.info();
-    return {
-      ...info,
-      estimatedSize: info?.sizes?.file || 0
-    };
+    return await this.withRemoteDatabase(dbRet.db, async (db) => {
+      const info = await db.info();
+      return {
+        ...info,
+        estimatedSize: info?.sizes?.file || 0
+      };
+    });
   }
   async countCompromisedChunks(setting = this.currentSettings) {
     const dbRet = await this.connectRemoteCouchDBWithSetting(setting, this.isMobile(), true);
@@ -1181,8 +1229,7 @@ ${sendingDocs}/(${sentDocsCount} done)`,
       Logger(this.translate("liveSyncReplicator.couldNotConnectToURI", { uri, dbRet }), LOG_LEVEL_NOTICE);
       return false;
     }
-    const compromised = await countCompromisedChunks(dbRet.db);
-    return compromised;
+    return await this.withRemoteDatabase(dbRet.db, countCompromisedChunks);
   }
   async getConnectedDeviceList(setting = this.currentSettings) {
     const dbRet = await this.connectRemoteCouchDBWithSetting(setting, this.isMobile(), true);
@@ -1191,14 +1238,16 @@ ${sendingDocs}/(${sentDocsCount} done)`,
       Logger(this.translate("liveSyncReplicator.couldNotConnectToURI", { uri, dbRet }), LOG_LEVEL_NOTICE);
       return false;
     }
-    const milestoneDoc = await dbRet.db.get(MILESTONE_DOCID);
-    if (!milestoneDoc) {
-      Logger("Could not retrieve remote milestone", LOG_LEVEL_NOTICE);
-      return false;
-    }
-    const nodeInfo = milestoneDoc.node_info;
-    const acceptedNodes = milestoneDoc.accepted_nodes || [];
-    return { node_info: nodeInfo, accepted_nodes: acceptedNodes };
+    return await this.withRemoteDatabase(dbRet.db, async (db) => {
+      const milestoneDoc = await db.get(MILESTONE_DOCID);
+      if (!milestoneDoc) {
+        Logger("Could not retrieve remote milestone", LOG_LEVEL_NOTICE);
+        return false;
+      }
+      const nodeInfo = milestoneDoc.node_info;
+      const acceptedNodes = milestoneDoc.accepted_nodes || [];
+      return { node_info: nodeInfo, accepted_nodes: acceptedNodes };
+    });
   }
 }
 export {