@vrtmrz/livesync-commonlib 0.1.13 → 0.1.14

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 {

package/dist/services/base/RemoteService.js

@@ -203,6 +203,12 @@ class RemoteService extends ServiceBase {
       const exMsg = ex instanceof Error ? ex : LiveSyncError.fromError(ex);
       const msg = `${exMsg.name}:${exMsg.message}`;
       this._log(ex, LOG_LEVEL_VERBOSE);
+      try {
+        await db.close();
+      } catch (closeError) {
+        this._log("Failed to close remote database after connection failure.", LOG_LEVEL_INFO);
+        this._log(closeError, LOG_LEVEL_VERBOSE);
+      }
       return msg;
     }
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vrtmrz/livesync-commonlib",
-  "version": "0.1.13",
+  "version": "0.1.14",
   "description": "Shared data, storage, and replication primitives for Self-hosted LiveSync clients.",
   "type": "module",
   "types": "./dist/index.d.ts",