@vrtmrz/livesync-commonlib 0.1.0-rc.0

package/dist/managers/EntryManager/EntryManager.d.ts

@@ -0,0 +1,37 @@
+import { type FilePathWithPrefix, type FilePath, type LoadedEntry, type EntryDoc, type SavingEntry, type MetaEntry } from "../../common/types.js";
+import type { ChunkManager } from "../ChunkManager.js";
+import type { ContentSplitter } from "../../ContentSplitter/ContentSplitters.js";
+import type { HashManager } from "../HashManager/HashManager.js";
+import type { GeneratedChunk } from "../../pouchdb/LiveSyncLocalDB.js";
+import type { IPathService, ISettingService } from "../../services/base/IService.js";
+export interface EntryManagerOptions {
+    hashManager: HashManager;
+    chunkManager: ChunkManager;
+    splitter: ContentSplitter;
+    database: PouchDB.Database<EntryDoc>;
+    settingService: ISettingService;
+    pathService: IPathService;
+}
+export declare class EntryManager {
+    options: EntryManagerOptions;
+    constructor(options: EntryManagerOptions);
+    get localDatabase(): PouchDB.Database<EntryDoc>;
+    get hashManager(): HashManager;
+    get chunkManager(): ChunkManager;
+    get splitter(): ContentSplitter;
+    get serviceHost(): {
+        services: {
+            setting: ISettingService;
+            path: IPathService;
+        };
+        serviceModules: {};
+    };
+    get isOnDemandChunkEnabled(): boolean;
+    isTargetFile(filenameSrc: string): boolean;
+    prepareChunk(piece: string): Promise<GeneratedChunk>;
+    getDBEntryMeta(path: FilePathWithPrefix | FilePath, opt?: PouchDB.Core.GetOptions, includeDeleted?: boolean): Promise<false | LoadedEntry>;
+    getDBEntry(path: FilePathWithPrefix | FilePath, opt?: PouchDB.Core.GetOptions, dump?: boolean, waitForReady?: boolean, includeDeleted?: boolean): Promise<false | LoadedEntry>;
+    getDBEntryFromMeta(meta: LoadedEntry | MetaEntry, dump?: boolean, waitForReady?: boolean): Promise<false | LoadedEntry>;
+    deleteDBEntry(path: FilePathWithPrefix | FilePath, opt?: PouchDB.Core.GetOptions): Promise<boolean>;
+    putDBEntry(note: SavingEntry, onlyChunks?: boolean, conflictBaseRev?: string): Promise<false | PouchDB.Core.Response>;
+}

package/dist/managers/EntryManager/EntryManager.js

@@ -0,0 +1,73 @@
+import {
+  REMOTE_COUCHDB
+} from "../../common/types.js";
+import {
+  deleteDBEntryByPath,
+  getDBEntryByPath,
+  getDBEntryFromMeta,
+  getDBEntryMetaByPath,
+  isTargetFile,
+  prepareChunk,
+  putDBEntry
+} from "./EntryManagerImpls.js";
+class EntryManager {
+  options;
+  constructor(options) {
+    this.options = options;
+  }
+  get localDatabase() {
+    return this.options.database;
+  }
+  get hashManager() {
+    return this.options.hashManager;
+  }
+  get chunkManager() {
+    return this.options.chunkManager;
+  }
+  get splitter() {
+    return this.options.splitter;
+  }
+  get serviceHost() {
+    return {
+      services: {
+        setting: this.options.settingService,
+        path: this.options.pathService
+      },
+      serviceModules: {}
+    };
+  }
+  get isOnDemandChunkEnabled() {
+    const settings = this.options.settingService.currentSettings();
+    if (settings.remoteType !== REMOTE_COUCHDB) {
+      return false;
+    }
+    if (settings.useOnlyLocalChunk) {
+      return false;
+    }
+    return true;
+  }
+  isTargetFile(filenameSrc) {
+    return isTargetFile(this.serviceHost, filenameSrc);
+  }
+  async prepareChunk(piece) {
+    return await prepareChunk(this, piece);
+  }
+  async getDBEntryMeta(path, opt, includeDeleted = false) {
+    return await getDBEntryMetaByPath(this.serviceHost, this, path, opt, includeDeleted);
+  }
+  async getDBEntry(path, opt, dump = false, waitForReady = true, includeDeleted = false) {
+    return await getDBEntryByPath(this.serviceHost, this, path, opt, dump, waitForReady, includeDeleted);
+  }
+  async getDBEntryFromMeta(meta, dump = false, waitForReady = true) {
+    return await getDBEntryFromMeta(this.serviceHost, this, meta, dump, waitForReady);
+  }
+  async deleteDBEntry(path, opt) {
+    return await deleteDBEntryByPath(this.serviceHost, this, path, opt);
+  }
+  async putDBEntry(note, onlyChunks, conflictBaseRev) {
+    return await putDBEntry(this.serviceHost, this, note, onlyChunks, conflictBaseRev);
+  }
+}
+export {
+  EntryManager
+};

package/dist/managers/EntryManager/EntryManagerImpls.d.ts

@@ -0,0 +1,74 @@
+import { type SavingEntry, type DocumentID, type EntryDoc, type EntryBase, type FilePath, type FilePathWithPrefix, type LoadedEntry, type ObsidianLiveSyncSettings, type MetaEntry } from "../../common/types.js";
+import type { ContentSplitter } from "../../ContentSplitter/ContentSplitters.js";
+import type { HashManager } from "../HashManager/HashManager.js";
+import type { LayeredChunkManager as ChunkManager } from "../LayeredChunkManager.js";
+import type { NecessaryServicesInterfaces } from "../../interfaces/ServiceModule.js";
+import type { GeneratedChunk } from "../../pouchdb/LiveSyncLocalDB.js";
+type Managers = {
+    hashManager: HashManager;
+    chunkManager: ChunkManager;
+    splitter: ContentSplitter;
+    localDatabase: PouchDB.Database<EntryDoc>;
+};
+type NecessaryManagers<T extends keyof Managers> = Pick<Managers, T>;
+export declare function createChunks(managers: NecessaryManagers<"chunkManager" | "hashManager" | "splitter">, dispFilename: string, note: SavingEntry): Promise<false | DocumentID[]>;
+export declare function putDBEntry(host: NecessaryServicesInterfaces<"path" | "setting", never>, managers: NecessaryManagers<"localDatabase" | "chunkManager" | "hashManager" | "splitter">, note: SavingEntry, onlyChunks?: boolean, conflictBaseRev?: string): Promise<false | PouchDB.Core.Response>;
+export declare function isTargetFile(host: NecessaryServicesInterfaces<"setting", never>, filenameSrc: string): boolean;
+export declare function prepareChunk({ chunkManager, hashManager }: NecessaryManagers<"chunkManager" | "hashManager">, piece: string): Promise<GeneratedChunk>;
+export declare function getDBEntryMetaByPath(host: NecessaryServicesInterfaces<"path" | "setting", never>, { localDatabase }: NecessaryManagers<"localDatabase">, path: FilePathWithPrefix | FilePath, opt?: PouchDB.Core.GetOptions, includeDeleted?: boolean): Promise<false | LoadedEntry>;
+export declare function isLegacyNote(meta: LoadedEntry | MetaEntry): boolean;
+export declare function canUseOnDemandChunking(settings: ObsidianLiveSyncSettings): boolean;
+/**
+ * Decide how to retrieve chunks based on settings and waitForReady flag.
+ * `waitForReady` allows an already-observable finite delivery lifecycle to finish.
+ */
+export declare function computeChunkRetrievalMethod(waitForReady: boolean, settings: ObsidianLiveSyncSettings): {
+    waitForDelivery: boolean;
+    preventRemoteRequest: boolean;
+};
+export declare function getDBEntryFromMeta(host: NecessaryServicesInterfaces<"path" | "setting", never>, { localDatabase, chunkManager }: NecessaryManagers<"localDatabase" | "chunkManager">, meta: LoadedEntry | MetaEntry, dump?: boolean, waitForReady?: boolean): Promise<false | (import("../../common/types.js").DatabaseEntry & EntryBase & import("../../common/types.js").EntryWithEden & {
+    path: FilePathWithPrefix;
+    data: string | string[];
+    type: import("../../common/models/db.type.js").EntryTypes["NOTE_LEGACY"];
+} & {
+    data: string | string[];
+    datatype: import("../../common/types.js").EntryTypeNotes;
+} & PouchDB.Core.IdMeta) | (import("../../common/types.js").DatabaseEntry & EntryBase & import("../../common/types.js").EntryWithEden & {
+    path: FilePathWithPrefix;
+    children: string[];
+    type: import("../../common/models/db.type.js").EntryTypes["NOTE_BINARY"];
+} & {
+    data: string | string[];
+    datatype: import("../../common/types.js").EntryTypeNotes;
+} & PouchDB.Core.IdMeta) | (import("../../common/types.js").DatabaseEntry & EntryBase & import("../../common/types.js").EntryWithEden & {
+    path: FilePathWithPrefix;
+    children: string[];
+    type: import("../../common/models/db.type.js").EntryTypes["NOTE_PLAIN"];
+} & {
+    data: string | string[];
+    datatype: import("../../common/types.js").EntryTypeNotes;
+} & PouchDB.Core.IdMeta)>;
+export declare function getDBEntryByPath(host: NecessaryServicesInterfaces<"path" | "setting", never>, managers: NecessaryManagers<"localDatabase" | "chunkManager">, path: FilePathWithPrefix | FilePath, opt?: PouchDB.Core.GetOptions, dump?: boolean, waitForReady?: boolean, includeDeleted?: boolean): Promise<false | (import("../../common/types.js").DatabaseEntry & EntryBase & import("../../common/types.js").EntryWithEden & {
+    path: FilePathWithPrefix;
+    data: string | string[];
+    type: import("../../common/models/db.type.js").EntryTypes["NOTE_LEGACY"];
+} & {
+    data: string | string[];
+    datatype: import("../../common/types.js").EntryTypeNotes;
+} & PouchDB.Core.IdMeta) | (import("../../common/types.js").DatabaseEntry & EntryBase & import("../../common/types.js").EntryWithEden & {
+    path: FilePathWithPrefix;
+    children: string[];
+    type: import("../../common/models/db.type.js").EntryTypes["NOTE_BINARY"];
+} & {
+    data: string | string[];
+    datatype: import("../../common/types.js").EntryTypeNotes;
+} & PouchDB.Core.IdMeta) | (import("../../common/types.js").DatabaseEntry & EntryBase & import("../../common/types.js").EntryWithEden & {
+    path: FilePathWithPrefix;
+    children: string[];
+    type: import("../../common/models/db.type.js").EntryTypes["NOTE_PLAIN"];
+} & {
+    data: string | string[];
+    datatype: import("../../common/types.js").EntryTypeNotes;
+} & PouchDB.Core.IdMeta)>;
+export declare function deleteDBEntryByPath(host: NecessaryServicesInterfaces<"path" | "setting", never>, { localDatabase }: NecessaryManagers<"localDatabase">, path: FilePathWithPrefix | FilePath, opt?: PouchDB.Core.GetOptions): Promise<boolean>;
+export {};

package/dist/managers/EntryManager/EntryManagerImpls.js

@@ -0,0 +1,499 @@
+import { Logger, LOG_LEVEL_VERBOSE, LOG_LEVEL_NOTICE } from "octagonal-wheels/common/logger";
+import {
+  IDPrefixes,
+  REMOTE_COUCHDB,
+  RemoteTypes
+} from "../../common/types.js";
+import { serialized } from "octagonal-wheels/concurrency/lock";
+import { createTextBlob, getFileRegExp, isTextBlob } from "../../common/utils.js";
+import { isErrorOfMissingDoc } from "../../pouchdb/utils_couchdb.js";
+import { stripAllPrefixes } from "../../string_and_binary/path.js";
+import { ICHeader, ICXHeader, PSCHeader } from "../../common/models/fileaccess.const.js";
+async function createChunks(managers, dispFilename, note) {
+  const { chunkManager, splitter } = managers;
+  let bufferedChunk = [];
+  let bufferedSize = 0;
+  let writeCount = 0;
+  let newCount = 0;
+  let cachedCount = 0;
+  let resultCachedCount = 0;
+  let duplicatedCount = 0;
+  let totalWritingCount = 0;
+  let createChunkCount = 0;
+  const MAX_WRITE_SIZE = 1e3 * 1024 * 2;
+  const chunks = [];
+  let writeChars = 0;
+  const flushBufferedChunks = async () => {
+    if (bufferedChunk.length === 0) {
+      Logger(`No chunks to flush for ${dispFilename}`, LOG_LEVEL_VERBOSE);
+      return true;
+    }
+    const writeBuf = [...bufferedChunk];
+    bufferedSize = 0;
+    bufferedChunk = [];
+    const result = await chunkManager.write(
+      writeBuf,
+      {
+        skipCache: false,
+        timeout: 0
+      },
+      note._id
+    );
+    if (result.result === false) {
+      Logger(`Failed to write buffered chunks for ${dispFilename}`, LOG_LEVEL_NOTICE);
+      return false;
+    }
+    totalWritingCount++;
+    writeCount += result.processed.written;
+    resultCachedCount += result.processed.cached;
+    duplicatedCount += result.processed.duplicated;
+    writeChars += writeBuf.map((e) => e.data.length).reduce((a, b) => a + b, 0);
+    Logger(`Flushed ${writeBuf.length} (${writeChars}) chunks for ${dispFilename}`, LOG_LEVEL_VERBOSE);
+    return true;
+  };
+  const flushIfNeeded = async () => {
+    if (bufferedSize > MAX_WRITE_SIZE) {
+      if (!await flushBufferedChunks()) {
+        Logger(`Failed to flush buffered chunks for ${dispFilename}`, LOG_LEVEL_NOTICE);
+        return false;
+      }
+    }
+    return true;
+  };
+  const addBuffer = async (id, data) => {
+    const chunk = {
+      _id: id,
+      data,
+      type: "leaf"
+    };
+    bufferedChunk.push(chunk);
+    chunks.push(chunk._id);
+    bufferedSize += chunk.data.length;
+    return await flushIfNeeded();
+  };
+  const pieces = await splitter.splitContent(note);
+  let totalChunkCount = 0;
+  try {
+    for await (const piece of pieces) {
+      totalChunkCount++;
+      if (piece.length === 0) {
+        continue;
+      }
+      createChunkCount++;
+      const chunk = await prepareChunk(managers, piece);
+      cachedCount += chunk.isNew ? 0 : 1;
+      newCount += chunk.isNew ? 1 : 0;
+      if (!await addBuffer(chunk.id, chunk.piece)) {
+        return false;
+      }
+    }
+  } catch (ex) {
+    Logger(`Error processing pieces for ${dispFilename}`);
+    Logger(ex, LOG_LEVEL_VERBOSE);
+    return false;
+  }
+  if (!await flushBufferedChunks()) {
+    return false;
+  }
+  const dataSize = note.data.size;
+  const stats = `(\u2728: ${newCount}, \u{1F5C3}\uFE0F: ${cachedCount} (${resultCachedCount}) / \u{1F5C4}\uFE0F: ${writeCount}, \u267B:${duplicatedCount})`;
+  Logger(
+    `Chunks processed for ${dispFilename} (${dataSize}): \u{1F4DA}:${totalChunkCount} (${createChunkCount}) , \u{1F4E5}:${totalWritingCount} ${stats}`,
+    LOG_LEVEL_VERBOSE
+  );
+  if (dataSize > 0 && totalWritingCount === 0) {
+    Logger(
+      `No data to save in ${dispFilename}!! This document may be corrupted in the local database! Please back it up immediately, and report an issue!`,
+      LOG_LEVEL_NOTICE
+    );
+  }
+  return chunks;
+}
+async function putDBEntry(host, managers, note, onlyChunks, conflictBaseRev) {
+  const { localDatabase, chunkManager, splitter } = managers;
+  const filename = host.services.path.id2path(note._id, note);
+  const dispFilename = stripAllPrefixes(filename);
+  if (!note.eden) note.eden = {};
+  if (!isTargetFile(host, filename)) {
+    Logger(`File skipped:${dispFilename}`, LOG_LEVEL_VERBOSE);
+    return false;
+  }
+  const data = note.data instanceof Blob ? note.data : createTextBlob(note.data);
+  note.data = data;
+  note.type = isTextBlob(data) ? "plain" : "newnote";
+  note.datatype = note.type;
+  await splitter.initialised;
+  const result = await chunkManager.transaction(async () => {
+    const chunks = await createChunks(managers, dispFilename, note);
+    if (chunks === false) {
+      return false;
+    }
+    if (onlyChunks) {
+      return {
+        id: note._id,
+        ok: true,
+        rev: "dummy"
+      };
+    }
+    const newDoc = {
+      children: chunks,
+      _id: note._id,
+      path: note.path,
+      ctime: note.ctime,
+      mtime: note.mtime,
+      size: note.size,
+      type: note.datatype,
+      eden: {}
+    };
+    return await serialized("file:" + filename, async () => {
+      if (conflictBaseRev) {
+        newDoc._rev = conflictBaseRev;
+      } else {
+        try {
+          const old = await localDatabase.get(newDoc._id);
+          newDoc._rev = old._rev;
+        } catch (ex) {
+          if (isErrorOfMissingDoc(ex)) {
+          } else {
+            throw ex;
+          }
+        }
+      }
+      const r = await localDatabase.put(newDoc, { force: true });
+      if (r.ok) {
+        return r;
+      } else {
+        return false;
+      }
+    }) ?? false;
+  });
+  if (result === false) {
+    Logger(`Failed to write document ${dispFilename}`, LOG_LEVEL_NOTICE);
+    return false;
+  }
+  Logger(`Document saved: ${dispFilename} (${result.id.substring(0, 8)}-${result.rev})`, LOG_LEVEL_VERBOSE);
+  return result;
+}
+function isTargetFile(host, filenameSrc) {
+  const settings = host.services.setting.currentSettings();
+  const file = filenameSrc.startsWith(ICHeader) ? filenameSrc.substring(ICHeader.length) : filenameSrc;
+  if (file.startsWith(ICXHeader)) return true;
+  if (file.startsWith(PSCHeader)) return true;
+  if (file.includes(":")) {
+    return false;
+  }
+  if (!settings.syncInternalFiles) {
+    if (file.startsWith(".")) {
+      return false;
+    }
+  }
+  if (settings.syncOnlyRegEx) {
+    const syncOnly = getFileRegExp(settings, "syncOnlyRegEx");
+    if (syncOnly.length > 0 && !syncOnly.some((e) => e.test(file))) return false;
+  }
+  if (settings.syncIgnoreRegEx) {
+    const syncIgnore = getFileRegExp(settings, "syncIgnoreRegEx");
+    if (syncIgnore.some((e) => e.test(file))) return false;
+  }
+  return true;
+}
+async function prepareChunk({ chunkManager, hashManager }, piece) {
+  const cachedChunkId = chunkManager.getChunkIDFromCache(piece);
+  if (cachedChunkId !== false) {
+    return { isNew: false, id: cachedChunkId, piece };
+  }
+  const chunkId = await hashManager.computeHash(piece);
+  return { isNew: true, id: `${IDPrefixes.Chunk}${chunkId}`, piece };
+}
+async function getDBEntryMetaByPath(host, { localDatabase }, path, opt, includeDeleted = false) {
+  if (!isTargetFile(host, path)) {
+    return false;
+  }
+  const id = await host.services.path.path2id(path);
+  try {
+    let obj = null;
+    if (opt) {
+      obj = await localDatabase.get(id, opt);
+    } else {
+      obj = await localDatabase.get(id);
+    }
+    const deleted = obj?.deleted ?? obj._deleted ?? void 0;
+    if (!includeDeleted && deleted) return false;
+    if (obj.type && obj.type == "leaf") {
+      return false;
+    }
+    if (!obj.type || obj.type && obj.type == "notes" || obj.type == "newnote" || obj.type == "plain") {
+      const note = obj;
+      let children = [];
+      let type = "plain";
+      if (obj.type == "newnote" || obj.type == "plain") {
+        children = obj.children;
+        type = obj.type;
+      }
+      const doc = {
+        data: "",
+        _id: note._id,
+        path,
+        ctime: note.ctime,
+        mtime: note.mtime,
+        size: note.size,
+        // _deleted: obj._deleted,
+        _rev: obj._rev,
+        _conflicts: obj._conflicts,
+        children,
+        datatype: type,
+        deleted,
+        _revisions: obj?._revisions ?? void 0,
+        _revs_info: obj?._revs_info ?? void 0,
+        type,
+        eden: "eden" in obj ? obj.eden : {}
+      };
+      return doc;
+    }
+  } catch (ex) {
+    if (isErrorOfMissingDoc(ex)) {
+      return false;
+    }
+    throw ex;
+  }
+  return false;
+}
+function isLegacyNote(meta) {
+  return !meta.type || meta.type && meta.type == "notes";
+}
+function complementEntryMeta(note) {
+  const deleted = note.deleted ?? note._deleted ?? void 0;
+  const doc = {
+    data: note.data,
+    path: note.path,
+    _id: note._id,
+    ctime: note.ctime,
+    mtime: note.mtime,
+    size: note.size,
+    // _deleted: obj._deleted,
+    _rev: note._rev,
+    _conflicts: note._conflicts,
+    children: [],
+    datatype: "newnote",
+    deleted,
+    type: "newnote",
+    eden: "eden" in note ? note.eden : {}
+  };
+  return doc;
+}
+function respondOldFashionedEntry(note, dump = false) {
+  const doc = complementEntryMeta(note);
+  if (dump) {
+    Logger(`--Old fashioned document--`);
+    Logger(doc);
+  }
+  return doc;
+}
+function canUseOnDemandChunking(settings) {
+  if (settings.remoteType !== REMOTE_COUCHDB) {
+    return false;
+  }
+  if (settings.useOnlyLocalChunk) {
+    return false;
+  }
+  return true;
+}
+function canFetchRemotely(settings) {
+  if (!canUseOnDemandChunking(settings)) {
+    return false;
+  }
+  if (settings.remoteType === RemoteTypes.REMOTE_MINIO) {
+    return false;
+  }
+  return true;
+}
+function computeChunkRetrievalMethod(waitForReady, settings) {
+  const isOnDemandFetchEnabled = canFetchRemotely(settings);
+  if (!waitForReady) {
+    if (isOnDemandFetchEnabled) {
+      return {
+        waitForDelivery: true,
+        preventRemoteRequest: false
+      };
+    }
+    return {
+      waitForDelivery: false,
+      preventRemoteRequest: true
+    };
+  }
+  return {
+    waitForDelivery: true,
+    preventRemoteRequest: !isOnDemandFetchEnabled
+  };
+}
+async function respondEntryFromMeta({ localDatabase, chunkManager }, settings, filename, meta, dump, waitForReady) {
+  const dispFilename = stripAllPrefixes(filename);
+  const deleted = meta.deleted ?? meta._deleted ?? void 0;
+  if (dump) {
+    const conflicts = await localDatabase.get(meta._id, {
+      rev: meta._rev,
+      conflicts: true,
+      revs_info: true
+    });
+    Logger("-- Conflicts --");
+    Logger(conflicts._conflicts ?? "No conflicts");
+    Logger("-- Revs info -- ");
+    Logger(conflicts._revs_info);
+  }
+  try {
+    if (dump) {
+      Logger(`--Bare document--`);
+      Logger(meta);
+    }
+    let edenChunks = {};
+    if (meta.eden && Object.keys(meta.eden).length > 0) {
+      const chunks2 = Object.entries(meta.eden).map(([id, data]) => ({
+        _id: id,
+        data: data.data,
+        type: "leaf"
+      }));
+      edenChunks = Object.fromEntries(chunks2.map((e) => [e._id, e]));
+    }
+    const { waitForDelivery, preventRemoteRequest } = computeChunkRetrievalMethod(waitForReady, settings);
+    const childrenKeys = [...meta.children];
+    const chunks = await chunkManager.read(
+      childrenKeys,
+      {
+        skipCache: false,
+        waitForDelivery,
+        preventRemoteRequest
+      },
+      edenChunks
+    );
+    if (chunks.some((e) => e === false)) {
+      throw new Error("Load failed");
+    }
+    const doc = {
+      data: chunks.map((e) => e.data),
+      path: meta.path,
+      _id: meta._id,
+      ctime: meta.ctime,
+      mtime: meta.mtime,
+      size: meta.size,
+      _rev: meta._rev,
+      children: meta.children,
+      datatype: meta.type,
+      _conflicts: meta._conflicts,
+      eden: meta.eden,
+      deleted,
+      type: meta.type
+    };
+    if (dump) {
+      Logger(`--Loaded Document--`);
+      Logger(doc);
+    }
+    return doc;
+  } catch (ex) {
+    if (isErrorOfMissingDoc(ex)) {
+      Logger(
+        `Missing document content!, could not read ${dispFilename}(${meta._id.substring(0, 8)}) from database.`,
+        LOG_LEVEL_NOTICE
+      );
+      return false;
+    }
+    Logger(
+      `Something went wrong on reading ${dispFilename}(${meta._id.substring(0, 8)}) from database:`,
+      LOG_LEVEL_NOTICE
+    );
+    Logger(ex);
+  }
+  return false;
+}
+async function getDBEntryFromMeta(host, { localDatabase, chunkManager }, meta, dump = false, waitForReady = true) {
+  const filename = host.services.path.id2path(meta._id, meta);
+  if (!isTargetFile(host, filename)) {
+    return false;
+  }
+  const settings = host.services.setting.currentSettings();
+  if (isLegacyNote(meta)) {
+    const note = meta;
+    return respondOldFashionedEntry(note, dump);
+  }
+  if (meta.type == "newnote" || meta.type == "plain") {
+    return await respondEntryFromMeta(
+      { localDatabase, chunkManager },
+      settings,
+      filename,
+      meta,
+      dump,
+      waitForReady
+    );
+  }
+  return false;
+}
+async function getDBEntryByPath(host, managers, path, opt, dump = false, waitForReady = true, includeDeleted = false) {
+  const meta = await getDBEntryMetaByPath(host, managers, path, opt, includeDeleted);
+  if (meta) {
+    return await getDBEntryFromMeta(host, managers, meta, dump, waitForReady);
+  } else {
+    return false;
+  }
+}
+async function deleteDBEntryByPath(host, { localDatabase }, path, opt) {
+  if (!isTargetFile(host, path)) {
+    return false;
+  }
+  const id = await host.services.path.path2id(path);
+  try {
+    return await serialized("file:" + path, async () => {
+      const settings = host.services.setting.currentSettings();
+      let obj = null;
+      if (opt) {
+        obj = await localDatabase.get(id, opt);
+      } else {
+        obj = await localDatabase.get(id);
+      }
+      const revDeletion = opt && ("rev" in opt ? opt.rev : "") != "";
+      if (obj.type && obj.type == "leaf") {
+        return false;
+      }
+      if (!obj.type || obj.type && obj.type == "notes") {
+        obj._deleted = true;
+        const r = await localDatabase.put(obj, { force: !revDeletion });
+        Logger(`Entry removed: ${path} (${obj._id.substring(0, 8)}-${r.rev}) `);
+        return true;
+      }
+      if (obj.type == "newnote" || obj.type == "plain") {
+        if (revDeletion) {
+          obj._deleted = true;
+        } else {
+          obj.deleted = true;
+          obj.mtime = Date.now();
+          if (settings.deleteMetadataOfDeletedFiles) {
+            obj._deleted = true;
+          }
+        }
+        const r = await localDatabase.put(obj, { force: !revDeletion });
+        Logger(
+          `Entry removed: [${revDeletion ? "REV" : "DEL"}] ${path} (${obj._id.substring(0, 8)}-${r.rev})`
+        );
+        return true;
+      } else {
+        return false;
+      }
+    }) ?? false;
+  } catch (ex) {
+    if (isErrorOfMissingDoc(ex)) {
+      return false;
+    }
+    throw ex;
+  }
+}
+export {
+  canUseOnDemandChunking,
+  computeChunkRetrievalMethod,
+  createChunks,
+  deleteDBEntryByPath,
+  getDBEntryByPath,
+  getDBEntryFromMeta,
+  getDBEntryMetaByPath,
+  isLegacyNote,
+  isTargetFile,
+  prepareChunk,
+  putDBEntry
+};