@vrtmrz/livesync-commonlib 0.1.0-rc.0

package/dist/replication/journal/JournalSyncTypes.d.ts

@@ -0,0 +1,9 @@
+export type CheckPointInfo = {
+    lastLocalSeq: number | string;
+    journalEpoch: string;
+    knownIDs: Set<string>;
+    sentIDs: Set<string>;
+    receivedFiles: Set<string>;
+    sentFiles: Set<string>;
+};
+export declare const CheckPointInfoDefault: CheckPointInfo;

package/dist/replication/journal/JournalSyncTypes.js

@@ -0,0 +1,11 @@
+const CheckPointInfoDefault = {
+  lastLocalSeq: 0,
+  journalEpoch: "",
+  knownIDs: /* @__PURE__ */ new Set(),
+  sentIDs: /* @__PURE__ */ new Set(),
+  receivedFiles: /* @__PURE__ */ new Set(),
+  sentFiles: /* @__PURE__ */ new Set()
+};
+export {
+  CheckPointInfoDefault
+};

package/dist/replication/journal/LiveSyncJournalReplicator.d.ts

@@ -0,0 +1,40 @@
+import { type RemoteDBSettings, type EntryLeaf, type ChunkVersionRange, type TweakValues, type NodeData } from "../../common/types.js";
+import { JournalSyncCore } from "./JournalSyncCore.js";
+import { LiveSyncAbstractReplicator, type RemoteDBStatus } from "../LiveSyncAbstractReplicator.js";
+import { type ENSURE_DB_RESULT } from "../../pouchdb/LiveSyncDBFunctions.js";
+import type { CheckPointInfo } from "./JournalSyncTypes.js";
+import { type SimpleStore } from "../../common/utils.js";
+import type { LiveSyncJournalReplicatorEnv } from "./LiveSyncJournalReplicatorEnv.js";
+export declare class LiveSyncJournalReplicator extends LiveSyncAbstractReplicator {
+    env: LiveSyncJournalReplicatorEnv;
+    get isChunkSendingSupported(): boolean;
+    get client(): JournalSyncCore;
+    get simpleStore(): SimpleStore<CheckPointInfo>;
+    _client: JournalSyncCore;
+    getReplicationPBKDF2Salt(setting: RemoteDBSettings, refresh?: boolean): Promise<Uint8Array<ArrayBuffer>>;
+    setupJournalSyncClient(): JournalSyncCore;
+    ensureBucketIsCompatible(deviceNodeID: string, currentVersionRange: ChunkVersionRange): Promise<ENSURE_DB_RESULT>;
+    constructor(env: LiveSyncJournalReplicatorEnv);
+    migrate(from: number, to: number): Promise<boolean>;
+    terminateSync(): void;
+    openReplication(setting: RemoteDBSettings, _: boolean, showResult: boolean, ignoreCleanLock?: boolean): Promise<boolean>;
+    replicateAllToServer(setting: RemoteDBSettings, showingNotice?: boolean): Promise<boolean>;
+    replicateAllFromServer(setting: RemoteDBSettings, showingNotice?: boolean): Promise<boolean>;
+    checkReplicationConnectivity(skipCheck: boolean, ignoreCleanLock?: boolean, showMessage?: boolean): Promise<boolean>;
+    fetchRemoteChunks(missingChunks: string[], showResult: boolean): Promise<false | EntryLeaf[]>;
+    closeReplication(): void;
+    tryResetRemoteDatabase(setting: RemoteDBSettings): Promise<void>;
+    tryCreateRemoteDatabase(setting: RemoteDBSettings): Promise<void>;
+    markRemoteLocked(setting: RemoteDBSettings, locked: boolean, lockByClean: boolean): Promise<void>;
+    markRemoteResolved(setting: RemoteDBSettings): Promise<void>;
+    tryConnectRemote(setting: RemoteDBSettings, showResult?: boolean): Promise<boolean>;
+    resetRemoteTweakSettings(setting: RemoteDBSettings): Promise<void>;
+    setPreferredRemoteTweakSettings(setting: RemoteDBSettings): Promise<void>;
+    getRemotePreferredTweakValues(setting: RemoteDBSettings): Promise<false | TweakValues>;
+    getRemoteStatus(setting: RemoteDBSettings): Promise<false | RemoteDBStatus>;
+    countCompromisedChunks(): Promise<number>;
+    getConnectedDeviceList(setting?: RemoteDBSettings): Promise<false | {
+        node_info: Record<string, NodeData>;
+        accepted_nodes: string[];
+    }>;
+}

package/dist/replication/journal/LiveSyncJournalReplicator.js

@@ -0,0 +1,294 @@
+import {
+  LOG_LEVEL_NOTICE,
+  LOG_LEVEL_VERBOSE,
+  DEVICE_ID_PREFERRED,
+  TweakValuesTemplate
+} from "../../common/types.js";
+import { Logger } from "../../common/logger.js";
+import { JournalSyncCore } from "./JournalSyncCore.js";
+import { MinioStorageAdapter } from "./objectstore/MinioStorageAdapter.js";
+import { LiveSyncAbstractReplicator } from "../LiveSyncAbstractReplicator.js";
+import { ensureRemoteIsCompatible } from "../../pouchdb/LiveSyncDBFunctions.js";
+import { fireAndForget } from "../../common/utils.js";
+import { extractObject } from "../../common/utils.js";
+import { clearHandlers } from "../SyncParamsHandler.js";
+const MILSTONE_DOCID = "_00000000-milestone.json";
+const currentVersionRange = {
+  min: 0,
+  max: 2,
+  current: 2
+};
+class LiveSyncJournalReplicator extends LiveSyncAbstractReplicator {
+  get isChunkSendingSupported() {
+    return false;
+  }
+  get client() {
+    return this.setupJournalSyncClient();
+  }
+  get simpleStore() {
+    return this.env.services.keyValueDB.simpleStore;
+  }
+  _client;
+  async getReplicationPBKDF2Salt(setting, refresh) {
+    return await this.client.getReplicationPBKDF2Salt(refresh);
+  }
+  setupJournalSyncClient() {
+    const settings = this.currentSettings;
+    if (this._client) {
+      this._client.applyNewConfig(settings, this.simpleStore, this.env);
+    } else {
+      this._client = new JournalSyncCore(
+        settings,
+        this.simpleStore,
+        this.env,
+        new MinioStorageAdapter(settings, this.env)
+      );
+    }
+    return this._client;
+  }
+  async ensureBucketIsCompatible(deviceNodeID, currentVersionRange2) {
+    const downloadedMilestone = await this.client.downloadJson(MILSTONE_DOCID);
+    const cPointInfo = await this.client.getCheckpointInfo();
+    const progress = [...cPointInfo?.receivedFiles || []].sort().pop() || "";
+    return await ensureRemoteIsCompatible(
+      downloadedMilestone,
+      this.currentSettings,
+      deviceNodeID,
+      currentVersionRange2,
+      {
+        app_version: this.env.services.API.getAppVersion(),
+        plugin_version: this.env.services.API.getPluginVersion(),
+        vault_name: this.env.services.vault.vaultName(),
+        device_name: this.env.services.vault.getVaultName(),
+        progress
+      },
+      async (info) => {
+        await this.client.uploadJson(MILSTONE_DOCID, info);
+      }
+    );
+  }
+  constructor(env) {
+    super(env);
+    this.env = env;
+    fireAndForget(() => this.initializeDatabaseForReplication());
+    this.rawDatabase.on("close", () => {
+      this.closeReplication();
+    });
+  }
+  async migrate(from, to) {
+    Logger(`Database updated from ${from} to ${to}`, LOG_LEVEL_NOTICE);
+    return Promise.resolve(true);
+  }
+  terminateSync() {
+    this.client.requestStop();
+  }
+  async openReplication(setting, _, showResult, ignoreCleanLock = false) {
+    if (!await this.checkReplicationConnectivity(false, ignoreCleanLock, showResult)) return false;
+    await this.client.sync(showResult);
+    return true;
+  }
+  async replicateAllToServer(setting, showingNotice) {
+    if (!await this.checkReplicationConnectivity(false, false, !!showingNotice)) return false;
+    return await this.client.sendLocalJournal(showingNotice);
+  }
+  async replicateAllFromServer(setting, showingNotice) {
+    if (!await this.checkReplicationConnectivity(false, false, !!showingNotice)) return false;
+    return await this.client.receiveRemoteJournal(showingNotice);
+  }
+  async checkReplicationConnectivity(skipCheck, ignoreCleanLock = false, showMessage = false) {
+    if (!await this.client.isAvailable()) {
+      return false;
+    }
+    if (!skipCheck) {
+      await this.client.ensureCheckpointCachesAreFresh();
+      this.remoteCleaned = false;
+      this.remoteLocked = false;
+      this.remoteLockedAndDeviceNotAccepted = false;
+      this.tweakSettingsMismatched = false;
+      const ensure = await this.ensureBucketIsCompatible(this.nodeid, currentVersionRange);
+      if (ensure == "INCOMPATIBLE") {
+        Logger(
+          "The remote database has no compatibility with the running version. Please upgrade the plugin.",
+          LOG_LEVEL_NOTICE
+        );
+        return false;
+      } else if (ensure == "NODE_LOCKED") {
+        Logger(
+          "The remote database has been rebuilt or corrupted since we have synchronized last time. Fetch rebuilt DB, explicit unlocking or chunk clean-up is required.",
+          LOG_LEVEL_NOTICE
+        );
+        this.remoteLockedAndDeviceNotAccepted = true;
+        this.remoteLocked = true;
+        return false;
+      } else if (ensure == "LOCKED") {
+        this.remoteLocked = true;
+      } else if (ensure == "NODE_CLEANED") {
+        if (ignoreCleanLock) {
+          this.remoteLocked = true;
+        } else {
+          Logger(
+            "The remote database has been cleaned up. Fetch rebuilt DB, explicit unlocking or chunk clean-up is required.",
+            LOG_LEVEL_NOTICE
+          );
+          this.remoteLockedAndDeviceNotAccepted = true;
+          this.remoteLocked = true;
+          this.remoteCleaned = true;
+          return false;
+        }
+      } else if (ensure == "OK") {
+      } else if (ensure[0] == "MISMATCHED") {
+        Logger(this.translate("liveSyncReplicator.mismatchedTweakDetected"), LOG_LEVEL_NOTICE);
+        this.tweakSettingsMismatched = true;
+        this.preferredTweakValue = ensure[1];
+        return false;
+      }
+    }
+    return true;
+  }
+  async fetchRemoteChunks(missingChunks, showResult) {
+    return Promise.resolve([]);
+  }
+  closeReplication() {
+    this.client.requestStop();
+    this.syncStatus = "CLOSED";
+    Logger("Replication closed");
+    this.updateInfo();
+  }
+  async tryResetRemoteDatabase(setting) {
+    this.closeReplication();
+    try {
+      await this.client.resetBucket();
+      clearHandlers();
+      Logger("Remote Bucket Cleared", LOG_LEVEL_NOTICE);
+      await this.tryCreateRemoteDatabase(setting);
+    } catch (ex) {
+      Logger("Something happened on Remote Bucket Clear", LOG_LEVEL_NOTICE);
+      Logger(ex, LOG_LEVEL_NOTICE);
+    }
+  }
+  async tryCreateRemoteDatabase(setting) {
+    this.closeReplication();
+    Logger("Remote Database Created or Connected", LOG_LEVEL_NOTICE);
+    clearHandlers();
+    await this.ensurePBKDF2Salt(setting, true, false);
+    return await Promise.resolve();
+  }
+  async markRemoteLocked(setting, locked, lockByClean) {
+    const defInitPoint = {
+      _id: MILSTONE_DOCID,
+      type: "milestoneinfo",
+      created: Date.now(),
+      locked,
+      cleaned: lockByClean,
+      accepted_nodes: [this.nodeid],
+      node_chunk_info: { [this.nodeid]: currentVersionRange },
+      node_info: {},
+      tweak_values: {}
+    };
+    const remoteMilestone = {
+      ...defInitPoint,
+      ...await this.client.downloadJson(MILSTONE_DOCID) || {}
+    };
+    remoteMilestone.node_chunk_info = { ...defInitPoint.node_chunk_info, ...remoteMilestone.node_chunk_info };
+    remoteMilestone.accepted_nodes = [this.nodeid];
+    remoteMilestone.locked = locked;
+    remoteMilestone.cleaned = remoteMilestone.cleaned || lockByClean;
+    if (locked) {
+      Logger("Lock remote bucket to prevent data corruption", LOG_LEVEL_NOTICE);
+    } else {
+      Logger("Unlock remote bucket to prevent data corruption", LOG_LEVEL_NOTICE);
+    }
+    await this.client.uploadJson(MILSTONE_DOCID, remoteMilestone);
+  }
+  async markRemoteResolved(setting) {
+    const defInitPoint = {
+      _id: MILSTONE_DOCID,
+      type: "milestoneinfo",
+      created: Date.now(),
+      locked: false,
+      accepted_nodes: [this.nodeid],
+      node_chunk_info: { [this.nodeid]: currentVersionRange },
+      node_info: {},
+      tweak_values: {}
+    };
+    const remoteMilestone = {
+      ...defInitPoint,
+      ...await this.client.downloadJson(MILSTONE_DOCID) || {}
+    };
+    remoteMilestone.node_chunk_info = { ...defInitPoint.node_chunk_info, ...remoteMilestone.node_chunk_info };
+    remoteMilestone.accepted_nodes = Array.from(/* @__PURE__ */ new Set([...remoteMilestone.accepted_nodes, this.nodeid]));
+    Logger("Mark this device as 'resolved'.", LOG_LEVEL_NOTICE);
+    await this.client.uploadJson(MILSTONE_DOCID, remoteMilestone);
+  }
+  async tryConnectRemote(setting, showResult = true) {
+    const endpoint = setting.endpoint;
+    const testClient = new MinioStorageAdapter(setting, this.env);
+    try {
+      await testClient.listFiles("", 1);
+      Logger(`Connected to ${endpoint} successfully!`, LOG_LEVEL_NOTICE);
+      return true;
+    } catch (ex) {
+      Logger(`Error! Could not connected to ${endpoint}
+${ex.message}`, LOG_LEVEL_NOTICE);
+      Logger(ex, LOG_LEVEL_NOTICE);
+      return false;
+    }
+  }
+  async resetRemoteTweakSettings(setting) {
+    try {
+      const remoteMilestone = await this.client.downloadJson(MILSTONE_DOCID);
+      if (!remoteMilestone) {
+        throw new Error("Missing remote milestone");
+      }
+      remoteMilestone.tweak_values = {};
+      Logger(`tweak values on the remote database have been cleared`, LOG_LEVEL_VERBOSE);
+      await this.client.uploadJson(MILSTONE_DOCID, remoteMilestone);
+    } catch (ex) {
+      Logger(`Could not retrieve remote milestone`, LOG_LEVEL_NOTICE);
+      throw ex;
+    }
+  }
+  async setPreferredRemoteTweakSettings(setting) {
+    try {
+      const remoteMilestone = await this.client.downloadJson(MILSTONE_DOCID);
+      if (!remoteMilestone) {
+        throw new Error("Missing remote milestone");
+      }
+      remoteMilestone.tweak_values[DEVICE_ID_PREFERRED] = extractObject(TweakValuesTemplate, {
+        ...setting
+      });
+      Logger(`tweak values on the remote database have been cleared`, LOG_LEVEL_VERBOSE);
+      await this.client.uploadJson(MILSTONE_DOCID, remoteMilestone);
+    } catch (ex) {
+      Logger(`Could not retrieve remote milestone`, LOG_LEVEL_NOTICE);
+      throw ex;
+    }
+  }
+  async getRemotePreferredTweakValues(setting) {
+    try {
+      const remoteMilestone = await this.client.downloadJson(MILSTONE_DOCID);
+      if (!remoteMilestone) {
+        throw new Error("Missing remote milestone");
+      }
+      return remoteMilestone?.tweak_values?.[DEVICE_ID_PREFERRED] || false;
+    } catch (ex) {
+      Logger(`Could not retrieve remote milestone`, LOG_LEVEL_NOTICE);
+      Logger(ex, LOG_LEVEL_VERBOSE);
+      return false;
+    }
+  }
+  async getRemoteStatus(setting) {
+    const testClient = new MinioStorageAdapter(setting, this.env);
+    return await testClient.getUsage();
+  }
+  countCompromisedChunks() {
+    Logger(`Bucket Sync Replicator cannot count compromised chunks`, LOG_LEVEL_VERBOSE);
+    return Promise.resolve(0);
+  }
+  getConnectedDeviceList(setting) {
+    return Promise.resolve(false);
+  }
+}
+export {
+  LiveSyncJournalReplicator
+};

package/dist/replication/journal/LiveSyncJournalReplicatorEnv.d.ts

@@ -0,0 +1,3 @@
+import type { LiveSyncReplicatorEnv } from "../LiveSyncAbstractReplicator.js";
+export interface LiveSyncJournalReplicatorEnv extends LiveSyncReplicatorEnv {
+}

package/dist/replication/journal/objectstore/JournalStorageAdapter.d.ts

@@ -0,0 +1,15 @@
+import type { RemoteDBStatus } from "../../LiveSyncAbstractReplicator.js";
+import type { BucketSyncSetting } from "../../../common/types.js";
+export interface IJournalStorage {
+    upload(key: string, data: Uint8Array, mime: string): Promise<boolean>;
+    download(key: string, ignoreCache?: boolean): Promise<Uint8Array | false>;
+    listFiles(from: string, limit?: number): Promise<string[]>;
+    deleteFiles(keys: string[]): Promise<boolean>;
+    isAvailable(): Promise<boolean>;
+    getUsage(): Promise<false | RemoteDBStatus>;
+    applyNewConfig(settings: BucketSyncSetting): void;
+}
+import type { LiveSyncJournalReplicatorEnv } from "../LiveSyncJournalReplicatorEnv.js";
+export interface IJournalStorageAdapterClass {
+    new (settings: BucketSyncSetting, env: LiveSyncJournalReplicatorEnv): IJournalStorage;
+}

package/dist/replication/journal/objectstore/MinioStorageAdapter.d.ts

@@ -0,0 +1,21 @@
+import { S3 } from "@aws-sdk/client-s3";
+import { type BucketSyncSetting } from "../../../common/types.js";
+import type { RemoteDBStatus } from "../../LiveSyncAbstractReplicator.js";
+import type { IJournalStorage } from "./JournalStorageAdapter.js";
+import type { LiveSyncJournalReplicatorEnv } from "../LiveSyncJournalReplicatorEnv.js";
+export declare class MinioStorageAdapter implements IJournalStorage {
+    _instance?: S3;
+    _settings: BucketSyncSetting;
+    _env: LiveSyncJournalReplicatorEnv;
+    constructor(settings: BucketSyncSetting, env: LiveSyncJournalReplicatorEnv);
+    private runTrackedRequest;
+    applyNewConfig(settings: BucketSyncSetting): void;
+    get customHeaders(): [string, string][];
+    _getClient(): S3;
+    upload(key: string, data: Uint8Array, mime: string): Promise<boolean>;
+    download(key: string, ignoreCache?: boolean): Promise<Uint8Array | false>;
+    listFiles(from: string, limit?: number): Promise<string[]>;
+    deleteFiles(keys: string[]): Promise<boolean>;
+    isAvailable(): Promise<boolean>;
+    getUsage(): Promise<false | RemoteDBStatus>;
+}

package/dist/replication/journal/objectstore/MinioStorageAdapter.js

@@ -0,0 +1,204 @@
+import {
+  DeleteObjectsCommand,
+  GetObjectCommand,
+  HeadBucketCommand,
+  PutObjectCommand,
+  S3
+} from "@aws-sdk/client-s3";
+import { applyMd5BodyChecksumMiddleware } from "@smithy/middleware-apply-body-checksum";
+import { Md5 } from "@smithy/md5-js";
+import { ConfiguredRetryStrategy } from "@smithy/util-retry";
+import { promiseWithResolvers } from "octagonal-wheels/promises";
+import { LOG_LEVEL_NOTICE, LOG_LEVEL_VERBOSE } from "../../../common/types.js";
+import { Logger } from "../../../common/logger.js";
+import { parseHeaderValues } from "../../../common/utils.js";
+import { runWithTrackedPhysicalRequest } from "../../../services/lib/remoteActivity.js";
+class MinioStorageAdapter {
+  _instance;
+  _settings;
+  _env;
+  constructor(settings, env) {
+    this._settings = settings;
+    this._env = env;
+  }
+  async runTrackedRequest(task) {
+    return await runWithTrackedPhysicalRequest(this._env.services.API, task);
+  }
+  applyNewConfig(settings) {
+    this._settings = settings;
+    this._instance = void 0;
+  }
+  get customHeaders() {
+    return this._settings.bucketCustomHeaders.length == 0 ? [] : Object.entries(parseHeaderValues(this._settings.bucketCustomHeaders));
+  }
+  _getClient() {
+    if (this._instance) return this._instance;
+    const ep = this._settings.endpoint ? {
+      endpoint: this._settings.endpoint,
+      forcePathStyle: this._settings.forcePathStyle
+    } : {};
+    this._instance = new S3({
+      region: this._settings.region,
+      ...ep,
+      credentials: {
+        accessKeyId: this._settings.accessKey,
+        secretAccessKey: this._settings.secretKey
+      },
+      maxAttempts: 4,
+      retryStrategy: new ConfiguredRetryStrategy(4, (attempt) => 100 + attempt * 1e3),
+      requestHandler: this._settings.useCustomRequestHandler ? this._env.services.API.getCustomFetchHandler() : void 0,
+      requestChecksumCalculation: "WHEN_REQUIRED",
+      responseChecksumValidation: "WHEN_REQUIRED"
+    });
+    const bucketCustomHeaders = this.customHeaders;
+    this._instance.middlewareStack.add(
+      (next, context) => (args) => {
+        bucketCustomHeaders.forEach(([key, value]) => {
+          if (key && value) {
+            args.request.headers[key] = value;
+          }
+        });
+        return next(args);
+      },
+      {
+        name: "addBucketCustomHeadersMiddleware",
+        step: "finalizeRequest",
+        priority: "low"
+      }
+    );
+    const arrayBufferToBase64Sync = (buffer) => {
+      return btoa(String.fromCharCode(...new Uint8Array(buffer)));
+    };
+    this._instance.middlewareStack.add(
+      applyMd5BodyChecksumMiddleware({
+        md5: Md5,
+        base64Encoder: (data) => arrayBufferToBase64Sync(data.buffer),
+        streamHasher: (hashConstructor, stream) => {
+          const result = promiseWithResolvers();
+          const hash = new hashConstructor();
+          stream.on("data", (chunk) => {
+            hash.update(chunk);
+          });
+          stream.on("end", () => {
+            result.resolve(hash.digest());
+          });
+          return result.promise;
+        }
+      }),
+      {
+        step: "build",
+        name: "applyMd5BodyChecksumMiddlewareForDeleteObjects"
+      }
+    );
+    return this._instance;
+  }
+  async upload(key, data, mime) {
+    try {
+      const client = this._getClient();
+      const cmd = new PutObjectCommand({
+        Bucket: this._settings.bucket,
+        Key: `${this._settings.bucketPrefix}${key}`,
+        Body: data,
+        ContentType: mime
+      });
+      if (await this.runTrackedRequest(() => client.send(cmd))) {
+        return true;
+      }
+    } catch (ex) {
+      Logger(`Could not upload ${key}`);
+      Logger(ex, LOG_LEVEL_VERBOSE);
+    }
+    return false;
+  }
+  async download(key, ignoreCache = false) {
+    const client = this._getClient();
+    const cmd = new GetObjectCommand({
+      Bucket: this._settings.bucket,
+      Key: `${this._settings.bucketPrefix}${key}`,
+      ...ignoreCache ? { ResponseCacheControl: "no-cache" } : {}
+    });
+    try {
+      return await this.runTrackedRequest(async () => {
+        const r = await client.send(cmd);
+        if (r.Body) {
+          return new Uint8Array(await r.Body.transformToByteArray());
+        }
+        return false;
+      });
+    } catch (ex) {
+      Logger(`Could not download ${key}`);
+      Logger(ex, LOG_LEVEL_VERBOSE);
+    }
+    return false;
+  }
+  async listFiles(from, limit) {
+    const client = this._getClient();
+    const objects = await this.runTrackedRequest(
+      () => client.listObjectsV2({
+        Bucket: this._settings.bucket,
+        Prefix: this._settings.bucketPrefix,
+        StartAfter: `${this._settings.bucketPrefix || ""}${from || ""}`,
+        ...limit ? { MaxKeys: limit } : {}
+      })
+    );
+    if (!objects.Contents) return [];
+    return objects.Contents.filter((e) => e.Key?.startsWith(this._settings.bucketPrefix)).map(
+      (e) => e.Key?.substring(this._settings.bucketPrefix.length)
+    );
+  }
+  async deleteFiles(keys) {
+    if (keys.length === 0) return true;
+    const client = this._getClient();
+    try {
+      const cmd = new DeleteObjectsCommand({
+        Bucket: this._settings.bucket,
+        Delete: {
+          Objects: keys.map((e) => ({ Key: `${this._settings.bucketPrefix}${e}` }))
+        }
+      });
+      const r = await this.runTrackedRequest(() => client.send(cmd));
+      const { Deleted, Errors } = r;
+      const deleteCount = Deleted?.length || 0;
+      const errorCount = Errors?.length || 0;
+      Logger(
+        `${deleteCount} items deleted.${errorCount !== 0 ? ` (${errorCount} items failed to delete)` : ""}`,
+        LOG_LEVEL_VERBOSE,
+        "reset-bucket"
+      );
+      return errorCount === 0;
+    } catch (ex) {
+      Logger(`WARNING! Could not delete files.`, LOG_LEVEL_NOTICE, "reset-bucket");
+      Logger(ex, LOG_LEVEL_VERBOSE);
+      return false;
+    }
+  }
+  async isAvailable() {
+    const client = this._getClient();
+    const cmd = new HeadBucketCommand({ Bucket: this._settings.bucket });
+    try {
+      await this.runTrackedRequest(() => client.send(cmd));
+      return true;
+    } catch (ex) {
+      Logger(`Could not connect to the remote bucket`, LOG_LEVEL_NOTICE);
+      Logger(ex, LOG_LEVEL_VERBOSE);
+      return false;
+    }
+  }
+  async getUsage() {
+    const client = this._getClient();
+    try {
+      const objects = await this.runTrackedRequest(() => client.listObjectsV2({ Bucket: this._settings.bucket }));
+      if (!objects.Contents) return {};
+      return {
+        estimatedSize: objects.Contents.reduce((acc, e) => acc + (e.Size || 0), 0)
+      };
+    } catch (ex) {
+      Logger(`Could not get status of the remote bucket`, LOG_LEVEL_NOTICE);
+      Logger(ex, LOG_LEVEL_VERBOSE);
+      return false;
+    }
+  }
+}
+export {
+  MinioStorageAdapter
+};