@naturalcycles/cloud-storage-lib 1.0.0

package/dist/index.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runCommonStorageTest = exports.InMemoryCommonStorage = exports.CommonStorageBucket = exports.CommonStorageKeyValueDB = exports.CloudStorage = void 0;
+const cloudStorage_1 = require("./cloudStorage");
+Object.defineProperty(exports, "CloudStorage", { enumerable: true, get: function () { return cloudStorage_1.CloudStorage; } });
+const commonStorageBucket_1 = require("./commonStorageBucket");
+Object.defineProperty(exports, "CommonStorageBucket", { enumerable: true, get: function () { return commonStorageBucket_1.CommonStorageBucket; } });
+const commonStorageKeyValueDB_1 = require("./commonStorageKeyValueDB");
+Object.defineProperty(exports, "CommonStorageKeyValueDB", { enumerable: true, get: function () { return commonStorageKeyValueDB_1.CommonStorageKeyValueDB; } });
+const inMemoryCommonStorage_1 = require("./inMemoryCommonStorage");
+Object.defineProperty(exports, "InMemoryCommonStorage", { enumerable: true, get: function () { return inMemoryCommonStorage_1.InMemoryCommonStorage; } });
+const commonStorageTest_1 = require("./testing/commonStorageTest");
+Object.defineProperty(exports, "runCommonStorageTest", { enumerable: true, get: function () { return commonStorageTest_1.runCommonStorageTest; } });

package/dist/model.d.ts

@@ -0,0 +1,5 @@
+export interface GCPServiceAccount {
+    client_email: string;
+    private_key: string;
+    project_id: string;
+}

package/dist/model.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/testing/commonStorageTest.d.ts

@@ -0,0 +1,5 @@
+import { CommonStorage } from '../commonStorage';
+/**
+ * This test suite must be idempotent.
+ */
+export declare function runCommonStorageTest(storage: CommonStorage, bucketName: string): void;

package/dist/testing/commonStorageTest.js

@@ -0,0 +1,108 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runCommonStorageTest = void 0;
+const js_lib_1 = require("@naturalcycles/js-lib");
+const nodejs_lib_1 = require("@naturalcycles/nodejs-lib");
+const TEST_FOLDER = 'test/subdir';
+const TEST_ITEMS = (0, js_lib_1._range)(10).map(n => ({
+    id: `id_${n + 1}`,
+    n,
+    even: n % 2 === 0,
+}));
+const TEST_ITEMS2 = (0, js_lib_1._range)(10).map(n => ({
+    fileType: 2,
+    id: `id_${n + 1}`,
+    n,
+    even: n % 2 === 0,
+}));
+const TEST_ITEMS3 = (0, js_lib_1._range)(10).map(n => ({
+    fileType: 3,
+    id: `id_${n + 1}`,
+    n,
+    even: n % 2 === 0,
+}));
+const TEST_FILES = [TEST_ITEMS, TEST_ITEMS2, TEST_ITEMS3].map((obj, i) => ({
+    filePath: `${TEST_FOLDER}/file_${i + 1}.json`,
+    content: Buffer.from(JSON.stringify(obj)),
+}));
+/**
+ * This test suite must be idempotent.
+ */
+function runCommonStorageTest(storage, bucketName) {
+    // test('createBucket', async () => {
+    //   await storage.createBucket(bucketName)
+    // })
+    test('ping', async () => {
+        await storage.ping();
+    });
+    test('listBuckets', async () => {
+        const buckets = await storage.getBucketNames();
+        console.log(buckets);
+    });
+    test('streamBuckets', async () => {
+        const buckets = await (0, nodejs_lib_1.readableToArray)(storage.getBucketNamesStream());
+        console.log(buckets);
+    });
+    test('prepare: clear bucket', async () => {
+        await (0, js_lib_1.pMap)(TEST_FILES.map(f => f.filePath), async (filePath) => await storage.deletePath(bucketName, filePath));
+    });
+    test('listFileNames on root should return empty', async () => {
+        const fileNames = await storage.getFileNames(bucketName, '');
+        expect(fileNames).toEqual([]);
+    });
+    test(`listFileNames on ${TEST_FOLDER} should return empty`, async () => {
+        const fileNames = await storage.getFileNames(bucketName, TEST_FOLDER);
+        expect(fileNames).toEqual([]);
+    });
+    test('streamFileNames on root should return empty', async () => {
+        const fileNames = await (0, nodejs_lib_1.readableToArray)(storage.getFileNamesStream(bucketName, ''));
+        expect(fileNames).toEqual([]);
+    });
+    test(`exists should return empty array`, async () => {
+        await (0, js_lib_1.pMap)(TEST_FILES, async (f) => {
+            const exists = await storage.fileExists(bucketName, f.filePath);
+            expect(exists).toBe(false);
+        });
+    });
+    test(`saveFiles, then listFileNames, streamFileNames and getFiles should return just saved files`, async () => {
+        const testFilesMap = Object.fromEntries(TEST_FILES.map(f => [f.filePath, f.content]));
+        // It's done in the same test to ensure "strong consistency"
+        await (0, js_lib_1.pMap)(TEST_FILES, async (f) => await storage.saveFile(bucketName, f.filePath, f.content));
+        const fileNames = await storage.getFileNames(bucketName, TEST_FOLDER);
+        expect(fileNames.sort()).toEqual(TEST_FILES.map(f => f.filePath).sort());
+        const streamedFileNames = await (0, nodejs_lib_1.readableToArray)(storage.getFileNamesStream(bucketName, TEST_FOLDER));
+        expect(streamedFileNames.sort()).toEqual(TEST_FILES.map(f => f.filePath).sort());
+        const filesMap = {};
+        await (0, js_lib_1.pMap)(fileNames, async (filePath) => {
+            filesMap[filePath] = (await storage.getFile(bucketName, filePath));
+        });
+        expect(filesMap).toEqual(testFilesMap);
+        await (0, js_lib_1.pMap)(fileNames, async (filePath) => {
+            const exists = await storage.fileExists(bucketName, filePath);
+            expect(exists).toBe(true);
+        });
+    });
+    test('cleanup', async () => {
+        await storage.deletePath(bucketName, '');
+    });
+    // Cannot update access control for an object when uniform bucket-level access is enabled. Read more at https://cloud.google.com/storage/docs/uniform-bucket-level-access
+    /*
+    test(`get/set FilesVisibility`, async () => {
+      const fileNames = TEST_FILES.map(f => f.filePath)
+  
+      let map = await storage.getFilesVisibility(bucketName, fileNames)
+      expect(map).toEqual(Object.fromEntries(fileNames.map(f => [f, false])))
+  
+      await storage.setFilesVisibility(bucketName, fileNames, true)
+  
+      map = await storage.getFilesVisibility(bucketName, fileNames)
+      expect(map).toEqual(Object.fromEntries(fileNames.map(f => [f, true])))
+  
+      await storage.setFilesVisibility(bucketName, fileNames, false)
+  
+      map = await storage.getFilesVisibility(bucketName, fileNames)
+      expect(map).toEqual(Object.fromEntries(fileNames.map(f => [f, false])))
+    })
+     */
+}
+exports.runCommonStorageTest = runCommonStorageTest;

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "@naturalcycles/cloud-storage-lib",
+  "scripts": {
+    "prepare": "husky install"
+  },
+  "dependencies": {
+    "@google-cloud/storage": "^5.14.0",
+    "@naturalcycles/db-lib": "^8.25.0",
+    "@naturalcycles/js-lib": "^14.41.0",
+    "@naturalcycles/nodejs-lib": "^12.31.0"
+  },
+  "devDependencies": {
+    "@naturalcycles/dev-lib": "^12.1.3",
+    "@types/node": "^17.0.5",
+    "jest": "^27.1.0"
+  },
+  "files": [
+    "dist",
+    "src",
+    "!src/test",
+    "!src/**/*.test.ts",
+    "!src/**/__snapshots__",
+    "!src/**/__exclude"
+  ],
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/NaturalCycles/cloud-storage-lib"
+  },
+  "engines": {
+    "node": ">=14.16.0"
+  },
+  "version": "1.0.0",
+  "description": "",
+  "author": "Natural Cycles Team",
+  "license": "MIT"
+}

package/readme.md

@@ -0,0 +1,20 @@
+## @naturalcycles/cloud-storage-lib
+
+> CommonStorage implementation based on Google Cloud Storage
+
+[![npm](https://img.shields.io/npm/v/@naturalcycles/cloud-storage-lib/latest.svg)](https://www.npmjs.com/package/@naturalcycles/cloud-storage-lib)
+[![min.gz size](https://badgen.net/bundlephobia/minzip/@naturalcycles/cloud-storage-lib)](https://bundlephobia.com/result?p=@naturalcycles/cloud-storage-lib)
+[![code style: prettier](https://img.shields.io/badge/code_style-prettier-ff69b4.svg?style=flat-square)](https://github.com/prettier/prettier)
+
+Implements:
+
+- `CommonStorage`
+- `CommonKeyValueDB`
+
+Exports:
+
+- `CommonStorage`
+- `CommonStorageBucket`
+- `CloudStorage`
+- `CommonStorageKeyValueDB`
+- `InMemoryCommonStorage`

package/src/cloudStorage.ts

@@ -0,0 +1,171 @@
+import * as Buffer from 'buffer'
+import { Readable, Writable } from 'stream'
+import { Bucket, File, Storage } from '@google-cloud/storage'
+import { ReadableTyped, transformMap, transformMapSimple } from '@naturalcycles/nodejs-lib'
+import { CommonStorage, CommonStorageGetOptions, FileEntry } from './commonStorage'
+import { GCPServiceAccount } from './model'
+
+/**
+ * This object is intentionally made to NOT extend StorageOptions,
+ * because StorageOptions is complicated and provides just too many ways
+ * to configure credentials.
+ *
+ * Here we define the minimum simple set of credentials needed.
+ * All of these properties are available from the "service account" json file
+ * (either personal one or non-personal).
+ */
+export interface CloudStorageCfg {
+  credentials: GCPServiceAccount
+}
+
+export class CloudStorage implements CommonStorage {
+  constructor(public cfg: CloudStorageCfg) {
+    this.storage = new Storage({
+      credentials: cfg.credentials,
+      // Explicitly passing it here to fix this error:
+      // Error: Unable to detect a Project Id in the current environment.
+      // To learn more about authentication and Google APIs, visit:
+      // https://cloud.google.com/docs/authentication/getting-started
+      //     at /root/repo/node_modules/google-auth-library/build/src/auth/googleauth.js:95:31
+      projectId: cfg.credentials.project_id,
+    })
+  }
+
+  storage: Storage
+
+  // async createBucket(bucketName: string): Promise<void> {
+  //   const bucket = await this.storage.createBucket(bucketName)
+  //   console.log(bucket) // debugging
+  // }
+
+  async ping(bucketName?: string): Promise<void> {
+    await this.storage.bucket(bucketName || 'non-existing-for-sure').exists()
+  }
+
+  async getBucketNames(opt: CommonStorageGetOptions = {}): Promise<string[]> {
+    const [buckets] = await this.storage.getBuckets({
+      maxResults: opt.limit,
+    })
+
+    return buckets.map(b => b.name)
+  }
+
+  getBucketNamesStream(): ReadableTyped<string> {
+    return this.storage.getBucketsStream().pipe(transformMapSimple<Bucket, string>(b => b.name))
+  }
+
+  async deletePath(bucketName: string, prefix: string): Promise<void> {
+    await this.storage.bucket(bucketName).deleteFiles({
+      prefix,
+      // to keep going in case error occurs, similar to THROW_AGGREGATED
+      force: true,
+    })
+  }
+
+  async fileExists(bucketName: string, filePath: string): Promise<boolean> {
+    const [exists] = await this.storage.bucket(bucketName).file(filePath).exists()
+    return exists
+  }
+
+  async getFileNames(bucketName: string, prefix: string): Promise<string[]> {
+    const [files] = await this.storage.bucket(bucketName).getFiles({
+      prefix,
+    })
+    return files.map(f => f.name)
+  }
+
+  getFileNamesStream(
+    bucketName: string,
+    prefix: string,
+    opt: CommonStorageGetOptions = {},
+  ): ReadableTyped<string> {
+    return this.storage
+      .bucket(bucketName)
+      .getFilesStream({
+        prefix,
+        maxResults: opt.limit,
+      })
+      .pipe(transformMapSimple<File, string>(f => f.name))
+  }
+
+  getFilesStream(
+    bucketName: string,
+    prefix: string,
+    opt: CommonStorageGetOptions = {},
+  ): ReadableTyped<FileEntry> {
+    return this.storage
+      .bucket(bucketName)
+      .getFilesStream({
+        prefix,
+        maxResults: opt.limit,
+      })
+      .pipe(
+        transformMap<File, FileEntry>(async f => {
+          const [content] = await f.download()
+          return { filePath: f.name, content }
+        }),
+      )
+  }
+
+  async getFile(bucketName: string, filePath: string): Promise<Buffer | null> {
+    const [buf] = await this.storage
+      .bucket(bucketName)
+      .file(filePath)
+      .download()
+      .catch(err => {
+        if (err?.code === 404) return [null] // file not found
+        throw err // rethrow otherwise
+      })
+
+    return buf
+  }
+
+  /**
+   * Returns a Readable that is NOT object mode,
+   * so you can e.g pipe it to fs.createWriteStream()
+   */
+  getFileReadStream(bucketName: string, filePath: string): Readable {
+    return this.storage.bucket(bucketName).file(filePath).createReadStream()
+  }
+
+  async saveFile(bucketName: string, filePath: string, content: Buffer): Promise<void> {
+    await this.storage.bucket(bucketName).file(filePath).save(content)
+  }
+
+  getFileWriteStream(bucketName: string, filePath: string): Writable {
+    return this.storage.bucket(bucketName).file(filePath).createWriteStream()
+  }
+
+  async setFileVisibility(bucketName: string, filePath: string, isPublic: boolean): Promise<void> {
+    await this.storage.bucket(bucketName).file(filePath)[isPublic ? 'makePublic' : 'makePrivate']()
+  }
+
+  async getFileVisibility(bucketName: string, filePath: string): Promise<boolean> {
+    const [isPublic] = await this.storage.bucket(bucketName).file(filePath).isPublic()
+    return isPublic
+  }
+
+  async copyFile(
+    fromBucket: string,
+    fromPath: string,
+    toPath: string,
+    toBucket?: string,
+  ): Promise<void> {
+    await this.storage
+      .bucket(fromBucket)
+      .file(fromPath)
+      .copy(this.storage.bucket(toBucket || fromBucket).file(toPath))
+  }
+
+  async moveFile(
+    fromBucket: string,
+    fromPath: string,
+    toPath: string,
+    toBucket?: string,
+  ): Promise<void> {
+    await this.storage
+      .bucket(fromBucket)
+      .file(fromPath)
+      .move(this.storage.bucket(toBucket || fromBucket).file(toPath))
+  }
+}

package/src/commonStorage.ts

@@ -0,0 +1,103 @@
+import { Readable, Writable } from 'stream'
+import { ReadableTyped } from '@naturalcycles/nodejs-lib'
+
+export interface FileEntry {
+  filePath: string
+  content: Buffer
+}
+
+// TODO: move it away to a separate repo
+
+export interface CommonStorageGetOptions {
+  /**
+   * Will filter resulting files based on `prefix`.
+   */
+  prefix?: string
+
+  /**
+   * Limits the number of results.
+   *
+   * By default it's unlimited.
+   */
+  limit?: number
+}
+
+/**
+ * Common denominator interface for File Storage.
+ * Modelled after GCP Cloud Storage, Firebase Storage.
+ *
+ * Uses the concept of Bucket (identified by string name) and Path within the Bucket.
+ *
+ * Path MUST NOT start with a slash !
+ *
+ * Similarly to CommonDB, Bucket is like a Table, and Path is like an `id`.
+ */
+export interface CommonStorage {
+  /**
+   * Ensure that the credentials are correct and the connection is working.
+   * Idempotent.
+   *
+   * Pass `bucketName` in case you only have permissions to operate on that bucket.
+   */
+  ping(bucketName?: string): Promise<void>
+
+  /**
+   * Often needs a special permission.
+   */
+  getBucketNames(opt?: CommonStorageGetOptions): Promise<string[]>
+
+  getBucketNamesStream(): ReadableTyped<string>
+
+  /**
+   * Creates a new bucket by given name.
+   * todo: check what to do if it already exists
+   */
+  // createBucket(bucketName: string): Promise<void>
+
+  fileExists(bucketName: string, filePath: string): Promise<boolean>
+
+  getFile(bucketName: string, filePath: string): Promise<Buffer | null>
+
+  saveFile(bucketName: string, filePath: string, content: Buffer): Promise<void>
+
+  /**
+   * Should recursively delete all files in a folder, if path is a folder.
+   */
+  deletePath(bucketName: string, prefix: string): Promise<void>
+
+  /**
+   * Returns an array of strings which are file paths.
+   * Files that are not found by the path are not present in the map.
+   *
+   * Second argument is called `prefix` (same as `path`) to explain how
+   * listing works (it filters all files by `startsWith`). Also, to match
+   * GCP Cloud Storage API.
+   *
+   * Important difference between `prefix` and `path` is that `prefix` will
+   * return all files from sub-directories too!
+   */
+  getFileNames(bucketName: string, prefix: string): Promise<string[]>
+
+  getFileNamesStream(
+    bucketName: string,
+    prefix: string,
+    opt?: CommonStorageGetOptions,
+  ): ReadableTyped<string>
+
+  getFilesStream(
+    bucketName: string,
+    prefix: string,
+    opt?: CommonStorageGetOptions,
+  ): ReadableTyped<FileEntry>
+
+  getFileReadStream(bucketName: string, filePath: string): Readable
+
+  getFileWriteStream(bucketName: string, filePath: string): Writable
+
+  setFileVisibility(bucketName: string, filePath: string, isPublic: boolean): Promise<void>
+
+  getFileVisibility(bucketName: string, filePath: string): Promise<boolean>
+
+  copyFile(fromBucket: string, fromPath: string, toPath: string, toBucket?: string): Promise<void>
+  moveFile(fromBucket: string, fromPath: string, toPath: string, toBucket?: string): Promise<void>
+}

package/src/commonStorageBucket.ts

@@ -0,0 +1,171 @@
+import { Readable, Writable } from 'stream'
+import { AppError, pMap } from '@naturalcycles/js-lib'
+import { ReadableTyped } from '@naturalcycles/nodejs-lib'
+import { CommonStorage, CommonStorageGetOptions, FileEntry } from './commonStorage'
+
+export interface CommonStorageBucketCfg {
+  storage: CommonStorage
+  bucketName: string
+}
+
+/**
+ * Convenience wrapper around CommonStorage for a given Bucket.
+ *
+ * Similar to what CommonDao is to CommonDB.
+ */
+export class CommonStorageBucket {
+  constructor(public cfg: CommonStorageBucketCfg) {}
+
+  async ping(bucketName?: string): Promise<void> {
+    await this.cfg.storage.ping(bucketName)
+  }
+
+  async fileExists(filePath: string): Promise<boolean> {
+    return await this.cfg.storage.fileExists(this.cfg.bucketName, filePath)
+  }
+
+  async getFile(filePath: string): Promise<Buffer | null> {
+    return await this.cfg.storage.getFile(this.cfg.bucketName, filePath)
+  }
+
+  async getFileAsString(filePath: string): Promise<string | null> {
+    const buf = await this.cfg.storage.getFile(this.cfg.bucketName, filePath)
+    return buf?.toString() || null
+  }
+
+  async getFileAsJson<T = any>(filePath: string): Promise<T | null> {
+    const buf = await this.cfg.storage.getFile(this.cfg.bucketName, filePath)
+    if (!buf) return null
+    return JSON.parse(buf.toString())
+  }
+
+  async requireFile(filePath: string): Promise<Buffer> {
+    const buf = await this.cfg.storage.getFile(this.cfg.bucketName, filePath)
+    if (!buf) this.throwRequiredError(filePath)
+    return buf
+  }
+
+  async requireFileAsString(filePath: string): Promise<string> {
+    const s = await this.getFileAsString(filePath)
+    return s ?? this.throwRequiredError(filePath)
+  }
+
+  async requireFileAsJson<T = any>(filePath: string): Promise<T> {
+    const v = await this.getFileAsJson<T>(filePath)
+    return v ?? this.throwRequiredError(filePath)
+  }
+
+  private throwRequiredError(filePath: string): never {
+    throw new AppError(`File required, but not found: ${this.cfg.bucketName}/${filePath}`, {
+      code: 'FILE_REQUIRED',
+    })
+  }
+
+  async getFileContents(paths: string[]): Promise<Buffer[]> {
+    return (
+      await pMap(
+        paths,
+        async filePath => (await this.cfg.storage.getFile(this.cfg.bucketName, filePath))!,
+      )
+    ).filter(Boolean)
+  }
+
+  async getFileContentsAsJson<T = any>(paths: string[]): Promise<T[]> {
+    return (
+      await pMap(paths, async filePath => {
+        const buf = await this.cfg.storage.getFile(this.cfg.bucketName, filePath)
+        return buf ? JSON.parse(buf.toString()) : null
+      })
+    ).filter(Boolean)
+  }
+
+  async getFileEntries(paths: string[]): Promise<FileEntry[]> {
+    return (
+      await pMap(paths, async filePath => {
+        const content = await this.cfg.storage.getFile(this.cfg.bucketName, filePath)
+        return { filePath, content: content! }
+      })
+    ).filter(f => f.content)
+  }
+
+  async getFileEntriesAsJson<T = any>(
+    paths: string[],
+  ): Promise<{ filePath: string; content: T }[]> {
+    return (
+      await pMap(paths, async filePath => {
+        const buf = await this.cfg.storage.getFile(this.cfg.bucketName, filePath)
+        return buf ? { filePath, content: JSON.parse(buf.toString()) } : (null as any)
+      })
+    ).filter(Boolean)
+  }
+
+  async saveFile(filePath: string, content: Buffer): Promise<void> {
+    await this.cfg.storage.saveFile(this.cfg.bucketName, filePath, content)
+  }
+
+  async saveFiles(entries: FileEntry[]): Promise<void> {
+    await pMap(entries, async f => {
+      await this.cfg.storage.saveFile(this.cfg.bucketName, f.filePath, f.content)
+    })
+  }
+
+  /**
+   * Should recursively delete all files in a folder, if path is a folder.
+   */
+  async deletePath(prefix: string): Promise<void> {
+    return await this.cfg.storage.deletePath(this.cfg.bucketName, prefix)
+  }
+
+  async deletePaths(prefixes: string[]): Promise<void> {
+    await pMap(prefixes, async prefix => {
+      return await this.cfg.storage.deletePath(this.cfg.bucketName, prefix)
+    })
+  }
+
+  /**
+   * Returns an array of strings which are file paths.
+   * Files that are not found by the path are not present in the map.
+   *
+   * Second argument is called `prefix` (same as `path`) to explain how
+   * listing works (it filters all files by `startsWith`). Also, to match
+   * GCP Cloud Storage API.
+   *
+   * Important difference between `prefix` and `path` is that `prefix` will
+   * return all files from sub-directories too!
+   */
+  async getFileNames(prefix: string): Promise<string[]> {
+    return await this.cfg.storage.getFileNames(this.cfg.bucketName, prefix)
+  }
+
+  getFileNamesStream(prefix: string, opt?: CommonStorageGetOptions): ReadableTyped<string> {
+    return this.cfg.storage.getFileNamesStream(this.cfg.bucketName, prefix, opt)
+  }
+
+  getFilesStream(prefix: string, opt?: CommonStorageGetOptions): ReadableTyped<FileEntry> {
+    return this.cfg.storage.getFilesStream(this.cfg.bucketName, prefix, opt)
+  }
+
+  getFileReadStream(filePath: string): Readable {
+    return this.cfg.storage.getFileReadStream(this.cfg.bucketName, filePath)
+  }
+
+  getFileWriteStream(filePath: string): Writable {
+    return this.cfg.storage.getFileWriteStream(this.cfg.bucketName, filePath)
+  }
+
+  async setFileVisibility(filePath: string, isPublic: boolean): Promise<void> {
+    await this.cfg.storage.setFileVisibility(this.cfg.bucketName, filePath, isPublic)
+  }
+
+  async getFileVisibility(filePath: string): Promise<boolean> {
+    return await this.cfg.storage.getFileVisibility(this.cfg.bucketName, filePath)
+  }
+
+  async copyFile(fromPath: string, toPath: string, toBucket?: string): Promise<void> {
+    await this.cfg.storage.copyFile(this.cfg.bucketName, fromPath, toPath, toBucket)
+  }
+
+  async moveFile(fromPath: string, toPath: string, toBucket?: string): Promise<void> {
+    await this.cfg.storage.moveFile(this.cfg.bucketName, fromPath, toPath, toBucket)
+  }
+}