@vrtmrz/livesync-commonlib 0.1.0-rc.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022 vorotamoroz
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,49 @@
+# Self-hosted LiveSync Commonlib
+
+Commonlib provides the shared data, storage, and replication primitives used by Self-hosted LiveSync, its CLI, Webapp, and WebPeer.
+
+The package is pre-1.0. Pin an exact reviewed version, and treat `compat/*` subpaths as migration-only interfaces. A source-directory import, Git submodule, or consumer-defined TypeScript alias is not a supported package boundary.
+
+## Package entry points
+
+- `@vrtmrz/livesync-commonlib` contains the deliberately small root API.
+- `@vrtmrz/livesync-commonlib/context` contains host-context and translation injection contracts.
+- `@vrtmrz/livesync-commonlib/browser` contains browser-only adapters, including rooted File System Access API storage.
+- `@vrtmrz/livesync-commonlib/node` contains Node-only capabilities and rooted storage.
+- `@vrtmrz/livesync-commonlib/rpc` contains the focused RPC API.
+- `@vrtmrz/livesync-commonlib/compat/*` contains temporary explicit exports required by existing Self-hosted LiveSync consumers.
+
+Import only the entry point required by the current runtime. Browser code must not import the Node entry.
+
+## Rooted storage
+
+Both platform storage factories receive an existing root from the host. They never select a directory, request browser permission, infer a process directory, or persist a handle.
+
+```ts
+import { createFileSystemAccessStorage } from '@vrtmrz/livesync-commonlib/browser';
+
+declare const authorisedRoot: FileSystemDirectoryHandle;
+const storage = createFileSystemAccessStorage({ rootHandle: authorisedRoot });
+await storage.write('notes/example.md', '# Example');
+```
+
+```ts
+import { createNodeStorage } from '@vrtmrz/livesync-commonlib/node';
+
+const storage = createNodeStorage({ rootPath: '/srv/livesync' });
+await storage.write('notes/example.md', '# Example');
+```
+
+See [the platform storage contract](docs/platform-storage.md) for path, ownership, and permission details.
+
+## API status
+
+The package is currently an infrastructure and compatibility boundary. `DirectFileManipulator` is useful for existing integrations, but its enumeration, watch ownership, failure, conflict, concurrency, and disposal semantics are not yet a stable high-level SDK contract.
+
+TODO: define and document the first high-level client façade before declaring list, get, put, delete, watch, and close behaviour stable.
+
+Development and package validation are documented in [the developer guide](docs/development.md).
+
+## Licence
+
+MIT

package/dist/API/DirectFileManipulator.d.ts

@@ -0,0 +1,2 @@
+export { DirectFileManipulator } from "./DirectFileManipulatorV2.js";
+export type { DirectFileManipulatorOptions } from "./DirectFileManipulatorV2.js";

package/dist/API/DirectFileManipulator.js

@@ -0,0 +1,4 @@
+import { DirectFileManipulator } from "./DirectFileManipulatorV2.js";
+export {
+  DirectFileManipulator
+};

package/dist/API/DirectFileManipulatorV2.d.ts

@@ -0,0 +1,150 @@
+/**
+ * The API for manipulating files stored in the CouchDB by Self-hosted LiveSync or its families.
+ */
+import { type DocumentID, type FilePathWithPrefix, type EntryHasPath, type FilePath, type EntryDoc, type NewEntry, type PlainEntry, type LoadedEntry, type HashAlgorithm, type RemoteDBSettings, type ChunkSplitterVersion, type SyncParameters, type E2EEAlgorithm } from "../common/types.js";
+import { LiveSyncLocalDB, type LiveSyncLocalDBEnv } from "../pouchdb/LiveSyncLocalDB.js";
+import { HeadlessServiceHub } from "../services/HeadlessServices.js";
+import { HeadlessDatabaseService } from "../services/implements/headless/HeadlessDatabaseService.js";
+import { ServiceContext } from "../services/base/ServiceBase.js";
+export type DirectFileManipulatorOptions = {
+    url: string;
+    username: string;
+    password: string;
+    passphrase: string | undefined;
+    database: string;
+    obfuscatePassphrase: string | undefined;
+    useDynamicIterationCount?: boolean;
+    customChunkSize?: number;
+    minimumChunkSize?: number;
+    hashAlg?: HashAlgorithm;
+    useEden?: boolean;
+    maxChunksInEden?: number;
+    maxTotalLengthInEden?: number;
+    maxAgeInEden?: number;
+    /**
+     * @deprecated use chunkSplitterVersion instead.
+     */
+    enableChunkSplitterV2?: boolean;
+    enableCompression?: boolean;
+    handleFilenameCaseSensitive?: boolean;
+    doNotUseFixedRevisionForChunks?: boolean;
+    chunkSplitterVersion?: ChunkSplitterVersion;
+    E2EEAlgorithm?: E2EEAlgorithm;
+};
+export type ReadyEntry = (NewEntry | PlainEntry) & {
+    data: string[];
+};
+export type MetaEntry = (NewEntry | PlainEntry) & {
+    children: string[];
+};
+export type FileInfo = {
+    ctime: number;
+    mtime: number;
+    size: number;
+};
+export type EnumerateConditions = {
+    startKey?: string;
+    endKey?: string;
+    ids?: string[];
+    metaOnly: boolean;
+};
+export declare class DirectFileManipulator implements LiveSyncLocalDBEnv {
+    liveSyncLocalDB: LiveSyncLocalDB;
+    options: DirectFileManipulatorOptions;
+    ready: {
+        promise: Promise<void>;
+        resolve: (value: void | PromiseLike<void>) => void;
+        reject: (reason?: any) => void;
+    };
+    services: HeadlessServiceHub<ServiceContext>;
+    init(): Promise<void>;
+    getBoundDatabaseService(options: () => DirectFileManipulatorOptions): typeof HeadlessDatabaseService;
+    constructor(options: DirectFileManipulatorOptions);
+    $$id2path(id: DocumentID, entry?: EntryHasPath, stripPrefix?: boolean): FilePathWithPrefix;
+    $$path2id(filename: FilePathWithPrefix | FilePath, prefix?: string): Promise<DocumentID>;
+    getInitialSyncParameters(setting: RemoteDBSettings): Promise<SyncParameters>;
+    getSyncParameters(setting: RemoteDBSettings): Promise<SyncParameters>;
+    putSyncParameters(setting: RemoteDBSettings, params: SyncParameters): Promise<boolean>;
+    getReplicationPBKDF2Salt(setting: RemoteDBSettings, refresh?: boolean): Promise<Uint8Array<ArrayBuffer>>;
+    $everyOnInitializeDatabase(db: LiveSyncLocalDB): Promise<boolean>;
+    getSettings(): RemoteDBSettings;
+    close(): Promise<void>;
+    path2id(filename: FilePathWithPrefix | FilePath, prefix?: string): Promise<DocumentID>;
+    get settings(): RemoteDBSettings;
+    /**
+     * Get specific document from the Remote Database by path.
+     * @param path
+     * @param metaOnly if it has been enabled, the note does not contains the content.
+     * @returns
+     */
+    get(path: FilePathWithPrefix, metaOnly?: boolean): Promise<false | LoadedEntry>;
+    /**
+     * Get specific document from the Remote Database by ID.
+     * @param path
+     * @param metaOnly if it has been enabled, the note does not contains the content.
+     * @returns
+     */
+    getById(id: string, metaOnly?: boolean): Promise<false | MetaEntry | ReadyEntry>;
+    getByMeta(doc: MetaEntry): Promise<ReadyEntry>;
+    rawGet<T>(id: DocumentID): Promise<false | T>;
+    /**
+     * Put a note to the remote database
+     * @param path
+     * @param data
+     * @param info
+     * @param type
+     * @returns
+     */
+    put(path: string, data: string[] | Blob, info: FileInfo, _type?: "newnote" | "plain"): Promise<boolean>;
+    delete(path: string): Promise<boolean>;
+    enumerate(_cond: EnumerateConditions): AsyncGenerator<never, void, unknown>;
+    _enumerate(startKey: string, endKey: string, opt: {
+        metaOnly: boolean;
+    }): AsyncGenerator<ReadyEntry, AsyncGenerator<(import("../common/types.js").DatabaseEntry & import("../common/types.js").EntryBase & import("../common/types.js").EntryWithEden & {
+        path: FilePathWithPrefix;
+        children: string[];
+        type: import("../common/models/db.type.js").EntryTypes["NOTE_BINARY"];
+    } & PouchDB.Core.AllDocsMeta & PouchDB.Core.IdMeta & PouchDB.Core.RevisionIdMeta) | (import("../common/types.js").DatabaseEntry & import("../common/types.js").EntryBase & import("../common/types.js").EntryWithEden & {
+        path: FilePathWithPrefix;
+        children: string[];
+        type: import("../common/models/db.type.js").EntryTypes["NOTE_PLAIN"];
+    } & PouchDB.Core.AllDocsMeta & PouchDB.Core.IdMeta & PouchDB.Core.RevisionIdMeta) | (import("../common/types.js").DatabaseEntry & import("../common/types.js").EntryBase & import("../common/types.js").EntryWithEden & {
+        path: FilePathWithPrefix;
+        children: string[];
+        type: import("../common/models/db.type.js").EntryTypes["NOTE_BINARY"];
+    } & {
+        deleted?: boolean;
+    } & PouchDB.Core.AllDocsMeta & PouchDB.Core.IdMeta & PouchDB.Core.RevisionIdMeta) | (import("../common/types.js").DatabaseEntry & import("../common/types.js").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.AllDocsMeta & PouchDB.Core.IdMeta & PouchDB.Core.RevisionIdMeta) | (import("../common/types.js").DatabaseEntry & import("../common/types.js").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.AllDocsMeta & PouchDB.Core.IdMeta & PouchDB.Core.RevisionIdMeta) | (import("../common/types.js").DatabaseEntry & import("../common/types.js").EntryBase & import("../common/types.js").EntryWithEden & {
+        path: FilePathWithPrefix;
+        children: string[];
+        type: import("../common/models/db.type.js").EntryTypes["NOTE_BINARY"];
+    } & {
+        deleted?: boolean;
+    } & {
+        data: string | string[];
+        datatype: import("../common/types.js").EntryTypeNotes;
+    } & PouchDB.Core.AllDocsMeta & PouchDB.Core.IdMeta & PouchDB.Core.RevisionIdMeta), void, unknown>, unknown>;
+    enumerateAllNormalDocs(opt: {
+        metaOnly: boolean;
+    }): AsyncGenerator<ReadyEntry, void, unknown>;
+    watching: boolean;
+    changes: PouchDB.Core.Changes<EntryDoc> | undefined;
+    since: string;
+    beginWatch(callback: (doc: ReadyEntry, seq?: string | number) => Promise<any> | void, checkIsInterested?: (doc: MetaEntry) => boolean): boolean;
+    endWatch(): void;
+    followUpdates(callback: (doc: ReadyEntry, seq?: string | number) => Promise<any> | void, checkIsInterested?: (doc: MetaEntry) => boolean): Promise<string | number>;
+}

package/dist/API/DirectFileManipulatorV2.js

@@ -0,0 +1,424 @@
+import {
+  DEFAULT_SETTINGS,
+  DEFAULT_SYNC_PARAMETERS,
+  ProtocolVersions,
+  DOCID_SYNC_PARAMETERS,
+  E2EEAlgorithms
+} from "../common/types.js";
+import { PouchDB } from "../pouchdb/pouchdb-http.js";
+import { LiveSyncLocalDB } from "../pouchdb/LiveSyncLocalDB.js";
+import { isErrorOfMissingDoc } from "../pouchdb/utils_couchdb.js";
+import { replicationFilter } from "../pouchdb/compress.js";
+import { disableEncryption } from "../pouchdb/encryption.js";
+import { enableEncryption } from "../pouchdb/encryption.js";
+import {
+  LEVEL_INFO,
+  LEVEL_VERBOSE,
+  LOG_LEVEL_INFO,
+  LOG_LEVEL_NOTICE,
+  LOG_LEVEL_VERBOSE,
+  Logger
+} from "octagonal-wheels/common/logger";
+import { createBlob, determineTypeFromBlob } from "../common/utils.js";
+import { promiseWithResolvers } from "octagonal-wheels/promises";
+import {
+  createSyncParamsHanderForServer,
+  SyncParamsFetchError,
+  SyncParamsNotFoundError,
+  SyncParamsUpdateError
+} from "../replication/SyncParamsHandler.js";
+import { HeadlessServiceHub } from "../services/HeadlessServices.js";
+import { HeadlessDatabaseService } from "../services/implements/headless/HeadlessDatabaseService.js";
+import { ServiceContext } from "../services/base/ServiceBase.js";
+import { compatGlobal } from "../common/coreEnvFunctions.js";
+function isNoteEntry(doc) {
+  if (!doc) return false;
+  return doc.type == "newnote" || doc.type == "plain";
+}
+function isReadyEntry(doc) {
+  if (!doc) return false;
+  return "data" in doc;
+}
+class DirectFileManipulator {
+  liveSyncLocalDB;
+  options;
+  ready = promiseWithResolvers();
+  services;
+  async init() {
+    await this.services.appLifecycle.onReady();
+    await this.liveSyncLocalDB.initializeDatabase();
+    this.ready.resolve();
+    this.liveSyncLocalDB.refreshSettings();
+  }
+  getBoundDatabaseService(options) {
+    const _option = options;
+    return class HeadlessDatabaseServiceExt extends HeadlessDatabaseService {
+      createPouchDBInstance(_name, _options) {
+        const option = _option();
+        return new PouchDB(option.url + "/" + option.database, {
+          auth: { username: option.username, password: option.password }
+        });
+      }
+    };
+  }
+  constructor(options) {
+    this.options = options;
+    const getSettings = () => this.settings;
+    const context = new ServiceContext();
+    this.services = new HeadlessServiceHub(context, {
+      pouchDB: PouchDB,
+      database: this.getBoundDatabaseService(() => this.options)
+    });
+    this.services.setting.saveData.setHandler((data) => {
+      console.warn("Saving settings is not supported in DirectFileManipulator.");
+      return Promise.resolve();
+    });
+    this.services.setting.loadData.setHandler(() => {
+      console.warn("Loading settings is not supported in DirectFileManipulator.");
+      return Promise.resolve(getSettings());
+    });
+    this.services.databaseEvents.onDatabaseInitialisation.addHandler(this.$everyOnInitializeDatabase.bind(this));
+    this.liveSyncLocalDB = new LiveSyncLocalDB(this.options.url, this);
+    void this.init();
+  }
+  $$id2path(id, entry, stripPrefix) {
+    return this.services.path.id2path(id, entry, stripPrefix);
+  }
+  async $$path2id(filename, prefix) {
+    return await this.services.path.path2id(filename, prefix);
+  }
+  // $$createPouchDBInstance<T extends object>(
+  //     _name?: string,
+  //     _options?: PouchDB.Configuration.DatabaseConfiguration
+  // ): PouchDB.Database<T> {
+  //     return new PouchDB(this.options.url + "/" + this.options.database, {
+  //         auth: { username: this.options.username, password: this.options.password },
+  //     });
+  // }
+  getInitialSyncParameters(setting) {
+    return Promise.resolve({
+      ...DEFAULT_SYNC_PARAMETERS,
+      protocolVersion: ProtocolVersions.ADVANCED_E2EE
+    });
+  }
+  async getSyncParameters(setting) {
+    try {
+      const downloadedSyncParams = await this.rawGet(DOCID_SYNC_PARAMETERS);
+      if (!downloadedSyncParams) {
+        throw new SyncParamsNotFoundError(`Sync parameters have not been found in the database.`);
+      }
+      return downloadedSyncParams;
+    } catch (ex) {
+      Logger(`Could not retrieve remote sync parameters`, LOG_LEVEL_INFO);
+      throw SyncParamsFetchError.fromError(ex);
+    }
+  }
+  async putSyncParameters(setting, params) {
+    try {
+      const ret = await this.liveSyncLocalDB.putRaw(params);
+      if (ret.ok) {
+        return true;
+      }
+      throw new SyncParamsUpdateError(`Could not store remote sync parameters`);
+    } catch (ex) {
+      Logger(`Could not store remote sync parameters`, LOG_LEVEL_INFO);
+      throw SyncParamsUpdateError.fromError(ex);
+    }
+  }
+  async getReplicationPBKDF2Salt(setting, refresh) {
+    const server = `${setting.couchDB_URI.replace(/\/+$/, "")}/${setting.couchDB_DBNAME}`;
+    const manager = createSyncParamsHanderForServer(server, {
+      put: (params) => this.putSyncParameters(setting, params),
+      get: () => this.getSyncParameters(setting),
+      create: () => this.getInitialSyncParameters(setting)
+    });
+    return await manager.getPBKDF2Salt(refresh);
+  }
+  $everyOnInitializeDatabase(db) {
+    replicationFilter(db.localDatabase, this.options.enableCompression ?? false);
+    disableEncryption();
+    if (this.options.passphrase && typeof this.options.passphrase === "string") {
+      enableEncryption(
+        db.localDatabase,
+        this.options.passphrase,
+        this.options.useDynamicIterationCount ?? false,
+        false,
+        async () => await this.getReplicationPBKDF2Salt(this.getSettings()),
+        this.options.E2EEAlgorithm ?? E2EEAlgorithms.V2
+      );
+    }
+    return Promise.resolve(true);
+  }
+  getSettings() {
+    return this.settings;
+  }
+  async close() {
+    await this.liveSyncLocalDB.close();
+    return this.liveSyncLocalDB.onunload();
+  }
+  async path2id(filename, prefix) {
+    return await this.services.path.path2id(filename, prefix);
+  }
+  get settings() {
+    const retObj = {
+      ...DEFAULT_SETTINGS,
+      ...{
+        minimumChunkSize: this.options.minimumChunkSize ?? DEFAULT_SETTINGS.minimumChunkSize,
+        encrypt: this.options.passphrase ? true : false,
+        passphrase: this.options.passphrase ?? "",
+        deleteMetadataOfDeletedFiles: DEFAULT_SETTINGS.deleteMetadataOfDeletedFiles,
+        customChunkSize: this.options.customChunkSize ?? DEFAULT_SETTINGS.customChunkSize,
+        doNotPaceReplication: DEFAULT_SETTINGS.doNotPaceReplication,
+        hashAlg: this.options.hashAlg ?? DEFAULT_SETTINGS.hashAlg,
+        useEden: this.options.useEden ?? DEFAULT_SETTINGS.useEden,
+        maxChunksInEden: this.options.maxChunksInEden ?? DEFAULT_SETTINGS.maxChunksInEden,
+        maxTotalLengthInEden: this.options.maxTotalLengthInEden ?? DEFAULT_SETTINGS.maxTotalLengthInEden,
+        maxAgeInEden: this.options.maxAgeInEden ?? DEFAULT_SETTINGS.maxAgeInEden,
+        enableChunkSplitterV2: this.options.enableChunkSplitterV2 ?? DEFAULT_SETTINGS.enableChunkSplitterV2,
+        chunkSplitterVersion: this.options.chunkSplitterVersion ?? DEFAULT_SETTINGS.chunkSplitterVersion,
+        disableWorkerForGeneratingChunks: true,
+        processSmallFilesInUIThread: true,
+        doNotUseFixedRevisionForChunks: this.options.doNotUseFixedRevisionForChunks ?? DEFAULT_SETTINGS.doNotUseFixedRevisionForChunks,
+        couchDB_URI: this.options.url,
+        couchDB_DBNAME: this.options.database,
+        couchDB_USER: this.options.username,
+        couchDB_PASSWORD: this.options.password,
+        accessKey: "",
+        secretKey: "",
+        bucket: "",
+        region: "",
+        endpoint: "",
+        enableCompression: this.options.enableCompression ?? DEFAULT_SETTINGS.enableCompression,
+        handleFilenameCaseSensitive: this.options.handleFilenameCaseSensitive ?? DEFAULT_SETTINGS.handleFilenameCaseSensitive,
+        E2EEAlgorithm: this.options.E2EEAlgorithm ?? E2EEAlgorithms.V2
+      }
+    };
+    return retObj;
+  }
+  /**
+   * Get specific document from the Remote Database by path.
+   * @param path
+   * @param metaOnly if it has been enabled, the note does not contains the content.
+   * @returns
+   */
+  async get(path, metaOnly = false) {
+    if (metaOnly) {
+      return await this.liveSyncLocalDB.getDBEntryMeta(path);
+    } else {
+      return await this.liveSyncLocalDB.getDBEntry(path);
+    }
+  }
+  /**
+   * Get specific document from the Remote Database by ID.
+   * @param path
+   * @param metaOnly if it has been enabled, the note does not contains the content.
+   * @returns
+   */
+  async getById(id, metaOnly = false) {
+    const meta = await this.liveSyncLocalDB.getRaw(id);
+    if (!isNoteEntry(meta)) return false;
+    if (metaOnly) {
+      return meta;
+    }
+    return this.getByMeta(meta);
+  }
+  async getByMeta(doc) {
+    const docX = await this.liveSyncLocalDB.getDBEntryFromMeta(doc);
+    if (!isReadyEntry(docX)) {
+      throw new Error(`Corrupted document: ${doc.path}`);
+    }
+    return docX;
+  }
+  async rawGet(id) {
+    try {
+      const doc = await this.liveSyncLocalDB.getRaw(id);
+      return doc;
+    } catch (ex) {
+      if (isErrorOfMissingDoc(ex)) {
+        return false;
+      }
+      throw ex;
+    }
+  }
+  /**
+   * Put a note to the remote database
+   * @param path
+   * @param data
+   * @param info
+   * @param type
+   * @returns
+   */
+  async put(path, data, info, _type = "plain") {
+    const id = await this.path2id(path);
+    const saveData = data instanceof Blob ? data : createBlob(data);
+    const datatype = determineTypeFromBlob(saveData);
+    const putDoc = {
+      _id: id,
+      path,
+      data: saveData,
+      ctime: info.ctime,
+      mtime: info.mtime,
+      size: info.size,
+      type: datatype,
+      eden: {},
+      children: [],
+      datatype
+    };
+    Logger(`PUT: UPLOADING: ${path}`, LOG_LEVEL_VERBOSE);
+    const ret = await this.liveSyncLocalDB.putDBEntry(putDoc);
+    if (ret) {
+      Logger(`PUT: DONE: ${path}`, LOG_LEVEL_INFO);
+      return true;
+    } else {
+      Logger(`PUT: FAILED: ${path}`, LOG_LEVEL_NOTICE);
+      return false;
+    }
+  }
+  async delete(path) {
+    Logger(`DELETE: START: ${path}`, LOG_LEVEL_VERBOSE);
+    const ret = await this.liveSyncLocalDB.deleteDBEntry(path);
+    if (ret) {
+      Logger(`DELETE: DONE: ${path}`, LOG_LEVEL_INFO);
+      return true;
+    } else {
+      Logger(`DELETE: FAILED: ${path}`, LOG_LEVEL_INFO);
+      return false;
+    }
+  }
+  // Untested
+  async *enumerate(_cond) {
+  }
+  async *_enumerate(startKey, endKey, opt) {
+    if (opt.metaOnly) return this.liveSyncLocalDB.findEntries(startKey, endKey, {});
+    for await (const f of this.liveSyncLocalDB.findEntries(startKey, endKey, {})) {
+      yield await this.getByMeta(f);
+    }
+  }
+  async *enumerateAllNormalDocs(opt) {
+    const targets = [
+      this._enumerate("", "h:", opt),
+      this._enumerate(`h:\u{10FFFF}`, "i:", opt),
+      this._enumerate(`i:\u{10FFFF}`, "ix:", opt),
+      this._enumerate(`ix:\u{10FFFF}`, "ps:", opt),
+      this._enumerate(`ps:\u{10FFFF}`, "\u{10FFFF}", opt)
+    ];
+    for (const target of targets) {
+      for await (const f of target) {
+        yield f;
+      }
+    }
+  }
+  watching = false;
+  // _abortController?: AbortController;
+  changes;
+  since = "";
+  beginWatch(callback, checkIsInterested) {
+    if (this.watching) return false;
+    this.watching = true;
+    this.changes = this.liveSyncLocalDB.localDatabase.changes({
+      include_docs: true,
+      since: this.since,
+      selector: {
+        type: { $ne: "leaf" }
+      },
+      live: true
+    }).on("change", async (change) => {
+      const doc = change.doc;
+      if (!doc) {
+        return;
+      }
+      if (!isNoteEntry(doc)) {
+        return;
+      }
+      if (checkIsInterested) {
+        if (!checkIsInterested(doc)) {
+          Logger(`WATCH: SKIP ${doc.path}: OUT OF TARGET FOLDER`, LOG_LEVEL_VERBOSE, "watch");
+          return;
+        }
+      }
+      Logger(`WATCH: PROCESSING: ${doc.path}`, LEVEL_VERBOSE, "watch");
+      const docX = await this.getByMeta(doc);
+      try {
+        await callback(docX, change.seq);
+        Logger(`WATCH: PROCESS DONE: ${doc.path}`, LEVEL_INFO, "watch");
+      } catch (ex) {
+        Logger(`WATCH: PROCESS FAILED`, LEVEL_INFO, "watch");
+        Logger(ex, LEVEL_VERBOSE, "watch");
+      }
+    }).on("complete", () => {
+      Logger(`WATCH: FINISHED`, LEVEL_INFO, "watch");
+      this.watching = false;
+      this.changes = void 0;
+    }).on("error", (err) => {
+      Logger(`WATCH: ERROR: `, LEVEL_INFO, "watch");
+      Logger(err, LEVEL_VERBOSE, "watch");
+      if (this.watching) {
+        Logger(`WATCH: CONNECTION HAS BEEN CLOSED, RECONNECTING...`, LEVEL_INFO, "watch");
+        this.watching = false;
+        this.changes = void 0;
+        compatGlobal.setTimeout(() => {
+          this.beginWatch(callback, checkIsInterested);
+        }, 1e4);
+      } else {
+        Logger(`WATCH: CONNECTION HAS BEEN CLOSED.`, LEVEL_INFO, "watch");
+      }
+    });
+  }
+  endWatch() {
+    if (this.changes) {
+      Logger(`WATCH: CANCELLING PROCESS.`, LEVEL_INFO, "watch");
+      this.changes.cancel();
+      Logger(`WATCH: CANCELLING SIGNAL HAS BEEN SENT.`, LEVEL_INFO, "watch");
+    }
+  }
+  async followUpdates(callback, checkIsInterested) {
+    try {
+      if (this.since == "") {
+        this.since = "0";
+      }
+      Logger(`FOLLOW: START: (since:${this.since})`, LEVEL_INFO, "followUpdates");
+      const last = await this.liveSyncLocalDB.localDatabase.changes({
+        include_docs: true,
+        since: this.since,
+        filter: "replicate/pull",
+        live: false
+      }).on("change", async (change) => {
+        const doc = change.doc;
+        if (!doc) {
+          return;
+        }
+        if (!isNoteEntry(doc)) {
+          return;
+        }
+        if (checkIsInterested) {
+          if (!checkIsInterested(doc)) {
+            Logger(`FOLLOW: SKIP ${doc._id}: OUT OF TARGET FOLDER`, LOG_LEVEL_VERBOSE, "watch");
+            return;
+          }
+        }
+        Logger(`FOLLOW: PROCESSING: ${doc.path}`, LEVEL_VERBOSE, "watch");
+        const docX = await this.getByMeta(doc);
+        try {
+          await callback(docX, change.seq);
+          Logger(`FOLLOW: PROCESS DONE: ${doc.path}`, LEVEL_INFO, "watch");
+        } catch (ex) {
+          Logger(`FOLLOW: PROCESS FAILED`, LEVEL_INFO, "watch");
+          Logger(ex, LEVEL_VERBOSE, "watch");
+        }
+      }).on("complete", () => {
+        Logger(`FOLLOW: FINISHED AT ${this.since}`, LEVEL_INFO, "watch");
+        this.watching = false;
+        this.changes = void 0;
+      }).on("error", (err) => {
+        Logger(`FOLLOW: ERROR at ${this.since}: ${err}`, LEVEL_INFO, "watch");
+      });
+      return last.last_seq;
+    } catch (e) {
+      Logger(`FOLLOW: ERROR: ${e}`, LEVEL_INFO, "watch");
+    }
+    return this.since;
+  }
+}
+export {
+  DirectFileManipulator
+};