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

package/dist/AbstractAdapter.js

@@ -1,4 +1,13 @@
 "use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -12,7 +21,6 @@ class AbstractAdapter {
         this._provider = general_1.Provider.NONE;
         this._configError = null;
         this._bucketName = null;
-        this._client = null; // eslint-disable-line
     }
     get provider() {
         return this._provider;
@@ -61,8 +69,8 @@ class AbstractAdapter {
     getFileAndBucketAndOptions(...args) {
         const [arg1, arg2, arg3] = args;
         // console.log("getFileAndBucketAndOptions", arg1, arg2, arg3);
-        let bucketName = null;
-        let fileName = null;
+        let bucketName = undefined;
+        let fileName = undefined;
         let options = {};
         let error = null;
         if (typeof arg1 !== "string" && typeof arg2 !== "string") {
@@ -77,7 +85,7 @@ class AbstractAdapter {
             return { bucketName, fileName, options, error };
         }
         if (typeof arg1 !== "string" && typeof arg2 === "string") {
-            bucketName = this._bucketName;
+            bucketName = this._bucketName === null ? undefined : this._bucketName;
             if (bucketName === null) {
                 return { bucketName, fileName, options, error: "Please provide or select a bucket" };
             }
@@ -88,7 +96,7 @@ class AbstractAdapter {
             return { bucketName, fileName, options, error };
         }
         if (typeof arg1 === "string" && typeof arg2 !== "string") {
-            bucketName = this._bucketName;
+            bucketName = this._bucketName === null ? undefined : this._bucketName;
             if (bucketName === null) {
                 return { bucketName, fileName, options, error: "Please provide or select a bucket" };
             }
@@ -104,284 +112,354 @@ class AbstractAdapter {
         if (fileName === null) {
             return { bucketName, fileName, options, error: "Please provide a filename" };
         }
+        return { bucketName, fileName, options, error };
     }
-    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.",
-                };
+    checkBucket(name_1) {
+        return __awaiter(this, arguments, void 0, function* (name, checkIfExists = true) {
+            if (this._configError !== null) {
+                return { value: null, error: this.configError };
             }
-            name = this._bucketName;
-        }
-        if (checkIfExists === true) {
-            const { value, error } = await this._bucketExists(name);
-            if (error !== null) {
-                return { value: null, error };
+            if (typeof name === "undefined") {
+                if (this._bucketName === null) {
+                    return {
+                        value: null,
+                        error: "No bucket selected.",
+                    };
+                }
+                name = this._bucketName;
             }
-            else if (value === false) {
-                return { value: null, error: `No bucket '${name}' found.` };
+            if (checkIfExists === true) {
+                const { value, error } = yield 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 };
+            return { value: name, error: null };
+        });
+    }
+    checkFile(bucketName, fileName) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const r = yield 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) {
-            return { value: null, error: this.configError };
-        }
-        return this._listBuckets();
+    listBuckets() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this._configError !== null) {
+                return { value: null, error: this.configError };
+            }
+            return this._listBuckets();
+        });
     }
-    async createBucket(...args) {
-        if (this._configError !== null) {
-            return { value: null, error: this.configError };
-        }
-        const [arg1, arg2] = args;
-        let name;
-        if (typeof arg1 !== "string") {
-            if (this._bucketName === null) {
-                return {
-                    value: null,
-                    error: "No bucket selected.",
-                };
+    createBucket(...args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this._configError !== null) {
+                return { value: null, error: this.configError };
             }
-            name = this._bucketName;
-        }
-        else {
-            name = arg1;
-            const error = (0, util_1.validateName)(name, this.provider);
+            const [arg1, arg2] = args;
+            let name;
+            if (typeof arg1 !== "string") {
+                if (this._bucketName === null) {
+                    return {
+                        value: null,
+                        error: "No bucket selected.",
+                    };
+                }
+                name = this._bucketName;
+            }
+            else {
+                name = arg1;
+                const error = (0, util_1.validateName)(name, this.provider);
+                if (error !== null) {
+                    return { value: null, error };
+                }
+            }
+            const { value, error } = yield this.bucketExists(name);
             if (error !== null) {
                 return { value: null, error };
             }
-        }
-        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) {
-        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) {
-        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 if (value === true) {
+                return { value: null, error: `Bucket '${name}' already exists.` };
+            }
+            return this._createBucket(name, arg2 || {});
+        });
+    }
+    clearBucket(name) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const r = yield this.checkBucket(name, true);
+            if (r.error !== null) {
+                return { value: null, error: r.error };
+            }
+            name = r.value;
+            return this._clearBucket(name);
+        });
+    }
+    deleteBucket(name) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const r = yield 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 = r.value;
+            const data = yield this._clearBucket(name);
+            if (data.error !== null) {
+                return { value: null, error: data.error };
+            }
+            const r2 = yield this._deleteBucket(name);
+            if (r2.error === null) {
+                if (this.selectedBucket === name) {
+                    this.selectedBucket = null;
+                }
+            }
+            return r2;
+        });
+    }
+    bucketExists(name) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const r = yield this.checkBucket(name, false);
+            if (r.error !== null) {
+                return { value: null, error: r.error };
+            }
+            name = r.value;
+            return this._bucketExists(name);
+        });
+    }
+    bucketIsPublic(name) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const r = yield this.checkBucket(name, true);
+            if (r.error !== null) {
+                return { value: null, error: r.error };
+            }
+            name = r.value;
+            return this._bucketIsPublic(name);
+        });
+    }
+    listFiles(...args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const [arg1, arg2] = args;
+            let bucketName = undefined;
+            let numFiles = 10000;
+            if (typeof arg1 === "number") {
+                numFiles = arg1;
+            }
+            else if (typeof arg1 === "string") {
+                bucketName = arg1;
+                if (typeof arg2 === "number") {
+                    numFiles = arg2;
+                }
+            }
+            const r = yield this.checkBucket(bucketName, true);
+            if (r.error) {
+                return { value: null, error: r.error };
+            }
+            // console.log(bucketName, numFiles)
+            return this._listFiles(r.value, numFiles);
+        });
+    }
+    addFileFromPath(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.addFile(params);
+        });
+    }
+    addFileFromBuffer(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.addFile(params);
+        });
+    }
+    addFileFromStream(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.addFile(params);
+        });
+    }
+    addFile(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { bucketName, fileName: _fn, options, error, } = this.getFileAndBucketAndOptions(params.bucketName, params.targetPath, params.options);
+            if (error !== null) {
+                return { value: null, error: error };
+            }
+            let checkIfBucketExists = true;
+            // console.log(bucketName, _fn, options, error);
+            if (typeof options.checkIfBucketExists === "boolean") {
+                checkIfBucketExists = options.checkIfBucketExists;
+            }
+            const r = yield this.checkBucket(bucketName, checkIfBucketExists);
+            if (r.error !== null) {
+                return { value: null, error: r.error };
             }
             else {
-                return r;
+                params.bucketName = r.value;
+                params.options = options === null ? {} : options;
             }
-        }
-        name = r.value;
-        if (this.selectedBucket === name) {
-            this.selectedBucket = null;
-        }
-        return this._deleteBucket(name);
-    }
-    async bucketExists(name) {
-        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) {
-        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) {
-        const [arg1, arg2] = args;
-        let bucketName;
-        let numFiles = 10000;
-        if (typeof arg1 === "number") {
-            numFiles = arg1;
-        }
-        else if (typeof arg1 === "string") {
-            bucketName = arg1;
-            if (typeof arg2 === "number") {
-                numFiles = arg2;
+            let fh = null;
+            if (typeof params.origPath === "string") {
+                const f = params.origPath;
+                try {
+                    fh = yield fs_1.default.promises.open(f);
+                }
+                catch (e) {
+                    return { value: null, error: (0, util_1.getErrorMessage)(e) };
+                }
+                const readStream = fs_1.default.createReadStream(f);
+                params = {
+                    bucketName: params.bucketName,
+                    options: params.options,
+                    stream: readStream,
+                    targetPath: params.targetPath,
+                };
             }
-        }
-        const r = await this.checkBucket(bucketName, true);
-        if (r.error) {
-            return { value: null, error: r.error };
-        }
-        // 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) {
-        const { bucketName, fileName: _fn, options, error } = this.getFileAndBucketAndOptions(params.bucketName, params.targetPath, params.options);
-        if (error !== null) {
-            return { value: null, error };
-        }
-        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;
+            const r2 = yield this._addFile(params);
+            if (fh !== null) {
+                fh.close();
+            }
+            return r2;
+        });
     }
-    async getFileAsStream(...args) {
-        const { bucketName, fileName, options, error } = this.getFileAndBucketAndOptions(...args);
-        // console.log(bucketName, fileName, options, error);
-        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 };
-        }
-        return this._getFileAsStream(r.value, fileName, options === null ? {} : options);
+    getFileAsStream(...args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { bucketName, fileName, options, error } = this.getFileAndBucketAndOptions(...args);
+            // console.log(bucketName, fileName, options, error);
+            if (error !== null) {
+                return { value: null, error: error };
+            }
+            let checkIfBucketExists = true;
+            if (typeof options.checkIfBucketExists === "boolean") {
+                checkIfBucketExists = options.checkIfBucketExists;
+            }
+            const r = yield this.checkBucket(bucketName, checkIfBucketExists);
+            if (r.error !== null) {
+                return { value: null, error: r.error };
+            }
+            const r2 = yield this.checkFile(r.value, fileName);
+            if (r2.error !== null) {
+                return { value: null, error: r2.error };
+            }
+            return this._getFileAsStream(r.value, fileName, options === null ? {} : options);
+        });
     }
-    async getPublicURL(...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(r.value, fileName, options);
+    getPublicURL(...args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { bucketName, fileName, options: opt, error } = this.getFileAndBucketAndOptions(...args);
+            if (error !== null) {
+                return { value: null, error: error };
+            }
+            const r = yield this.checkBucket(bucketName);
+            if (r.error !== null) {
+                return { value: null, error: r.error };
+            }
+            const r2 = yield this.checkFile(r.value, fileName);
+            if (r2.error !== null) {
+                return { value: null, error: r2.error };
+            }
+            const options = opt === null ? {} : opt;
+            if (options.noCheck !== true && this.provider !== general_1.Provider.CUBBIT /*ouch!*/ && this.provider !== general_1.Provider.CLOUDFLARE /*ugly!*/) {
+                const result = yield this._bucketIsPublic(bucketName);
+                if (result.error !== null) {
+                    return { value: null, error: result.error };
+                }
+                if (result.value === false) {
+                    return { value: null, error: `Bucket "${bucketName}" is not public!` };
+                }
+            }
+            return this._getPublicURL(r.value, fileName, options);
+        });
     }
-    async getSignedURL(...args) {
-        const { bucketName, fileName, options, 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 };
-        }
-        return this._getSignedURL(r.value, fileName, options === null ? {} : options);
+    getSignedURL(...args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { bucketName, fileName, options, error } = this.getFileAndBucketAndOptions(...args);
+            if (error !== null) {
+                return { value: null, error: error };
+            }
+            const r = yield this.checkBucket(bucketName);
+            if (r.error !== null) {
+                return { value: null, error: r.error };
+            }
+            const r2 = yield 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) {
-        const { bucketName, fileName, options: _o, 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 };
-        }
-        const r2 = await this.checkFile(r.value, fileName);
-        if (r2.error !== null) {
-            return { value: null, error: r2.error };
-        }
-        return this._sizeOf(r.value, fileName);
+    sizeOf(...args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { bucketName, fileName, options: _o, error } = this.getFileAndBucketAndOptions(...args);
+            if (error !== null) {
+                return { value: null, error: error };
+            }
+            const r = yield this.checkBucket(bucketName);
+            if (r.error !== null) {
+                return { value: null, error: r.error };
+            }
+            const r2 = yield this.checkFile(r.value, fileName);
+            if (r2.error !== null) {
+                return { value: null, error: r2.error };
+            }
+            return this._sizeOf(r.value, fileName);
+        });
     }
-    async fileExists(...args) {
-        const { bucketName, fileName, options: _o, 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._fileExists(r.value, fileName);
+    fileExists(...args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { bucketName, fileName, options: _o, error } = this.getFileAndBucketAndOptions(...args);
+            if (error !== null) {
+                return { value: null, error: error };
+            }
+            const r = yield this.checkBucket(bucketName);
+            if (r.error !== null) {
+                return { value: null, error: r.error };
+            }
+            return this._fileExists(r.value, fileName);
+        });
     }
-    async removeFile(...args) {
-        const { bucketName, fileName, options: _allVersions, 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 };
-        }
-        // 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 };
+    removeFile(...args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { bucketName, fileName, options: _allVersions, error, } = this.getFileAndBucketAndOptions(...args);
+            if (error !== null) {
+                return { value: null, error: error };
             }
-            else {
-                return { value: null, error: r2.error };
+            const r = yield this.checkBucket(bucketName);
+            if (r.error !== null) {
+                return { value: null, error: r.error };
             }
-        }
-        return this._removeFile(bucketName, fileName);
+            // check if file exists, this is especially necessary for Backblaze B2 with S3 adapter!
+            const r2 = yield 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 };
+                }
+                else {
+                    return { value: null, error: r2.error };
+                }
+            }
+            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);
+    getPresignedUploadURL(...args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { bucketName, fileName, options, error } = this.getFileAndBucketAndOptions(...args);
+            if (error !== null) {
+                return { value: null, error: error };
+            }
+            const r = yield this.checkBucket(bucketName);
+            if (r.error !== null) {
+                return { value: null, error: r.error };
+            }
+            return this._getPresignedUploadURL(r.value, fileName, options);
+        });
     }
 }
 exports.AbstractAdapter = AbstractAdapter;