@vrtmrz/livesync-commonlib 0.2.3 → 0.3.0

package/dist/replication/trystero/TrysteroReplicator.js

@@ -28,6 +28,9 @@ import { compatGlobal } from "../../common/coreEnvFunctions.js";
 import { computeKeyedId, configuredIdKey } from "../../common/idDerivation.js";
 import { getWebCrypto } from "../../mods.js";
 import { uint8ArrayToHexString } from "../../string_and_binary/convert.js";
+import { getPathNormalizationVersion } from "../../common/pathNormalization.js";
+import { readLocalP2PPathIdentity, readRemoteP2PPathIdentity } from "./TrysteroReplicator.pathIdentity.js";
+import { assertDatabasePathIdentity } from "../../pouchdb/pathIdentityCompatibility.js";
 import {
   fromP2PReplicationWireResult,
   toP2PReplicationWireResult,
@@ -205,6 +208,11 @@ class TrysteroReplicator {
     this._onSetup = false;
   }
   async getTweakSettings(fromPeerId) {
+    const currentSettings = this.currentSettings;
+    const pathNormalizationVersion = getPathNormalizationVersion(currentSettings);
+    if (pathNormalizationVersion === 1) {
+      await assertDatabasePathIdentity(this.db, currentSettings, true);
+    }
     const allSettings = JSON.parse(JSON.stringify(this.settings));
     for (const key in allSettings) {
       if (key == "encrypt") {
@@ -223,6 +231,7 @@ class TrysteroReplicator {
     const idKey = configuredIdKey({ idDerivationVersion, idDerivationKey: idSettings.idDerivationKey ?? "" });
     return {
       ...allSettings,
+      pathNormalizationVersion,
       idDerivationVersion,
       idDerivationProof: idKey && idSettings.encrypt && idSettings.usePathObfuscation ? await computeKeyedId(idKey, "peer-agreement", fromPeerId) : ""
     };
@@ -553,6 +562,28 @@ class TrysteroReplicator {
     }
     if (signal?.aborted) return P2P_REPLICATION_CANCELLED;
     const logLevel = showNotice ? LOG_LEVEL_NOTICE : LOG_LEVEL_INFO;
+    const rejection = await this.checkPeerForReplication(remotePeer, logLevel, signal);
+    if (rejection) return rejection;
+    Logger(`P2P Replicating from ${remotePeer}`, logLevel, "p2p-replicator");
+    if (this._replicateFromPeers.has(remotePeer)) {
+      Logger(`Replication from ${remotePeer} is already in progress`, logLevel, "p2p-replicator");
+      return p2pReplicationFailed(new Error("Replication from this peer is already in progress"));
+    }
+    this._replicateFromPeers.add(remotePeer);
+    this.dispatchStatus();
+    try {
+      return await this.transferFromPeer(remotePeer, fromStart, logLevel, signal);
+    } catch (e) {
+      if (signal?.aborted) return P2P_REPLICATION_CANCELLED;
+      Logger("Error while P2P replicating", logLevel, "p2p-replicator");
+      Logger(e, LOG_LEVEL_VERBOSE);
+      return p2pReplicationFailed(e);
+    } finally {
+      this._replicateFromPeers.delete(remotePeer);
+      this.dispatchStatus();
+    }
+  }
+  async checkPeerForReplication(remotePeer, logLevel, signal) {
     Logger(`P2P Requesting Authentication to ${remotePeer}`, logLevel, "p2p-replicator");
     const authenticated = signal ? await this.requestAuthenticate(remotePeer, signal) : await this.requestAuthenticate(remotePeer);
     if (authenticated !== true) {
@@ -572,71 +603,62 @@ class TrysteroReplicator {
       Logger("Tweak values are not matched", logLevel, "p2p-replicator");
       return p2pReplicationFailed(new Error("Tweak values are not matched"));
     }
-    Logger(`P2P Replicating from ${remotePeer}`, logLevel, "p2p-replicator");
-    if (this._replicateFromPeers.has(remotePeer)) {
-      Logger(`Replication from ${remotePeer} is already in progress`, logLevel, "p2p-replicator");
-      return p2pReplicationFailed(new Error("Replication from this peer is already in progress"));
-    }
-    this._replicateFromPeers.add(remotePeer);
-    this.dispatchStatus();
-    try {
-      if (!this.server) {
-        throw new Error("Server is not available");
-      }
-      const connection = this.server.getConnection(remotePeer);
-      const remoteDB = connection.getRemoteDB(signal);
-      Logger(`P2P replicateFrom preparing remote DB info for ${remotePeer}`, LOG_LEVEL_VERBOSE, "p2p-replicator");
-      const remoteDBInfo = await remoteDB.info();
-      Logger(
-        `P2P replicateFrom remote DB info for ${remotePeer}: ${remoteDBInfo.db_name} seq=${remoteDBInfo.update_seq}`,
-        LOG_LEVEL_VERBOSE,
-        "p2p-replicator"
-      );
-      const localDBInfo = await this.db.info();
-      Logger(
-        `P2P replicateFrom local DB info for ${remotePeer}: ${localDBInfo.db_name} seq=${localDBInfo.update_seq}`,
-        LOG_LEVEL_VERBOSE,
-        "p2p-replicator"
-      );
-      Logger(`P2P replicateFrom entering replicateShim for ${remotePeer}`, LOG_LEVEL_VERBOSE, "p2p-replicator");
-      const outcome = await replicateShim(
-        this.db,
-        remoteDB,
-        async (docs, info) => {
-          await this._env.processReplicatedDocs(docs);
-          void this.dispatchReplicationProgress(remotePeer, info);
-          void this.acknowledgeProgress(remotePeer, info);
-          void this.notifyProgress(remotePeer);
-          Logger(
-            `P2P Replication from ${remotePeer}
+    return void 0;
+  }
+  async transferFromPeer(remotePeer, fromStart, logLevel, signal) {
+    if (!this.server) {
+      throw new Error("Server is not available");
+    }
+    const connection = this.server.getConnection(remotePeer);
+    const remoteDB = connection.getRemoteDB(signal);
+    const pathNormalizationVersion = getPathNormalizationVersion(this.currentSettings);
+    const [localPathIdentity, remotePathIdentity] = await Promise.all([
+      readLocalP2PPathIdentity(this.db, pathNormalizationVersion),
+      readRemoteP2PPathIdentity(remoteDB, pathNormalizationVersion)
+    ]);
+    if (localPathIdentity !== pathNormalizationVersion || remotePathIdentity !== pathNormalizationVersion) {
+      const error = new Error("P2P database path identity does not match the configured path identity.");
+      Logger(error.message, logLevel, "p2p-replicator");
+      return p2pReplicationFailed(error);
+    }
+    Logger(`P2P replicateFrom preparing remote DB info for ${remotePeer}`, LOG_LEVEL_VERBOSE, "p2p-replicator");
+    const remoteDBInfo = await remoteDB.info();
+    Logger(
+      `P2P replicateFrom remote DB info for ${remotePeer}: ${remoteDBInfo.db_name} seq=${remoteDBInfo.update_seq}`,
+      LOG_LEVEL_VERBOSE,
+      "p2p-replicator"
+    );
+    const localDBInfo = await this.db.info();
+    Logger(
+      `P2P replicateFrom local DB info for ${remotePeer}: ${localDBInfo.db_name} seq=${localDBInfo.update_seq}`,
+      LOG_LEVEL_VERBOSE,
+      "p2p-replicator"
+    );
+    Logger(`P2P replicateFrom entering replicateShim for ${remotePeer}`, LOG_LEVEL_VERBOSE, "p2p-replicator");
+    const outcome = await replicateShim(
+      this.db,
+      remoteDB,
+      async (docs, info) => {
+        await this._env.processReplicatedDocs(docs);
+        void this.dispatchReplicationProgress(remotePeer, info);
+        void this.acknowledgeProgress(remotePeer, info);
+        void this.notifyProgress(remotePeer);
+        Logger(
+          `P2P Replication from ${remotePeer}
 ${info.lastSeq} / ${info.maxSeqInBatch})`,
-            logLevel,
-            "p2p-replicator"
-          );
-        },
-        {
-          live: false,
-          rewind: fromStart,
-          signal
-          /*, batch_size: batchSize */
-        }
-      );
-      Logger(`P2P replicateFrom replicateShim returned for ${remotePeer}`, LOG_LEVEL_VERBOSE, "p2p-replicator");
-      void this.acknowledgeProgress(remotePeer, void 0);
-      if (outcome.status === "cancelled") {
-        Logger(`P2P Replication from ${remotePeer} has been cancelled`, logLevel, "p2p-replicator");
-        return P2P_REPLICATION_CANCELLED;
-      }
-      Logger(`P2P Replication from ${remotePeer} has been completed`, logLevel, "p2p-replicator");
-    } catch (e) {
-      if (signal?.aborted) return P2P_REPLICATION_CANCELLED;
-      Logger("Error while P2P replicating", logLevel, "p2p-replicator");
-      Logger(e, LOG_LEVEL_VERBOSE);
-      return p2pReplicationFailed(e);
-    } finally {
-      this._replicateFromPeers.delete(remotePeer);
-      this.dispatchStatus();
+          logLevel,
+          "p2p-replicator"
+        );
+      },
+      { live: false, rewind: fromStart, signal }
+    );
+    Logger(`P2P replicateFrom replicateShim returned for ${remotePeer}`, LOG_LEVEL_VERBOSE, "p2p-replicator");
+    void this.acknowledgeProgress(remotePeer, void 0);
+    if (outcome.status === "cancelled") {
+      Logger(`P2P Replication from ${remotePeer} has been cancelled`, logLevel, "p2p-replicator");
+      return P2P_REPLICATION_CANCELLED;
     }
+    Logger(`P2P Replication from ${remotePeer} has been completed`, logLevel, "p2p-replicator");
     return P2P_REPLICATION_COMPLETED;
   }
   notifyProgress(excludePeerId) {
@@ -739,12 +761,6 @@ ${info.lastSeq} / ${info.maxSeqInBatch})`,
       Logger("Peer is not found", logLevel);
       return false;
     }
-    if (this.platform === "pseudo-replicator") {
-      return true;
-    }
-    if (peerPlatform === "pseudo-replicator") {
-      return true;
-    }
     const connection = this.server.getConnection(peerId);
     const challengeBytes = new Uint8Array(16);
     (await getWebCrypto()).getRandomValues(challengeBytes);
@@ -752,6 +768,15 @@ ${info.lastSeq} / ${info.maxSeqInBatch})`,
     const tweakValues = await connection.invokeRemoteObjectFunction("getTweakSettings", [challenge], 5e3, signal);
     if (signal?.aborted) return false;
     const thisTweakValues = await this.getTweakSettings(challenge);
+    const localPathNormalizationVersion = getPathNormalizationVersion(thisTweakValues);
+    const peerPathNormalizationVersion = getPathNormalizationVersion(tweakValues);
+    if (localPathNormalizationVersion !== peerPathNormalizationVersion) {
+      Logger("Replication cancelled: The path identity mode does not match this peer.", logLevel);
+      return false;
+    }
+    if (this.platform === "pseudo-replicator" || peerPlatform === "pseudo-replicator") {
+      return true;
+    }
     if (thisTweakValues.passphrase !== tweakValues.passphrase) {
       Logger(
         "Replication cancelled: Passphrase is not matched\nCannot replicate to a remote database until the problem is resolved.",
@@ -760,7 +785,10 @@ ${info.lastSeq} / ${info.maxSeqInBatch})`,
       return false;
     }
     if (thisTweakValues.encrypt !== tweakValues.encrypt || thisTweakValues.usePathObfuscation !== tweakValues.usePathObfuscation) {
-      Logger("Replication cancelled: The encryption or path obfuscation settings do not match this peer.", logLevel);
+      Logger(
+        "Replication cancelled: The encryption or path obfuscation settings do not match this peer.",
+        logLevel
+      );
       return false;
     }
     if (thisTweakValues.encrypt && thisTweakValues.usePathObfuscation && ((thisTweakValues.idDerivationVersion ?? 0) !== (tweakValues.idDerivationVersion ?? 0) || (thisTweakValues.idDerivationProof ?? "") !== (tweakValues.idDerivationProof ?? ""))) {

package/dist/replication/trystero/TrysteroReplicator.pathIdentity.d.ts

@@ -0,0 +1,11 @@
+import type { PathNormalizationVersion } from "../../common/models/setting.type.js";
+export declare function readLocalP2PPathIdentity(database: {
+    get(id: string): Promise<unknown>;
+}, configuredVersion: PathNormalizationVersion): Promise<PathNormalizationVersion>;
+export declare function readRemoteP2PPathIdentity(database: {
+    bulkGet(options: {
+        docs: {
+            id: string;
+        }[];
+    }): Promise<unknown>;
+}, configuredVersion: PathNormalizationVersion): Promise<PathNormalizationVersion>;

package/dist/replication/trystero/TrysteroReplicator.pathIdentity.js

@@ -0,0 +1,72 @@
+import { VERSIONING_DOCID } from "../../common/models/db.const.js";
+import {
+  assessRemoteFeatureDocument,
+  describeRemoteFeatureRejection,
+  NFC_PATH_IDENTITY_FEATURE
+} from "../../pouchdb/remoteFeatureCompatibility.js";
+import { isErrorOfMissingDoc } from "../../pouchdb/utils_couchdb.js";
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function hasOwnField(value, key) {
+  return Object.hasOwn(value, key);
+}
+function isVersionInfoResponse(value) {
+  if (!isRecord(value) || !Array.isArray(value.results) || value.results.length !== 1) return false;
+  const [result] = value.results;
+  return isRecord(result) && result.id === VERSIONING_DOCID && Array.isArray(result.docs) && result.docs.length === 1 && isRecord(result.docs[0]);
+}
+function isMissingDocumentResult(result) {
+  if (!hasOwnField(result, "error")) return false;
+  const error = result.error;
+  const errorDetails = isRecord(error) ? error : void 0;
+  const status = errorDetails?.status ?? result.status;
+  const errorName = errorDetails?.name ?? result.name;
+  const errorCode = typeof error === "string" ? error : errorDetails?.error;
+  return status === 404 || status === void 0 && (errorName === "not_found" || errorCode === "not_found");
+}
+function parseRemotePathIdentityDocument(response) {
+  if (!isVersionInfoResponse(response)) {
+    throw new Error("P2P remote versioninfo response is malformed.");
+  }
+  const [documentResult] = response.results[0].docs;
+  if (hasOwnField(documentResult, "ok")) {
+    const document = documentResult.ok;
+    if (!isRecord(document) || document._id !== VERSIONING_DOCID) {
+      throw new Error("P2P remote versioninfo response is malformed.");
+    }
+    return { kind: "found", document };
+  }
+  if (isMissingDocumentResult(documentResult)) return { kind: "missing" };
+  throw new Error("P2P remote versioninfo could not be read.");
+}
+function resolvePathIdentity(result, configuredVersion) {
+  if (result.kind === "missing") {
+    if (configuredVersion === 0) return 0;
+    throw new Error("P2P NFC database is missing path identity version information.");
+  }
+  const assessment = assessRemoteFeatureDocument(result.document);
+  if (assessment.status === "older-generation" && configuredVersion === 0) return 0;
+  if (assessment.status !== "supported") {
+    throw new Error(describeRemoteFeatureRejection(assessment));
+  }
+  return assessment.usedFeatures.includes(NFC_PATH_IDENTITY_FEATURE) ? 1 : 0;
+}
+async function readLocalP2PPathIdentity(database, configuredVersion) {
+  let result;
+  try {
+    result = { kind: "found", document: await database.get(VERSIONING_DOCID) };
+  } catch (error) {
+    if (!isErrorOfMissingDoc(error)) throw error;
+    result = { kind: "missing" };
+  }
+  return resolvePathIdentity(result, configuredVersion);
+}
+async function readRemoteP2PPathIdentity(database, configuredVersion) {
+  const response = await database.bulkGet({ docs: [{ id: VERSIONING_DOCID }] });
+  return resolvePathIdentity(parseRemotePathIdentityDocument(response), configuredVersion);
+}
+export {
+  readLocalP2PPathIdentity,
+  readRemoteP2PPathIdentity
+};

package/dist/replication/trystero/p2pReplicatorConfigurationIdentity.js

@@ -7,6 +7,7 @@ import {
   splitP2PRelayUrls,
   splitP2PTurnServerUrls
 } from "../../common/models/setting.p2p.js";
+import { getPathNormalizationVersion } from "../../common/pathNormalization.js";
 function getP2PReplicatorConfigurationIdentity(settings) {
   const managedTurnSelected = hasManagedP2PTurnConfiguration(settings);
   const turnServerValue = settings.P2P_turnServers ?? "";
@@ -25,6 +26,7 @@ function getP2PReplicatorConfigurationIdentity(settings) {
     managedTurnSelected ? [settings.P2P_managedType, settings.P2P_managedId, settings.P2P_managedToken] : void 0,
     normaliseP2PMaxWirePayloadBytes(settings.P2P_maxWirePayloadBytes),
     effectivePath,
+    getPathNormalizationVersion(settings),
     settings.P2P_useDiagRTC ?? false
   ]);
 }

package/dist/replication/trystero/useP2PReplicatorFeature.js

@@ -15,7 +15,7 @@ import {
   supportedStopActiveTransfer
 } from "../index.js";
 import { getP2PReplicatorConfigurationIdentity } from "./p2pReplicatorConfigurationIdentity.js";
-import { getPathNormalizationVersion } from "../../common/pathNormalization.js";
+import { assertSupportedPathNormalizationVersion } from "../../common/pathNormalization.js";
 function useP2PReplicatorFeature(host, openReplicationUIFactory, openRebuildUIFactory, options = {}) {
   const service = createP2PService(
     {
@@ -63,7 +63,11 @@ function useP2PReplicatorFeature(host, openReplicationUIFactory, openRebuildUIFa
         kind: REMOTE_P2P,
         diagnosticName: "P2P",
         readiness: PEER_REPLICATION_READINESS,
-        isConfigured: (settings) => settings.remoteType === REMOTE_P2P && settings.P2P_Enabled && getPathNormalizationVersion(settings) === 0,
+        isConfigured: (settings) => {
+          if (settings.remoteType !== REMOTE_P2P || !settings.P2P_Enabled) return false;
+          assertSupportedPathNormalizationVersion(settings.pathNormalizationVersion);
+          return true;
+        },
         configurationIdentity: getP2PReplicatorConfigurationIdentity,
         create: createP2PReplicator,
         remoteResources: NO_REMOTE_RESOURCE_CAPABILITIES,

package/dist/serviceModules/Rebuilder.d.ts

@@ -66,6 +66,7 @@ export declare class ServiceRebuilder extends ServiceModuleBase<ServiceRebuilder
     private scheduleInitialisation;
     scheduleRebuild(prepareBeforeRestart?: () => Promise<void>): Promise<boolean>;
     scheduleFetch(prepareBeforeRestart?: () => Promise<void>): Promise<boolean>;
+    private markRemoteLockedForRebuild;
     private _tryResetRemoteDatabase;
     private _onResetLocalDatabase;
     suspendAllSync(): Promise<void>;

package/dist/serviceModules/Rebuilder.js

@@ -26,6 +26,12 @@ const FAST_FETCH_RETRY_DELAYS = [2e3, 5e3, 1e4, 2e4];
 function canResetCentralRemote(replicator) {
   return "tryResetRemoteDatabase" in replicator && typeof replicator.tryResetRemoteDatabase === "function";
 }
+function canCheckJournalPathIdentity(replicator) {
+  return "assertRemotePathIdentity" in replicator && typeof replicator.assertRemotePathIdentity === "function";
+}
+function canLockJournalForRebuild(replicator) {
+  return canResetCentralRemote(replicator) && "markRemoteLockedForRebuild" in replicator && typeof replicator.markRemoteLockedForRebuild === "function";
+}
 class ServiceRebuilder extends ServiceModuleBase {
   events;
   appLifecycle;
@@ -100,7 +106,7 @@ Please enable them from the settings screen after setup is complete.`,
       notifyThresholdOfRemoteStorageSize: DEFAULT_SETTINGS.notifyThresholdOfRemoteStorageSize
     });
     await this.control.applySettings();
-    await this.replication.markLocked();
+    await this.markRemoteLockedForRebuild();
     await this._tryResetRemoteDatabase();
     await this.replication.markLocked();
     await delay(500);
@@ -145,7 +151,7 @@ Please enable them from the settings screen after setup is complete.`,
       }
       return;
     }
-    await this.replication.markLocked();
+    await this.markRemoteLockedForRebuild();
     await this._tryResetRemoteDatabase();
     await this.replication.markLocked();
     await delay(500);
@@ -170,9 +176,6 @@ Please enable them from the settings screen after setup is complete.`,
       await assertDatabasePathIdentity(this.database.localDatabase.localDatabase, settings);
     }
     if (getPathNormalizationVersion(settings) === 0) return;
-    if (settings.remoteType !== REMOTE_COUCHDB) {
-      throw new Error("NFC path identity is supported only with CouchDB. No database has been reset.");
-    }
     const paths = await this.storageAccess.getFileNames();
     const selected = [];
     const databaseReady = this.database.isDatabaseReady();
@@ -191,6 +194,19 @@ Please enable them from the settings screen after setup is complete.`,
   }
   async checkRemotePathIdentityBeforeFetch() {
     const settings = this.setting.currentSettings();
+    if (settings.remoteType === REMOTE_MINIO) {
+      const trial = await this.replicator.getNewReplicator(settings);
+      if (!trial) throw new Error("Could not create a Journal replicator for the Fetch identity check.");
+      try {
+        if (!canCheckJournalPathIdentity(trial)) {
+          throw new Error("The Journal replicator does not support the Fetch identity check.");
+        }
+        await trial.assertRemotePathIdentity(settings);
+      } finally {
+        await trial.closeReplication();
+      }
+      return;
+    }
     if (settings.remoteType !== REMOTE_COUCHDB) return;
     const remote = settings.couchDB_URI.replace(/\/+$/, "") + (settings.couchDB_DBNAME === "" ? "" : "/" + settings.couchDB_DBNAME);
     const connection = await this.remote.connect(
@@ -262,6 +278,18 @@ Please enable them from the settings screen after setup is complete.`,
   scheduleFetch(prepareBeforeRestart) {
     return this.scheduleInitialisation(FlagFilesHumanReadable.FETCH_ALL, prepareBeforeRestart);
   }
+  async markRemoteLockedForRebuild() {
+    const settings = this.setting.currentSettings();
+    if (settings.remoteType !== REMOTE_MINIO) {
+      await this.replication.markLocked();
+      return;
+    }
+    const replicator = this.replicator.getActiveReplicator();
+    if (!replicator || !canLockJournalForRebuild(replicator)) {
+      throw new Error("The active Journal replicator does not support safe reconstruction.");
+    }
+    await replicator.markRemoteLockedForRebuild(settings);
+  }
   async _tryResetRemoteDatabase() {
     const currentReplicator = this.replicator.getActiveReplicator();
     const settings = this.setting.currentSettings();