@vrtmrz/livesync-commonlib 0.1.0-rc.0

package/dist/pouchdb/compress.js

@@ -0,0 +1,99 @@
+import * as fflate from "fflate";
+import {
+  tryConvertBase64ToArrayBuffer,
+  arrayBufferToBase64Single,
+  base64ToArrayBuffer
+} from "../string_and_binary/convert.js";
+async function _compressText(text) {
+  const converted = tryConvertBase64ToArrayBuffer(text);
+  const data = new Uint8Array(
+    converted || await new Blob([text], { type: "application/octet-stream" }).arrayBuffer()
+  );
+  if (data.buffer.byteLength == 0) {
+    return "";
+  }
+  const df = await wrappedDeflate(new Uint8Array(data), { consume: true, level: 8 });
+  const deflateResult = (converted ? "~" : "") + await arrayBufferToBase64Single(df);
+  return deflateResult;
+}
+const wrappedInflate = wrapFflateFunc(fflate.inflate);
+const wrappedDeflate = wrapFflateFunc(fflate.deflate);
+async function _decompressText(compressed, _useUTF16 = false) {
+  if (compressed.length == 0) {
+    return "";
+  }
+  const converted = compressed[0] == "~";
+  const src = compressed.substring(converted ? 1 : 0);
+  if (src.length == 0) {
+    return "";
+  }
+  const ab = new Uint8Array(base64ToArrayBuffer(src));
+  if (ab.length == 0) {
+    return "";
+  }
+  const ret = await wrappedInflate(new Uint8Array(ab), { consume: true });
+  if (converted) {
+    return await arrayBufferToBase64Single(ret);
+  }
+  const response = new Blob([ret]);
+  const text = await response.text();
+  return text;
+}
+async function compressDoc(doc) {
+  if (!("data" in doc)) {
+    return doc;
+  }
+  if (typeof doc.data !== "string") return doc;
+  if (doc.data.startsWith(MARK_SHIFT_COMPRESSED)) return doc;
+  const oldData = doc.data;
+  const compressed = await _compressText(oldData);
+  const newData = MARK_SHIFT_COMPRESSED + compressed;
+  if (doc.data.length > newData.length) doc.data = newData;
+  return doc;
+}
+async function decompressDoc(doc) {
+  if (!("data" in doc)) {
+    return doc;
+  }
+  if (typeof doc.data !== "string") return doc;
+  if (doc.data.startsWith(MARK_SHIFT_COMPRESSED)) {
+    doc.data = await _decompressText(doc.data.substring(MARK_SHIFT_COMPRESSED.length));
+  }
+  return doc;
+}
+function wrapFflateFunc(func) {
+  return (data, opts) => {
+    return new Promise((res, rej) => {
+      func(data, opts, (err, result) => {
+        if (err) rej(err);
+        else res(new Uint8Array(result));
+      });
+    });
+  };
+}
+const replicationFilter = (db, compress) => {
+  db.transform({
+    //@ts-ignore
+    async incoming(doc) {
+      if (!compress) return doc;
+      return await compressDoc(doc);
+    },
+    //@ts-ignore
+    async outgoing(doc) {
+      return await decompressDoc(doc);
+    }
+  });
+};
+const MARK_SHIFT = `L`;
+const MARK_SHIFT_COMPRESSED = `${MARK_SHIFT}Z`;
+export {
+  MARK_SHIFT_COMPRESSED,
+  _compressText,
+  _decompressText,
+  compressDoc,
+  decompressDoc,
+  replicationFilter,
+  wrapFflateFunc,
+  wrappedDeflate,
+  wrappedInflate
+};

package/dist/pouchdb/encryption.d.ts

@@ -0,0 +1,20 @@
+import { type EntryDoc, type AnyEntry, type EntryLeaf, type DocumentID, type E2EEAlgorithm } from "../common/types.js";
+import { encryptWorker, decryptWorker, encryptHKDFWorker, decryptHKDFWorker } from "#worker";
+export declare const encrypt: typeof encryptWorker;
+export declare const decrypt: typeof decryptWorker;
+export declare const encryptHKDF: typeof encryptHKDFWorker;
+export declare const decryptHKDF: typeof decryptHKDFWorker;
+export declare let preprocessOutgoing: (doc: AnyEntry | EntryLeaf) => Promise<AnyEntry | EntryLeaf>;
+export declare let preprocessIncoming: (doc: EntryDoc) => Promise<EntryDoc>;
+export declare function getConfiguredFunctionsForEncryption(passphrase: string, useDynamicIterationCount: boolean, migrationDecrypt: boolean, getPBKDF2Salt: () => Promise<Uint8Array<ArrayBuffer>>, algorithm: E2EEAlgorithm): {
+    incoming: (doc: AnyEntry | EntryLeaf) => Promise<AnyEntry | EntryLeaf>;
+    outgoing: (doc: EntryDoc) => Promise<AnyEntry | EntryLeaf>;
+};
+export declare const enableEncryption: (db: PouchDB.Database<EntryDoc>, passphrase: string, useDynamicIterationCount: boolean, migrationDecrypt: boolean, getPBKDF2Salt: () => Promise<Uint8Array<ArrayBuffer>>, algorithm: E2EEAlgorithm) => void;
+export declare function disableEncryption(): void;
+export declare const EDEN_ENCRYPTED_KEY: DocumentID;
+export declare const EDEN_ENCRYPTED_KEY_HKDF: DocumentID;
+export declare function shouldEncryptEden(doc: AnyEntry | EntryLeaf): doc is AnyEntry;
+export declare function shouldEncryptEdenHKDF(doc: AnyEntry | EntryLeaf): doc is AnyEntry;
+export declare function shouldDecryptEden(doc: AnyEntry | EntryLeaf): doc is AnyEntry;
+export declare function shouldDecryptEdenHKDF(doc: AnyEntry | EntryLeaf): doc is AnyEntry;

package/dist/pouchdb/encryption.js

@@ -0,0 +1,458 @@
+import { Logger, LOG_LEVEL_NOTICE, LOG_LEVEL_VERBOSE } from "../common/logger.js";
+import {
+  E2EEAlgorithms,
+  isMetaEntry
+} from "../common/types.js";
+import { isEncryptedChunkEntry, isSyncInfoEntry, isObfuscatedEntry } from "../common/utils.js";
+import { isPathProbablyObfuscated, obfuscatePath } from "octagonal-wheels/encryption/encryption";
+import { getPath } from "../string_and_binary/path.js";
+import { encryptWorker, decryptWorker, encryptHKDFWorker, decryptHKDFWorker } from "#worker";
+const encrypt = encryptWorker;
+const decrypt = decryptWorker;
+const encryptHKDF = encryptHKDFWorker;
+const decryptHKDF = decryptHKDFWorker;
+const Encrypt_HKDF_Header = "%=";
+const Encrypt_OLD_Header = "%";
+const EncryptionVersions = {
+  UNENCRYPTED: 0,
+  ENCRYPTED: 1,
+  HKDF: 2,
+  UNKNOWN: 99
+};
+function getEncryptionVersion(data) {
+  if ("e_" in data && data.e_ === true) {
+    if (data.data.startsWith(Encrypt_HKDF_Header)) {
+      return EncryptionVersions.HKDF;
+    } else if (data.data.startsWith(Encrypt_OLD_Header)) {
+      return EncryptionVersions.ENCRYPTED;
+    }
+    return EncryptionVersions.UNKNOWN;
+  }
+  return EncryptionVersions.UNENCRYPTED;
+}
+async function tryDecryptV1AsFallback(encryptedData, passphrase, useDynamicIterationCount) {
+  try {
+    return await decrypt(encryptedData, passphrase, useDynamicIterationCount);
+  } catch (ex) {
+    try {
+      Logger(
+        "Failed to decrypt with V1 method. Fallback to disable useDynamicIterationCount.",
+        LOG_LEVEL_VERBOSE
+      );
+      Logger(ex, LOG_LEVEL_VERBOSE);
+      return await decrypt(encryptedData, passphrase, false);
+    } catch (ex2) {
+      Logger("Completely failed to decrypt with V1 method.", LOG_LEVEL_VERBOSE);
+      Logger(ex2, LOG_LEVEL_VERBOSE);
+      return false;
+    }
+  }
+}
+const ENCRYPTED_META_PREFIX = "/\\:";
+function isEncryptedMeta(doc) {
+  return "path" in doc && doc.path.startsWith(ENCRYPTED_META_PREFIX);
+}
+async function encryptMetaWithHKDF(doc, passphrase, pbkdf2Salt) {
+  if (isEncryptedMeta(doc)) {
+    return doc.path;
+  }
+  const props = {
+    path: getPath(doc),
+    mtime: doc.mtime,
+    ctime: doc.ctime,
+    size: doc.size,
+    children: isMetaEntry(doc) ? doc.children : void 0
+  };
+  const propStr = JSON.stringify(props);
+  const encryptedMeta = await encryptHKDFWorker(propStr, passphrase, pbkdf2Salt);
+  return ENCRYPTED_META_PREFIX + encryptedMeta;
+}
+async function decryptMetaWithHKDF(meta, passphrase, pbkdf2Salt) {
+  if (!meta.startsWith(ENCRYPTED_META_PREFIX)) {
+    throw new Error("Meta is not encrypted with HKDF.");
+  }
+  const encryptedMeta = meta.slice(ENCRYPTED_META_PREFIX.length);
+  const props = await decryptHKDF(encryptedMeta, passphrase, pbkdf2Salt);
+  const parsedProps = JSON.parse(props);
+  return parsedProps;
+}
+const MESSAGE_FALLBACK_DECRYPT_FAILED = "Failed to decrypt the data with V1 method. Cannot encrypt with HKDF.";
+const ENCRYPTION_HKDF_FAILED = "Encryption with HKDF failed.";
+const DECRYPTION_HKDF_FAILED = "Decryption with HKDF failed.";
+const DECRYPTION_FALLBACK_FAILED = "Decryption with fallback failed.";
+async function incomingEncryptHKDF(doc, passphrase, useDynamicIterationCount, getPBKDF2Salt) {
+  const saveDoc = {
+    ...doc
+  };
+  if (isEncryptedChunkEntry(saveDoc) || isSyncInfoEntry(saveDoc)) {
+    try {
+      const encryptionVersion = getEncryptionVersion(saveDoc);
+      if (encryptionVersion === EncryptionVersions.ENCRYPTED) {
+        const decrypted = await tryDecryptV1AsFallback(saveDoc.data, passphrase, useDynamicIterationCount);
+        if (decrypted === false) {
+          Logger(MESSAGE_FALLBACK_DECRYPT_FAILED, LOG_LEVEL_NOTICE);
+          throw new Error(MESSAGE_FALLBACK_DECRYPT_FAILED);
+        }
+        const pbkdf2salt = await getPBKDF2Salt();
+        saveDoc.data = await encryptHKDF(saveDoc.data, passphrase, pbkdf2salt);
+        saveDoc.e_ = true;
+      }
+      if (encryptionVersion === EncryptionVersions.HKDF) {
+      } else if (encryptionVersion === EncryptionVersions.UNENCRYPTED) {
+        const pbkdf2salt = await getPBKDF2Salt();
+        saveDoc.data = await encryptHKDF(saveDoc.data, passphrase, pbkdf2salt);
+        saveDoc.e_ = true;
+      }
+    } catch (ex) {
+      Logger(ENCRYPTION_HKDF_FAILED, LOG_LEVEL_NOTICE);
+      Logger(ex);
+      throw ex;
+    }
+  }
+  if (shouldEncryptEdenHKDF(saveDoc)) {
+    const pbkdf2salt = await getPBKDF2Salt();
+    try {
+      saveDoc.eden = {
+        [EDEN_ENCRYPTED_KEY_HKDF]: {
+          data: await encryptHKDF(JSON.stringify(saveDoc.eden), passphrase, pbkdf2salt),
+          epoch: 999999
+        }
+      };
+    } catch (ex) {
+      Logger(`${ENCRYPTION_HKDF_FAILED} on Eden`, LOG_LEVEL_NOTICE);
+      Logger(ex);
+      throw ex;
+    }
+  }
+  if (isObfuscatedEntry(saveDoc)) {
+    const pbkdf2salt = await getPBKDF2Salt();
+    if (!isEncryptedMeta(saveDoc)) {
+      try {
+        saveDoc.path = await encryptMetaWithHKDF(
+          saveDoc,
+          passphrase,
+          pbkdf2salt
+        );
+        saveDoc.mtime = 0;
+        saveDoc.ctime = 0;
+        saveDoc.size = 0;
+        if ("children" in saveDoc) saveDoc.children = [];
+      } catch (ex) {
+        Logger(`${ENCRYPTION_HKDF_FAILED} on Metadata`, LOG_LEVEL_NOTICE);
+        Logger(ex);
+        throw ex;
+      }
+    }
+  }
+  return saveDoc;
+}
+async function outgoingDecryptHKDF(doc, migrationDecrypt, decrypted, passphrase, useDynamicIterationCount, getPBKDF2Salt) {
+  const loadDoc = {
+    ...doc
+  };
+  if (isEncryptedChunkEntry(loadDoc) || isSyncInfoEntry(loadDoc)) {
+    try {
+      const encryptionVersion = getEncryptionVersion(loadDoc);
+      if (encryptionVersion === EncryptionVersions.HKDF) {
+        const pbkdf2salt = await getPBKDF2Salt();
+        loadDoc.data = await decryptHKDF(loadDoc.data, passphrase, pbkdf2salt);
+        delete loadDoc.e_;
+      } else if (encryptionVersion === EncryptionVersions.ENCRYPTED) {
+        const decryptedData = await tryDecryptV1AsFallback(loadDoc.data, passphrase, useDynamicIterationCount);
+        if (decryptedData === false) {
+          Logger(MESSAGE_FALLBACK_DECRYPT_FAILED, LOG_LEVEL_NOTICE);
+          throw new Error(MESSAGE_FALLBACK_DECRYPT_FAILED);
+        }
+        loadDoc.data = decryptedData;
+        delete loadDoc.e_;
+      } else if (encryptionVersion === EncryptionVersions.UNENCRYPTED) {
+      } else {
+        Logger("Unknown encryption version. Cannot decrypt.", LOG_LEVEL_NOTICE);
+        throw new Error("Unknown encryption version. Cannot decrypt.");
+      }
+    } catch (ex) {
+      Logger(DECRYPTION_HKDF_FAILED, LOG_LEVEL_NOTICE);
+      Logger(ex);
+      throw ex;
+    }
+  }
+  if (isObfuscatedEntry(loadDoc)) {
+    const path = getPath(loadDoc);
+    if (isEncryptedMeta(loadDoc)) {
+      const pbkdf2salt = await getPBKDF2Salt();
+      try {
+        const metadata = await decryptMetaWithHKDF(path, passphrase, pbkdf2salt);
+        for (const key of Object.keys(metadata)) {
+          loadDoc[key] = metadata[key];
+        }
+      } catch (ex) {
+        Logger(`${DECRYPTION_HKDF_FAILED} on Path`, LOG_LEVEL_NOTICE);
+        Logger(ex);
+        throw ex;
+      }
+    } else if (isPathProbablyObfuscated(path)) {
+      const decryptedPath = await tryDecryptV1AsFallback(path, passphrase, useDynamicIterationCount);
+      if (decryptedPath === false) {
+        Logger(`${MESSAGE_FALLBACK_DECRYPT_FAILED} on Path`, LOG_LEVEL_NOTICE);
+        throw new Error(MESSAGE_FALLBACK_DECRYPT_FAILED);
+      }
+      loadDoc.path = decryptedPath;
+    }
+  }
+  let readEden = {};
+  let edenDecrypted = false;
+  if (shouldDecryptEden(loadDoc)) {
+    try {
+      const decryptedEden = await tryDecryptV1AsFallback(
+        loadDoc.eden[EDEN_ENCRYPTED_KEY].data,
+        passphrase,
+        useDynamicIterationCount
+      );
+      if (decryptedEden === false) throw new Error(MESSAGE_FALLBACK_DECRYPT_FAILED);
+      readEden = {
+        ...readEden,
+        ...JSON.parse(decryptedEden)
+      };
+      edenDecrypted = true;
+    } catch (ex) {
+      Logger(`${DECRYPTION_FALLBACK_FAILED} on Eden`, LOG_LEVEL_NOTICE);
+      Logger(ex);
+      throw ex;
+    }
+  }
+  if (shouldDecryptEdenHKDF(loadDoc)) {
+    const pbkdf2salt = await getPBKDF2Salt();
+    try {
+      const decryptedEdenData = await decryptHKDF(
+        loadDoc.eden[EDEN_ENCRYPTED_KEY_HKDF].data,
+        passphrase,
+        pbkdf2salt
+      );
+      readEden = {
+        ...readEden,
+        ...JSON.parse(decryptedEdenData)
+      };
+      edenDecrypted = true;
+    } catch (ex) {
+      Logger(`${DECRYPTION_HKDF_FAILED} on Eden`, LOG_LEVEL_NOTICE);
+      Logger(ex);
+      throw ex;
+    }
+  }
+  if (edenDecrypted) {
+    loadDoc.eden = readEden;
+  } else {
+  }
+  return loadDoc;
+}
+async function incomingEncryptV1(doc, passphrase, useDynamicIterationCount) {
+  const saveDoc = {
+    ...doc
+  };
+  if (isEncryptedChunkEntry(saveDoc) || isSyncInfoEntry(saveDoc)) {
+    try {
+      if (!("e_" in saveDoc)) {
+        saveDoc.data = await encrypt(saveDoc.data, passphrase, useDynamicIterationCount);
+        saveDoc.e_ = true;
+      }
+    } catch (ex) {
+      Logger("Encryption failed.", LOG_LEVEL_NOTICE);
+      Logger(ex);
+      throw ex;
+    }
+  }
+  if (shouldEncryptEden(saveDoc)) {
+    saveDoc.eden = {
+      [EDEN_ENCRYPTED_KEY]: {
+        data: await encrypt(JSON.stringify(saveDoc.eden), passphrase, useDynamicIterationCount),
+        epoch: 999999
+      }
+    };
+  }
+  if (isObfuscatedEntry(saveDoc)) {
+    try {
+      const path = getPath(saveDoc);
+      if (!isPathProbablyObfuscated(path)) {
+        saveDoc.path = await obfuscatePath(
+          path,
+          passphrase,
+          useDynamicIterationCount
+        );
+      }
+    } catch (ex) {
+      Logger("Encryption failed.", LOG_LEVEL_NOTICE);
+      Logger(ex);
+      throw ex;
+    }
+  }
+  return saveDoc;
+}
+async function outgoingDecryptV1(doc, migrationDecrypt, decrypted, passphrase, useDynamicIterationCount) {
+  const loadDoc = {
+    ...doc
+  };
+  const _isChunkOrSyncInfo = isEncryptedChunkEntry(loadDoc) || isSyncInfoEntry(loadDoc);
+  const _isObfuscatedEntry = isObfuscatedEntry(loadDoc);
+  const _shouldDecryptEden = shouldDecryptEden(loadDoc);
+  if (_isChunkOrSyncInfo || _isObfuscatedEntry || _shouldDecryptEden) {
+    if (migrationDecrypt && decrypted.has(loadDoc._id)) {
+      return loadDoc;
+    }
+    try {
+      if (_isChunkOrSyncInfo) {
+        loadDoc.data = await decrypt(loadDoc.data, passphrase, useDynamicIterationCount);
+        delete loadDoc.e_;
+      } else if ("e_" in loadDoc) {
+        loadDoc.data = await decrypt(
+          loadDoc.data,
+          passphrase,
+          useDynamicIterationCount
+        );
+        delete loadDoc.e_;
+      }
+      if (_isObfuscatedEntry) {
+        const path = getPath(loadDoc);
+        if (isPathProbablyObfuscated(path)) {
+          loadDoc.path = await decrypt(
+            path,
+            passphrase,
+            useDynamicIterationCount
+          );
+        }
+      }
+      if (_shouldDecryptEden) {
+        loadDoc.eden = JSON.parse(
+          await decrypt(loadDoc.eden[EDEN_ENCRYPTED_KEY].data, passphrase, useDynamicIterationCount)
+        );
+      }
+      if (migrationDecrypt) {
+        decrypted.set(loadDoc._id, true);
+      }
+    } catch (ex) {
+      if (useDynamicIterationCount) {
+        try {
+          if (_isChunkOrSyncInfo) {
+            loadDoc.data = await decrypt(loadDoc.data, passphrase, false);
+          }
+          if (_isObfuscatedEntry) {
+            const path = getPath(loadDoc);
+            if (isPathProbablyObfuscated(path)) {
+              loadDoc.path = await decrypt(path, passphrase, false);
+            }
+          }
+          if (_shouldDecryptEden) {
+            loadDoc.eden = JSON.parse(
+              await decrypt(loadDoc.eden[EDEN_ENCRYPTED_KEY].data, passphrase, false)
+            );
+          }
+          if (migrationDecrypt) {
+            decrypted.set(loadDoc._id, true);
+          }
+        } catch (ex2) {
+          if (migrationDecrypt && ex2 instanceof SyntaxError) {
+            return loadDoc;
+          }
+          Logger("Decryption failed.", LOG_LEVEL_NOTICE);
+          Logger(ex2, LOG_LEVEL_VERBOSE);
+          Logger(`id:${loadDoc._id}-${loadDoc._rev?.substring(0, 10)}`, LOG_LEVEL_VERBOSE);
+          throw ex2;
+        }
+      } else {
+        Logger("Decryption failed.", LOG_LEVEL_NOTICE);
+        Logger(ex, LOG_LEVEL_VERBOSE);
+        Logger(`id:${loadDoc._id}-${loadDoc._rev?.substring(0, 10)}`, LOG_LEVEL_VERBOSE);
+        throw ex;
+      }
+    }
+  }
+  return loadDoc;
+}
+let preprocessOutgoing = async (doc) => {
+  return await Promise.resolve(doc);
+};
+let preprocessIncoming = async (doc) => {
+  return await Promise.resolve(doc);
+};
+function getConfiguredFunctionsForEncryption(passphrase, useDynamicIterationCount, migrationDecrypt, getPBKDF2Salt, algorithm) {
+  const decryptedCache = /* @__PURE__ */ new Map();
+  const incoming = (doc) => algorithm === E2EEAlgorithms.V2 ? incomingEncryptHKDF(doc, passphrase, useDynamicIterationCount, getPBKDF2Salt) : incomingEncryptV1(doc, passphrase, useDynamicIterationCount);
+  const outgoing = (doc) => algorithm !== E2EEAlgorithms.ForceV1 ? outgoingDecryptHKDF(
+    doc,
+    migrationDecrypt,
+    decryptedCache,
+    passphrase,
+    useDynamicIterationCount,
+    getPBKDF2Salt
+  ) : outgoingDecryptV1(doc, migrationDecrypt, decryptedCache, passphrase, useDynamicIterationCount);
+  return {
+    incoming,
+    outgoing
+  };
+}
+const enableEncryption = (db, passphrase, useDynamicIterationCount, migrationDecrypt, getPBKDF2Salt, algorithm) => {
+  const { incoming, outgoing } = getConfiguredFunctionsForEncryption(
+    passphrase,
+    useDynamicIterationCount,
+    migrationDecrypt,
+    getPBKDF2Salt,
+    algorithm
+  );
+  db.transform({
+    incoming,
+    outgoing
+  });
+};
+function disableEncryption() {
+  preprocessOutgoing = async (doc) => {
+    return await Promise.resolve(doc);
+  };
+  preprocessIncoming = async (doc) => {
+    return await Promise.resolve(doc);
+  };
+}
+const EDEN_ENCRYPTED_KEY = "h:++encrypted";
+const EDEN_ENCRYPTED_KEY_HKDF = "h:++encrypted-hkdf";
+function shouldEncryptEden(doc) {
+  if ("eden" in doc && !(EDEN_ENCRYPTED_KEY in doc.eden)) {
+    return true;
+  }
+  return false;
+}
+function shouldEncryptEdenHKDF(doc) {
+  if ("eden" in doc && !(EDEN_ENCRYPTED_KEY_HKDF in doc.eden)) {
+    if (Object.keys(doc.eden).length === 0) {
+      return false;
+    }
+    return true;
+  }
+  return false;
+}
+function shouldDecryptEden(doc) {
+  if ("eden" in doc && EDEN_ENCRYPTED_KEY in doc.eden) {
+    return true;
+  }
+  return false;
+}
+function shouldDecryptEdenHKDF(doc) {
+  if ("eden" in doc && EDEN_ENCRYPTED_KEY_HKDF in doc.eden) {
+    return true;
+  }
+  return false;
+}
+export {
+  EDEN_ENCRYPTED_KEY,
+  EDEN_ENCRYPTED_KEY_HKDF,
+  decrypt,
+  decryptHKDF,
+  disableEncryption,
+  enableEncryption,
+  encrypt,
+  encryptHKDF,
+  getConfiguredFunctionsForEncryption,
+  preprocessIncoming,
+  preprocessOutgoing,
+  shouldDecryptEden,
+  shouldDecryptEdenHKDF,
+  shouldEncryptEden,
+  shouldEncryptEdenHKDF
+};

package/dist/pouchdb/negotiation.d.ts

@@ -0,0 +1,9 @@
+export declare const checkRemoteVersion: (db: PouchDB.Database, migrate: (from: number, to: number) => Promise<boolean>, barrier?: number) => Promise<boolean>;
+export declare const bumpRemoteVersion: (db: PouchDB.Database, barrier?: number) => Promise<boolean>;
+export declare const checkSyncInfo: (db: PouchDB.Database) => Promise<boolean>;
+/**
+ * Counts the number of remote (potentially) compromised chunks in the database.
+ * @param db The PouchDB database instance.
+ * @returns The number of compromised chunks or false if an error occurs.
+ */
+export declare function countCompromisedChunks(db: PouchDB.Database): Promise<number | false>;

package/dist/pouchdb/negotiation.js

@@ -0,0 +1,109 @@
+import { LOG_LEVEL_INFO, Logger } from "../common/logger.js";
+import {
+  LOG_LEVEL_VERBOSE,
+  SYNCINFO_ID,
+  VER,
+  VERSIONING_DOCID
+} from "../common/types.js";
+import { resolveWithIgnoreKnownError } from "../common/utils.js";
+import { isErrorOfMissingDoc } from "./utils_couchdb.js";
+const checkRemoteVersion = async (db, migrate, barrier = VER) => {
+  try {
+    const versionInfo = await db.get(VERSIONING_DOCID);
+    if (versionInfo.type != "versioninfo") {
+      return false;
+    }
+    const version = versionInfo.version;
+    if (version < barrier) {
+      const versionUpResult = await migrate(version, barrier);
+      if (versionUpResult) {
+        await bumpRemoteVersion(db);
+        return true;
+      }
+    }
+    if (version == barrier) return true;
+    return false;
+  } catch (ex) {
+    if (isErrorOfMissingDoc(ex)) {
+      if (await bumpRemoteVersion(db)) {
+        return true;
+      }
+      return false;
+    }
+    throw ex;
+  }
+};
+const bumpRemoteVersion = async (db, barrier = VER) => {
+  const vi = {
+    _id: VERSIONING_DOCID,
+    version: barrier,
+    type: "versioninfo"
+    // pbkdf2salt: "", // this will be set later.
+  };
+  const versionInfo = await resolveWithIgnoreKnownError(db.get(VERSIONING_DOCID), vi);
+  if (versionInfo.type != "versioninfo") {
+    return false;
+  }
+  vi._rev = versionInfo._rev;
+  await db.put(vi);
+  return true;
+};
+const checkSyncInfo = async (db) => {
+  try {
+    const syncinfo = await db.get(SYNCINFO_ID);
+    console.log(syncinfo);
+    return true;
+  } catch (ex) {
+    if (isErrorOfMissingDoc(ex)) {
+      const randomStrSrc = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
+      const temp = [...Array(30)].map((_e) => Math.floor(Math.random() * randomStrSrc.length)).map((e) => randomStrSrc[e]).join("");
+      const newSyncInfo = {
+        _id: SYNCINFO_ID,
+        type: "syncinfo",
+        data: temp
+      };
+      if (await db.put(newSyncInfo)) {
+        return true;
+      }
+      return false;
+    } else {
+      console.dir(ex);
+      return false;
+    }
+  }
+};
+const SELECTOR_COMPROMISED_CHUNK_1 = {
+  selector: {
+    _id: {
+      $lt: "h:"
+    },
+    type: "leaf"
+  }
+};
+const SELECTOR_COMPROMISED_CHUNK_2 = {
+  selector: {
+    _id: {
+      $gt: "h;"
+    },
+    type: "leaf"
+  }
+};
+async function countCompromisedChunks(db) {
+  try {
+    Logger(`Counting compromised chunks...`, LOG_LEVEL_VERBOSE);
+    const task1 = db.find(SELECTOR_COMPROMISED_CHUNK_1);
+    const task2 = db.find(SELECTOR_COMPROMISED_CHUNK_2);
+    const [result1, result2] = await Promise.all([task1, task2]);
+    return result1.docs.length + result2.docs.length;
+  } catch (ex) {
+    Logger(`Error counting compromised chunks!`, LOG_LEVEL_INFO);
+    Logger(ex, LOG_LEVEL_VERBOSE);
+    return false;
+  }
+}
+export {
+  bumpRemoteVersion,
+  checkRemoteVersion,
+  checkSyncInfo,
+  countCompromisedChunks
+};

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

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