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

package/dist/serviceModules/Rebuilder.d.ts

@@ -48,10 +48,6 @@ export declare class ServiceRebuilder extends ServiceModuleBase<ServiceRebuilder
     constructor(services: ServiceRebuilderDependencies);
     $performRebuildDB(method: "localOnly" | "remoteOnly" | "rebuildBothByThisDevice" | "localOnlyWithChunks"): Promise<void>;
     informOptionalFeatures(): Promise<void>;
-    askUsingOptionalFeature(opt: {
-        enableFetch?: boolean;
-        enableOverwrite?: boolean;
-    }): Promise<void>;
     rebuildRemote(): Promise<void>;
     private performRemoteRebuild;
     $rebuildRemote(): Promise<void>;
@@ -60,8 +56,9 @@ export declare class ServiceRebuilder extends ServiceModuleBase<ServiceRebuilder
     $rebuildEverything(): Promise<void>;
     $fetchLocal(makeLocalChunkBeforeSync?: boolean, preventMakeLocalFilesBeforeSync?: boolean): Promise<void>;
     $fetchLocalDBFast(autoResume: boolean): Promise<void>;
-    scheduleRebuild(): Promise<void>;
-    scheduleFetch(): Promise<void>;
+    private scheduleInitialisation;
+    scheduleRebuild(prepareBeforeRestart?: () => Promise<void>): Promise<boolean>;
+    scheduleFetch(prepareBeforeRestart?: () => Promise<void>): Promise<boolean>;
     private _tryResetRemoteDatabase;
     private _onResetLocalDatabase;
     suspendAllSync(): Promise<void>;

package/dist/serviceModules/Rebuilder.js

@@ -1,5 +1,5 @@
 import { FlagFilesHumanReadable } from "../common/models/redflag.const.js";
-import { REMOTE_COUCHDB, REMOTE_MINIO } from "../common/models/setting.const.js";
+import { REMOTE_COUCHDB, REMOTE_MINIO, REMOTE_P2P } from "../common/models/setting.const.js";
 import { DEFAULT_SETTINGS } from "../common/models/setting.const.defaults.js";
 import { LOG_LEVEL_NOTICE, LOG_LEVEL_VERBOSE } from "octagonal-wheels/common/logger";
 import { delay } from "octagonal-wheels/promises";
@@ -67,14 +67,6 @@ Please enable them from the settings screen after setup is complete.`,
       ["OK"]
     );
   }
-  async askUsingOptionalFeature(opt) {
-    if (await this.UI.confirm.askYesNoDialog(
-      "Do you want to enable extra features? If you are new to Self-hosted LiveSync, try the core feature first!",
-      { title: "Enable extra features", defaultOption: "No", timeout: 15 }
-    ) == "yes") {
-      await this.setting.suggestOptionalFeatures(opt);
-    }
-  }
   async rebuildRemote() {
     await this.replicator.runBoundedRemoteActivity(() => this.performRemoteRebuild(), {
       label: "rebuild-remote"
@@ -95,7 +87,7 @@ Please enable them from the settings screen after setup is complete.`,
     await delay(1e3);
     await this.replication.replicateAllToRemote(true);
     await delay(1e3);
-    await this.replication.replicateAllToRemote(true, true);
+    await this.replication.replicateAllToRemote(true);
   }
   $rebuildRemote() {
     return this.rebuildRemote();
@@ -116,6 +108,9 @@ Please enable them from the settings screen after setup is complete.`,
     await this.resetLocalDatabase();
     await delay(1e3);
     await this.databaseEvents.initialiseDatabase(true, true, true);
+    if (this.setting.currentSettings().remoteType === REMOTE_P2P) {
+      return;
+    }
     await this.replication.markLocked();
     await this._tryResetRemoteDatabase();
     await this.replication.markLocked();
@@ -123,7 +118,7 @@ Please enable them from the settings screen after setup is complete.`,
     await delay(1e3);
     await this.replication.replicateAllToRemote(true);
     await delay(1e3);
-    await this.replication.replicateAllToRemote(true, true);
+    await this.replication.replicateAllToRemote(true);
   }
   $rebuildEverything() {
     return this.rebuildEverything();
@@ -134,23 +129,35 @@ Please enable them from the settings screen after setup is complete.`,
   $fetchLocalDBFast(autoResume) {
     return this.fetchLocalDBFast(autoResume);
   }
-  async scheduleRebuild() {
+  async scheduleInitialisation(flag, prepareBeforeRestart) {
     try {
-      await this.storageAccess.writeFileAuto(FlagFilesHumanReadable.REBUILD_ALL, "");
+      await this.storageAccess.writeFileAuto(flag, "");
     } catch (ex) {
-      this._log(`Could not create ${FlagFilesHumanReadable.REBUILD_ALL}`, LOG_LEVEL_NOTICE);
+      this._log(`Could not create ${flag}`, LOG_LEVEL_NOTICE);
       this._log(ex, LOG_LEVEL_VERBOSE);
+      return false;
     }
-    this.appLifecycle.performRestart();
-  }
-  async scheduleFetch() {
+    this.appLifecycle.setSuspended(true);
     try {
-      await this.storageAccess.writeFileAuto(FlagFilesHumanReadable.FETCH_ALL, "");
+      await prepareBeforeRestart?.();
     } catch (ex) {
-      this._log(`Could not create ${FlagFilesHumanReadable.FETCH_ALL}`, LOG_LEVEL_NOTICE);
-      this._log(ex, LOG_LEVEL_VERBOSE);
+      try {
+        await this.storageAccess.delete(flag, true);
+      } catch (cleanupError) {
+        this._log(`Could not remove ${flag} after restart preparation failed`, LOG_LEVEL_NOTICE);
+        this._log(cleanupError, LOG_LEVEL_VERBOSE);
+      }
+      this.appLifecycle.setSuspended(false);
+      throw ex;
     }
     this.appLifecycle.performRestart();
+    return true;
+  }
+  scheduleRebuild(prepareBeforeRestart) {
+    return this.scheduleInitialisation(FlagFilesHumanReadable.REBUILD_ALL, prepareBeforeRestart);
+  }
+  scheduleFetch(prepareBeforeRestart) {
+    return this.scheduleInitialisation(FlagFilesHumanReadable.FETCH_ALL, prepareBeforeRestart);
   }
   async _tryResetRemoteDatabase() {
     const currentReplicator = this.replicator.getActiveReplicator();
@@ -269,8 +276,10 @@ Are you sure you wish to proceed?`;
     await this.replication.markResolved();
     await delay(500);
     await this.replication.replicateAllFromRemote(true);
-    await delay(1e3);
-    await this.replication.replicateAllFromRemote(true);
+    if (this.setting.currentSettings().remoteType !== REMOTE_P2P) {
+      await delay(1e3);
+      await this.replication.replicateAllFromRemote(true);
+    }
     if (autoResume) {
       await this.finishRebuild();
     }

package/dist/serviceModules/ServiceDatabaseFileAccessBase.d.ts

@@ -26,10 +26,15 @@ export declare class ServiceDatabaseFileAccessBase extends ServiceModuleBase<Ser
     delete(file: UXFileInfoStub | FilePathWithPrefix, rev?: string): Promise<boolean>;
     createChunks(file: UXFileInfo, force?: boolean, skipCheck?: boolean): Promise<boolean>;
     store(file: UXFileInfo, force?: boolean, skipCheck?: boolean): Promise<boolean>;
+    storeWithBaseRevision(file: UXFileInfo, baseRevision: string | undefined, skipCheck?: boolean): Promise<string | false>;
     storeAsConflictedRevision(file: UXFileInfo, currentRev: string, skipCheck?: boolean): Promise<boolean>;
+    storeAsConflictedRevisionWithResult(file: UXFileInfo, currentRev: string, skipCheck?: boolean): Promise<string | false>;
+    storeDeletionWithBaseRevision(file: UXFileInfoStub | FilePathWithPrefix, baseRevision: string): Promise<string | false>;
     storeContent(path: FilePathWithPrefix, content: string): Promise<boolean>;
     private __store;
     private getParentRev;
+    private findContentRevisionsInternal;
+    findContentRevisions(file: UXFileInfoStub | FilePathWithPrefix, content: string | string[] | Blob | ArrayBuffer, currentRev?: string): Promise<string[]>;
     hasContentInRevisionHistory(file: UXFileInfoStub | FilePathWithPrefix, content: string | string[] | Blob | ArrayBuffer, currentRev?: string): Promise<boolean>;
     getConflictedRevs(file: UXFileInfoStub | FilePathWithPrefix): Promise<string[]>;
     fetch(file: UXFileInfoStub | FilePathWithPrefix, rev?: string, waitForReady?: boolean, skipCheck?: boolean): Promise<UXFileInfo | false>;

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,28 @@ 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>;
+    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>;
     dbToStorage(entryInfo: MetaEntry | FilePathWithPrefix, info: UXFileInfoStub | UXFileInfo | FilePath | null, force?: boolean): Promise<boolean>;
+    private applyDatabaseEntryToStorage;
     private preserveUnsyncedStorageAsConflict;
     private _anyHandlerProcessesFileEvent;
     _anyProcessReplicatedDoc(entry: MetaEntry): Promise<boolean>;