@vrtmrz/livesync-commonlib 0.1.0-rc.8 → 0.1.0

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,62 @@ class ServiceFileHandlerBase extends ServiceModuleBase {
     return file;
   }
   async storeFileToDB(info, force = false, onlyChunks = false) {
+    return await this.storeFileToDBFromRevision(info, force, onlyChunks);
+  }
+  async storeFileToDBWithBaseRevision(info, baseRevision, createIfDifferent = true) {
+    const file = await this.infoToStub(info);
+    if (file == null) {
+      this._log(`File ${tryGetFilePath(info)} is not exist on the storage`, LOG_LEVEL_VERBOSE);
+      return false;
+    }
+    if (file.isInternal) {
+      this._log(
+        `Internal file ${file.path} is not allowed to be stored through the ordinary file handler`,
+        LOG_LEVEL_VERBOSE
+      );
+      return false;
+    }
+    const [baseEntry, currentEntry, conflictedRevisions] = await Promise.all([
+      this.db.fetchEntryMeta(file, baseRevision, true),
+      this.db.fetchEntryMeta(file, void 0, true),
+      this.db.getConflictedRevs(file)
+    ]);
+    const liveRevisions = /* @__PURE__ */ new Set([
+      ...currentEntry && currentEntry._rev ? [currentEntry._rev] : [],
+      ...conflictedRevisions
+    ]);
+    if (!baseEntry || baseEntry._rev !== baseRevision || !liveRevisions.has(baseRevision)) {
+      this._log(
+        `Could not store ${file.path} on revision ${baseRevision}; the selected revision is no longer live`,
+        LOG_LEVEL_NOTICE
+      );
+      return false;
+    }
+    const readFile = await this.readFileFromStub(file);
+    if (!baseEntry.deleted && !baseEntry._deleted) {
+      const loadedBase = await this.db.fetchEntry(file, baseRevision, true, true);
+      if (loadedBase && await isDocContentSame(getDocDataAsArray(loadedBase.data), readFile.body)) {
+        await this.setProvenance(file.path, baseRevision, readFile.stat.mtime);
+        await this.conflict.queueCheckFor(file.path);
+        return true;
+      }
+    }
+    if (!createIfDifferent) {
+      this._log(
+        `Could not mark ${file.path} as revision ${baseRevision}; the storage content differs`,
+        LOG_LEVEL_NOTICE
+      );
+      return false;
+    }
+    const storedRevision = await this.db.storeWithBaseRevision(readFile, baseRevision, true);
+    if (storedRevision === false) {
+      return false;
+    }
+    await this.setProvenance(file.path, storedRevision, readFile.stat.mtime);
+    await this.conflict.queueCheckFor(file.path);
+    return true;
+  }
+  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 +215,70 @@ 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 currentEntry = entry || await this.db.fetchEntryMeta(file, void 0, true);
+      const currentRevision = currentEntry && currentEntry._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 +286,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 +315,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 +351,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 +385,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,54 +404,107 @@ 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);
+    const path = getStoragePathFromUXFileInfo(info);
+    const provenance = await this.getProvenance(path);
+    const deleted = await this.db.delete(info, rev);
+    if (deleted && provenance?.revision === rev) {
+      await this.deleteProvenance(path);
+    }
+    return deleted;
   }
   async resolveConflictedByDeletingRevision(info, rev) {
     const path = getStoragePathFromUXFileInfo(info);
+    const file = await this.infoToStub(info);
+    const docEntry = await this.db.fetchEntryMeta(file ?? info, rev, true);
+    if (!docEntry) {
+      this._log(`Failed to read the conflicted revision ${rev} of ${path}`, LOG_LEVEL_VERBOSE);
+      return false;
+    }
     if (!await this.deleteRevisionFromDB(info, rev)) {
       this._log(`Failed to delete the conflicted revision ${rev} of ${path}`, LOG_LEVEL_VERBOSE);
       return false;
     }
-    if (!await this.dbToStorageWithSpecificRev(info, rev, true)) {
+    if (!await this.applyDatabaseEntryToStorage(docEntry, file, true)) {
       this._log(`Failed to apply the resolved revision ${rev} of ${path} to the storage`, LOG_LEVEL_VERBOSE);
       return false;
     }
+    await this.deleteProvenance(path);
   }
   async dbToStorageWithSpecificRev(info, rev, force) {
-    const file = await this.infoToStub(info);
-    if (file == null) {
-      this._log(`File ${tryGetFilePath(info)} is not exist on the storage`, LOG_LEVEL_VERBOSE);
+    if (info == null) {
+      this._log(`Cannot select database revision ${rev} without a file path`, LOG_LEVEL_VERBOSE);
       return false;
     }
-    const docEntry = await this.db.fetchEntryMeta(file, rev, true);
+    const file = await this.infoToStub(info);
+    const databaseTarget = file ?? info;
+    const [docEntry, currentEntry, conflictedRevisions] = await Promise.all([
+      this.db.fetchEntryMeta(databaseTarget, rev, true),
+      this.db.fetchEntryMeta(databaseTarget, void 0, true),
+      this.db.getConflictedRevs(databaseTarget)
+    ]);
     if (!docEntry) {
-      this._log(`File ${file.path} is not exist on the database`, LOG_LEVEL_VERBOSE);
+      this._log(`File ${tryGetFilePath(info)} is not exist on the database`, LOG_LEVEL_VERBOSE);
+      return false;
+    }
+    const liveRevisions = /* @__PURE__ */ new Set([
+      ...currentEntry && currentEntry._rev ? [currentEntry._rev] : [],
+      ...conflictedRevisions
+    ]);
+    if (!liveRevisions.has(rev)) {
+      this._log(
+        `Could not apply ${tryGetFilePath(info)} revision ${rev}; the selected revision is no longer live`,
+        LOG_LEVEL_NOTICE
+      );
       return false;
     }
-    return await this.dbToStorage(docEntry, file, force);
+    return await this.applyDatabaseEntryToStorage(docEntry, file, force, true);
   }
   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, allowExistingConflicts = false) {
+    const mode = file == null ? "create" : "modify";
     const path = this.getPath(docEntry);
     const settings = this.setting.currentSettings();
     const revs = await this.db.getConflictedRevs(path);
-    if (revs.length > 0) {
+    if (revs.length > 0 && !allowExistingConflicts) {
       if (settings.writeDocumentsIfConflicted) {
       } else {
         await this.conflict.queueCheckForIfOpen(path);
@@ -261,6 +519,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 +527,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 +554,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);
@@ -311,6 +572,14 @@ class ServiceFileHandlerBase extends ServiceModuleBase {
       }
     }
     const docData = readContent(docRead);
+    if (allowExistingConflicts && existDoc && !force) {
+      const readFile = await this.readFileFromStub(existDoc);
+      if (await isDocContentSame(docData, readFile.body)) {
+        await this.setProvenance(path, docEntry._rev, existDoc.stat.mtime);
+        this.path.markChangesAreSame(docRead, docRead.mtime, existDoc.stat.mtime);
+        return true;
+      }
+    }
     if (existDoc && !force) {
       let shouldApplied = false;
       const freshness = this.path.compareFileFreshness(existDoc, docEntry);
@@ -327,6 +596,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 +613,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 +633,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/base/KeyValueDBService.d.ts

@@ -37,6 +37,6 @@ export declare abstract class KeyValueDBService<T extends ServiceContext = Servi
         set: (key: string, value: unknown) => Promise<void>;
         delete: (key: string) => Promise<void>;
         keys: (from: string | undefined, to: string | undefined, count?: number) => Promise<string[]>;
-        db: Promise<KeyValueDatabase>;
+        readonly db: Promise<KeyValueDatabase>;
     };
 }

package/dist/services/base/KeyValueDBService.js

@@ -124,7 +124,9 @@ class KeyValueDBService extends ServiceBase {
         );
         return ret.map((e) => (typeof e === "string" ? e : JSON.stringify(e)).toString()).filter((e) => e.startsWith(prefix)).map((e) => e.substring(prefix.length));
       },
-      db: Promise.resolve(getDB())
+      get db() {
+        return Promise.resolve(getDB());
+      }
     };
   }
 }