@vrtmrz/livesync-commonlib 0.1.0-rc.0 → 0.1.0-rc.10

package/dist/serviceModules/ServiceFileHandlerBase.js

@@ -45,6 +45,7 @@ class ServiceFileHandlerBase extends ServiceModuleBase {
   path;
   setting;
   vault;
+  fileReflectionProvenance;
   constructor(services) {
     super(services);
     this.events = services.events;
@@ -54,6 +55,7 @@ class ServiceFileHandlerBase extends ServiceModuleBase {
     this.path = services.path;
     this.setting = services.setting;
     this.vault = services.vault;
+    this.fileReflectionProvenance = services.fileReflectionProvenance;
     services.fileProcessing.processFileEvent.addHandler(this._anyHandlerProcessesFileEvent.bind(this), 100);
     services.replication.processSynchroniseResult.addHandler(this._anyProcessReplicatedDoc.bind(this), 100);
   }
@@ -63,6 +65,66 @@ class ServiceFileHandlerBase extends ServiceModuleBase {
   get storage() {
     return this.storageAccess;
   }
+  async getProvenance(path) {
+    if (!this.fileReflectionProvenance) return void 0;
+    try {
+      const record = await this.fileReflectionProvenance.get(path);
+      if (!record) return void 0;
+      const entry = await this.db.fetchEntryMeta(path, record.revision, true);
+      if (entry && !entry._deleted && !entry.deleted) {
+        return record;
+      }
+      await this.fileReflectionProvenance.delete(path);
+    } catch (ex) {
+      this._log(`Could not read file reflection provenance for ${path}`, LOG_LEVEL_VERBOSE);
+      this._log(ex, LOG_LEVEL_VERBOSE);
+    }
+    return void 0;
+  }
+  async setProvenance(path, revision, observedStorageMtime) {
+    if (!this.fileReflectionProvenance || !revision) return;
+    try {
+      await this.fileReflectionProvenance.set(path, {
+        revision,
+        observedStorageMtime
+      });
+    } catch (ex) {
+      this._log(`Could not record file reflection provenance for ${path}`, LOG_LEVEL_VERBOSE);
+      this._log(ex, LOG_LEVEL_VERBOSE);
+    }
+  }
+  async deleteProvenance(path) {
+    if (!this.fileReflectionProvenance) return;
+    try {
+      await this.fileReflectionProvenance.delete(path);
+    } catch (ex) {
+      this._log(`Could not delete file reflection provenance for ${path}`, LOG_LEVEL_VERBOSE);
+      this._log(ex, LOG_LEVEL_VERBOSE);
+    }
+  }
+  async findUniqueContentRevision(file) {
+    try {
+      const revisions = await this.db.findContentRevisions(file, file.body);
+      return revisions.length === 1 ? revisions[0] : void 0;
+    } catch (ex) {
+      this._log(`Could not reconstruct file reflection provenance for ${file.path}`, LOG_LEVEL_VERBOSE);
+      this._log(ex, LOG_LEVEL_VERBOSE);
+      return void 0;
+    }
+  }
+  async getProvenBaseRevision(file, preferredPath) {
+    const path = preferredPath ?? file.path;
+    const recorded = await this.getProvenance(path) ?? (preferredPath && preferredPath !== file.path ? await this.getProvenance(file.path) : void 0);
+    if (recorded) {
+      return recorded.revision;
+    }
+    const matched = await this.findUniqueContentRevision(file);
+    if (matched) {
+      await this.setProvenance(path, matched, file.stat.mtime);
+      return matched;
+    }
+    return void 0;
+  }
   getPath(entry) {
     return this.path.getPath(entry);
   }
@@ -85,6 +147,9 @@ class ServiceFileHandlerBase extends ServiceModuleBase {
     return file;
   }
   async storeFileToDB(info, force = false, onlyChunks = false) {
+    return await this.storeFileToDBFromRevision(info, force, onlyChunks);
+  }
+  async storeFileToDBFromRevision(info, force = false, onlyChunks = false, preferredBasePath) {
     const file = await this.infoToStub(info);
     if (file == null) {
       this._log(`File ${tryGetFilePath(info)} is not exist on the storage`, LOG_LEVEL_VERBOSE);
@@ -97,27 +162,69 @@ class ServiceFileHandlerBase extends ServiceModuleBase {
       );
       return false;
     }
+    if (onlyChunks) {
+      const readFile2 = await this.readFileFromStub(file);
+      return await this.db.createChunks(readFile2, force, true);
+    }
+    const readFile = await this.readFileFromStub(file);
     const entry = await this.db.fetchEntry(file, void 0, true, true);
+    const conflictedRevs = await this.db.getConflictedRevs(file);
+    const isConflicted = conflictedRevs.length > 0;
+    if (isConflicted) {
+      const baseRevision = await this.getProvenBaseRevision(readFile, preferredBasePath);
+      if (baseRevision) {
+        const baseEntry = await this.db.fetchEntry(file, baseRevision, true, true);
+        if (baseEntry && await isDocContentSame(getDocDataAsArray(baseEntry.data), readFile.body) && !force) {
+          await this.setProvenance(file.path, baseRevision, readFile.stat.mtime);
+          this._log(`File ${file.path} is not changed on its displayed conflict branch`, LOG_LEVEL_VERBOSE);
+          return true;
+        }
+        const storedRevision3 = await this.db.storeWithBaseRevision(readFile, baseRevision, true);
+        if (storedRevision3 === false) return false;
+        if (preferredBasePath && preferredBasePath !== file.path) {
+          await this.deleteProvenance(preferredBasePath);
+        }
+        await this.setProvenance(file.path, storedRevision3, readFile.stat.mtime);
+        await this.conflict.queueCheckFor(file.path);
+        return true;
+      }
+      const currentRevision = entry && entry._rev;
+      if (!currentRevision) {
+        this._log(
+          `Could not preserve the unknown conflict branch for ${file.path}; no current revision is available`,
+          LOG_LEVEL_NOTICE
+        );
+        await this.conflict.queueCheckFor(file.path);
+        return false;
+      }
+      const storedRevision2 = await this.db.storeAsConflictedRevisionWithResult(readFile, currentRevision, true);
+      if (storedRevision2 === false) {
+        this._log(`Could not preserve the unknown conflict branch for ${file.path}`, LOG_LEVEL_NOTICE);
+        await this.conflict.queueCheckFor(file.path);
+        return false;
+      }
+      if (preferredBasePath && preferredBasePath !== file.path) {
+        await this.deleteProvenance(preferredBasePath);
+      }
+      await this.setProvenance(file.path, storedRevision2, readFile.stat.mtime);
+      await this.conflict.queueCheckFor(file.path);
+      return true;
+    }
     if (!entry || entry.deleted || entry._deleted) {
-      const readFile = await this.readFileFromStub(file);
-      if (!onlyChunks) {
-        return await this.db.store(readFile);
-      } else {
-        return await this.db.createChunks(readFile, false, true);
+      const storedRevision2 = await this.db.storeWithBaseRevision(readFile, entry && entry._rev, true);
+      if (storedRevision2 === false) return false;
+      if (preferredBasePath && preferredBasePath !== file.path) {
+        await this.deleteProvenance(preferredBasePath);
       }
+      await this.setProvenance(file.path, storedRevision2, readFile.stat.mtime);
+      return true;
     }
     let shouldApplied = false;
     if (!force && !onlyChunks) {
       if (this.path.compareFileFreshness(file, entry) !== EVEN) {
         shouldApplied = true;
       }
-      let readFile = void 0;
       if (!shouldApplied) {
-        readFile = await this.readFileFromStub(file);
-        if (!readFile) {
-          this._log(`File ${file.path} is not exist on the storage`, LOG_LEVEL_NOTICE);
-          return false;
-        }
         if (await isDocContentSame(getDocDataAsArray(entry.data), readFile.body)) {
           this.path.markChangesAreSame(readFile, readFile.stat.mtime, entry.mtime);
         } else {
@@ -125,28 +232,23 @@ class ServiceFileHandlerBase extends ServiceModuleBase {
         }
       }
       if (!shouldApplied) {
+        await this.setProvenance(file.path, entry._rev, readFile.stat.mtime);
         this._log(`File ${file.path} is not changed`, LOG_LEVEL_VERBOSE);
         return true;
       }
-      if (!readFile) readFile = await this.readFileFromStub(file);
-      if (onlyChunks) {
-        return await this.db.createChunks(readFile, false, true);
-      } else {
-        return await this.db.store(readFile, false, true);
-      }
-    } else {
-      const readFile = await this.readFileFromStub(file);
-      if (onlyChunks) {
-        return await this.db.createChunks(readFile, true, true);
-      } else {
-        return await this.db.store(readFile, true, true);
-      }
     }
+    const storedRevision = await this.db.storeWithBaseRevision(readFile, entry._rev, true);
+    if (storedRevision === false) return false;
+    if (preferredBasePath && preferredBasePath !== file.path) {
+      await this.deleteProvenance(preferredBasePath);
+    }
+    await this.setProvenance(file.path, storedRevision, readFile.stat.mtime);
+    return true;
   }
   async deleteFileFromDB(info) {
     const file = await this.infoToStub(info);
+    const path = typeof info === "string" ? info : tryGetFilePath(info);
     if (file == null) {
-      const path = typeof info === "string" ? info : tryGetFilePath(info);
       if (path === void 0) {
         this._log(`File ${tryGetFilePath(info)} is not exist on the storage`, LOG_LEVEL_VERBOSE);
         return false;
@@ -159,8 +261,27 @@ class ServiceFileHandlerBase extends ServiceModuleBase {
         );
         return false;
       }
+      const conflictedRevs2 = await this.db.getConflictedRevs(path);
+      if (conflictedRevs2.length > 0) {
+        const provenance = await this.getProvenance(path);
+        if (!provenance) {
+          this._log(
+            `The deleted storage file ${path} has conflicts, but its displayed revision is unknown; preserving every database branch`,
+            LOG_LEVEL_NOTICE
+          );
+          await this.conflict.queueCheckFor(path);
+          return true;
+        }
+        const storedRevision = await this.db.storeDeletionWithBaseRevision(path, provenance.revision);
+        if (storedRevision === false) return false;
+        await this.deleteProvenance(path);
+        await this.conflict.queueCheckFor(path);
+        return true;
+      }
       this._log(`File ${path} is missing on storage; deleting from the database by path`, LOG_LEVEL_INFO);
-      return await this.db.delete(path);
+      const deleted2 = await this.db.delete(path);
+      if (deleted2) await this.deleteProvenance(path);
+      return deleted2;
     }
     if (file.isInternal) {
       this._log(
@@ -176,9 +297,31 @@ class ServiceFileHandlerBase extends ServiceModuleBase {
     }
     const conflictedRevs = await this.db.getConflictedRevs(file);
     if (conflictedRevs.length > 0) {
-      return await this.db.delete(file, entry._rev);
+      let baseRevision = (await this.getProvenance(file.path))?.revision;
+      if (!baseRevision) {
+        try {
+          const readFile = await this.readFileFromStub(file);
+          baseRevision = await this.findUniqueContentRevision(readFile);
+        } catch {
+        }
+      }
+      if (!baseRevision) {
+        this._log(
+          `The deleted storage file ${file.path} has conflicts, but its displayed revision is unknown; preserving every database branch`,
+          LOG_LEVEL_NOTICE
+        );
+        await this.conflict.queueCheckFor(file.path);
+        return true;
+      }
+      const storedRevision = await this.db.storeDeletionWithBaseRevision(file.path, baseRevision);
+      if (storedRevision === false) return false;
+      await this.deleteProvenance(file.path);
+      await this.conflict.queueCheckFor(file.path);
+      return true;
     }
-    return await this.db.delete(file);
+    const deleted = await this.db.delete(file);
+    if (deleted) await this.deleteProvenance(file.path);
+    return deleted;
   }
   async renameFileInDB(info, oldPath) {
     const newPath = getStoragePathFromUXFileInfo(info);
@@ -188,9 +331,17 @@ class ServiceFileHandlerBase extends ServiceModuleBase {
     ]);
     if (oldDocumentId === newDocumentId) {
       this._log(`Updating the stored path for case-only rename: ${oldPath} -> ${newPath}`, LOG_LEVEL_VERBOSE);
-      return await this.storeFileToDB(info, true);
+      return await this.storeFileToDBFromRevision(info, true, false, oldPath);
     }
     const oldEntry = await this.db.fetchEntryMeta(oldPath, void 0, true);
+    const newEntry = await this.db.fetchEntryMeta(newPath, void 0, true);
+    if (newEntry && !newEntry.deleted && !newEntry._deleted) {
+      this._log(
+        `Refusing to overwrite the existing database entry while renaming ${oldPath} to ${newPath}`,
+        LOG_LEVEL_NOTICE
+      );
+      return false;
+    }
     if (!await this.storeFileToDB(info, true)) {
       this._log(`Failed to store rename target; preserving source in the database: ${oldPath}`, LOG_LEVEL_NOTICE);
       return false;
@@ -199,13 +350,34 @@ class ServiceFileHandlerBase extends ServiceModuleBase {
       this._log(`Rename source is not present in the database: ${oldPath}`, LOG_LEVEL_VERBOSE);
       return true;
     }
-    const oldFile = {
-      path: oldPath,
-      name: oldPath.split("/").pop() ?? info.name,
-      stat: info.stat,
-      deleted: true
-    };
-    return await this.deleteFileFromDB(oldFile);
+    const oldConflicts = await this.db.getConflictedRevs(oldPath);
+    if (oldConflicts.length > 0) {
+      let baseRevision = (await this.getProvenance(oldPath))?.revision;
+      if (!baseRevision) {
+        const readFile = await this.readFileFromStub(info);
+        const revisions = await this.db.findContentRevisions(oldPath, readFile.body);
+        baseRevision = revisions.length === 1 ? revisions[0] : void 0;
+      }
+      if (!baseRevision) {
+        this._log(
+          `Renamed ${oldPath} to ${newPath}, but preserved every conflicted source branch because the displayed source revision is unknown`,
+          LOG_LEVEL_NOTICE
+        );
+        await this.conflict.queueCheckFor(oldPath);
+        return true;
+      }
+      const storedRevision = await this.db.storeDeletionWithBaseRevision(
+        oldPath,
+        baseRevision
+      );
+      if (storedRevision === false) return false;
+      await this.deleteProvenance(oldPath);
+      await this.conflict.queueCheckFor(oldPath);
+      return true;
+    }
+    const deleted = await this.db.delete(oldPath);
+    if (deleted) await this.deleteProvenance(oldPath);
+    return deleted;
   }
   async deleteRevisionFromDB(info, rev) {
     return await this.db.delete(info, rev);
@@ -232,17 +404,20 @@ class ServiceFileHandlerBase extends ServiceModuleBase {
       this._log(`File ${file.path} is not exist on the database`, LOG_LEVEL_VERBOSE);
       return false;
     }
-    return await this.dbToStorage(docEntry, file, force);
+    return await this.applyDatabaseEntryToStorage(docEntry, file, force);
   }
   async dbToStorage(entryInfo, info, force) {
     const file = await this.infoToStub(info);
-    const mode = file == null ? "create" : "modify";
     const pathFromEntryInfo = typeof entryInfo === "string" ? entryInfo : this.getPath(entryInfo);
     const docEntry = await this.db.fetchEntryMeta(pathFromEntryInfo, void 0, true);
     if (!docEntry) {
       this._log(`File ${pathFromEntryInfo} is not exist on the database`, LOG_LEVEL_VERBOSE);
       return false;
     }
+    return await this.applyDatabaseEntryToStorage(docEntry, file, force);
+  }
+  async applyDatabaseEntryToStorage(docEntry, file, force) {
+    const mode = file == null ? "create" : "modify";
     const path = this.getPath(docEntry);
     const settings = this.setting.currentSettings();
     const revs = await this.db.getConflictedRevs(path);
@@ -261,6 +436,7 @@ class ServiceFileHandlerBase extends ServiceModuleBase {
     const existOnDB = !(docEntry._deleted || docEntry.deleted || false);
     if (!existOnDB && !existDoc) {
       this._log(`File ${path} seems to be deleted, but already not on storage`, LOG_LEVEL_VERBOSE);
+      await this.deleteProvenance(path);
       return true;
     }
     if (!existOnDB && existDoc) {
@@ -268,6 +444,7 @@ class ServiceFileHandlerBase extends ServiceModuleBase {
         return true;
       }
       await this.storage.deleteVaultItem(path);
+      await this.deleteProvenance(path);
       return true;
     }
     if (existDoc && existDoc.path !== path) {
@@ -294,6 +471,7 @@ class ServiceFileHandlerBase extends ServiceModuleBase {
         this._log(`Could not apply the stored filename case: ${existDoc.path} -> ${path}`, LOG_LEVEL_NOTICE);
         return false;
       }
+      await this.deleteProvenance(existDoc.path);
       existDoc = renamedFile;
     }
     const docRead = await this.db.fetchEntryFromMeta(docEntry);
@@ -327,6 +505,7 @@ class ServiceFileHandlerBase extends ServiceModuleBase {
         }
       }
       if (!shouldApplied) {
+        await this.setProvenance(path, docEntry._rev, existDoc.stat.mtime);
         this._log(`File ${docRead.path} is not changed`, LOG_LEVEL_VERBOSE);
         return true;
       }
@@ -343,6 +522,10 @@ class ServiceFileHandlerBase extends ServiceModuleBase {
     const ret = await this.storage.writeFileAuto(path, docData, { ctime: docRead.ctime, mtime: docRead.mtime });
     await this.storage.touched(path);
     this.storage.triggerFileEvent(mode, path);
+    if (ret && this.fileReflectionProvenance) {
+      const storedStat = await this.storage.stat(path);
+      await this.setProvenance(path, docEntry._rev, storedStat?.mtime);
+    }
     return ret;
   }
   async preserveUnsyncedStorageAsConflict(path, existDoc, incomingEntry, incomingContent) {
@@ -359,11 +542,12 @@ class ServiceFileHandlerBase extends ServiceModuleBase {
     if (await this.db.hasContentInRevisionHistory(path, readFile.body, incomingEntry._rev)) {
       return false;
     }
-    const stored = await this.db.storeAsConflictedRevision(readFile, incomingEntry._rev, true);
-    if (!stored) {
+    const storedRevision = await this.db.storeAsConflictedRevisionWithResult(readFile, incomingEntry._rev, true);
+    if (storedRevision === false) {
       this._log(`Prevented overwriting unsynchronised local changes for ${path}`, LOG_LEVEL_NOTICE);
       return true;
     }
+    await this.setProvenance(path, storedRevision, readFile.stat.mtime);
     this._log(`Preserved unsynchronised local changes as a conflict for ${path}`, LOG_LEVEL_NOTICE);
     await this.conflict.queueCheckFor(path);
     return true;

package/dist/services/BrowserServices.d.ts

@@ -8,6 +8,7 @@ import type { ReplicatorService } from "./base/ReplicatorService.js";
 import type { UIService } from "./implements/base/UIService.js";
 import type { InjectableAPIService } from "./implements/injectable/InjectableAPIService.js";
 import type { KeyValueDatabaseFactory } from "../interfaces/KeyValueDatabase.js";
+import type { ObsidianLiveSyncSettings } from "../common/types.js";
 export type BrowserServiceHostDependencies<T extends ServiceContext> = {
     API: InjectableAPIService<T>;
     appLifecycle: AppLifecycleService<T>;
@@ -29,6 +30,7 @@ export type BrowserServiceHubOptions<T extends ServiceContext> = {
     context?: T;
     host: BrowserServiceHost<T>;
     openKeyValueDatabase?: KeyValueDatabaseFactory;
+    onDisplayLanguageChanged?: (language: ObsidianLiveSyncSettings["displayLanguage"]) => void;
 };
 export declare class BrowserServiceHub<T extends ServiceContext> extends InjectableServiceHub<T> {
     get vault(): InjectableVaultServiceCompat<T>;

package/dist/services/BrowserServices.js

@@ -32,7 +32,10 @@ class BrowserServiceHub extends InjectableServiceHub {
     const API = options.host.createAPI(context);
     const conflict = new InjectableConflictService(context);
     const fileProcessing = new InjectableFileProcessingService(context);
-    const setting = new InjectableSettingService(context, { APIService: API });
+    const setting = new InjectableSettingService(context, {
+      APIService: API,
+      onDisplayLanguageChanged: options.onDisplayLanguageChanged
+    });
     const appLifecycle = new BrowserAppLifecycleService(context, { settingService: setting });
     const remote = new InjectableRemoteService(context, {
       pouchDB: PouchDB,

package/dist/services/HeadlessServices.d.ts

@@ -4,11 +4,13 @@ import type { DatabaseService } from "./base/DatabaseService.js";
 import type { Constructor } from "../common/utils.type.js";
 import type { KeyValueDatabaseFactory } from "../interfaces/KeyValueDatabase.js";
 import type { PouchDBConstructor } from "../pouchdb/PouchDBConstructor.js";
+import type { ObsidianLiveSyncSettings } from "../common/types.js";
 export declare class HeadlessServiceHub<T extends ServiceContext> extends InjectableServiceHub<T> {
     constructor(_context: T | undefined, overrideServiceConstructor: {
         /** PouchDB with the adapters required by this headless runtime. */
         pouchDB: PouchDBConstructor;
         database?: Constructor<DatabaseService<T>>;
         openKeyValueDatabase?: KeyValueDatabaseFactory;
+        onDisplayLanguageChanged?: (language: ObsidianLiveSyncSettings["displayLanguage"]) => void;
     });
 }

package/dist/services/HeadlessServices.js

@@ -54,7 +54,8 @@ class HeadlessServiceHub extends InjectableServiceHub {
     const conflict = new InjectableConflictService(context);
     const fileProcessing = new InjectableFileProcessingService(context);
     const setting = new InjectableSettingService(context, {
-      APIService: API
+      APIService: API,
+      onDisplayLanguageChanged: overrideServiceConstructor.onDisplayLanguageChanged
     });
     const appLifecycle = new HeadlessAppLifecycleService(context, {
       settingService: setting