@vrtmrz/livesync-commonlib 0.1.0-rc.0

package/dist/pouchdb/pouchdb-browser.js

@@ -0,0 +1,96 @@
+import PouchDB from "pouchdb-core";
+import IDBPouch from "pouchdb-adapter-idb";
+import INDEXEDDBPouch from "pouchdb-adapter-indexeddb";
+import HttpPouch from "pouchdb-adapter-http";
+import mapreduce from "pouchdb-mapreduce";
+import replication from "pouchdb-replication";
+import find from "pouchdb-find";
+import transform from "transform-pouch";
+import { findPathToLeaf } from "pouchdb-merge";
+import { adapterFun } from "pouchdb-utils";
+import { createError, MISSING_DOC, UNKNOWN_ERROR } from "pouchdb-errors";
+import { mapAllTasksWithConcurrencyLimit, unwrapTaskResult } from "octagonal-wheels/concurrency/task";
+PouchDB.plugin(IDBPouch).plugin(INDEXEDDBPouch).plugin(HttpPouch).plugin(mapreduce).plugin(replication).plugin(find).plugin(transform);
+function appendPurgeSeqs(db, docs) {
+  return db.get("_local/purges").then(function(doc) {
+    for (const [docId, rev$$1] of docs) {
+      const purgeSeq = doc.purgeSeq + 1;
+      doc.purges.push({
+        docId,
+        rev: rev$$1,
+        purgeSeq
+      });
+      if (doc.purges.length > db.purged_infos_limit) {
+        doc.purges.splice(0, doc.purges.length - db.purged_infos_limit);
+      }
+      doc.purgeSeq = purgeSeq;
+    }
+    return doc;
+  }).catch(function(err) {
+    if (err.status !== 404) {
+      throw err;
+    }
+    return {
+      _id: "_local/purges",
+      purges: docs.map(([docId, rev$$1], idx) => ({
+        docId,
+        rev: rev$$1,
+        purgeSeq: idx
+      })),
+      purgeSeq: docs.length
+    };
+  }).then(function(doc) {
+    return db.put(doc);
+  });
+}
+PouchDB.prototype.purgeMulti = adapterFun(
+  "_purgeMulti",
+  function(docs, callback) {
+    if (typeof this._purge === "undefined") {
+      return callback(
+        //@ts-ignore: this ts-ignore might be hiding a `this` bug where we don't have "this" conext.
+        createError(UNKNOWN_ERROR, "Purge is not implemented in the " + this.adapter + " adapter.")
+      );
+    }
+    const self = this;
+    const tasks = docs.map(
+      (param) => () => new Promise((res, rej) => {
+        const [docId, rev$$1] = param;
+        self._getRevisionTree(docId, (error, revs) => {
+          if (error) {
+            return res([param, error]);
+          }
+          if (!revs) {
+            return res([param, createError(MISSING_DOC)]);
+          }
+          let path;
+          try {
+            path = findPathToLeaf(revs, rev$$1);
+          } catch (error2) {
+            return res([param, error2.message || error2]);
+          }
+          self._purge(docId, path, (error2, result) => {
+            if (error2) {
+              return res([param, error2]);
+            } else {
+              return res([param, result]);
+            }
+          });
+        });
+      })
+    );
+    (async () => {
+      const ret = await mapAllTasksWithConcurrencyLimit(1, tasks);
+      const retAll = ret.map((e) => unwrapTaskResult(e));
+      await appendPurgeSeqs(
+        self,
+        retAll.filter((e) => "ok" in e[1]).map((e) => e[0])
+      );
+      const result = Object.fromEntries(retAll.map((e) => [e[0][0], e[1]]));
+      return result;
+    })().then((result) => callback(void 0, result)).catch((error) => callback(error));
+  }
+);
+export {
+  PouchDB
+};

package/dist/pouchdb/pouchdb-http.d.ts

@@ -0,0 +1,2 @@
+import PouchDB from "pouchdb-core";
+export { PouchDB };

package/dist/pouchdb/pouchdb-http.js

@@ -0,0 +1,94 @@
+import PouchDB from "pouchdb-core";
+import HttpPouch from "pouchdb-adapter-http";
+import mapreduce from "pouchdb-mapreduce";
+import replication from "pouchdb-replication";
+import find from "pouchdb-find";
+import transform from "transform-pouch";
+import { findPathToLeaf } from "pouchdb-merge";
+import { adapterFun } from "pouchdb-utils";
+import { createError, MISSING_DOC, UNKNOWN_ERROR } from "pouchdb-errors";
+import { mapAllTasksWithConcurrencyLimit, unwrapTaskResult } from "octagonal-wheels/concurrency/task";
+PouchDB.plugin(HttpPouch).plugin(mapreduce).plugin(replication).plugin(find).plugin(transform);
+function appendPurgeSeqs(db, docs) {
+  return db.get("_local/purges").then(function(doc) {
+    for (const [docId, rev$$1] of docs) {
+      const purgeSeq = doc.purgeSeq + 1;
+      doc.purges.push({
+        docId,
+        rev: rev$$1,
+        purgeSeq
+      });
+      if (doc.purges.length > db.purged_infos_limit) {
+        doc.purges.splice(0, doc.purges.length - db.purged_infos_limit);
+      }
+      doc.purgeSeq = purgeSeq;
+    }
+    return doc;
+  }).catch(function(err) {
+    if (err.status !== 404) {
+      throw err;
+    }
+    return {
+      _id: "_local/purges",
+      purges: docs.map(([docId, rev$$1], idx) => ({
+        docId,
+        rev: rev$$1,
+        purgeSeq: idx
+      })),
+      purgeSeq: docs.length
+    };
+  }).then(function(doc) {
+    return db.put(doc);
+  });
+}
+PouchDB.prototype.purgeMulti = adapterFun(
+  "_purgeMulti",
+  function(docs, callback) {
+    if (typeof this._purge === "undefined") {
+      return callback(
+        //@ts-ignore: this ts-ignore might be hiding a `this` bug where we don't have "this" conext.
+        createError(UNKNOWN_ERROR, "Purge is not implemented in the " + this.adapter + " adapter.")
+      );
+    }
+    const self = this;
+    const tasks = docs.map(
+      (param) => () => new Promise((res, rej) => {
+        const [docId, rev$$1] = param;
+        self._getRevisionTree(docId, (error, revs) => {
+          if (error) {
+            return res([param, error]);
+          }
+          if (!revs) {
+            return res([param, createError(MISSING_DOC)]);
+          }
+          let path;
+          try {
+            path = findPathToLeaf(revs, rev$$1);
+          } catch (error2) {
+            return res([param, error2.message || error2]);
+          }
+          self._purge(docId, path, (error2, result) => {
+            if (error2) {
+              return res([param, error2]);
+            } else {
+              return res([param, result]);
+            }
+          });
+        });
+      })
+    );
+    (async () => {
+      const ret = await mapAllTasksWithConcurrencyLimit(1, tasks);
+      const retAll = ret.map((e) => unwrapTaskResult(e));
+      await appendPurgeSeqs(
+        self,
+        retAll.filter((e) => "ok" in e[1]).map((e) => e[0])
+      );
+      const result = Object.fromEntries(retAll.map((e) => [e[0][0], e[1]]));
+      return result;
+    })().then((result) => callback(void 0, result)).catch((error) => callback(error));
+  }
+);
+export {
+  PouchDB
+};

package/dist/pouchdb/pouchdb-test.d.ts

@@ -0,0 +1,2 @@
+import PouchDB from "pouchdb-core";
+export { PouchDB };

package/dist/pouchdb/pouchdb-test.js

@@ -0,0 +1,12 @@
+import PouchDB from "pouchdb-core";
+import IDBPouch from "pouchdb-adapter-idb";
+import HttpPouch from "pouchdb-adapter-http";
+import mapreduce from "pouchdb-mapreduce";
+import replication from "pouchdb-replication";
+import find from "pouchdb-find";
+import transform from "transform-pouch";
+import adapterMemory from "pouchdb-adapter-memory";
+PouchDB.plugin(IDBPouch).plugin(HttpPouch).plugin(mapreduce).plugin(replication).plugin(find).plugin(adapterMemory).plugin(transform);
+export {
+  PouchDB
+};

package/dist/pouchdb/utils_couchdb.d.ts

@@ -0,0 +1,4 @@
+export declare const isValidRemoteCouchDBURI: (uri: string) => boolean;
+export declare function isCloudantURI(uri: string): boolean;
+export declare function isErrorOfMissingDoc(ex: unknown): boolean;
+export declare const _requestToCouchDBFetch: (baseUri: string, username: string, password: string, path?: string, body?: unknown, method?: string) => Promise<Response>;

package/dist/pouchdb/utils_couchdb.js

@@ -0,0 +1,38 @@
+import { _fetch, compatGlobal } from "../common/coreEnvFunctions.js";
+import { writeString } from "../string_and_binary/convert.js";
+const isValidRemoteCouchDBURI = (uri) => {
+  if (uri.startsWith("https://")) return true;
+  if (uri.startsWith("http://")) return true;
+  return false;
+};
+function isCloudantURI(uri) {
+  if (uri.indexOf(".cloudantnosqldb.") !== -1 || uri.indexOf(".cloudant.com") !== -1) return true;
+  return false;
+}
+function isErrorOfMissingDoc(ex) {
+  return (ex && ex.status) == 404;
+}
+const _requestToCouchDBFetch = async (baseUri, username, password, path, body, method) => {
+  const utf8str = String.fromCharCode.apply(null, [...writeString(`${username}:${password}`)]);
+  const encoded = compatGlobal.btoa(utf8str);
+  const authHeader = "Basic " + encoded;
+  const transformedHeaders = {
+    authorization: authHeader,
+    "content-type": "application/json"
+  };
+  const uri = `${baseUri}/${path}`;
+  const requestParam = {
+    url: uri,
+    method: method || (body ? "PUT" : "GET"),
+    headers: new Headers(transformedHeaders),
+    contentType: "application/json",
+    body: JSON.stringify(body)
+  };
+  return await _fetch(uri, requestParam);
+};
+export {
+  _requestToCouchDBFetch,
+  isCloudantURI,
+  isErrorOfMissingDoc,
+  isValidRemoteCouchDBURI
+};

package/dist/replication/LiveSyncAbstractReplicator.d.ts

@@ -0,0 +1,69 @@
+import { type EntryDoc, type DatabaseConnectingStatus, type RemoteDBSettings, type EntryLeaf, type TweakValues, type NodeData } from "../common/types.js";
+import type { RequiredServices } from "../interfaces/ServiceModule.js";
+import type { TranslationParameters } from "../services/base/MessageTranslator.js";
+export type ReplicationCallback = (e: PouchDB.Core.ExistingDocument<EntryDoc>[]) => Promise<boolean> | boolean;
+export type ReplicationStat = {
+    sent: number;
+    arrived: number;
+    maxPullSeq: number;
+    maxPushSeq: number;
+    lastSyncPullSeq: number;
+    lastSyncPushSeq: number;
+    syncStatus: DatabaseConnectingStatus;
+};
+export interface LiveSyncReplicatorEnv {
+    services: RequiredServices<"API" | "appLifecycle" | "setting" | "vault" | "database" | "databaseEvents" | "keyValueDB" | "replication" | "config" | "UI" | "replicator" | "remote">;
+}
+export type RemoteDBStatus = {
+    [key: string]: unknown;
+    estimatedSize?: number;
+};
+export declare abstract class LiveSyncAbstractReplicator {
+    syncStatus: DatabaseConnectingStatus;
+    docArrived: number;
+    docSent: number;
+    lastSyncPullSeq: number;
+    maxPullSeq: number;
+    lastSyncPushSeq: number;
+    maxPushSeq: number;
+    controller?: AbortController;
+    originalSetting: RemoteDBSettings;
+    nodeid: string;
+    remoteLocked: boolean;
+    remoteCleaned: boolean;
+    remoteLockedAndDeviceNotAccepted: boolean;
+    tweakSettingsMismatched: boolean;
+    preferredTweakValue?: TweakValues;
+    abstract get isChunkSendingSupported(): boolean;
+    get database(): import("../pouchdb/LiveSyncLocalDB.js").LiveSyncLocalDB;
+    get rawDatabase(): PouchDB.Database<EntryDoc>;
+    get currentSettings(): import("../common/types.js").ObsidianLiveSyncSettings;
+    protected translate<TKey extends string>(key: TKey, params?: TranslationParameters): string;
+    sendChunks(setting: RemoteDBSettings, remoteDB: PouchDB.Database<EntryDoc> | undefined, showResult: boolean, fromSeq?: number | string): Promise<boolean>;
+    abstract getReplicationPBKDF2Salt(setting: RemoteDBSettings, refresh?: boolean): Promise<Uint8Array<ArrayBuffer>>;
+    ensurePBKDF2Salt(setting: RemoteDBSettings, showMessage?: boolean, useCache?: boolean): Promise<boolean>;
+    env: LiveSyncReplicatorEnv;
+    initializeDatabaseForReplication(): Promise<boolean>;
+    constructor(env: LiveSyncReplicatorEnv);
+    abstract terminateSync(): void;
+    abstract openReplication(setting: RemoteDBSettings, keepAlive: boolean, showResult: boolean, ignoreCleanLock: boolean): Promise<void | boolean>;
+    updateInfo: () => void;
+    abstract tryConnectRemote(setting: RemoteDBSettings, showResult?: boolean): Promise<boolean>;
+    abstract replicateAllToServer(setting: RemoteDBSettings, showingNotice?: boolean, sendChunksInBulkDisabled?: boolean): Promise<boolean>;
+    abstract replicateAllFromServer(setting: RemoteDBSettings, showingNotice?: boolean): Promise<boolean>;
+    abstract closeReplication(): void;
+    abstract tryResetRemoteDatabase(setting: RemoteDBSettings): Promise<void>;
+    abstract tryCreateRemoteDatabase(setting: RemoteDBSettings): Promise<void>;
+    abstract markRemoteLocked(setting: RemoteDBSettings, locked: boolean, lockByClean: boolean): Promise<void>;
+    abstract markRemoteResolved(setting: RemoteDBSettings): Promise<void>;
+    abstract resetRemoteTweakSettings(setting: RemoteDBSettings): Promise<void>;
+    abstract setPreferredRemoteTweakSettings(setting: RemoteDBSettings): Promise<void>;
+    abstract fetchRemoteChunks(missingChunks: string[], showResult: boolean): Promise<false | EntryLeaf[]>;
+    abstract getRemoteStatus(setting: RemoteDBSettings): Promise<false | RemoteDBStatus>;
+    abstract getRemotePreferredTweakValues(setting: RemoteDBSettings): Promise<false | TweakValues>;
+    abstract countCompromisedChunks(setting?: RemoteDBSettings): Promise<number | boolean>;
+    abstract getConnectedDeviceList(setting?: RemoteDBSettings): Promise<false | {
+        node_info: Record<string, NodeData>;
+        accepted_nodes: string[];
+    }>;
+}

package/dist/replication/LiveSyncAbstractReplicator.js

@@ -0,0 +1,92 @@
+import {
+  NODEINFO_DOCID
+} from "../common/types.js";
+import { LOG_LEVEL_INFO, LOG_LEVEL_NOTICE, LOG_LEVEL_VERBOSE, Logger } from "../common/logger.js";
+import { resolveWithIgnoreKnownError } from "../common/utils.js";
+import { arrayBufferToBase64Single } from "../string_and_binary/convert.js";
+class LiveSyncAbstractReplicator {
+  syncStatus = "NOT_CONNECTED";
+  docArrived = 0;
+  docSent = 0;
+  lastSyncPullSeq = 0;
+  maxPullSeq = 0;
+  lastSyncPushSeq = 0;
+  maxPushSeq = 0;
+  controller;
+  // localDatabase: PouchDB.Database<EntryDoc>;
+  originalSetting;
+  nodeid = "";
+  remoteLocked = false;
+  remoteCleaned = false;
+  remoteLockedAndDeviceNotAccepted = false;
+  tweakSettingsMismatched = false;
+  preferredTweakValue;
+  get database() {
+    return this.env.services.database.localDatabase;
+  }
+  get rawDatabase() {
+    return this.env.services.database.localDatabase.localDatabase;
+  }
+  get currentSettings() {
+    return this.env.services.setting.currentSettings();
+  }
+  translate(key, params) {
+    return this.env.services.context.translate(key, params);
+  }
+  sendChunks(setting, remoteDB, showResult, fromSeq) {
+    return Promise.resolve(true);
+  }
+  async ensurePBKDF2Salt(setting, showMessage = false, useCache = true) {
+    try {
+      const hash = await this.getReplicationPBKDF2Salt(setting, !useCache);
+      if (hash.length == 0) {
+        throw new Error("PBKDF2 salt (Security Seed) is empty");
+      }
+      Logger(`PBKDF2 salt (Security Seed): ${await arrayBufferToBase64Single(hash)}`, LOG_LEVEL_VERBOSE);
+      return true;
+    } catch (ex) {
+      const level = showMessage ? LOG_LEVEL_NOTICE : LOG_LEVEL_INFO;
+      Logger(`Failed to obtain PBKDF2 salt (Security Seed) for replication`, level);
+      Logger(ex, LOG_LEVEL_VERBOSE);
+      return false;
+    }
+  }
+  env;
+  async initializeDatabaseForReplication() {
+    const db = this.rawDatabase;
+    try {
+      const nodeinfo = await resolveWithIgnoreKnownError(db.get(NODEINFO_DOCID), {
+        _id: NODEINFO_DOCID,
+        type: "nodeinfo",
+        nodeid: "",
+        v20220607: true
+      });
+      if (nodeinfo.nodeid == "") {
+        nodeinfo.nodeid = Math.random().toString(36).slice(-10);
+        await db.put(nodeinfo);
+      }
+      this.nodeid = nodeinfo.nodeid;
+      return true;
+    } catch (ex) {
+      Logger(ex);
+    }
+    return false;
+  }
+  constructor(env) {
+    this.env = env;
+  }
+  updateInfo = () => {
+    this.env.services.replicator.replicationStatics.value = {
+      sent: this.docSent,
+      arrived: this.docArrived,
+      maxPullSeq: this.maxPullSeq,
+      maxPushSeq: this.maxPushSeq,
+      lastSyncPullSeq: this.lastSyncPullSeq,
+      lastSyncPushSeq: this.lastSyncPushSeq,
+      syncStatus: this.syncStatus
+    };
+  };
+}
+export {
+  LiveSyncAbstractReplicator
+};

package/dist/replication/SyncParamsHandler.d.ts

@@ -0,0 +1,35 @@
+import type { SyncParameters } from "../common/types.js";
+import { LiveSyncError } from "../common/LSError.js";
+/**
+ * Creates a SyncParamsHandler for managing synchronisation parameters.
+ */
+type putFunc = (params: SyncParameters) => Promise<boolean>;
+/**
+ * Fetches synchronisation parameters from the server.
+ */
+type getFunc = () => Promise<SyncParameters>;
+/**
+ * The function to create new synchronisation parameters.
+ * Note that this function should not return `pbkdf2salt` in the result; it should be generated and stored in the handler.
+ */
+type createFunc = () => Promise<SyncParameters>;
+type CreateSyncParamsHanderOptions = {
+    put: putFunc;
+    get: getFunc;
+    create: createFunc;
+};
+export type SyncParamsHandler = {
+    fetch: (refresh?: boolean) => Promise<SyncParameters | false>;
+    getPBKDF2Salt: (refresh?: boolean) => Promise<Uint8Array<ArrayBuffer>>;
+};
+export declare function createSyncParamsHanderForServer(key: string, options: CreateSyncParamsHanderOptions): SyncParamsHandler;
+export declare function clearHandlers(): void;
+export declare class SyncParamsHandlerError extends LiveSyncError {
+}
+export declare class SyncParamsFetchError extends SyncParamsHandlerError {
+}
+export declare class SyncParamsNotFoundError extends SyncParamsHandlerError {
+}
+export declare class SyncParamsUpdateError extends SyncParamsHandlerError {
+}
+export {};

package/dist/replication/SyncParamsHandler.js

@@ -0,0 +1,118 @@
+import { createPBKDF2Salt } from "octagonal-wheels/encryption/hkdf";
+import { LOG_LEVEL_INFO, LOG_LEVEL_VERBOSE, Logger } from "../common/logger.js";
+import { arrayBufferToBase64Single, base64ToArrayBufferInternalBrowser } from "../string_and_binary/convert.js";
+import { LiveSyncError } from "../common/LSError.js";
+const _handlers = /* @__PURE__ */ new Map();
+function createSyncParamsHanderForServer(key, options) {
+  if (_handlers.has(key)) {
+    return _handlers.get(key);
+  }
+  const handler = createSyncParamsHandler(options);
+  _handlers.set(key, handler);
+  return handler;
+}
+function clearHandlers() {
+  _handlers.clear();
+}
+class SyncParamsHandlerError extends LiveSyncError {
+}
+class SyncParamsFetchError extends SyncParamsHandlerError {
+}
+class SyncParamsNotFoundError extends SyncParamsHandlerError {
+}
+class SyncParamsUpdateError extends SyncParamsHandlerError {
+}
+function createSyncParamsHandler({ put, get, create }) {
+  let taskFetchParameters = void 0;
+  const _fetchSyncParameters = async () => {
+    let syncParams = void 0;
+    try {
+      let shouldRetry = false;
+      do {
+        shouldRetry = false;
+        try {
+          syncParams = await get();
+          Logger(`Fetched synchronisation parameters`, LOG_LEVEL_INFO);
+        } catch (ex) {
+          if (LiveSyncError.isCausedBy(ex, SyncParamsNotFoundError)) {
+            Logger(`Synchronisation parameters not found, creating new ones`, LOG_LEVEL_INFO);
+            const newSyncParams = await create();
+            const putResult = await put(newSyncParams);
+            if (!putResult) {
+              Logger(`Failed to store initial synchronisation parameters`, LOG_LEVEL_INFO);
+              throw new SyncParamsUpdateError(`Failed to store initial synchronisation parameters`);
+            }
+            Logger(
+              `Initial synchronisation parameters stored successfully, retrying fetch`,
+              LOG_LEVEL_INFO
+            );
+            shouldRetry = true;
+          } else {
+            throw ex;
+          }
+        }
+      } while (shouldRetry);
+      if (!syncParams) {
+        throw new SyncParamsFetchError(`Unexpected empty synchronisation parameters`);
+      }
+      if (!syncParams.pbkdf2salt) {
+        Logger(`Synchronisation parameters do not have PBKDF2 salt, generating a new salt`, LOG_LEVEL_INFO);
+        const salt = await arrayBufferToBase64Single(createPBKDF2Salt());
+        if (!salt) {
+          Logger(`Failed to generate PBKDF2 salt`, LOG_LEVEL_INFO);
+          throw new SyncParamsFetchError(`Failed to generate PBKDF2 salt`);
+        }
+        syncParams.pbkdf2salt = salt;
+        const putResult = await put(syncParams);
+        if (!putResult) {
+          Logger(`Failed to store synchronisation parameters with new PBKDF2 salt`, LOG_LEVEL_INFO);
+          throw new SyncParamsUpdateError(`Failed to store synchronisation parameters with new PBKDF2 salt`);
+        }
+        syncParams = await get();
+      }
+      if (!syncParams) {
+        throw new Error(`Failed to prepare synchronisation key in synchronisation parameters`);
+      }
+      Logger(`Synchronisation parameters fetched successfully`, LOG_LEVEL_INFO);
+      if (!syncParams.pbkdf2saltDecoded) {
+        const decodedSalt = new Uint8Array(base64ToArrayBufferInternalBrowser(syncParams.pbkdf2salt));
+        if (!decodedSalt) {
+          throw new SyncParamsFetchError(`Failed to decode PBKDF2 salt`);
+        }
+        syncParams.pbkdf2saltDecoded = decodedSalt;
+      }
+      return syncParams;
+    } catch (ex) {
+      Logger(`Failed to fetch synchronisation parameters`, LOG_LEVEL_INFO);
+      Logger(ex, LOG_LEVEL_VERBOSE);
+      taskFetchParameters = void 0;
+      return false;
+    }
+  };
+  const fetchSyncParameters = (refresh = false) => {
+    if (taskFetchParameters && !refresh) {
+      return taskFetchParameters;
+    }
+    taskFetchParameters = _fetchSyncParameters();
+    return taskFetchParameters;
+  };
+  return {
+    fetch: fetchSyncParameters,
+    getPBKDF2Salt: async (refresh = false) => {
+      const syncParams = await fetchSyncParameters(refresh);
+      if (!syncParams) {
+        Logger(`Failed to fetch synchronisation parameters`, LOG_LEVEL_INFO);
+        throw new SyncParamsFetchError(`Failed to fetch synchronisation parameters`);
+      }
+      return syncParams.pbkdf2saltDecoded;
+    }
+  };
+}
+export {
+  SyncParamsFetchError,
+  SyncParamsHandlerError,
+  SyncParamsNotFoundError,
+  SyncParamsUpdateError,
+  clearHandlers,
+  createSyncParamsHanderForServer
+};

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

@@ -0,0 +1,85 @@
+import { type EntryDoc, type RemoteDBSettings, type EntryLeaf, type TweakValues, type SyncParameters, type DatabaseEntry, type NodeData } from "../../common/types.js";
+import { LiveSyncAbstractReplicator, type LiveSyncReplicatorEnv, type RemoteDBStatus } from "../LiveSyncAbstractReplicator.js";
+import type { ServiceHub } from "../../services/ServiceHub.js";
+export interface LiveSyncCouchDBReplicatorEnv extends LiveSyncReplicatorEnv {
+    services: ServiceHub;
+}
+export declare class LiveSyncCouchDBReplicator extends LiveSyncAbstractReplicator {
+    get isChunkSendingSupported(): boolean;
+    isMobile(): boolean;
+    constructor(env: LiveSyncCouchDBReplicatorEnv);
+    getInitialSyncParameters(setting: RemoteDBSettings): Promise<SyncParameters>;
+    getSyncParameters(setting: RemoteDBSettings): Promise<SyncParameters>;
+    putSyncParameters(setting: RemoteDBSettings, params: SyncParameters): Promise<boolean>;
+    getReplicationPBKDF2Salt(setting: RemoteDBSettings, refresh?: boolean): Promise<Uint8Array<ArrayBuffer>>;
+    migrate(from: number, to: number): Promise<boolean>;
+    terminateSync(): void;
+    openReplication(setting: RemoteDBSettings, keepAlive: boolean, showResult: boolean, ignoreCleanLock: boolean): Promise<boolean>;
+    replicationActivated(showResult: boolean): void;
+    replicationChangeDetected(e: PouchDB.Replication.SyncResult<EntryDoc>, showResult: boolean, docSentOnStart: number, docArrivedOnStart: number): Promise<void>;
+    replicationCompleted(showResult: boolean): void;
+    replicationDenied(e: unknown): void;
+    replicationErrored(e: unknown): void;
+    replicationPaused(): void;
+    processSync(syncHandler: PouchDB.Replication.Sync<EntryDoc> | PouchDB.Replication.Replication<EntryDoc>, showResult: boolean, docSentOnStart: number, docArrivedOnStart: number, syncMode: "sync" | "pullOnly" | "pushOnly", retrying: boolean, reportCancelledAsDone?: boolean): Promise<"DONE" | "NEED_RETRY" | "NEED_RESURRECT" | "FAILED" | "CANCELLED">;
+    getEmptyMaxEntry(remoteID: number): {
+        _id: string;
+        maxSeq: number | string;
+        remoteID: number;
+        seqStatusMap: Record<number, boolean>;
+        _rev: string | undefined;
+    };
+    getLastTransferredSeqOfChunks(localDB: PouchDB.Database, remoteID: number): Promise<ReturnType<typeof this.getEmptyMaxEntry>>;
+    updateMaxTransferredSeqOnChunks(localDB: PouchDB.Database, remoteID: number, seqStatusMap: Record<number, boolean>): Promise<ReturnType<typeof this.getEmptyMaxEntry>>;
+    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>;
+    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 | {
+        db: PouchDB.Database<EntryDoc>;
+        info: PouchDB.Core.DatabaseInfo;
+        syncOptionBase: PouchDB.Replication.SyncOptions;
+        syncOption: PouchDB.Replication.SyncOptions;
+    }>;
+    openContinuousReplication(setting: RemoteDBSettings, showResult: boolean, retrying: boolean): Promise<boolean>;
+    closeReplication(): void;
+    tryResetRemoteDatabase(setting: RemoteDBSettings): Promise<void>;
+    tryCreateRemoteDatabase(setting: RemoteDBSettings): Promise<void>;
+    markRemoteLocked(setting: RemoteDBSettings, locked: boolean, lockByClean: boolean): Promise<void>;
+    markRemoteResolved(setting: RemoteDBSettings): Promise<void>;
+    connectRemoteCouchDBWithSetting(settings: RemoteDBSettings, isMobile: boolean, performSetup?: boolean, skipInfo?: boolean): Promise<string | {
+        db: PouchDB.Database<EntryDoc>;
+        info: PouchDB.Core.DatabaseInfo;
+    }> | "Empty passphrases cannot be used without explicit permission";
+    _ensureConnection<T extends DatabaseEntry>(settings: RemoteDBSettings, performSetup?: boolean): Promise<PouchDB.Database<T>>;
+    /**
+     * Fetch a document from the remote database directly.
+     * @param settings RemoteDBSettings for the connection.
+     * @param id Document ID to fetch.
+     * @param db Optional PouchDB instance to use. If provided, it will use this instance instead of creating a new connection (then settings will be ignored).
+     * @returns The fetched document or false if the document does not exist.
+     * @throws {Error} Other errors that may occur during the fetch operation.
+     */
+    fetchRemoteDocument<T extends DatabaseEntry>(settings: RemoteDBSettings, id: string, db?: PouchDB.Database<T>): Promise<T | false>;
+    /**
+     * Puts a document to the remote database directly
+     * @param settings RemoteDBSettings for the connection.
+     * @param doc Document to put.
+     * @param db Optional PouchDB instance to use. If provided, it will use this instance instead of creating a new connection (then settings will be ignored).
+     * @returns Response from the remote database or false if an error occurred.
+     * @throws {Error} If the document could not be put.
+     */
+    putRemoteDocument<T extends DatabaseEntry>(settings: RemoteDBSettings, doc: T, db?: PouchDB.Database<T>): Promise<PouchDB.Core.Response>;
+    fetchRemoteChunks(missingChunks: string[], showResult: boolean): Promise<false | EntryLeaf[]>;
+    tryConnectRemote(setting: RemoteDBSettings, showResult?: boolean): Promise<boolean>;
+    resetRemoteTweakSettings(setting: RemoteDBSettings): Promise<void>;
+    setPreferredRemoteTweakSettings(setting: RemoteDBSettings): Promise<void>;
+    getRemotePreferredTweakValues(setting: RemoteDBSettings): Promise<TweakValues | false>;
+    compactRemote(setting: RemoteDBSettings): Promise<boolean>;
+    getRemoteStatus(setting: RemoteDBSettings): Promise<RemoteDBStatus | false>;
+    countCompromisedChunks(setting?: RemoteDBSettings): Promise<number | boolean>;
+    getConnectedDeviceList(setting?: RemoteDBSettings): Promise<false | {
+        node_info: Record<string, NodeData>;
+        accepted_nodes: string[];
+    }>;
+}