@vrtmrz/livesync-commonlib 0.1.0-rc.9 → 0.1.1-rc.0

package/dist/serviceModules/ServiceDatabaseFileAccessBase.js

@@ -47,18 +47,37 @@ class ServiceDatabaseFileAccessBase extends ServiceModuleBase {
     }
   }
   async createChunks(file, force = false, skipCheck) {
-    return await this.__store(file, force, skipCheck, true);
+    return await this.__store(file, force, skipCheck, true) !== false;
   }
   async store(file, force = false, skipCheck) {
-    return await this.__store(file, force, skipCheck, false);
+    return await this.__store(file, force, skipCheck, false) !== false;
+  }
+  async storeWithBaseRevision(file, baseRevision, skipCheck) {
+    const result = await this.__store(file, true, skipCheck, false, baseRevision);
+    return result !== null && typeof result === "object" && "rev" in result ? result.rev : false;
   }
   async storeAsConflictedRevision(file, currentRev, skipCheck) {
+    return await this.storeAsConflictedRevisionWithResult(file, currentRev, skipCheck) !== false;
+  }
+  async storeAsConflictedRevisionWithResult(file, currentRev, skipCheck) {
     const conflictBaseRev = await this.getParentRev(file, currentRev);
     if (!conflictBaseRev) {
       this._log(`Could not find parent revision for ${file.path} (${currentRev})`, LOG_LEVEL_VERBOSE);
       return false;
     }
-    return await this.__store(file, true, skipCheck, false, conflictBaseRev);
+    return await this.storeWithBaseRevision(file, conflictBaseRev, skipCheck);
+  }
+  async storeDeletionWithBaseRevision(file, baseRevision) {
+    if (!await this.checkIsTargetFile(file)) {
+      return false;
+    }
+    const fullPath = getDatabasePathFromUXFileInfo(file);
+    const result = await this.database.localDatabase.storeDeletionAtRevision(fullPath, baseRevision);
+    if (result === false) {
+      return false;
+    }
+    this.events.emitEvent(EVENT_FILE_SAVED);
+    return result.rev;
   }
   async storeContent(path, content) {
     const blob = createTextBlob(content);
@@ -76,7 +95,7 @@ class ServiceDatabaseFileAccessBase extends ServiceModuleBase {
       body: blob,
       isInternal
     };
-    return await this.__store(dummyUXFileInfo, true, false, false);
+    return await this.__store(dummyUXFileInfo, true, false, false) !== false;
   }
   async __store(file, force = false, skipCheck, onlyChunks, conflictBaseRev) {
     if (!skipCheck) {
@@ -169,7 +188,7 @@ class ServiceDatabaseFileAccessBase extends ServiceModuleBase {
       this._log(msg + fullPath);
       this.events.emitEvent(EVENT_FILE_SAVED);
     }
-    return ret != false;
+    return ret;
   }
   async getParentRev(file, rev) {
     const filename = getDatabasePathFromUXFileInfo(file);
@@ -189,10 +208,7 @@ class ServiceDatabaseFileAccessBase extends ServiceModuleBase {
       return false;
     }
   }
-  async hasContentInRevisionHistory(file, content, currentRev) {
-    if (!await this.checkIsTargetFile(file)) {
-      return true;
-    }
+  async findContentRevisionsInternal(file, content, currentRev) {
     const filename = getDatabasePathFromUXFileInfo(file);
     try {
       const doc = await this.database.localDatabase.getDBEntryMeta(
@@ -201,24 +217,64 @@ class ServiceDatabaseFileAccessBase extends ServiceModuleBase {
         true
       );
       if (doc === false) {
-        return false;
+        return [];
       }
       const revisions = doc._revs_info;
       const availableRevs = new Set((revisions || []).filter((e) => e.status === "available").map((e) => e.rev));
       if (currentRev) {
         availableRevs.add(currentRev);
       }
+      const leaves = await this.database.localDatabase.getRaw(doc._id, {
+        open_revs: "all"
+      });
+      if (!Array.isArray(leaves)) {
+        return [];
+      }
+      for (const leaf of leaves) {
+        const leafRev = leaf.ok?._rev;
+        if (!leafRev) {
+          continue;
+        }
+        const branch = await this.database.localDatabase.getDBEntryMeta(
+          filename,
+          { rev: leafRev, revs_info: true },
+          true
+        );
+        if (branch === false) {
+          continue;
+        }
+        const branchRevisions = branch._revs_info;
+        for (const revision of branchRevisions || []) {
+          if (revision.status === "available") {
+            availableRevs.add(revision.rev);
+          }
+        }
+      }
+      const matchingRevisions = [];
       for (const rev of availableRevs) {
         const entry = await this.database.localDatabase.getDBEntry(filename, { rev }, false, true, true);
-        if (entry !== false && await isDocContentSame(readContent(entry), content)) {
-          return true;
+        if (entry !== false && !entry._deleted && await isDocContentSame(readContent(entry), content)) {
+          matchingRevisions.push(rev);
         }
       }
+      return matchingRevisions;
     } catch (ex) {
       this._log(`Could not check revision history for ${filename}`, LOG_LEVEL_VERBOSE);
       this._log(ex, LOG_LEVEL_VERBOSE);
     }
-    return false;
+    return [];
+  }
+  async findContentRevisions(file, content, currentRev) {
+    if (!await this.checkIsTargetFile(file)) {
+      return [];
+    }
+    return await this.findContentRevisionsInternal(file, content, currentRev);
+  }
+  async hasContentInRevisionHistory(file, content, currentRev) {
+    if (!await this.checkIsTargetFile(file)) {
+      return true;
+    }
+    return (await this.findContentRevisionsInternal(file, content, currentRev)).length > 0;
   }
   async getConflictedRevs(file) {
     if (!await this.checkIsTargetFile(file)) {

package/dist/serviceModules/ServiceFileHandlerBase.d.ts

@@ -11,6 +11,7 @@ import type { ConflictService } from "../services/base/ConflictService.js";
 import type { PathService } from "../services/base/PathService.js";
 import type { SettingService } from "../services/base/SettingService.js";
 import type { VaultService } from "../services/base/VaultService.js";
+import type { FileReflectionProvenance } from "../interfaces/FileReflectionProvenance.js";
 export interface ServiceFileHandlerDependencies {
     events: LiveSyncEventHub;
     API: APIService;
@@ -22,6 +23,17 @@ export interface ServiceFileHandlerDependencies {
     path: PathService;
     setting: SettingService;
     vault: VaultService;
+    /**
+     * Device-local record of the exact database revision reflected in storage.
+     *
+     * This is optional for compatibility hosts. Maintained hosts should provide
+     * it so edits made while a document is conflicted extend the displayed
+     * branch instead of whichever branch PouchDB currently selects as winner.
+     * The host must finish opening its backing store before it dispatches file
+     * or replication events; provenance does not hide lifecycle violations by
+     * waiting for readiness.
+     */
+    fileReflectionProvenance?: FileReflectionProvenance;
 }
 export declare abstract class ServiceFileHandlerBase extends ServiceModuleBase<ServiceFileHandlerDependencies> implements IFileHandler {
     private events;
@@ -31,20 +43,29 @@ export declare abstract class ServiceFileHandlerBase extends ServiceModuleBase<S
     private path;
     private setting;
     private vault;
+    private fileReflectionProvenance?;
     constructor(services: ServiceFileHandlerDependencies);
     get db(): DatabaseFileAccess;
     get storage(): StorageAccess;
+    private getProvenance;
+    private setProvenance;
+    private deleteProvenance;
+    private findUniqueContentRevision;
+    private getProvenBaseRevision;
     getPath(entry: AnyEntry): FilePathWithPrefix;
     getPathWithoutPrefix(entry: AnyEntry): FilePathWithPrefix;
     readFileFromStub(file: UXFileInfoStub | UXFileInfo): Promise<UXFileInfo>;
     private infoToStub;
     storeFileToDB(info: UXFileInfoStub | UXFileInfo | UXInternalFileInfoStub | FilePathWithPrefix, force?: boolean, onlyChunks?: boolean): Promise<boolean>;
+    storeFileToDBWithBaseRevision(info: UXFileInfoStub | UXFileInfo | FilePathWithPrefix, baseRevision: string, createIfDifferent?: boolean): Promise<boolean>;
+    private storeFileToDBFromRevision;
     deleteFileFromDB(info: UXFileInfoStub | UXInternalFileInfoStub | FilePath): Promise<boolean>;
     renameFileInDB(info: UXFileInfoStub | UXFileInfo, oldPath: FilePath | FilePathWithPrefix): Promise<boolean>;
     deleteRevisionFromDB(info: UXFileInfoStub | FilePath | FilePathWithPrefix, rev: string): Promise<boolean | undefined>;
     resolveConflictedByDeletingRevision(info: UXFileInfoStub | FilePath, rev: string): Promise<boolean | undefined>;
-    dbToStorageWithSpecificRev(info: UXFileInfoStub | UXFileInfo | FilePath | null, rev: string, force?: boolean): Promise<boolean>;
+    dbToStorageWithSpecificRev(info: UXFileInfoStub | UXFileInfo | FilePath | FilePathWithPrefix | null, rev: string, force?: boolean): Promise<boolean>;
     dbToStorage(entryInfo: MetaEntry | FilePathWithPrefix, info: UXFileInfoStub | UXFileInfo | FilePath | null, force?: boolean): Promise<boolean>;
+    private applyDatabaseEntryToStorage;
     private preserveUnsyncedStorageAsConflict;
     private _anyHandlerProcessesFileEvent;
     _anyProcessReplicatedDoc(entry: MetaEntry): Promise<boolean>;