@tweedegolf/sab-adapter-backblaze-b2 1.0.7 → 3.0.0

package/README.md

@@ -11,10 +11,10 @@ It is also possible to access all the specific functionality of the cloud servic
 If you are new to the Storage Abstraction library you may want to read [this](https://github.com/tweedegolf/storage-abstraction/blob/master/README.md#how-it-works) first.
 
 ```typescript
-import { Storage, StorageType } from "@tweedegolf/storage-abstraction";
+import { Storage, Provider } from "@tweedegolf/storage-abstraction";
 
 const configuration = {
-  type: StorageType.B2,
+  type: Provider.B2,
   applicationKey: "key",
   applicationKeyId: "keyId",
 };
@@ -28,13 +28,13 @@ console.log(result);
 
 The Storage class is cloud service agnostic and doesn't know anything about the adapter it uses and adapters are completely interchangeable. It only expects the adapter to have implemented all methods of the `IAdapter` interface, see the [API](https://github.com/tweedegolf/storage-abstraction/blob/master/README.md#adapter-api).
 
-When you create a Storage instance it checks the mandatory `type` key in the configuration object and then loads the appropriate adapter module automatically from your node_modules folder using `require()`. For more information please read [this](https://github.com/tweedegolf/storage-abstraction/blob/master/README.md#register-your-adapter).
+When you create a Storage instance it checks the mandatory `provider` key in the configuration object and then loads the appropriate adapter module automatically from your node_modules folder using `require()`. For more information please read [this](https://github.com/tweedegolf/storage-abstraction/blob/master/README.md#register-your-adapter).
 
 ## Configuration
 
 The configuration object that you pass to the Storage constructor is forwarded to the constructor of the adapter.
 
-The Storage constructor is only interested in the `type` key of the configuration object, all other keys are necessary for configuring the adapter.
+The Storage constructor is only interested in the `provider` key of the configuration object, all other keys are necessary for configuring the adapter.
 
 The Storage constructor expects the configuration to be of type `StorageAdapterConfig`.
 
@@ -66,13 +66,13 @@ Examples with configuration object:
 
 ```typescript
 const s = new Storage({
-  type: StorageType.B2,
+  type: Provider.B2,
   applicationKeyId: "your-key-id",
   applicationKey: "your-key",
 });
 
 const s = new Storage({
-  type: StorageType.B2,
+  type: Provider.B2,
   applicationKeyId: "your-key-id",
   applicationKey: "your-key",
   bucketName: "the-buck",

package/changelog.md

@@ -1,3 +1,12 @@
+# 3.0.0
+- version bump to match the version of Storage and the API
+- removed support for versioning (wasn't implemented consistently anyway)
+- removed `getFileAsURL`
+- removed option `{allVersions: boolean}` for `removeFile`
+- `removeFile` does not fail if the file doesn't exist
+- `deleteBucket` does not fail if the bucket doesn't exist
+- see also the [migration guide](https://github.com/tweedegolf/storage-abstraction/blob/master/migration_to_api3.0.md)
+
 # 1.0.7
 - include @deprecated functions
 

package/dist/AbstractAdapter.d.ts

@@ -1,15 +1,15 @@
-import { AdapterConfig, IAdapter, Options, StreamOptions } from "./types/general";
+import { AdapterConfig, IAdapter, Options, Provider, StreamOptions } from "./types/general";
 import { FileBufferParams, FilePathParams, FileStreamParams } from "./types/add_file_params";
-import { ResultObject, ResultObjectBoolean, ResultObjectBuckets, ResultObjectFiles, ResultObjectNumber, ResultObjectStream } from "./types/result";
+import { ResultObject, ResultObjectBoolean, ResultObjectBuckets, ResultObjectFiles, ResultObjectNumber, ResultObjectObject, ResultObjectStream } from "./types/result";
 export declare abstract class AbstractAdapter implements IAdapter {
-    protected _type: string;
+    protected _provider: Provider;
     protected _config: AdapterConfig | null;
     protected _configError: string | null;
     protected _bucketName: string;
     protected _client: any;
     constructor(config: string | AdapterConfig);
-    get type(): string;
-    getType(): string;
+    get provider(): Provider;
+    getProvider(): Provider;
     get config(): AdapterConfig;
     getConfig(): AdapterConfig;
     get configError(): string;
@@ -22,24 +22,9 @@ export declare abstract class AbstractAdapter implements IAdapter {
     get selectedBucket(): string | null;
     set bucketName(bucketName: string | null);
     get bucketName(): string | null;
-    addFileFromPath(params: FilePathParams): Promise<ResultObject>;
-    addFileFromBuffer(params: FileBufferParams): Promise<ResultObject>;
-    addFileFromStream(params: FileStreamParams): Promise<ResultObject>;
-    protected _getFileAndBucketAndOptions(...args: [
-        bucketName: string,
-        fileName: string,
-        options?: boolean | Options | StreamOptions
-    ] | [
-        fileName: string,
-        options?: boolean | Options | StreamOptions
-    ] | [
-        options: boolean | Options | StreamOptions
-    ]): {
-        bucketName: string;
-        fileName: string;
-        options: object | boolean;
-        error: string;
-    };
+    private getFileAndBucketAndOptions;
+    private checkBucket;
+    private checkFile;
     protected abstract _listBuckets(): Promise<ResultObjectBuckets>;
     protected abstract _createBucket(name: string, options: Options): Promise<ResultObject>;
     protected abstract _clearBucket(name: string): Promise<ResultObject>;
@@ -51,10 +36,10 @@ export declare abstract class AbstractAdapter implements IAdapter {
     protected abstract _addFile(params: FilePathParams | FileBufferParams | FileStreamParams): Promise<ResultObject>;
     protected abstract _fileExists(bucketName: string, fileName: string): Promise<ResultObjectBoolean>;
     protected abstract _getFileAsStream(bucketName: string, fileName: string, options: StreamOptions): Promise<ResultObjectStream>;
-    protected abstract _getFileAsURL(bucketName: string, fileName: string, options: Options): Promise<ResultObject>;
     protected abstract _getPublicURL(bucketName: string, fileName: string, options: Options): Promise<ResultObject>;
     protected abstract _getSignedURL(bucketName: string, fileName: string, options: Options): Promise<ResultObject>;
-    protected abstract _removeFile(bucketName: string, fileName: string, allVersions: boolean): Promise<ResultObject>;
+    protected abstract _removeFile(bucketName: string, fileName: string): Promise<ResultObject>;
+    protected abstract _getPresignedUploadURL(bucketName: string, fileName: string, options: Options): Promise<ResultObjectObject>;
     listBuckets(): Promise<ResultObjectBuckets>;
     createBucket(...args: [
         bucketName?: string,
@@ -74,6 +59,9 @@ export declare abstract class AbstractAdapter implements IAdapter {
     ] | [
         bucketName?: string
     ]): Promise<ResultObjectFiles>;
+    addFileFromPath(params: FilePathParams): Promise<ResultObject>;
+    addFileFromBuffer(params: FileBufferParams): Promise<ResultObject>;
+    addFileFromStream(params: FileStreamParams): Promise<ResultObject>;
     addFile(params: FilePathParams | FileBufferParams | FileStreamParams): Promise<ResultObject>;
     getFileAsStream(...args: [
         bucketName: string,
@@ -83,17 +71,6 @@ export declare abstract class AbstractAdapter implements IAdapter {
         fileName: string,
         options?: StreamOptions
     ]): Promise<ResultObjectStream>;
-    /**
-     * @deprecated: please use getPublicURL or getSignedURL
-     */
-    getFileAsURL(...args: [
-        bucketName: string,
-        fileName: string,
-        options?: Options
-    ] | [
-        fileName: string,
-        options?: Options
-    ]): Promise<ResultObject>;
     getPublicURL(...args: [
         bucketName: string,
         fileName: string,
@@ -123,11 +100,17 @@ export declare abstract class AbstractAdapter implements IAdapter {
         fileName: string
     ]): Promise<ResultObjectBoolean>;
     removeFile(...args: [
+        bucketName: string,
+        fileName: string
+    ] | [
+        fileName: string
+    ]): Promise<ResultObject>;
+    getPresignedUploadURL(...args: [
         bucketName: string,
         fileName: string,
-        allVersions?: boolean
+        options?: Options
     ] | [
         fileName: string,
-        allVersions?: boolean
-    ]): Promise<ResultObject>;
+        options?: Options
+    ]): Promise<ResultObjectObject>;
 }

package/dist/AbstractAdapter.js

@@ -1,19 +1,24 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AbstractAdapter = void 0;
+const fs_1 = __importDefault(require("fs"));
+const general_1 = require("./types/general");
 const util_1 = require("./util");
 class AbstractAdapter {
     constructor(config) {
-        this._type = "abstract-adapter";
+        this._provider = general_1.Provider.NONE;
         this._configError = null;
         this._bucketName = null;
         this._client = null; // eslint-disable-line
     }
-    get type() {
-        return this._type;
+    get provider() {
+        return this._provider;
     }
-    getType() {
-        return this.type;
+    getProvider() {
+        return this.provider;
     }
     get config() {
         return this._config;
@@ -53,18 +58,9 @@ class AbstractAdapter {
     get bucketName() {
         return this._bucketName;
     }
-    async addFileFromPath(params) {
-        return await this.addFile(params);
-    }
-    async addFileFromBuffer(params) {
-        return await this.addFile(params);
-    }
-    async addFileFromStream(params) {
-        return await this.addFile(params);
-    }
-    _getFileAndBucketAndOptions(...args) {
+    getFileAndBucketAndOptions(...args) {
         const [arg1, arg2, arg3] = args;
-        // console.log("_getFileAndBucketAndOptions", arg1, arg2, arg3);
+        // console.log("getFileAndBucketAndOptions", arg1, arg2, arg3);
         let bucketName = null;
         let fileName = null;
         let options = {};
@@ -109,6 +105,40 @@ class AbstractAdapter {
             return { bucketName, fileName, options, error: "Please provide a filename" };
         }
     }
+    async checkBucket(name, checkIfExists = true) {
+        if (this._configError !== null) {
+            return { value: null, error: this.configError };
+        }
+        if (typeof name === "undefined") {
+            if (this._bucketName === null) {
+                return {
+                    value: null,
+                    error: "No bucket selected.",
+                };
+            }
+            name = this._bucketName;
+        }
+        if (checkIfExists === true) {
+            const { value, error } = await this._bucketExists(name);
+            if (error !== null) {
+                return { value: null, error };
+            }
+            else if (value === false) {
+                return { value: null, error: `No bucket '${name}' found.` };
+            }
+        }
+        return { value: name, error: null };
+    }
+    async checkFile(bucketName, fileName) {
+        const r = await this._fileExists(bucketName, fileName);
+        if (r.error) {
+            return { value: null, error: r.error };
+        }
+        if (r.value === false) {
+            return { value: null, error: `No file '${fileName}' found in bucket '${bucketName}'` };
+        }
+        return { value: null, error: null };
+    }
     // public
     async listBuckets() {
         if (this._configError !== null) {
@@ -121,94 +151,77 @@ class AbstractAdapter {
             return { value: null, error: this.configError };
         }
         const [arg1, arg2] = args;
-        let bucketName;
+        let name;
         if (typeof arg1 !== "string") {
             if (this._bucketName === null) {
                 return {
                     value: null,
-                    error: "no bucket selected",
+                    error: "No bucket selected.",
                 };
             }
-            bucketName = this._bucketName;
+            name = this._bucketName;
         }
         else {
-            bucketName = arg1;
-            const error = (0, util_1.validateName)(bucketName);
+            name = arg1;
+            const error = (0, util_1.validateName)(name, this.provider);
             if (error !== null) {
                 return { value: null, error };
             }
         }
-        return this._createBucket(bucketName, arg2 || {});
+        const { value, error } = await this.bucketExists(name);
+        if (error !== null) {
+            return { value: null, error };
+        }
+        else if (value === true) {
+            return { value: null, error: `Bucket '${name}' already exists.` };
+        }
+        return this._createBucket(name, arg2 || {});
     }
     async clearBucket(name) {
-        if (this._configError !== null) {
-            return { value: null, error: this.configError };
-        }
-        if (typeof name === "undefined") {
-            if (this._bucketName === null) {
-                return {
-                    value: null,
-                    error: "no bucket selected",
-                };
-            }
-            name = this._bucketName;
+        const r = await this.checkBucket(name, true);
+        if (r.error !== null) {
+            return { value: null, error: r.error };
         }
+        name = r.value;
         return this._clearBucket(name);
     }
     async deleteBucket(name) {
-        if (this._configError !== null) {
-            return { value: null, error: this.configError };
-        }
-        if (typeof name === "undefined") {
-            if (this._bucketName === null) {
-                return {
-                    value: null,
-                    error: "no bucket selected",
-                };
+        const r = await this.checkBucket(name, true);
+        if (r.error !== null) {
+            if (r.error === `No bucket '${name}' found.`) {
+                return { value: r.error, error: null };
+            }
+            else {
+                return r;
             }
-            name = this._bucketName;
         }
+        name = r.value;
         if (this.selectedBucket === name) {
             this.selectedBucket = null;
         }
         return this._deleteBucket(name);
     }
     async bucketExists(name) {
-        if (this._configError !== null) {
-            return { value: null, error: this.configError };
-        }
-        if (typeof name === "undefined") {
-            if (this._bucketName === null) {
-                return { value: null, error: "no bucket selected" };
-            }
-            name = this._bucketName;
+        const r = await this.checkBucket(name, false);
+        if (r.error !== null) {
+            return { value: null, error: r.error };
         }
+        name = r.value;
         return this._bucketExists(name);
     }
     async bucketIsPublic(name) {
-        if (this._configError !== null) {
-            return { value: null, error: this.configError };
-        }
-        if (typeof name === "undefined") {
-            if (this._bucketName === null) {
-                return { value: null, error: "no bucket selected" };
-            }
-            name = this._bucketName;
+        const r = await this.checkBucket(name, true);
+        if (r.error !== null) {
+            return { value: null, error: r.error };
         }
+        name = r.value;
         return this._bucketIsPublic(name);
     }
     async listFiles(...args) {
-        if (this._configError !== null) {
-            return { value: null, error: this.configError };
-        }
         const [arg1, arg2] = args;
         let bucketName;
         let numFiles = 10000;
         if (typeof arg1 === "number") {
-            if (this._bucketName === null) {
-                return { value: null, error: "no bucket selected" };
-            }
-            bucketName = this._bucketName;
             numFiles = arg1;
         }
         else if (typeof arg1 === "string") {
@@ -217,115 +230,158 @@ class AbstractAdapter {
                 numFiles = arg2;
             }
         }
-        else {
-            if (this._bucketName === null) {
-                return { value: null, error: "no bucket selected" };
-            }
-            bucketName = this._bucketName;
+        const r = await this.checkBucket(bucketName, true);
+        if (r.error) {
+            return { value: null, error: r.error };
         }
-        return this._listFiles(bucketName, numFiles);
+        // console.log(bucketName, numFiles)
+        return this._listFiles(r.value, numFiles);
+    }
+    async addFileFromPath(params) {
+        return await this.addFile(params);
+    }
+    async addFileFromBuffer(params) {
+        return await this.addFile(params);
+    }
+    async addFileFromStream(params) {
+        return await this.addFile(params);
     }
     async addFile(params) {
-        if (this._configError !== null) {
-            return { value: null, error: this.configError };
-        }
-        const { bucketName, fileName: _fn, options, error } = this._getFileAndBucketAndOptions(params.bucketName, params.targetPath, params.options);
+        const { bucketName, fileName: _fn, options, error } = this.getFileAndBucketAndOptions(params.bucketName, params.targetPath, params.options);
         if (error !== null) {
             return { value: null, error };
         }
-        params.bucketName = bucketName;
-        params.options = options === null ? {} : options;
-        return this._addFile(params);
+        const r = await this.checkBucket(bucketName);
+        if (r.error !== null) {
+            return { value: null, error: r.error };
+        }
+        else {
+            params.bucketName = r.value;
+            params.options = options === null ? {} : options;
+        }
+        let fh = null;
+        if (typeof params.origPath === "string") {
+            const f = params.origPath;
+            try {
+                fh = await fs_1.default.promises.open(f);
+            }
+            catch (e) {
+                return { value: null, error: e.message };
+            }
+            const readStream = fs_1.default.createReadStream(f);
+            delete params.origPath;
+            params.stream = readStream;
+        }
+        const r2 = await this._addFile(params);
+        if (fh !== null) {
+            fh.close();
+        }
+        return r2;
     }
     async getFileAsStream(...args) {
-        if (this.configError !== null) {
-            return { error: this.configError, value: null };
-        }
-        const { bucketName, fileName, options, error } = this._getFileAndBucketAndOptions(...args);
+        const { bucketName, fileName, options, error } = this.getFileAndBucketAndOptions(...args);
         // console.log(bucketName, fileName, options, error);
         if (error !== null) {
             return { error, value: null };
         }
-        return this._getFileAsStream(bucketName, fileName, options === null ? {} : options);
-    }
-    /**
-     * @deprecated: please use getPublicURL or getSignedURL
-     */
-    async getFileAsURL(...args) {
-        if (this._configError !== null) {
-            return { value: null, error: this.configError };
+        const r = await this.checkBucket(bucketName);
+        if (r.error !== null) {
+            return { value: null, error: r.error };
         }
-        const { bucketName, fileName, options, error } = this._getFileAndBucketAndOptions(...args);
-        if (error !== null) {
-            return { error, value: null };
+        const r2 = await this.checkFile(r.value, fileName);
+        if (r2.error !== null) {
+            return { value: null, error: r2.error };
         }
-        return this._getFileAsURL(bucketName, fileName, options === null ? {} : options);
+        return this._getFileAsStream(r.value, fileName, options === null ? {} : options);
     }
     async getPublicURL(...args) {
-        const { bucketName, fileName, options: opt, error } = this._getFileAndBucketAndOptions(...args);
+        const { bucketName, fileName, options: opt, error } = this.getFileAndBucketAndOptions(...args);
         if (error !== null) {
             return { error, value: null };
         }
+        const r = await this.checkBucket(bucketName);
+        if (r.error !== null) {
+            return { value: null, error: r.error };
+        }
+        const r2 = await this.checkFile(r.value, fileName);
+        if (r2.error !== null) {
+            return { value: null, error: r2.error };
+        }
         const options = opt === null ? {} : opt;
-        return this._getPublicURL(bucketName, fileName, options);
+        return this._getPublicURL(r.value, fileName, options);
     }
     async getSignedURL(...args) {
-        const { bucketName, fileName, options, error } = this._getFileAndBucketAndOptions(...args);
+        const { bucketName, fileName, options, error } = this.getFileAndBucketAndOptions(...args);
         if (error !== null) {
             return { error, value: null };
         }
-        return this._getSignedURL(bucketName, fileName, options === null ? {} : options);
+        const r = await this.checkBucket(bucketName);
+        if (r.error !== null) {
+            return { value: null, error: r.error };
+        }
+        const r2 = await this.checkFile(r.value, fileName);
+        if (r2.error !== null) {
+            return { value: null, error: r2.error };
+        }
+        return this._getSignedURL(r.value, fileName, options === null ? {} : options);
     }
     async sizeOf(...args) {
-        if (this.configError !== null) {
-            return { value: null, error: this.configError };
-        }
-        const { bucketName, fileName, options: _o, error } = this._getFileAndBucketAndOptions(...args);
+        const { bucketName, fileName, options: _o, error } = this.getFileAndBucketAndOptions(...args);
         if (error !== null) {
             return { value: null, error };
         }
-        return this._sizeOf(bucketName, fileName);
+        const r = await this.checkBucket(bucketName);
+        if (r.error !== null) {
+            return { value: null, error: r.error };
+        }
+        const r2 = await this.checkFile(r.value, fileName);
+        if (r2.error !== null) {
+            return { value: null, error: r2.error };
+        }
+        return this._sizeOf(r.value, fileName);
     }
     async fileExists(...args) {
-        if (this.configError !== null) {
-            return { value: null, error: this.configError };
-        }
-        const { bucketName, fileName, options: _o, error } = this._getFileAndBucketAndOptions(...args);
+        const { bucketName, fileName, options: _o, error } = this.getFileAndBucketAndOptions(...args);
         if (error !== null) {
             return { value: null, error };
         }
-        return this._fileExists(bucketName, fileName);
+        const r = await this.checkBucket(bucketName);
+        if (r.error !== null) {
+            return { value: null, error: r.error };
+        }
+        return this._fileExists(r.value, fileName);
     }
     async removeFile(...args) {
-        if (this.configError !== null) {
-            return { value: null, error: this.configError };
-        }
-        if (this.configError !== null) {
-            return { value: null, error: this.configError };
-        }
-        const { bucketName, fileName, options: allVersions, error } = this._getFileAndBucketAndOptions(...args);
+        const { bucketName, fileName, options: _allVersions, error } = this.getFileAndBucketAndOptions(...args);
         if (error !== null) {
             return { error, value: null };
         }
-        /*
-            let r = await this.bucketExists(bucketName);
-            if (r.error) {
-              return { value: null, error: r.error }
-            }
-            if (r.value === false) {
-              return { value: null, error: `No bucket '${bucketName}' found` }
-            }
-        
-            // check if file exists, this is especially necessary for Backblaze B2 with S3 adapter!
-            r = await this.fileExists(bucketName, fileName);
-            if (r.error) {
-              return { value: null, error: r.error }
+        const r = await this.checkBucket(bucketName);
+        if (r.error !== null) {
+            return { value: null, error: r.error };
+        }
+        // check if file exists, this is especially necessary for Backblaze B2 with S3 adapter!
+        const r2 = await this.checkFile(r.value, fileName);
+        if (r2.error !== null) {
+            if (r2.error.startsWith(`No file '${fileName}' found in bucket`)) {
+                return { value: r2.error, error: null };
             }
-            if (r.value === false) {
-              return { value: null, error: `No file '${fileName}' found in bucket '${bucketName}'` }
+            else {
+                return { value: null, error: r2.error };
             }
-        */
-        return this._removeFile(bucketName, fileName, allVersions === null ? false : allVersions);
+        }
+        return this._removeFile(bucketName, fileName);
+    }
+    async getPresignedUploadURL(...args) {
+        const { bucketName, fileName, options, error } = this.getFileAndBucketAndOptions(...args);
+        if (error !== null) {
+            return { value: null, error };
+        }
+        const r = await this.checkBucket(bucketName);
+        if (r.error !== null) {
+            return { value: null, error: r.error };
+        }
+        return this._getPresignedUploadURL(r.value, fileName, options);
     }
 }
 exports.AbstractAdapter = AbstractAdapter;