@vrtmrz/livesync-commonlib 0.1.0-rc.0

package/dist/serviceModules/FileAccessBase.d.ts

@@ -0,0 +1,93 @@
+import type { FilePath, UXDataWriteOptions, UXFileInfoStub, UXFolderInfo } from "../common/types.js";
+import type { IStorageAccessManager } from "../interfaces/StorageAccess.js";
+import type { IAPIService, IPathService, ISettingService, IVaultService } from "../services/base/IService.js";
+import { createInstanceLogFunction } from "../services/lib/logUtils.js";
+import type { FileWithFileStat } from "../common/models/fileaccess.type.js";
+import type { IFileSystemAdapter } from "./adapters/index.js";
+export declare function toArrayBuffer(arr: Uint8Array<ArrayBuffer> | ArrayBuffer | DataView<ArrayBuffer>): ArrayBuffer;
+export interface FileAccessBaseDependencies {
+    vaultService: IVaultService;
+    storageAccessManager: IStorageAccessManager;
+    settingService: ISettingService;
+    pathService: IPathService;
+    APIService: IAPIService;
+}
+/**
+ * Type helper to extract the abstract file type from a file system adapter
+ */
+export type ExtractAbstractFile<T> = T extends IFileSystemAdapter<infer A, any, any, any> ? A : never;
+/**
+ * Type helper to extract the file type from a file system adapter
+ */
+export type ExtractFile<T> = T extends IFileSystemAdapter<any, infer F, any, any> ? F : never;
+/**
+ * Type helper to extract the folder type from a file system adapter
+ */
+export type ExtractFolder<T> = T extends IFileSystemAdapter<any, any, infer D, any> ? D : never;
+/**
+ * Type helper to extract the stat type from a file system adapter
+ */
+export type ExtractStat<T> = T extends IFileSystemAdapter<any, any, any, infer S> ? S : never;
+/**
+ * Base class for file access operations
+ * Uses adapter pattern for platform-specific implementations
+ *
+ * @template TAdapter - The file system adapter type, which determines all native file types
+ */
+export declare class FileAccessBase<TAdapter extends IFileSystemAdapter<any, any, any, any>> {
+    protected storageAccessManager: IStorageAccessManager;
+    protected vaultService: IVaultService;
+    protected settingService: ISettingService;
+    protected APIService: IAPIService;
+    protected path: IPathService;
+    protected adapter: TAdapter;
+    _log: ReturnType<typeof createInstanceLogFunction>;
+    constructor(adapter: TAdapter, dependencies: FileAccessBaseDependencies);
+    isFile(file: UXFileInfoStub | ExtractAbstractFile<TAdapter> | FilePath | ExtractFolder<TAdapter> | ExtractFile<TAdapter> | null): file is ExtractFile<TAdapter>;
+    isFolder(item: UXFileInfoStub | ExtractAbstractFile<TAdapter> | FilePath | ExtractFolder<TAdapter> | ExtractFile<TAdapter> | null): item is ExtractFolder<TAdapter>;
+    getPath(file: ExtractAbstractFile<TAdapter> | string): FilePath;
+    nativeFileToUXFileInfoStub(file: ExtractFile<TAdapter>): UXFileInfoStub;
+    nativeFolderToUXFolder(file: ExtractFolder<TAdapter>): UXFolderInfo;
+    normalisePath(path: string): string;
+    protected _writeOp<T extends ExtractAbstractFile<TAdapter> | string, U>(file: T, callback: (path: FilePath, file: T) => Promise<U>): Promise<U>;
+    protected _readOp<T extends ExtractAbstractFile<TAdapter> | string, U>(file: T, callback: (path: FilePath, file: T) => Promise<U>): Promise<U>;
+    tryAdapterStat(file: ExtractFile<TAdapter> | string): Promise<any>;
+    adapterStat(file: ExtractFile<TAdapter> | string): Promise<ExtractStat<TAdapter> | null>;
+    adapterExists(file: ExtractFile<TAdapter> | string): Promise<boolean>;
+    adapterRemove(file: ExtractFile<TAdapter> | string): Promise<void>;
+    adapterRead(file: ExtractFile<TAdapter> | string): Promise<string>;
+    adapterReadBinary(file: ExtractFile<TAdapter> | string): Promise<ArrayBuffer>;
+    adapterReadAuto(file: ExtractFile<TAdapter> | string): Promise<string | ArrayBuffer>;
+    adapterWrite(file: ExtractFile<TAdapter> | string, data: string | ArrayBuffer | Uint8Array<ArrayBuffer>, options?: UXDataWriteOptions): Promise<void>;
+    adapterList(basePath: string): Promise<{
+        files: string[];
+        folders: string[];
+    }>;
+    vaultCacheRead(file: ExtractFile<TAdapter>): Promise<string>;
+    vaultRead(file: ExtractFile<TAdapter>): Promise<string>;
+    vaultReadBinary(file: ExtractFile<TAdapter>): Promise<ArrayBuffer>;
+    vaultReadAuto(file: ExtractFile<TAdapter>): Promise<string | ArrayBuffer>;
+    vaultModify(file: ExtractFile<TAdapter>, data: string | ArrayBuffer | Uint8Array<ArrayBuffer>, options?: UXDataWriteOptions): Promise<boolean>;
+    vaultCreate(path: string, data: string | ArrayBuffer | Uint8Array<ArrayBuffer>, options?: UXDataWriteOptions): Promise<ExtractFile<TAdapter>>;
+    vaultRename(file: ExtractFile<TAdapter>, newPath: string): Promise<ExtractFile<TAdapter>>;
+    trigger(name: string, ...data: unknown[]): void;
+    reconcileInternalFile(path: string): Promise<void>;
+    /**
+     * Append data to a file using the adapter's append method. This is useful for large files that cannot be read into memory.
+     * Please note that this method does not check concurrent modifications.
+     * @param normalizedPath
+     * @param data
+     * @param options
+     * @returns
+     */
+    adapterAppend(normalizedPath: string, data: string, options?: UXDataWriteOptions): Promise<void>;
+    delete(file: ExtractAbstractFile<TAdapter> | ExtractFolder<TAdapter>, force?: boolean): Promise<void>;
+    trash(file: ExtractAbstractFile<TAdapter> | ExtractFolder<TAdapter>, force?: boolean): Promise<void>;
+    protected isStorageInsensitive(): boolean;
+    getAbstractFileByPath(path: FilePath | string): Promise<ExtractAbstractFile<TAdapter> | null>;
+    getFiles(): Promise<ExtractFile<TAdapter>[]>;
+    ensureDirectory(fullPath: string): Promise<void>;
+    touch(file: ExtractFile<TAdapter> | FilePath): Promise<void>;
+    recentlyTouched(file: ExtractFile<TAdapter> | UXFileInfoStub | FileWithFileStat): boolean;
+    clearTouched(): void;
+}

package/dist/serviceModules/FileAccessBase.js

@@ -0,0 +1,219 @@
+import { isPlainText } from "../string_and_binary/path.js";
+import { createBinaryBlob, isDocContentSame } from "../common/utils.js";
+import { createInstanceLogFunction } from "../services/lib/logUtils.js";
+function toArrayBuffer(arr) {
+  if (arr instanceof Uint8Array) {
+    return arr.buffer;
+  }
+  if (arr instanceof DataView) {
+    return arr.buffer;
+  }
+  return arr;
+}
+class FileAccessBase {
+  storageAccessManager;
+  vaultService;
+  settingService;
+  APIService;
+  path;
+  adapter;
+  _log;
+  constructor(adapter, dependencies) {
+    this.adapter = adapter;
+    this.storageAccessManager = dependencies.storageAccessManager;
+    this.vaultService = dependencies.vaultService;
+    this.settingService = dependencies.settingService;
+    this.APIService = dependencies.APIService;
+    this.path = dependencies.pathService;
+    this._log = createInstanceLogFunction("FileAccess", this.APIService);
+  }
+  // Delegated methods to adapter
+  isFile(file) {
+    return this.adapter.typeGuard.isFile(file);
+  }
+  isFolder(item) {
+    return this.adapter.typeGuard.isFolder(item);
+  }
+  getPath(file) {
+    return this.adapter.path.getPath(file);
+  }
+  nativeFileToUXFileInfoStub(file) {
+    return this.adapter.conversion.nativeFileToUXFileInfoStub(file);
+  }
+  nativeFolderToUXFolder(file) {
+    return this.adapter.conversion.nativeFolderToUXFolder(file);
+  }
+  normalisePath(path) {
+    return this.adapter.path.normalisePath(path);
+  }
+  _writeOp(file, callback) {
+    const path = this.getPath(file);
+    return this.storageAccessManager.processWriteFile(path, async () => await callback(path, file));
+  }
+  _readOp(file, callback) {
+    const path = this.getPath(file);
+    return this.storageAccessManager.processReadFile(path, async () => await callback(path, file));
+  }
+  async tryAdapterStat(file) {
+    return await this._readOp(file, async (path) => await this.adapter.storage.trystat(path));
+  }
+  async adapterStat(file) {
+    return await this._readOp(file, async (path) => await this.adapter.storage.stat(path));
+  }
+  async adapterExists(file) {
+    return await this._readOp(file, async (path) => await this.adapter.storage.exists(path));
+  }
+  async adapterRemove(file) {
+    return await this._writeOp(file, async (path) => await this.adapter.storage.remove(path));
+  }
+  async adapterRead(file) {
+    return await this._readOp(file, async (path) => await this.adapter.storage.read(path));
+  }
+  async adapterReadBinary(file) {
+    return await this._readOp(file, async (path) => await this.adapter.storage.readBinary(path));
+  }
+  async adapterReadAuto(file) {
+    const path = this.getPath(file);
+    if (isPlainText(path)) {
+      return await this._readOp(file, async (path2) => await this.adapter.storage.read(path2));
+    }
+    return await this._readOp(file, async (path2) => await this.adapter.storage.readBinary(path2));
+  }
+  async adapterWrite(file, data, options) {
+    if (typeof data === "string") {
+      return await this._writeOp(file, async (path) => await this.adapter.storage.write(path, data, options));
+    } else {
+      return await this._writeOp(
+        file,
+        async (path) => await this.adapter.storage.writeBinary(path, toArrayBuffer(data), options)
+      );
+    }
+  }
+  adapterList(basePath) {
+    return this.adapter.storage.list(basePath);
+  }
+  async vaultCacheRead(file) {
+    return await this._readOp(file, async (path) => await this.adapter.vault.cachedRead(file));
+  }
+  vaultRead(file) {
+    return this._readOp(file, async (path) => await this.adapter.vault.read(file));
+  }
+  vaultReadBinary(file) {
+    return this._readOp(file, async (path) => await this.adapter.vault.readBinary(file));
+  }
+  async vaultReadAuto(file) {
+    const path = this.getPath(file);
+    if (isPlainText(path)) {
+      return await this._readOp(path, async (path2) => await this.adapter.vault.read(file));
+    }
+    return await this._readOp(path, async (path2) => await this.adapter.vault.readBinary(file));
+  }
+  async vaultModify(file, data, options) {
+    if (typeof data === "string") {
+      return await this._writeOp(file, async (path) => {
+        const oldData = await this.adapter.vault.read(file);
+        if (data === oldData) {
+          const stat = await this.adapter.statFromNative(file);
+          if (options && options.mtime) this.path.markChangesAreSame(path, stat.mtime, options.mtime);
+          return true;
+        }
+        await this.adapter.vault.modify(file, data, options);
+        return true;
+      });
+    } else {
+      return await this._writeOp(file, async (path) => {
+        const oldData = await this.adapter.vault.readBinary(file);
+        if (await isDocContentSame(createBinaryBlob(oldData), createBinaryBlob(data))) {
+          const stat = await this.adapter.statFromNative(file);
+          if (options && options.mtime) this.path.markChangesAreSame(path, stat.mtime, options.mtime);
+          return true;
+        }
+        await this.adapter.vault.modifyBinary(file, toArrayBuffer(data), options);
+        return true;
+      });
+    }
+  }
+  async vaultCreate(path, data, options) {
+    if (typeof data === "string") {
+      return await this._writeOp(path, () => this.adapter.vault.create(path, data, options));
+    } else {
+      return await this._writeOp(
+        path,
+        () => this.adapter.vault.createBinary(path, toArrayBuffer(data), options)
+      );
+    }
+  }
+  async vaultRename(file, newPath) {
+    return await this._writeOp(file, async () => await this.adapter.renameFile(file, newPath));
+  }
+  trigger(name, ...data) {
+    return this.adapter.vault.trigger(name, ...data);
+  }
+  async reconcileInternalFile(path) {
+    return await this.adapter.reconcileInternalFile(path);
+  }
+  /**
+   * Append data to a file using the adapter's append method. This is useful for large files that cannot be read into memory.
+   * Please note that this method does not check concurrent modifications.
+   * @param normalizedPath
+   * @param data
+   * @param options
+   * @returns
+   */
+  async adapterAppend(normalizedPath, data, options) {
+    return await this.adapter.storage.append(normalizedPath, data, options);
+  }
+  async delete(file, force) {
+    return await this._writeOp(file, async (path, file2) => await this.adapter.vault.delete(file2, force));
+  }
+  async trash(file, force) {
+    return await this._writeOp(file, async (path, file2) => await this.adapter.vault.trash(file2, force));
+  }
+  isStorageInsensitive() {
+    return this.vaultService.isStorageInsensitive();
+  }
+  async getAbstractFileByPath(path) {
+    const setting = this.settingService.currentSettings();
+    if (!setting.handleFilenameCaseSensitive || this.isStorageInsensitive()) {
+      return await this.adapter.getAbstractFileByPathInsensitive(path);
+    }
+    return await this.adapter.getAbstractFileByPath(path);
+  }
+  async getFiles() {
+    return await this.adapter.getFiles();
+  }
+  async ensureDirectory(fullPath) {
+    const pathElements = fullPath.split("/");
+    pathElements.pop();
+    let c = "";
+    for (const v of pathElements) {
+      c += v;
+      try {
+        await this.adapter.storage.mkdir(c);
+      } catch (ex) {
+        if (ex?.message == "Folder already exists.") {
+        } else {
+          this._log("Folder Create Error");
+          this._log(ex);
+        }
+      }
+      c += "/";
+    }
+  }
+  async touch(file) {
+    const path = this.getPath(file);
+    const statOrg = this.isFile(file) ? file.stat : await this.adapter.storage.stat(path);
+    return this.storageAccessManager.touch({ path, stat: statOrg || { ctime: 0, mtime: 0, size: 0 } });
+  }
+  recentlyTouched(file) {
+    const path = file.path;
+    return this.storageAccessManager.recentlyTouched({ ...file, path });
+  }
+  clearTouched() {
+    return this.storageAccessManager.clearTouched();
+  }
+}
+export {
+  FileAccessBase,
+  toArrayBuffer
+};

package/dist/serviceModules/Rebuilder.d.ts

@@ -0,0 +1,92 @@
+import type { IFileHandler } from "../interfaces/FileHandler.js";
+import type { APIService } from "../services/base/APIService.js";
+import type { AppLifecycleService } from "../services/base/AppLifecycleService.js";
+import type { DatabaseEventService } from "../services/base/DatabaseEventService.js";
+import type { DatabaseService } from "../services/base/DatabaseService.js";
+import type { RemoteService } from "../services/base/RemoteService.js";
+import type { ReplicationService } from "../services/base/ReplicationService.js";
+import type { ReplicatorService } from "../services/base/ReplicatorService.js";
+import type { SettingService } from "../services/base/SettingService.js";
+import type { VaultService } from "../services/base/VaultService.js";
+import type { UIService } from "../services/implements/base/UIService.js";
+import type { Rebuilder } from "../interfaces/DatabaseRebuilder.js";
+import type { StorageAccess } from "../interfaces/StorageAccess.js";
+import type { LiveSyncEventHub } from "../hub/hub.js";
+import { ServiceModuleBase } from "./ServiceModuleBase.js";
+import type { ControlService } from "../services/base/ControlService.js";
+export interface ServiceRebuilderDependencies {
+    events: LiveSyncEventHub;
+    appLifecycle: AppLifecycleService;
+    API: APIService;
+    UI: UIService;
+    setting: SettingService;
+    remote: RemoteService;
+    databaseEvents: DatabaseEventService;
+    storageAccess: StorageAccess;
+    replicator: ReplicatorService;
+    vault: VaultService;
+    replication: ReplicationService;
+    database: DatabaseService;
+    fileHandler: IFileHandler;
+    control: ControlService;
+}
+export declare class ServiceRebuilder extends ServiceModuleBase<ServiceRebuilderDependencies> implements Rebuilder {
+    private events;
+    private appLifecycle;
+    private API;
+    private UI;
+    private setting;
+    private remote;
+    private databaseEvents;
+    private storageAccess;
+    private replicator;
+    private vault;
+    private replication;
+    private database;
+    private fileHandler;
+    private control;
+    constructor(services: ServiceRebuilderDependencies);
+    $performRebuildDB(method: "localOnly" | "remoteOnly" | "rebuildBothByThisDevice" | "localOnlyWithChunks"): Promise<void>;
+    informOptionalFeatures(): Promise<void>;
+    askUsingOptionalFeature(opt: {
+        enableFetch?: boolean;
+        enableOverwrite?: boolean;
+    }): Promise<void>;
+    rebuildRemote(): Promise<void>;
+    private performRemoteRebuild;
+    $rebuildRemote(): Promise<void>;
+    rebuildEverything(): Promise<void>;
+    private performRebuildEverything;
+    $rebuildEverything(): Promise<void>;
+    $fetchLocal(makeLocalChunkBeforeSync?: boolean, preventMakeLocalFilesBeforeSync?: boolean): Promise<void>;
+    $fetchLocalDBFast(autoResume: boolean): Promise<void>;
+    scheduleRebuild(): Promise<void>;
+    scheduleFetch(): Promise<void>;
+    private _tryResetRemoteDatabase;
+    private _onResetLocalDatabase;
+    suspendAllSync(): Promise<void>;
+    suspendReflectingDatabase(ignoreMinIO?: boolean): Promise<void>;
+    resumeReflectingDatabase(ignoreMinIO?: boolean): Promise<void>;
+    fetchLocal(makeLocalChunkBeforeSync?: boolean, preventMakeLocalFilesBeforeSync?: boolean, autoResume?: boolean): Promise<void>;
+    private performFetchLocal;
+    fetchLocalDBFast(autoResume: boolean): Promise<void>;
+    private performFetchLocalDBFast;
+    /**
+     * Finish rebuild process with resuming the reflection.
+     *
+     * @param ignoreMinIO Whether to ignore minio for resuming the reflection.
+     */
+    finishRebuild(ignoreMinIO?: boolean): Promise<void>;
+    /**
+     * Fetch local database with making all chunks.
+     * This is a wrapper for {@link fetchLocal} with makeLocalChunkBeforeSync = true.
+     *
+     * @returns
+     */
+    fetchLocalWithRebuild(): Promise<void>;
+    private _allSuspendAllSync;
+    resetLocalDatabase(): Promise<void>;
+    private getFastFetchCheckpoint;
+    private saveFastFetchCheckpoint;
+    private clearFastFetchCheckpoint;
+}