@vrtmrz/livesync-commonlib 0.1.14 → 0.1.16

package/dist/services/base/RemoteService.js

@@ -13,26 +13,84 @@ import { UnresolvedErrorManager } from "./UnresolvedErrorManager.js";
 import { createInstanceLogFunction, MARK_LOG_NETWORK_ERROR } from "../lib/logUtils.js";
 import { runWithTrackedPhysicalRequest } from "../lib/remoteActivity.js";
 import { LiveSyncError } from "../../common/LSError.js";
+function createRemoteConnectionScope(ownerSignal) {
+  const controller = new AbortController();
+  const combinedSignals = /* @__PURE__ */ new WeakMap();
+  let detachOwner = () => {
+  };
+  const abort = (reason) => {
+    detachOwner();
+    if (!controller.signal.aborted) {
+      controller.abort(reason);
+    }
+  };
+  if (ownerSignal?.aborted) {
+    abort(ownerSignal.reason);
+  } else if (ownerSignal) {
+    const onOwnerAbort = () => abort(ownerSignal.reason);
+    ownerSignal.addEventListener("abort", onOwnerAbort, { once: true });
+    detachOwner = () => ownerSignal.removeEventListener("abort", onOwnerAbort);
+  }
+  const combine = (signal) => {
+    if (!signal || signal === controller.signal) return controller.signal;
+    const cached = combinedSignals.get(signal);
+    if (cached) return cached;
+    const combined = combineAbortSignals(signal, controller.signal);
+    combinedSignals.set(signal, combined);
+    return combined;
+  };
+  return { signal: controller.signal, combine, abort };
+}
+function combineAbortSignals(first, second) {
+  if (first === second) return first;
+  const abortSignalWithAny = AbortSignal;
+  if (typeof abortSignalWithAny.any === "function") {
+    return abortSignalWithAny.any([first, second]);
+  }
+  const controller = new AbortController();
+  const listeners = /* @__PURE__ */ new Map();
+  const detach = () => {
+    for (const [signal, listener] of listeners) {
+      signal.removeEventListener("abort", listener);
+    }
+    listeners.clear();
+  };
+  const abortFrom = (signal) => {
+    detach();
+    if (!controller.signal.aborted) {
+      controller.abort(signal.reason);
+    }
+  };
+  for (const signal of [first, second]) {
+    if (signal.aborted) {
+      abortFrom(signal);
+      break;
+    }
+    const listener = () => abortFrom(signal);
+    listeners.set(signal, listener);
+    signal.addEventListener("abort", listener, { once: true });
+  }
+  return controller.signal;
+}
+function createCouchDBConnection(db, info, scope) {
+  let closePromise;
+  return {
+    db,
+    info,
+    close: () => {
+      closePromise ??= (async () => {
+        scope.abort(new Error("Remote connection closed."));
+        await db.close();
+      })();
+      return closePromise;
+    }
+  };
+}
 const FetchMethod = {
   webCompat: 0,
   native: 1
 };
 class RemoteService extends ServiceBase {
-  /**
-   * Connect to the remote database with the provided settings.
-   * @param uri  The URI of the remote database.
-   * @param auth  The authentication credentials for the remote database.
-   * @param disableRequestURI  Whether to disable the request URI.
-   * @param passphrase  The passphrase for the remote database.
-   * @param useDynamicIterationCount  Whether to use dynamic iteration count.
-   * @param performSetup  Whether to perform setup.
-   * @param skipInfo  Whether to skip information retrieval.
-   * @param compression  Whether to enable compression.
-   * @param customHeaders  Custom headers to include in the request.
-   * @param useRequestAPI  Whether to use the request API.
-   * @param getPBKDF2Salt  Function to retrieve the PBKDF2 salt.
-   * Note that this function is used for CouchDB and compatible only.
-   */
   _log;
   _authHeader = new AuthorizationHeaderGenerator();
   _APIService;
@@ -101,13 +159,35 @@ class RemoteService extends ServiceBase {
       return response;
     });
   }
-  async connect(uri, auth, disableRequestURI, passphrase, useDynamicIterationCount, performSetup, skipInfo, compression, customHeaders, useRequestAPI, getPBKDF2Salt) {
+  /**
+   * Opens a remote CouchDB connection with request cancellation bound to its
+   * owner.
+   *
+   * @param uri - The URI of the remote database.
+   * @param auth - Authentication credentials for the remote database.
+   * @param disableRequestURI - Whether request URI handling is disabled.
+   * @param passphrase - The database encryption passphrase, or `false` when
+   * encryption is disabled.
+   * @param useDynamicIterationCount - Whether legacy dynamic iteration counts
+   * are enabled.
+   * @param performSetup - Whether PouchDB may set up a missing database.
+   * @param skipInfo - Whether to omit the opening database information request.
+   * @param compression - Whether chunk compression is enabled.
+   * @param customHeaders - Additional HTTP headers for every request.
+   * @param useRequestAPI - Whether to use the host-native request adapter.
+   * @param getPBKDF2Salt - Resolves the PBKDF2 salt when encryption needs it.
+   * @param connectionOptions - Ownership and request fallback options.
+   * @returns An error description, or the owned connection. The caller must
+   * transfer ownership or call `close()`.
+   */
+  async connect(uri, auth, disableRequestURI, passphrase, useDynamicIterationCount, performSetup, skipInfo, compression, customHeaders, useRequestAPI, getPBKDF2Salt, connectionOptions = {}) {
     if (!isValidRemoteCouchDBURI(uri)) return "Remote URI is not valid";
     if (uri.toLowerCase() != uri) return "Remote URI and database name could not contain capital letters.";
     if (uri.indexOf(" ") !== -1) return "Remote URI and database name could not contain spaces.";
     if (!this._APIService.isOnline) {
       return "Network is offline";
     }
+    const connectionScope = createRemoteConnectionScope(connectionOptions.signal);
     const conf = {
       adapter: "http",
       auth: "username" in auth ? auth : void 0,
@@ -143,14 +223,18 @@ class RemoteService extends ServiceBase {
             headers.append("authorization", authHeader);
           }
           try {
+            const signal = connectionScope.combine(opts?.signal);
             const response = await this.performFetch(
               requestSrc,
-              { ...opts, headers },
+              { ...opts, headers, signal },
               useRequestAPI ? FetchMethod.native : FetchMethod.webCompat
             );
             return response;
           } catch (ex) {
             if (ex instanceof TypeError) {
+              if (connectionScope.signal.aborted || connectionOptions.allowNativeFallback === false) {
+                throw ex;
+              }
               if (useRequestAPI) {
                 this._log("Failed to request by API.");
                 throw ex;
@@ -176,7 +260,12 @@ class RemoteService extends ServiceBase {
         } catch (ex) {
           this._log(`HTTP:${method}${size} to:${localURL} -> failed`, LOG_LEVEL_VERBOSE);
           const msg = ex instanceof Error ? `${ex?.name}:${ex?.message}` : ex?.toString();
-          this.showError(`${MARK_LOG_NETWORK_ERROR}Network Error: Failed to fetch: ${msg}`, LOG_LEVEL_INFO);
+          if (!connectionScope.signal.aborted) {
+            this.showError(
+              `${MARK_LOG_NETWORK_ERROR}Network Error: Failed to fetch: ${msg}`,
+              LOG_LEVEL_INFO
+            );
+          }
           this._log(ex, LOG_LEVEL_VERBOSE);
           if (url.toString().indexOf("_bulk_docs") !== -1) {
             this.last_successful_post = false;
@@ -187,28 +276,44 @@ class RemoteService extends ServiceBase {
       }
     };
     const setting = this._settingService.currentSettings();
-    const db = new this._pouchDB(uri, conf);
-    replicationFilter(db, compression);
-    disableEncryption();
-    if (passphrase !== "false" && typeof passphrase === "string") {
-      enableEncryption(db, passphrase, useDynamicIterationCount, false, getPBKDF2Salt, setting.E2EEAlgorithm);
+    let db;
+    try {
+      db = new this._pouchDB(uri, conf);
+    } catch (ex) {
+      connectionScope.abort(ex);
+      throw ex;
+    }
+    const compatibilityInfo = { db_name: "", doc_count: 0, update_seq: "" };
+    const connection = createCouchDBConnection(db, compatibilityInfo, connectionScope);
+    const closeAfterConnectionFailure = async () => {
+      try {
+        await connection.close();
+      } catch (closeError) {
+        this._log("Failed to close remote database after connection failure.", LOG_LEVEL_INFO);
+        this._log(closeError, LOG_LEVEL_VERBOSE);
+      }
+    };
+    try {
+      replicationFilter(db, compression);
+      disableEncryption();
+      if (passphrase !== "false" && typeof passphrase === "string") {
+        enableEncryption(db, passphrase, useDynamicIterationCount, false, getPBKDF2Salt, setting.E2EEAlgorithm);
+      }
+    } catch (ex) {
+      await closeAfterConnectionFailure();
+      throw ex;
     }
     if (skipInfo) {
-      return { db, info: { db_name: "", doc_count: 0, update_seq: "" } };
+      return connection;
     }
     try {
       const info = await db.info();
-      return { db, info };
+      return { ...connection, info };
     } catch (ex) {
       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);
-      }
+      await closeAfterConnectionFailure();
       return msg;
     }
   }

package/dist/string_and_binary/path.js

@@ -68,11 +68,7 @@ function expandDocumentIDPrefix(id) {
 const _hashString = memorizeFuncWithLRUCache(async (key) => {
   const buff = writeString(key);
   const webcrypto = await getWebCrypto();
-  let digest = await webcrypto.subtle.digest("SHA-256", buff);
-  const len = key.length;
-  for (let i = 0; i < len; i++) {
-    digest = await webcrypto.subtle.digest("SHA-256", buff);
-  }
+  const digest = await webcrypto.subtle.digest("SHA-256", buff);
   return uint8ArrayToHexString(new Uint8Array(digest));
 });
 function hashString(key) {