@vrtmrz/livesync-commonlib 0.1.0-rc.0

package/dist/pouchdb/StreamingFetch.js

@@ -0,0 +1,263 @@
+import { _fetch } from "../common/coreEnvFunctions.js";
+import { LOG_LEVEL_VERBOSE, Logger } from "octagonal-wheels/common/logger";
+function generatePouchDBWriteStream(downloadToDB, decryptFunction, onCheckpoint) {
+  let batchBuffer = [];
+  let currentBatchSizeBytes = 0;
+  let batchLastSequence;
+  const BATCH_ITEM_LIMIT = 100;
+  const BATCH_SIZE_LIMIT = 2 * 1024 * 1024;
+  let flushPromise = null;
+  const flushToDB = async () => {
+    if (batchBuffer.length === 0) return;
+    if (flushPromise) {
+      await flushPromise;
+    }
+    try {
+      flushPromise = downloadToDB.bulkDocs(batchBuffer, { new_edits: false });
+      await flushPromise;
+      if (batchLastSequence !== void 0) {
+        await onCheckpoint?.(batchLastSequence);
+      }
+    } catch (error) {
+      Logger("Error bulk writing to PouchDB:", LOG_LEVEL_VERBOSE);
+      Logger(error, LOG_LEVEL_VERBOSE);
+      throw error;
+    } finally {
+      batchBuffer = [];
+      currentBatchSizeBytes = 0;
+      batchLastSequence = void 0;
+      flushPromise = null;
+    }
+  };
+  return new WritableStream({
+    async write(chunk) {
+      try {
+        const decryptedDoc = await decryptFunction(chunk.doc);
+        batchBuffer.push(decryptedDoc);
+        currentBatchSizeBytes += JSON.stringify(decryptedDoc).length;
+        batchLastSequence = chunk.seq;
+        if (batchBuffer.length >= BATCH_ITEM_LIMIT || currentBatchSizeBytes >= BATCH_SIZE_LIMIT) {
+          await flushToDB();
+        }
+      } catch (error) {
+        Logger("Error processing document stream:", LOG_LEVEL_VERBOSE);
+        throw error;
+      }
+    },
+    async close() {
+      await flushToDB();
+    },
+    abort(reason) {
+      Logger(`Stream aborted: ${reason}`, LOG_LEVEL_VERBOSE);
+      batchBuffer = [];
+      currentBatchSizeBytes = 0;
+    }
+  });
+}
+function setParamsToURL(url, params) {
+  for (const [key, value] of Object.entries(params)) {
+    url.searchParams.set(key, value);
+  }
+  return url;
+}
+function reachedTargetSequence(seq, targetSeq) {
+  if (seq === void 0 || targetSeq === void 0) return false;
+  const seqStr = seq.toString();
+  const targetSeqStr = targetSeq.toString();
+  if (seqStr === targetSeqStr) return true;
+  const seqNum = parseInt(seqStr.split("-")[0], 10);
+  const targetSeqNum = parseInt(targetSeqStr.split("-")[0], 10);
+  if (!isNaN(seqNum) && !isNaN(targetSeqNum)) {
+    return seqNum >= targetSeqNum;
+  }
+  return false;
+}
+async function fetchChangesForInitialSync(downloadToDB, remoteDbUrl, authHeader, decryptFunction, since = "0", onProgress, onCheckpoint) {
+  let totalFetched = 0;
+  let totalValidFetched = 0;
+  const changesBaseParams = {
+    feed: "continuous",
+    include_docs: "true",
+    style: "all_docs",
+    conflicts: "true",
+    revs: "true",
+    since: since.toString(),
+    heartbeat: "30000"
+  };
+  const fetchHeaders = {
+    Accept: "application/json",
+    Authorization: authHeader
+  };
+  let targetSeq = void 0;
+  try {
+    const dbInfoRes = await _fetch(remoteDbUrl, {
+      headers: fetchHeaders
+    });
+    if (dbInfoRes.ok) {
+      const dbInfo = await dbInfoRes.json();
+      targetSeq = dbInfo.update_seq;
+    }
+  } catch (e) {
+    Logger("Failed to fetch database info for target sequence:", LOG_LEVEL_VERBOSE);
+    Logger(e, LOG_LEVEL_VERBOSE);
+  }
+  const fetchURL = setParamsToURL(new URL(`${remoteDbUrl}/_changes`), {
+    ...changesBaseParams,
+    feed: "normal",
+    limit: "1"
+  });
+  const infoRes = await _fetch(fetchURL.toString(), {
+    headers: fetchHeaders
+  });
+  const infoSource = await infoRes.text();
+  const infoSourceTrimmed = infoSource.trim();
+  if (!infoSourceTrimmed) {
+    throw new Error("Failed to fetch changes from CouchDB. No data received.");
+  }
+  let info;
+  if (infoSourceTrimmed.startsWith("{") && infoSourceTrimmed.endsWith("}")) {
+    try {
+      info = JSON.parse(infoSourceTrimmed);
+    } catch {
+      const infoLines = infoSourceTrimmed.split("\n").filter((line) => line.trim() !== "");
+      const lastLine = infoLines[infoLines.length - 1];
+      info = JSON.parse(lastLine);
+    }
+  } else {
+    const infoLines = infoSourceTrimmed.split("\n").filter((line) => line.trim() !== "");
+    const lastLine = infoLines[infoLines.length - 1];
+    info = JSON.parse(lastLine);
+  }
+  const pendingDocs = info.pending || 0;
+  const docsToFetch = pendingDocs + 1;
+  if (targetSeq === void 0) {
+    targetSeq = info.last_seq || info.update_seq || info.seq;
+  }
+  const finalTargetSeq = targetSeq ?? "";
+  if (reachedTargetSequence(since, finalTargetSeq)) {
+    Logger("Already at the target sequence. Initial data synchronisation is complete.");
+    return;
+  }
+  Logger(
+    `Starting initial synchronisation. Current sequence: ${since}, Target sequence: ${finalTargetSeq}, Total documents to fetch: ${docsToFetch}.`
+  );
+  const controller = new AbortController();
+  const url = setParamsToURL(new URL(`${remoteDbUrl}/_changes`), {
+    ...changesBaseParams
+  });
+  const response = await _fetch(url.toString(), {
+    method: "GET",
+    headers: fetchHeaders,
+    signal: controller.signal
+  });
+  if (!response.body) {
+    throw new Error("ReadableStream is not supported by this browser.");
+  }
+  const sizeCaptureStream = new TransformStream({
+    transform(chunk, controller2) {
+      const chunkSize = chunk.length || chunk.byteLength || 0;
+      totalBytes += chunkSize;
+      controller2.enqueue(chunk);
+    }
+  });
+  const reader = response.body.pipeThrough(sizeCaptureStream).pipeThrough(new TextDecoderStream()).getReader();
+  const writeDocStream = generatePouchDBWriteStream(downloadToDB, decryptFunction, onCheckpoint);
+  const writer = writeDocStream.getWriter();
+  let buffer = "";
+  let lastProgress = 0;
+  let lastReportTime = Date.now();
+  let totalBytes = 0;
+  let abortedAfterTargetReached = false;
+  const reportProgress = () => {
+    if (totalFetched - lastProgress < 25) {
+      if (Date.now() - lastReportTime < 2e3) {
+        return;
+      }
+    }
+    lastProgress = totalFetched;
+    lastReportTime = Date.now();
+    onProgress?.({
+      totalFetched,
+      totalValidFetched,
+      targetSeq: finalTargetSeq,
+      docsToFetch,
+      totalBytes
+    });
+  };
+  try {
+    while (true) {
+      reportProgress();
+      const { value, done } = await reader.read();
+      if (value) {
+        totalBytes += value.length;
+      }
+      if (done) {
+        if (buffer.trim()) {
+          try {
+            totalFetched++;
+            const parsed = JSON.parse(buffer);
+            if (parsed.doc) {
+              await writer.write({ doc: parsed.doc, seq: parsed.seq });
+              totalValidFetched++;
+            } else {
+              await onCheckpoint?.(parsed.seq);
+            }
+            reportProgress();
+          } catch (e) {
+            Logger(`Failed to parse the final line: ${buffer}. Skipping it.`);
+            Logger(e, LOG_LEVEL_VERBOSE);
+          }
+        }
+        await writer.close();
+        break;
+      }
+      buffer += value;
+      const lines = buffer.split("\n");
+      buffer = lines.pop() || "";
+      for (const line of lines) {
+        if (!line.trim()) continue;
+        try {
+          const parsed = JSON.parse(line);
+          totalFetched++;
+          if (parsed.doc) {
+            await writer.write({ doc: parsed.doc, seq: parsed.seq });
+            totalValidFetched++;
+          } else {
+            await onCheckpoint?.(parsed.seq);
+          }
+          reportProgress();
+          if (totalFetched >= docsToFetch || reachedTargetSequence(parsed.seq, finalTargetSeq)) {
+            Logger(
+              `All documents fetched. Stopping the stream and writing remaining documents to PouchDB...`
+            );
+            await writer.close();
+            abortedAfterTargetReached = true;
+            controller.abort();
+            reportProgress();
+            return;
+          }
+        } catch (e) {
+          Logger(`JSON parsing failed. Skipping line: ${line}`, LOG_LEVEL_VERBOSE);
+          Logger(e, LOG_LEVEL_VERBOSE);
+        }
+      }
+    }
+    Logger("Initial data synchronisation via stream has completed.");
+    reportProgress();
+  } catch (error) {
+    if (abortedAfterTargetReached && error instanceof DOMException && error.name === "AbortError") {
+      Logger(
+        "Stream has been aborted as the target sequence has been reached. Finalising the synchronising process..."
+      );
+      return;
+    }
+    Logger("An error occurred during synchronisation:", LOG_LEVEL_VERBOSE);
+    Logger(error, LOG_LEVEL_VERBOSE);
+    throw error;
+  } finally {
+    reader.releaseLock();
+  }
+}
+export {
+  fetchChangesForInitialSync
+};

package/dist/pouchdb/chunks.d.ts

@@ -0,0 +1,38 @@
+import type { CouchDBConnection } from "../common/types.js";
+export declare function purgeUnreferencedChunks(db: PouchDB.Database, dryRun: boolean, connSetting?: CouchDBConnection, performCompact?: boolean): Promise<number>;
+export declare function transferChunks(key: string, label: string, dbFrom: PouchDB.Database, dbTo: PouchDB.Database, items: {
+    id: string;
+    rev: string;
+}[]): Promise<boolean>;
+export declare function balanceChunkPurgedDBs(local: PouchDB.Database, remote: PouchDB.Database): Promise<void>;
+export declare function fetchAllUsedChunks(local: PouchDB.Database, remote: PouchDB.Database): Promise<void>;
+export declare function purgeChunksLocal(db: PouchDB.Database, docs: {
+    id: string;
+    rev: string;
+}[]): Promise<void>;
+export declare function collectUnbalancedChunkIDs(local: PouchDB.Database, remote: PouchDB.Database): Promise<{
+    onlyOnLocal: {
+        id: string;
+        rev: string;
+    }[];
+    onlyOnRemote: {
+        id: string;
+        rev: string;
+    }[];
+}>;
+export declare function collectChunks(db: PouchDB.Database, type: "INUSE" | "DANGLING" | "ALL"): Promise<{
+    id: string;
+    rev: string;
+}[]>;
+export declare function collectChunksUsage(db: PouchDB.Database): Promise<{
+    value: number;
+    key: string[];
+}[]>;
+export declare function collectUnreferencedChunks(db: PouchDB.Database): Promise<{
+    id: string;
+    rev: string;
+}[]>;
+export declare function purgeChunksRemote(setting: CouchDBConnection, docs: {
+    id: string;
+    rev: string;
+}[]): Promise<void>;

package/dist/pouchdb/chunks.js

@@ -0,0 +1,314 @@
+import { Logger, LOG_LEVEL_NOTICE, LOG_LEVEL_VERBOSE } from "../common/logger.js";
+import { QueueProcessor } from "octagonal-wheels/concurrency/processor";
+import { arrayToChunkedArray, sizeToHumanReadable } from "../common/utils.js";
+import { serialized } from "octagonal-wheels/concurrency/lock";
+import { _requestToCouchDBFetch } from "./utils_couchdb.js";
+import { isNotFoundError } from "../common/utils.doc.js";
+async function purgeUnreferencedChunks(db, dryRun, connSetting, performCompact = false) {
+  const info = await db.info();
+  let resultCount = 0;
+  const getSize = function(info2, key) {
+    return Number.parseInt(info2?.sizes?.[key] ?? "0", 10);
+  };
+  const keySuffix = connSetting ? "-remote" : "-local";
+  Logger(`${dryRun ? "Counting" : "Cleaning"} ${connSetting ? "remote" : "local"} database`, LOG_LEVEL_NOTICE);
+  if (connSetting) {
+    Logger(
+      `Database active-size: ${sizeToHumanReadable(getSize(info, "active"))}, external-size:${sizeToHumanReadable(
+        getSize(info, "external")
+      )}, file-size: ${sizeToHumanReadable(getSize(info, "file"))}`,
+      LOG_LEVEL_NOTICE
+    );
+  }
+  Logger(`Collecting unreferenced chunks on ${info.db_name}`, LOG_LEVEL_NOTICE, "gc-count-chunk" + keySuffix);
+  const chunks = await collectUnreferencedChunks(db);
+  resultCount = chunks.length;
+  if (chunks.length == 0) {
+    Logger(`No unreferenced chunks! ${info.db_name}`, LOG_LEVEL_NOTICE, "gc-count-chunk" + keySuffix);
+  } else {
+    Logger(
+      `Number of unreferenced chunks on ${info.db_name}: ${chunks.length}`,
+      LOG_LEVEL_NOTICE,
+      "gc-count-chunk" + keySuffix
+    );
+    if (dryRun) {
+      Logger(`DryRun of cleaning ${connSetting ? "remote" : "local"} database up: Done`, LOG_LEVEL_NOTICE);
+      return resultCount;
+    }
+    if (connSetting) {
+      Logger(`Cleaning unreferenced chunks on remote`, LOG_LEVEL_NOTICE, "gc-purge" + keySuffix);
+      await purgeChunksRemote(connSetting, chunks);
+    } else {
+      Logger(`Cleaning unreferenced chunks on local`, LOG_LEVEL_NOTICE, "gc-purge" + keySuffix);
+      await purgeChunksLocal(db, chunks);
+    }
+    Logger(`Cleaning unreferenced chunks done!`, LOG_LEVEL_NOTICE, "gc-purge" + keySuffix);
+  }
+  if (performCompact) {
+    Logger(`Compacting database...`, LOG_LEVEL_NOTICE, "gc-compact" + keySuffix);
+    await db.compact();
+    Logger(`Compacting database done`, LOG_LEVEL_NOTICE, "gc-compact" + keySuffix);
+  }
+  if (connSetting) {
+    const endInfo = await db.info();
+    Logger(
+      `Processed database active-size: ${sizeToHumanReadable(
+        getSize(endInfo, "active")
+      )}, external-size:${sizeToHumanReadable(
+        getSize(endInfo, "external")
+      )}, file-size: ${sizeToHumanReadable(getSize(endInfo, "file"))}`,
+      LOG_LEVEL_NOTICE
+    );
+    Logger(
+      `Reduced sizes: active-size: ${sizeToHumanReadable(
+        getSize(info, "active") - getSize(endInfo, "active")
+      )}, external-size:${sizeToHumanReadable(
+        getSize(info, "external") - getSize(endInfo, "external")
+      )}, file-size: ${sizeToHumanReadable(getSize(info, "file") - getSize(endInfo, "file"))}`,
+      LOG_LEVEL_NOTICE
+    );
+  }
+  Logger(`Cleaning ${connSetting ? "remote" : "local"} database up: Done`, LOG_LEVEL_NOTICE);
+  return resultCount;
+}
+function transferChunks(key, label, dbFrom, dbTo, items) {
+  let totalProcessed = 0;
+  const total = items.length;
+  return new QueueProcessor(
+    async (batched) => {
+      const requestItems = batched.map((e) => e.id);
+      const local = await dbTo.allDocs({ keys: requestItems });
+      const batch = local.rows.filter((e) => "error" in e && e.error == "not_found").map((e) => e.key);
+      return batch;
+    },
+    {
+      batchSize: 50,
+      concurrentLimit: 5,
+      suspended: true,
+      delay: 100
+    },
+    items
+  ).pipeTo(
+    new QueueProcessor(
+      async (chunkIds) => {
+        const docs = await dbFrom.allDocs({
+          keys: chunkIds,
+          include_docs: true
+        });
+        const filteredDocs = docs.rows.filter((e) => !("error" in e)).map((e) => e.doc);
+        return filteredDocs;
+      },
+      {
+        batchSize: 25,
+        concurrentLimit: 1,
+        suspended: true,
+        delay: 100
+      }
+    )
+  ).pipeTo(
+    new QueueProcessor(
+      async (docs) => {
+        try {
+          await dbTo.bulkDocs(docs, { new_edits: false });
+        } catch (ex) {
+          Logger(`${label}: Something went wrong on balancing`, LOG_LEVEL_NOTICE);
+          Logger(ex, LOG_LEVEL_VERBOSE);
+        } finally {
+          totalProcessed += docs.length;
+          Logger(`${label}: ${totalProcessed} / ${total}`, LOG_LEVEL_NOTICE, "balance-" + key);
+        }
+        return;
+      },
+      { batchSize: 100, delay: 100, concurrentLimit: 2, suspended: false }
+    )
+  ).startPipeline().waitForAllDoneAndTerminate();
+}
+async function balanceChunkPurgedDBs(local, remote) {
+  Logger(`Complement missing chunks between databases`, LOG_LEVEL_NOTICE);
+  try {
+    const { onlyOnLocal, onlyOnRemote } = await collectUnbalancedChunkIDs(local, remote);
+    const localToRemote = transferChunks("l2r", "local -> remote", local, remote, onlyOnLocal);
+    const remoteToLocal = transferChunks("r2l", "remote -> local", remote, local, onlyOnRemote);
+    await Promise.all([localToRemote, remoteToLocal]);
+    Logger(`local -> remote: Done`, LOG_LEVEL_NOTICE, "balance-l2r");
+    Logger(`remote -> local: Done`, LOG_LEVEL_NOTICE, "balance-r2l");
+  } catch (ex) {
+    Logger("Something went wrong on balancing!", LOG_LEVEL_NOTICE);
+    Logger(ex, LOG_LEVEL_VERBOSE);
+  }
+  Logger("Complement completed!", LOG_LEVEL_NOTICE);
+}
+async function fetchAllUsedChunks(local, remote) {
+  try {
+    const chunksOnRemote = await collectChunks(remote, "INUSE");
+    await transferChunks("r2l", "remote -> local", remote, local, chunksOnRemote);
+    Logger(`remote -> local: Done`, LOG_LEVEL_NOTICE, "balance-r2l");
+  } catch (ex) {
+    Logger("Something went wrong on balancing!", LOG_LEVEL_NOTICE);
+    Logger(ex, LOG_LEVEL_VERBOSE);
+  }
+}
+async function purgeChunksLocal(db, docs) {
+  await serialized("purge-local", async () => {
+    try {
+      Logger(`Purging unused ${docs.length} chunks `, LOG_LEVEL_NOTICE, "purge-local-backup");
+      const batchDocsBackup = arrayToChunkedArray(docs, 100);
+      let total = { ok: 0, exist: 0, error: 0 };
+      for (const docsInBatch of batchDocsBackup) {
+        const backupDocsFrom = await db.allDocs({
+          keys: docsInBatch.map((e) => e.id),
+          include_docs: true
+        });
+        const backupDocs = backupDocsFrom.rows.filter((e) => "doc" in e).map((e) => {
+          const chunk = { ...e.doc };
+          delete chunk._rev;
+          chunk._id = `_local/${chunk._id}`;
+          return chunk;
+        });
+        const ret = await db.bulkDocs(backupDocs);
+        total = ret.map((e) => ({
+          ok: "ok" in e ? 1 : 0,
+          exist: "status" in e && e.status == 409 ? 1 : 0,
+          error: "status" in e && e.status != 409 ? 1 : 0
+        })).reduce((p, c) => ({ ok: p.ok + c.ok, exist: p.exist + c.exist, error: p.error + c.error }), total);
+        Logger(
+          `Local chunk backed up: new:${total.ok} ,exist:${total.exist}, error:${total.error}`,
+          LOG_LEVEL_NOTICE,
+          "purge-local-backup"
+        );
+        const erroredItems = ret.filter((e) => "error" in e && e.status != 409);
+        for (const item of erroredItems) {
+          Logger(`Failed to back up: ${item.id} / ${item.rev}`, LOG_LEVEL_VERBOSE);
+        }
+      }
+    } catch (ex) {
+      Logger(`Could not back up chunks`);
+      Logger(ex, LOG_LEVEL_VERBOSE);
+    }
+    Logger(`Purging unused ${docs.length} chunks... `, LOG_LEVEL_NOTICE, "purge-local");
+    const batchDocs = arrayToChunkedArray(docs, 100);
+    let totalRemoved = 0;
+    for (const docsInBatch of batchDocs) {
+      const removed = await db.purgeMulti(docsInBatch.map((e) => [e.id, e.rev]));
+      const removedCount = Object.values(removed).filter((e) => "ok" in e).length;
+      totalRemoved += removedCount;
+      Logger(`Purging:  ${totalRemoved} / ${docs.length}`, LOG_LEVEL_NOTICE, "purge-local");
+    }
+    Logger(
+      `Purging unused chunks done!: ${totalRemoved} chunks has been deleted.`,
+      LOG_LEVEL_NOTICE,
+      "purge-local"
+    );
+  });
+}
+async function collectUnbalancedChunkIDs(local, remote) {
+  const chunksOnLocal = await collectChunks(local, "INUSE");
+  const chunksOnRemote = await collectChunks(remote, "INUSE");
+  const onlyOnLocal = chunksOnLocal.filter((e) => !chunksOnRemote.some((ee) => ee.id == e.id));
+  const onlyOnRemote = chunksOnRemote.filter((e) => !chunksOnLocal.some((ee) => ee.id == e.id));
+  return { onlyOnLocal, onlyOnRemote };
+}
+async function collectChunks(db, type) {
+  const rows = await collectChunksUsage(db);
+  const rowF = type == "ALL" ? rows : rows.filter((e) => type == "DANGLING" ? e.value == 0 : e.value != 0);
+  const ids = rowF.flatMap((e) => e.key);
+  const docs = (await db.allDocs({ keys: ids })).rows;
+  const items = docs.filter((e) => !("error" in e)).map((e) => ({ id: e.id, rev: e.value.rev }));
+  return items;
+}
+async function prepareChunkDesignDoc(db) {
+  const chunkDesignDoc = {
+    _id: "_design/chunks",
+    _rev: void 0,
+    ver: 2,
+    views: {
+      collectDangling: {
+        map: function(doc) {
+          if (doc._id.startsWith("h:")) {
+            emit([doc._id], 0);
+          } else {
+            if ("children" in doc) {
+              doc.children.forEach((e) => emit([e], 1));
+            }
+          }
+        }.toString(),
+        reduce: "_sum"
+      }
+    }
+  };
+  let updateDDoc = false;
+  try {
+    const old = await db.get(chunkDesignDoc._id);
+    if (old?.ver ?? 0 < chunkDesignDoc.ver) {
+      chunkDesignDoc._rev = old._rev;
+      updateDDoc = true;
+    }
+  } catch (ex) {
+    if (isNotFoundError(ex)) {
+      updateDDoc = true;
+    } else {
+      Logger(`Failed to make design document for operating chunks`);
+      Logger(ex, LOG_LEVEL_VERBOSE);
+      return false;
+    }
+  }
+  try {
+    if (updateDDoc) {
+      await db.put(chunkDesignDoc);
+    }
+  } catch (ex) {
+    Logger(`Failed to make design document for operating chunks`);
+    Logger(ex, LOG_LEVEL_VERBOSE);
+    return false;
+  }
+  return true;
+}
+async function collectChunksUsage(db) {
+  if (!await prepareChunkDesignDoc(db)) {
+    Logger(`Could not prepare design document for operating chunks`);
+    return [];
+  }
+  const q = await db.query("chunks/collectDangling", { reduce: true, group: true });
+  const rows = q.rows;
+  return rows;
+}
+function collectUnreferencedChunks(db) {
+  return collectChunks(db, "DANGLING");
+}
+async function purgeChunksRemote(setting, docs) {
+  await serialized("purge-remote", async () => {
+    const CHUNK_SIZE = 100;
+    function makeChunkedArrayFromArray(items) {
+      const chunked = [];
+      for (let i = 0; i < items.length; i += CHUNK_SIZE) {
+        chunked.push(items.slice(i, i + CHUNK_SIZE));
+      }
+      return chunked;
+    }
+    const buffer = makeChunkedArrayFromArray(docs);
+    for (const chunkedPayload of buffer) {
+      const rets = await _requestToCouchDBFetch(
+        `${setting.couchDB_URI.replace(/\/+$/, "")}/${setting.couchDB_DBNAME}`,
+        setting.couchDB_USER,
+        setting.couchDB_PASSWORD,
+        "_purge",
+        Object.fromEntries(chunkedPayload.map((e) => [e.id, [e.rev]])),
+        "POST"
+      );
+      Logger(JSON.stringify(await rets.json()), LOG_LEVEL_VERBOSE);
+    }
+    return;
+  });
+}
+export {
+  balanceChunkPurgedDBs,
+  collectChunks,
+  collectChunksUsage,
+  collectUnbalancedChunkIDs,
+  collectUnreferencedChunks,
+  fetchAllUsedChunks,
+  purgeChunksLocal,
+  purgeChunksRemote,
+  purgeUnreferencedChunks,
+  transferChunks
+};

package/dist/pouchdb/compress.d.ts

@@ -0,0 +1,11 @@
+import * as fflate from "fflate";
+import type { EntryDoc } from "../common/types.js";
+export declare function _compressText(text: string): Promise<string>;
+export declare const wrappedInflate: (data: Uint8Array<ArrayBuffer>, opts: fflate.AsyncInflateOptions) => Promise<Uint8Array<ArrayBuffer>>;
+export declare const wrappedDeflate: (data: Uint8Array<ArrayBuffer>, opts: fflate.AsyncDeflateOptions) => Promise<Uint8Array<ArrayBuffer>>;
+export declare function _decompressText(compressed: string, _useUTF16?: boolean): Promise<string>;
+export declare function compressDoc(doc: EntryDoc): Promise<import("../common/types.js").NoteEntry | import("../common/types.js").NewEntry | import("../common/types.js").PlainEntry | import("../common/types.js").EntryLeaf | import("../common/types.js").EntryChunkPack | import("../common/types.js").EntryVersionInfo | import("../common/types.js").EntryMilestoneInfo | import("../common/types.js").EntryNodeInfo>;
+export declare function decompressDoc(doc: EntryDoc): Promise<import("../common/types.js").NoteEntry | import("../common/types.js").NewEntry | import("../common/types.js").PlainEntry | import("../common/types.js").EntryLeaf | import("../common/types.js").EntryChunkPack | import("../common/types.js").EntryVersionInfo | import("../common/types.js").EntryMilestoneInfo | import("../common/types.js").EntryNodeInfo>;
+export declare function wrapFflateFunc<T, U>(func: (data: T, opts: U, cb: fflate.FlateCallback) => unknown): (data: T, opts: U) => Promise<Uint8Array<ArrayBuffer>>;
+export declare const replicationFilter: (db: PouchDB.Database<EntryDoc>, compress: boolean) => void;
+export declare const MARK_SHIFT_COMPRESSED = "\u000ELZ\u001D";