@vrtmrz/livesync-commonlib 0.1.0-rc.0

package/dist/pouchdb/LiveSyncDBFunctions.js

@@ -0,0 +1,129 @@
+import {
+  MILESTONE_DOCID as MILESTONE_DOC_ID,
+  TweakValuesShouldMatchedTemplate,
+  TweakValuesTemplate,
+  DEVICE_ID_PREFERRED,
+  TweakValuesDefault
+} from "../common/types.js";
+import { extractObject, isObjectDifferent, resolveWithIgnoreKnownError } from "../common/utils.js";
+async function ensureRemoteIsCompatible(infoSrc, setting, deviceNodeID, currentVersionRange, nodeDeviceInfo, updateCallback) {
+  const now = Date.now();
+  const baseMilestone = {
+    _id: MILESTONE_DOC_ID,
+    type: "milestoneinfo",
+    created: now,
+    locked: false,
+    accepted_nodes: [deviceNodeID],
+    node_chunk_info: { [deviceNodeID]: currentVersionRange },
+    node_info: {
+      [deviceNodeID]: {
+        ...nodeDeviceInfo,
+        last_connected: 0,
+        progress: ""
+      }
+    },
+    tweak_values: {}
+  };
+  let remoteMilestone = infoSrc;
+  if (!remoteMilestone) remoteMilestone = baseMilestone;
+  const currentTweakValues = extractObject(TweakValuesTemplate, setting);
+  remoteMilestone.node_chunk_info = { ...baseMilestone.node_chunk_info, ...remoteMilestone.node_chunk_info };
+  let writeMilestone = remoteMilestone.node_chunk_info[deviceNodeID].min != currentVersionRange.min || remoteMilestone.node_chunk_info[deviceNodeID].max != currentVersionRange.max || isObjectDifferent(remoteMilestone.tweak_values?.[deviceNodeID], currentTweakValues) || typeof remoteMilestone._rev == "undefined" || !(DEVICE_ID_PREFERRED in remoteMilestone.tweak_values);
+  if (!remoteMilestone.node_info) {
+    remoteMilestone.node_info = {};
+  }
+  if (!(deviceNodeID in remoteMilestone.node_info)) {
+    remoteMilestone.node_info[deviceNodeID] = {
+      ...nodeDeviceInfo,
+      last_connected: 0,
+      progress: ""
+    };
+    writeMilestone = true;
+  }
+  const info = remoteMilestone.node_info[deviceNodeID];
+  const keys = ["device_name", "app_version", "plugin_version", "vault_name", "progress"];
+  for (const key of keys) {
+    if (info[key] != nodeDeviceInfo[key]) {
+      remoteMilestone.node_info[deviceNodeID][key] = nodeDeviceInfo[key];
+      writeMilestone = true;
+    }
+  }
+  const diffLastConnected = now - (remoteMilestone.node_info[deviceNodeID].last_connected || 0);
+  if (diffLastConnected > 6e4) {
+    remoteMilestone.node_info[deviceNodeID].last_connected = now;
+    writeMilestone = true;
+  }
+  if (writeMilestone) {
+    remoteMilestone.node_chunk_info[deviceNodeID].min = currentVersionRange.min;
+    remoteMilestone.node_chunk_info[deviceNodeID].max = currentVersionRange.max;
+    remoteMilestone.tweak_values = { ...remoteMilestone.tweak_values ?? {}, [deviceNodeID]: currentTweakValues };
+    if (!(DEVICE_ID_PREFERRED in remoteMilestone.tweak_values)) {
+      remoteMilestone.tweak_values[DEVICE_ID_PREFERRED] = currentTweakValues;
+    }
+    await updateCallback(remoteMilestone);
+  }
+  let globalMin = currentVersionRange.min;
+  let globalMax = currentVersionRange.max;
+  for (const nodeId of remoteMilestone.accepted_nodes) {
+    if (nodeId == deviceNodeID) continue;
+    if (nodeId in remoteMilestone.node_chunk_info) {
+      const nodeInfo = remoteMilestone.node_chunk_info[nodeId];
+      globalMin = Math.max(nodeInfo.min, globalMin);
+      globalMax = Math.min(nodeInfo.max, globalMax);
+    } else {
+      globalMin = 0;
+      globalMax = 0;
+    }
+  }
+  if (globalMax < globalMin) {
+    if (!setting.ignoreVersionCheck) {
+      return "INCOMPATIBLE";
+    }
+  }
+  if (!setting.disableCheckingConfigMismatch) {
+    const preferred_tweak = remoteMilestone.tweak_values?.[DEVICE_ID_PREFERRED] ?? currentTweakValues;
+    const current_tweak = currentTweakValues;
+    const preferred_should_matched = extractObject(TweakValuesShouldMatchedTemplate, {
+      ...TweakValuesDefault,
+      ...preferred_tweak
+    });
+    const current_should_matched = extractObject(TweakValuesShouldMatchedTemplate, {
+      ...TweakValuesDefault,
+      ...current_tweak
+    });
+    if (isObjectDifferent(preferred_should_matched, current_should_matched, true)) {
+      return ["MISMATCHED", preferred_tweak];
+    }
+  }
+  if (remoteMilestone.locked) {
+    if (remoteMilestone.accepted_nodes.indexOf(deviceNodeID) == -1) {
+      if (remoteMilestone.cleaned) {
+        return "NODE_CLEANED";
+      }
+      return "NODE_LOCKED";
+    }
+    return "LOCKED";
+  }
+  return "OK";
+}
+async function ensureDatabaseIsCompatible(db, setting, deviceNodeID, currentVersionRange, nodeDeviceInfo) {
+  const remoteMilestone = await resolveWithIgnoreKnownError(
+    db.get(MILESTONE_DOC_ID),
+    false
+  );
+  const ret = await ensureRemoteIsCompatible(
+    remoteMilestone,
+    setting,
+    deviceNodeID,
+    currentVersionRange,
+    nodeDeviceInfo,
+    async (info) => {
+      await db.put(info);
+    }
+  );
+  return ret;
+}
+export {
+  ensureDatabaseIsCompatible,
+  ensureRemoteIsCompatible
+};

package/dist/pouchdb/LiveSyncLocalDB.d.ts

@@ -0,0 +1,196 @@
+import { type EntryDoc, type EntryLeaf, type Credential, type RemoteDBSettings, type DocumentID, type FilePathWithPrefix, type FilePath, type DatabaseEntry, type LoadedEntry, type MetaEntry, type SavingEntry, type diff_result_leaf } from "../common/types.js";
+import type { LiveSyncEventHub } from "../hub/hub.js";
+import { LiveSyncManagers } from "../managers/LiveSyncManagers.js";
+import type { AutoMergeResult } from "../managers/ConflictManager.js";
+import type { IServiceHub } from "../services/base/IService.js";
+import type { ServiceContext } from "../services/base/ServiceBase.js";
+import { type LogFunction } from "../services/lib/logUtils.js";
+export declare const REMOTE_CHUNK_FETCHED = "remote-chunk-fetched";
+export type REMOTE_CHUNK_FETCHED = typeof REMOTE_CHUNK_FETCHED;
+declare global {
+    interface LSEvents {
+        [REMOTE_CHUNK_FETCHED]: EntryLeaf;
+    }
+}
+export type ChunkRetrievalResultSuccess = {
+    _id: DocumentID;
+    data: string;
+    type: "leaf";
+};
+export type ChunkRetrievalResultError = {
+    _id: DocumentID;
+    error: string;
+};
+export type ChunkRetrievalResult = ChunkRetrievalResultSuccess | ChunkRetrievalResultError;
+export interface LiveSyncLocalDBEnv {
+    services: Pick<IServiceHub, "API" | "database" | "databaseEvents" | "replicator" | "setting" | "path"> & {
+        context: ServiceContext;
+    };
+}
+export declare function getNoFromRev(rev: string): number;
+export type GeneratedChunk = {
+    isNew: boolean;
+    id: DocumentID;
+    piece: string;
+};
+export declare class LiveSyncLocalDB {
+    auth: Credential;
+    dbname: string;
+    settings: RemoteDBSettings;
+    localDatabase: PouchDB.Database<EntryDoc>;
+    _log: LogFunction;
+    private _managers?;
+    get managers(): LiveSyncManagers;
+    isReady: boolean;
+    needScanning: boolean;
+    env: LiveSyncLocalDBEnv;
+    clearCaches(): void;
+    _prepareHashFunctions(): Promise<void>;
+    onunload(): void;
+    refreshSettings(): void;
+    offRemoteChunkFetchedHandler?: ReturnType<LiveSyncEventHub["onEvent"]>;
+    constructor(dbname: string, env: LiveSyncLocalDBEnv);
+    close(): Promise<void>;
+    onNewLeaf(chunk: EntryLeaf): void;
+    initializeDatabase(): Promise<boolean>;
+    /**
+     * Retrieve all used and existing chunks in the database.
+     * @param includeDeleted  include deleted chunks in the result.
+     * @returns {used: Set<string>, existing: Map<string, EntryLeaf>} used: Set of chunk ids that are used in the database. existing: Map of chunk id and EntryLeaf that are existing in the database.
+     */
+    allChunks(includeDeleted?: boolean): Promise<{
+        used: Set<string>;
+        existing: Map<string, EntryLeaf>;
+    }>;
+    resetDatabase(): Promise<boolean>;
+    findEntries(startKey: string, endKey: string, opt: PouchDB.Core.AllDocsWithKeyOptions | PouchDB.Core.AllDocsOptions | PouchDB.Core.AllDocsWithKeysOptions | PouchDB.Core.AllDocsWithinRangeOptions): AsyncGenerator<(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) | (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) | (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) | (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) | (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) | (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>;
+    findAllDocs(opt?: PouchDB.Core.AllDocsWithKeyOptions | PouchDB.Core.AllDocsOptions | PouchDB.Core.AllDocsWithKeysOptions | PouchDB.Core.AllDocsWithinRangeOptions): AsyncGenerator<(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) | (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) | (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) | (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) | (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) | (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>;
+    findEntryNames(startKey: string, endKey: string, opt: PouchDB.Core.AllDocsWithKeyOptions | PouchDB.Core.AllDocsOptions | PouchDB.Core.AllDocsWithKeysOptions | PouchDB.Core.AllDocsWithinRangeOptions): AsyncGenerator<string, void, unknown>;
+    findAllDocNames(opt?: PouchDB.Core.AllDocsWithKeyOptions | PouchDB.Core.AllDocsOptions | PouchDB.Core.AllDocsWithKeysOptions | PouchDB.Core.AllDocsWithinRangeOptions): AsyncGenerator<string, void, unknown>;
+    findAllNormalDocs(opt?: PouchDB.Core.AllDocsWithKeyOptions | PouchDB.Core.AllDocsOptions | PouchDB.Core.AllDocsWithKeysOptions | PouchDB.Core.AllDocsWithinRangeOptions): AsyncGenerator<(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) | (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) | (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) | (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) | (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) | (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>;
+    removeRevision(docId: DocumentID, revision: string): Promise<boolean>;
+    getRaw<T extends EntryDoc>(docId: DocumentID, options?: PouchDB.Core.GetOptions): Promise<T & PouchDB.Core.IdMeta & PouchDB.Core.GetMeta>;
+    removeRaw(docId: DocumentID, revision: string, options?: PouchDB.Core.Options): Promise<PouchDB.Core.Response>;
+    putRaw<T extends EntryDoc>(doc: T, options?: PouchDB.Core.PutOptions): Promise<PouchDB.Core.Response>;
+    allDocsRaw<T extends EntryDoc | DatabaseEntry>(options?: PouchDB.Core.AllDocsWithKeyOptions | PouchDB.Core.AllDocsWithKeysOptions | PouchDB.Core.AllDocsWithinRangeOptions | PouchDB.Core.AllDocsOptions): Promise<PouchDB.Core.AllDocsResponse<T>>;
+    bulkDocsRaw<T extends EntryDoc>(docs: Array<PouchDB.Core.PutDocument<T>>, options?: PouchDB.Core.BulkDocsOptions): Promise<Array<PouchDB.Core.Response | PouchDB.Core.Error>>;
+    isTargetFile(filenameSrc: string): boolean;
+    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>;
+    getConflictedDoc(path: FilePathWithPrefix, rev: string): Promise<false | diff_result_leaf>;
+    tryAutoMerge(path: FilePathWithPrefix, enableMarkdownAutoMerge: boolean): AutoMergeResult;
+}