@vrtmrz/livesync-commonlib 0.1.0-rc.0

package/dist/pouchdb/LiveSyncLocalDB.js

@@ -0,0 +1,381 @@
+import {
+  VERSIONING_DOCID,
+  LOG_LEVEL_NOTICE,
+  LOG_LEVEL_VERBOSE,
+  SuffixDatabaseName
+} from "../common/types.js";
+import { Logger } from "../common/logger.js";
+import { isErrorOfMissingDoc } from "./utils_couchdb.js";
+import { EVENT_CHUNK_FETCHED } from "../managers/ChunkFetcher.js";
+import { FallbackWeakRef } from "octagonal-wheels/common/polyfill";
+import { LiveSyncManagers } from "../managers/LiveSyncManagers.js";
+import { createInstanceLogFunction } from "../services/lib/logUtils.js";
+const REMOTE_CHUNK_FETCHED = "remote-chunk-fetched";
+function getNoFromRev(rev) {
+  if (!rev) return 0;
+  return parseInt(rev.split("-")[0]);
+}
+class LiveSyncLocalDB {
+  auth;
+  dbname;
+  settings;
+  localDatabase;
+  _log;
+  _managers;
+  get managers() {
+    if (!this._managers) {
+      throw new Error("Managers are not ready yet.");
+    }
+    return this._managers;
+  }
+  isReady = false;
+  needScanning = false;
+  env;
+  clearCaches() {
+    this._managers?.clearCaches();
+  }
+  async _prepareHashFunctions() {
+    await this._managers?.prepareHashFunction();
+  }
+  onunload() {
+    void this.env.services.databaseEvents.onUnloadDatabase(this);
+    this.localDatabase.removeAllListeners();
+  }
+  refreshSettings() {
+    const settings = this.env.services.setting.currentSettings();
+    this.settings = settings;
+    void this._prepareHashFunctions();
+  }
+  offRemoteChunkFetchedHandler;
+  constructor(dbname, env) {
+    this.auth = {
+      username: "",
+      password: ""
+    };
+    this.dbname = dbname;
+    this.env = env;
+    this._log = createInstanceLogFunction("LiveSyncLocalDB", this.env.services.API);
+    this.refreshSettings();
+  }
+  async close() {
+    this._log("Database closed (by close)");
+    this.isReady = false;
+    this.offRemoteChunkFetchedHandler?.();
+    if (this.localDatabase != null) {
+      await this.localDatabase.close();
+    }
+    await this.env.services.databaseEvents.onUnloadDatabase(this);
+  }
+  onNewLeaf(chunk) {
+    this.managers.chunkManager?.emitEvent(EVENT_CHUNK_FETCHED, chunk);
+  }
+  async initializeDatabase() {
+    await this._prepareHashFunctions();
+    if (this.localDatabase != null) {
+      this.localDatabase.removeAllListeners();
+      await this.localDatabase.close();
+    }
+    this.localDatabase = null;
+    this.localDatabase = this.env.services.database.createPouchDBInstance(
+      this.dbname + SuffixDatabaseName,
+      {
+        auto_compaction: false,
+        revs_limit: 100,
+        deterministic_revs: true
+      }
+    );
+    const manager = new LiveSyncManagers({
+      database: this.localDatabase,
+      APIService: this.env.services.API,
+      pathService: this.env.services.path,
+      replicatorService: this.env.services.replicator,
+      settingService: this.env.services.setting,
+      databaseService: this.env.services.database
+    });
+    this._managers = manager;
+    if (!await this.env.services.databaseEvents.onDatabaseInitialisation(this)) {
+      this._log("Initializing Database has been failed on some module", LOG_LEVEL_NOTICE);
+    }
+    this._log("Opening Database...");
+    this._log("Database info", LOG_LEVEL_VERBOSE);
+    this._log(JSON.stringify(await this.localDatabase.info(), null, 2), LOG_LEVEL_VERBOSE);
+    await this.managers.initialise();
+    this.localDatabase.on("close", () => {
+      this._log("Database closed.");
+      this.isReady = false;
+      this.localDatabase.removeAllListeners();
+      this.env.services.replicator.getActiveReplicator()?.closeReplication();
+      void this.managers.teardownManagers();
+    });
+    const _instance = new FallbackWeakRef(this);
+    const unload = this.env.services.context.events.onEvent(REMOTE_CHUNK_FETCHED, (chunk) => {
+      if (_instance.deref() == null) {
+        unload();
+      }
+      _instance.deref()?.onNewLeaf(chunk);
+    });
+    this.offRemoteChunkFetchedHandler = unload;
+    this.isReady = true;
+    if (!await this.env.services.databaseEvents.onDatabaseHasReady()) {
+      this._log(
+        "Some module has prevented the database from being ready. The database is initialised but not ready for use.",
+        LOG_LEVEL_NOTICE
+      );
+      return false;
+    }
+    this._log("Database is now ready.");
+    return true;
+  }
+  /**
+   * Retrieve all used and existing chunks in the database.
+   * @param includeDeleted  include deleted chunks in the result.
+   * @returns {used: Set<string>, existing: Map<string, EntryLeaf>} used: Set of chunk ids that are used in the database. existing: Map of chunk id and EntryLeaf that are existing in the database.
+   */
+  async allChunks(includeDeleted = false) {
+    const used = /* @__PURE__ */ new Set();
+    const existing = /* @__PURE__ */ new Map();
+    let since = 0;
+    do {
+      const changes = await this.localDatabase.changes({
+        since,
+        limit: 100,
+        include_docs: true,
+        conflicts: true,
+        style: includeDeleted ? "all_docs" : "main_only"
+      });
+      if (changes.results.length == 0) {
+        break;
+      }
+      for (const change of changes.results) {
+        const doc = change.doc;
+        if (doc.type == "leaf") {
+          if (doc._deleted) {
+            if (!includeDeleted) {
+              continue;
+            }
+          }
+          existing.set(doc._id, doc);
+        }
+        if ("children" in doc) {
+          if (change.deleted) {
+            if (!doc._conflicts || doc._conflicts.length == 0) {
+              continue;
+            }
+          }
+          doc.children.forEach((e) => used.add(e));
+          if (doc._conflicts) {
+            const revs = await this.localDatabase.get(doc._id, { revs: true, revs_info: true });
+            const mineRevInfo = revs._revs_info || [];
+            const keepRevs = /* @__PURE__ */ new Set();
+            for (const conflict of doc._conflicts) {
+              const conflictedRevs = await this.localDatabase.get(doc._id, {
+                rev: conflict,
+                revs: true,
+                revs_info: true
+              });
+              const conflictedRevInfo = conflictedRevs._revs_info || [];
+              const diffRevs = mineRevInfo.filter(
+                (e) => !conflictedRevInfo.some((f) => f.rev == e.rev && f.status == e.status)
+              );
+              const diffRevs2 = conflictedRevInfo.filter(
+                (e) => !mineRevInfo.some((f) => f.rev == e.rev && f.status == e.status)
+              );
+              const diffRevs3 = diffRevs.concat(diffRevs2);
+              const sameRevs = mineRevInfo.filter((e) => conflictedRevInfo.some((f) => f.rev == e.rev && f.status == e.status)).filter((e) => e.status == "available").sort((a, b) => getNoFromRev(b.rev) - getNoFromRev(a.rev));
+              const sameRevsTop = sameRevs.length > 0 ? [sameRevs[0].rev] : [];
+              const keepRevList = [
+                ...diffRevs3.filter((e) => e.status == "available").map((e) => e.rev),
+                ...sameRevsTop
+              ];
+              keepRevList.forEach((e) => keepRevs.add(e));
+            }
+            const detail = await this.localDatabase.bulkGet({
+              docs: [...keepRevs.values()].map((e) => ({ id: doc._id, rev: e }))
+            });
+            for (const e of detail.results) {
+              if ("docs" in e) {
+                const docs = e.docs;
+                for (const doc2 of docs) {
+                  if ("ok" in doc2) {
+                    if ("children" in doc2.ok) {
+                      doc2.ok.children.forEach((e2) => used.add(e2));
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+      since = changes.results[changes.results.length - 1].seq;
+    } while (true);
+    return { used, existing };
+  }
+  async resetDatabase() {
+    await this.managers.teardownManagers();
+    this.env.services.replicator.getActiveReplicator()?.closeReplication();
+    if (!await this.env.services.databaseEvents.onResetDatabase(this)) {
+      Logger("Database reset has been prevented or failed on some modules.", LOG_LEVEL_NOTICE);
+      return false;
+    }
+    Logger("Database closed for reset Database.");
+    this.isReady = false;
+    await this.localDatabase.destroy();
+    this.localDatabase = null;
+    await this.initializeDatabase();
+    this._log("Local Database Reset", LOG_LEVEL_NOTICE);
+    return true;
+  }
+  async *findEntries(startKey, endKey, opt) {
+    const pageLimit = 100;
+    let nextKey = startKey;
+    if (endKey == "") endKey = "\u{10FFFF}";
+    let req = this.allDocsRaw({ limit: pageLimit, startkey: nextKey, endkey: endKey, include_docs: true, ...opt });
+    do {
+      const docs = await req;
+      if (docs.rows.length === 0) {
+        break;
+      }
+      nextKey = `${docs.rows[docs.rows.length - 1].id}`;
+      req = this.allDocsRaw({
+        limit: pageLimit,
+        skip: 1,
+        startkey: nextKey,
+        endkey: endKey,
+        include_docs: true,
+        ...opt
+      });
+      for (const row of docs.rows) {
+        const doc = row.doc;
+        if (!("type" in doc)) {
+          continue;
+        }
+        if (doc.type == "newnote" || doc.type == "plain") {
+          yield doc;
+        }
+      }
+    } while (nextKey != "");
+  }
+  async *findAllDocs(opt) {
+    const targets = [
+      () => this.findEntries("", "_", opt ?? {}),
+      () => this.findEntries("_\u{10FFFF}", "h:", opt ?? {}),
+      () => this.findEntries(`h:\u{10FFFF}`, "", opt ?? {})
+    ];
+    for (const targetFun of targets) {
+      yield* targetFun();
+    }
+  }
+  async *findEntryNames(startKey, endKey, opt) {
+    const pageLimit = 100;
+    let nextKey = startKey;
+    if (endKey == "") endKey = "\u{10FFFF}";
+    let req = this.allDocsRaw({ limit: pageLimit, startkey: nextKey, endkey: endKey, ...opt });
+    do {
+      const docs = await req;
+      if (docs.rows.length == 0) {
+        nextKey = "";
+        break;
+      }
+      nextKey = `${docs.rows[docs.rows.length - 1].key}`;
+      req = this.allDocsRaw({ limit: pageLimit, skip: 1, startkey: nextKey, endkey: endKey, ...opt });
+      for (const row of docs.rows) {
+        yield row.id;
+      }
+    } while (nextKey != "");
+  }
+  async *findAllDocNames(opt) {
+    const targets = [
+      () => this.findEntryNames("", "_", opt ?? {}),
+      () => this.findEntryNames("_\u{10FFFF}", "h:", opt ?? {}),
+      () => this.findEntryNames(`h:\u{10FFFF}`, "i:", opt ?? {}),
+      () => this.findEntryNames(`i:\u{10FFFF}`, "ix:", opt ?? {}),
+      () => this.findEntryNames(`ix:\u{10FFFF}`, "ps:", opt ?? {}),
+      () => this.findEntryNames(`ps:\u{10FFFF}`, "", opt ?? {})
+    ];
+    for (const targetFun of targets) {
+      const target = targetFun();
+      for await (const f of target) {
+        if (f.startsWith("_")) continue;
+        if (f == VERSIONING_DOCID) continue;
+        yield f;
+      }
+    }
+  }
+  async *findAllNormalDocs(opt) {
+    const targets = [
+      () => this.findEntries("", "_", opt ?? {}),
+      () => this.findEntries("_\u{10FFFF}", "h:", opt ?? {}),
+      () => this.findEntries(`h:\u{10FFFF}`, "i:", opt ?? {}),
+      () => this.findEntries(`i:\u{10FFFF}`, "ix:", opt ?? {}),
+      () => this.findEntries(`ix:\u{10FFFF}`, "ps:", opt ?? {}),
+      () => this.findEntries(`ps:\u{10FFFF}`, "", opt ?? {})
+    ];
+    for (const targetFun of targets) {
+      const target = targetFun();
+      for await (const f of target) {
+        if (f._id.startsWith("_")) continue;
+        if (f.type != "newnote" && f.type != "plain") continue;
+        yield f;
+      }
+    }
+  }
+  async removeRevision(docId, revision) {
+    try {
+      const doc = await this.localDatabase.get(docId, { rev: revision });
+      doc._deleted = true;
+      await this.localDatabase.put(doc);
+      return true;
+    } catch (ex) {
+      if (isErrorOfMissingDoc(ex)) {
+        Logger(`Remove revision: Missing target revision, ${docId}-${revision}`, LOG_LEVEL_VERBOSE);
+      }
+    }
+    return false;
+  }
+  getRaw(docId, options) {
+    return this.localDatabase.get(docId, options || {});
+  }
+  removeRaw(docId, revision, options) {
+    return this.localDatabase.remove(docId, revision, options || {});
+  }
+  putRaw(doc, options) {
+    return this.localDatabase.put(doc, options || {});
+  }
+  allDocsRaw(options) {
+    return this.localDatabase.allDocs(options);
+  }
+  bulkDocsRaw(docs, options) {
+    return this.localDatabase.bulkDocs(docs, options || {});
+  }
+  // For compatibility
+  isTargetFile(filenameSrc) {
+    return this.managers.entryManager.isTargetFile(filenameSrc);
+  }
+  async getDBEntryMeta(path, opt, includeDeleted = false) {
+    return await this.managers.entryManager.getDBEntryMeta(path, opt, includeDeleted);
+  }
+  async getDBEntry(path, opt, dump = false, waitForReady = true, includeDeleted = false) {
+    return await this.managers.entryManager.getDBEntry(path, opt, dump, waitForReady, includeDeleted);
+  }
+  async getDBEntryFromMeta(meta, dump = false, waitForReady = true) {
+    return await this.managers.entryManager.getDBEntryFromMeta(meta, dump, waitForReady);
+  }
+  async deleteDBEntry(path, opt) {
+    return await this.managers.entryManager.deleteDBEntry(path, opt);
+  }
+  async putDBEntry(note, onlyChunks, conflictBaseRev) {
+    return await this.managers.entryManager.putDBEntry(note, onlyChunks, conflictBaseRev);
+  }
+  async getConflictedDoc(path, rev) {
+    return await this.managers.conflictManager.getConflictedDoc(path, rev);
+  }
+  async tryAutoMerge(path, enableMarkdownAutoMerge) {
+    return await this.managers.conflictManager.tryAutoMerge(path, enableMarkdownAutoMerge);
+  }
+}
+export {
+  LiveSyncLocalDB,
+  REMOTE_CHUNK_FETCHED,
+  getNoFromRev
+};

package/dist/pouchdb/PouchDBConstructor.d.ts

@@ -0,0 +1,3 @@
+import type PouchDB from "pouchdb-core";
+/** A PouchDB constructor whose adapters have been selected by the host runtime. */
+export type PouchDBConstructor = typeof PouchDB;

package/dist/pouchdb/ReplicatorShim.d.ts

@@ -0,0 +1,51 @@
+export type SomeDocument<T extends object> = PouchDB.Core.ExistingDocument<T> & PouchDB.Core.ChangesMeta;
+/**
+ * Minimal subset of the PouchDB public API required by {@link replicateShim}.
+ * Both a real `PouchDB.Database` and an {@link RpcPouchDBProxy} satisfy this
+ * interface, allowing replication across an RPC transport.
+ */
+export type PouchDBShim<T extends object> = {
+    info: () => Promise<PouchDB.Core.DatabaseInfo>;
+    changes: (options: PouchDB.Core.ChangesOptions) => PromiseLike<PouchDB.Core.ChangesResponse<T>>;
+    revsDiff: (diff: PouchDB.Core.RevisionDiffOptions) => Promise<PouchDB.Core.RevisionDiffResponse>;
+    bulkDocs: (docs: PouchDB.Core.PutDocument<T>[], options?: PouchDB.Core.BulkDocsOptions) => Promise<(PouchDB.Core.Response | PouchDB.Core.Error)[]>;
+    bulkGet: (options: PouchDB.Core.BulkGetOptions) => Promise<PouchDB.Core.BulkGetResponse<T>>;
+    put: (doc: PouchDB.Core.PutDocument<T>, options?: PouchDB.Core.PutOptions) => Promise<PouchDB.Core.Response>;
+    get: (id: string, options?: PouchDB.Core.GetOptions) => Promise<T & PouchDB.Core.IdMeta & PouchDB.Core.GetMeta>;
+};
+type CompatibleDatabase<T extends object> = PouchDB.Database<SomeDocument<T>> | PouchDBShim<SomeDocument<T>>;
+/** Upserts a document by `id`, calling `func` to produce the updated version. */
+export declare function upsert<V extends object, TDB extends CompatibleDatabase<object> = CompatibleDatabase<any>, T extends SomeDocument<V> = SomeDocument<V>>(db: TDB, id: string, func: (doc: T) => T): Promise<T>;
+export type ShimReplicationOptionBase = {
+    rewind?: boolean;
+    batch_size?: number;
+};
+export type ShimReplicationOneShot = {
+    live?: false;
+    controller?: AbortController;
+} & ShimReplicationOptionBase;
+export type ShimReplicationOptionContinuous = {
+    live: true;
+    controller: AbortController;
+} & ShimReplicationOptionBase;
+export type ShimReplicationOption = ShimReplicationOneShot | ShimReplicationOptionContinuous;
+export type ProgressInfo = {
+    lastSeq: number;
+    maxSeqInBatch: number;
+};
+export type ShimReplicationProgressReportFunc<T extends object> = (progress: SomeDocument<T>[], progressInfo: ProgressInfo) => Promise<void>;
+/**
+ * Replicate documents from `sourceDB` into `targetDB` using a CouchDB-style
+ * checkpoint protocol.
+ *
+ * Both parameters accept either a real `PouchDB.Database` or any object
+ * implementing {@link PouchDBShim} — including {@link RpcPouchDBProxy} — so
+ * replication can span an RPC transport boundary.
+ *
+ * @param targetDB  Destination database (usually local).
+ * @param sourceDB  Source database (may be remote / RPC-backed).
+ * @param progress  Called after each batch with the written documents.
+ * @param option    Replication options (live mode, batch size, abort signal).
+ */
+export declare function replicateShim<T extends CompatibleDatabase<V>, U extends CompatibleDatabase<V>, V extends object>(targetDB: T, sourceDB: U, progress: ShimReplicationProgressReportFunc<V>, option?: ShimReplicationOption): Promise<void>;
+export {};

package/dist/pouchdb/ReplicatorShim.js

@@ -0,0 +1,109 @@
+import { serialized } from "octagonal-wheels/concurrency/lock";
+import { Logger } from "../common/logger.js";
+import { LOG_LEVEL_VERBOSE } from "../common/types.js";
+async function upsert(db, id, func) {
+  try {
+    const doc = await db.get(id);
+    const updated = func(doc);
+    const result = await db.put(updated, {});
+    if (result && result.ok) {
+      return updated;
+    }
+    throw new Error("Failed to update");
+  } catch (ex) {
+    const isNotFound = ex?.name === "not_found" || ex?.reason === "missing" || ex?.message === "missing" || ex?.message === "not_found";
+    if (isNotFound) {
+      const seed = func({ _id: id });
+      const result = await db.put(seed, {});
+      if (result && result.ok) {
+        return seed;
+      }
+      throw new Error("Failed to insert");
+    }
+    throw ex;
+  }
+}
+function parseSeq(seq) {
+  return parseInt(String(seq).split("-")[0], 10);
+}
+function buildRevsDiffParam(changesResults) {
+  const param = {};
+  for (const { id, changes } of changesResults) {
+    param[id] = [...param[id] ?? [], ...changes.map((c) => c.rev)];
+  }
+  return param;
+}
+function sortBySeq(docs, changesResults) {
+  const maxSeqById = /* @__PURE__ */ new Map();
+  for (const { id, seq } of changesResults) {
+    maxSeqById.set(id, Math.max(maxSeqById.get(id) ?? 0, parseSeq(seq)));
+  }
+  return docs.slice().sort((a, b) => (maxSeqById.get(a._id) ?? 0) - (maxSeqById.get(b._id) ?? 0));
+}
+async function replicateShim(targetDB, sourceDB, progress, option = {}) {
+  try {
+    const [targetDBInfo, sourceDBInfo] = await Promise.all([targetDB.info(), sourceDB.info()]);
+    const maxNumSeq = parseSeq(sourceDBInfo.update_seq);
+    await serialized(`replication-${targetDBInfo.db_name}-${sourceDBInfo.db_name}`, async () => {
+      Logger(
+        `Replication ${sourceDBInfo.db_name} (${sourceDBInfo.update_seq}) \u2192 ${targetDBInfo.db_name} (${targetDBInfo.update_seq})`,
+        LOG_LEVEL_VERBOSE
+      );
+      const { db_name: targetName } = targetDBInfo;
+      const { db_name: sourceName } = sourceDBInfo;
+      const sourceCheckpointID = `_local/replication-checkpoint-mark-${targetName}-${sourceName}`;
+      const { mark } = await upsert(sourceDB, sourceCheckpointID, (doc) => ({
+        ...doc,
+        mark: option.rewind ? String(Date.now()) : doc.mark ?? String(Date.now())
+      }));
+      Logger(`Replication mark: ${mark}`, LOG_LEVEL_VERBOSE);
+      const targetCheckpointID = `_local/replication-checkpoint-${targetName}-${mark}`;
+      const checkpoint = await upsert(targetDB, targetCheckpointID, (doc) => ({
+        ...doc,
+        since: doc.since ?? ""
+      }));
+      let since = checkpoint.since;
+      Logger(`Starting from seq ${since}`, LOG_LEVEL_VERBOSE);
+      const batchSize = option.batch_size ?? 33;
+      while (true) {
+        const changes = await sourceDB.changes({ since, style: "all_docs", limit: batchSize });
+        if (changes.results.length === 0) break;
+        if (option.controller?.signal?.aborted) break;
+        const changesResults = changes.results;
+        const revsDiffParam = buildRevsDiffParam(changesResults);
+        const diff = await targetDB.revsDiff(revsDiffParam);
+        const missingRequests = Object.entries(diff).filter(([, entry]) => entry.missing !== void 0).flatMap(([id, entry]) => entry.missing.map((rev) => ({ id, rev })));
+        if (missingRequests.length > 0) {
+          const bulkGetResult = await sourceDB.bulkGet({ docs: missingRequests, revs: true });
+          const fetchedDocs = bulkGetResult.results.flatMap((r) => r.docs).filter((d) => "ok" in d).map((d) => d.ok);
+          await targetDB.bulkDocs(fetchedDocs, { new_edits: false });
+          const uniqueIds = [...new Set(changesResults.map((c) => c.id))];
+          const refreshResult = await targetDB.bulkGet({ docs: uniqueIds.map((id) => ({ id })) });
+          const refreshedDocs = refreshResult.results.flatMap((r) => r.docs).filter((d) => "ok" in d).map((d) => d.ok);
+          const orderedDocs = sortBySeq(refreshedDocs, changesResults);
+          const lastSeqNum = parseSeq(changes.last_seq);
+          try {
+            await progress(orderedDocs, { lastSeq: lastSeqNum, maxSeqInBatch: maxNumSeq });
+          } catch (ex) {
+            Logger(`Progress callback failed during shim-replication`, LOG_LEVEL_VERBOSE);
+            Logger(ex, LOG_LEVEL_VERBOSE);
+          }
+        }
+        since = changes.last_seq;
+        await upsert(targetDB, targetCheckpointID, (doc) => ({
+          ...doc,
+          since
+        }));
+      }
+    });
+  } catch (ex) {
+    Logger(`Replication failed`, LOG_LEVEL_VERBOSE);
+    Logger(ex, LOG_LEVEL_VERBOSE);
+    throw ex;
+  }
+  Logger(`Replication completed`, LOG_LEVEL_VERBOSE);
+}
+export {
+  replicateShim,
+  upsert
+};

package/dist/pouchdb/StreamingFetch.d.ts

@@ -0,0 +1,19 @@
+import type { EntryDoc } from "../common/models/db.definition.js";
+import type { AnyEntry, EntryLeaf } from "../common/models/db.type.js";
+type DBSequence = number | string;
+export type FetchChangesForInitialSyncProgress = {
+    totalFetched: number;
+    totalValidFetched: number;
+    targetSeq: number | string;
+    docsToFetch: number;
+    totalBytes: number;
+};
+/**
+ * Fetches initial data from CouchDB as a stream and writes it into PouchDB.
+ * @param downloadToDB PouchDB instance.
+ * @param remoteDbUrl CouchDB database URL (for example: 'https://xxx.com/mydb').
+ * @param decryptFunction Function to decrypt each document.
+ * @param since Sequence ID to start fetching changes from (default is '0').
+ */
+export declare function fetchChangesForInitialSync(downloadToDB: PouchDB.Database, remoteDbUrl: string, authHeader: string, decryptFunction: (doc: EntryDoc) => Promise<AnyEntry | EntryLeaf>, since?: number | string, onProgress?: (progress: FetchChangesForInitialSyncProgress) => void, onCheckpoint?: (sequence: DBSequence) => void | Promise<void>): Promise<void>;
+export {};