@tweedegolf/sab-adapter-backblaze-b2 1.0.0

package/README.md

@@ -0,0 +1,94 @@
+# Backblaze B2 Storage Adapter
+
+This adapter is a peer dependency of the [storage abstraction package](https://www.npmjs.com/package/@tweedegolf/storage-abstraction). It provides an abstraction layer over the API of the Backblaze B2 cloud storage service.
+
+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";
+
+const configuration = {
+  type: StorageType.B2,
+  applicationKey: "key",
+  applicationKeyId: "keyId",
+};
+
+const storage = new Storage(configuration);
+
+const result = await storage.listBuckets();
+
+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).
+
+## 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 expects the configuration to be of type `StorageAdapterConfig`.
+
+The adapter expects the configuration to be of type `AdapterConfig` or a type that extends this type.
+
+```typescript
+export interface AdapterConfig {
+  bucketName?: string;
+  [id: string]: any; // any mandatory or optional key
+}
+
+export interface StorageAdapterConfig extends AdapterConfig {
+  type: string;
+}
+```
+
+The type of the configuration object for this adapter:
+
+```typescript
+export interface AdapterConfigB2 extends AdapterConfig {
+  applicationKey: string;
+  applicationKeyId: string;
+}
+```
+
+## Examples
+
+Example with configuration object:
+
+```typescript
+const s = new Storage({
+  type: StorageType.B2,
+  applicationKey: "key",
+  applicationKeyId: "keyId",
+});
+```
+
+Example with configuration url:
+
+```typescript
+const s = new Storage("b2://applicationKeyId=keyId&applicationKey=key");
+```
+
+For more information about configuration urls please read [this](https://github.com/tweedegolf/storage-abstraction/blob/master/README.md#configuration-url).
+
+## Standalone
+
+You can also use the adapter standalone, without the need to create a Storage instance:
+
+```typescript
+import { AdapterBackblazeB2 } from "@tweedegolf/sab-adapter-backblaze-b2";
+
+const a = new AdapterBackblazeB2({
+  applicationKey: "key",
+  applicationKeyId: "keyId",
+});
+const r = await a.listBuckets();
+console.log(r);
+```
+
+## API
+
+For a complete description of the Adapter API see [this part](https://github.com/tweedegolf/storage-abstraction/blob/master/README.md#adapter-api) documentation of the Storage Abstraction package readme.

package/dist/AbstractAdapter.d.ts

@@ -0,0 +1,33 @@
+import { AdapterConfig, IAdapter, Options, StreamOptions } from "./types/general";
+import { FileBufferParams, FilePathParams, FileStreamParams } from "./types/add_file_params";
+import { ResultObject, ResultObjectBoolean, ResultObjectBuckets, ResultObjectFiles, ResultObjectNumber, ResultObjectStream } from "./types/result";
+export declare abstract class AbstractAdapter implements IAdapter {
+    protected _type: string;
+    protected _config: AdapterConfig | null;
+    protected _configError: string | null;
+    protected _client: any;
+    constructor(config: string | AdapterConfig);
+    get type(): string;
+    getType(): string;
+    get config(): AdapterConfig;
+    getConfig(): AdapterConfig;
+    get configError(): string;
+    getConfigError(): string;
+    get serviceClient(): any;
+    getServiceClient(): any;
+    addFileFromPath(params: FilePathParams): Promise<ResultObject>;
+    addFileFromBuffer(params: FileBufferParams): Promise<ResultObject>;
+    addFileFromStream(params: FileStreamParams): Promise<ResultObject>;
+    abstract addFile(paramObject: FilePathParams | FileBufferParams | FileStreamParams): Promise<ResultObject>;
+    abstract createBucket(name: string, options?: Options): Promise<ResultObject>;
+    abstract clearBucket(name: string): Promise<ResultObject>;
+    abstract deleteBucket(name: string): Promise<ResultObject>;
+    abstract listBuckets(): Promise<ResultObjectBuckets>;
+    abstract getFileAsStream(bucketName: string, fileName: string, options?: StreamOptions): Promise<ResultObjectStream>;
+    abstract getFileAsURL(bucketName: string, fileName: string, options?: Options): Promise<ResultObject>;
+    abstract removeFile(bucketName: string, fileName: string, allVersions?: boolean): Promise<ResultObject>;
+    abstract listFiles(bucketName: string, maxFiles: number): Promise<ResultObjectFiles>;
+    abstract sizeOf(bucketName: string, fileName: string): Promise<ResultObjectNumber>;
+    abstract fileExists(bucketName: string, fileName: string): Promise<ResultObjectBoolean>;
+    abstract bucketExists(name: string): Promise<ResultObjectBoolean>;
+}

package/dist/AbstractAdapter.js

@@ -0,0 +1,74 @@
+"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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AbstractAdapter = void 0;
+const util_1 = require("./util");
+class AbstractAdapter {
+    constructor(config) {
+        this._type = "abstract-adapter";
+        this._configError = null;
+        this._client = null; // eslint-disable-line
+        if (typeof config === "string") {
+            const p = config.indexOf("://");
+            if (p !== -1) {
+                // strip the type, we don't need it anymore at this point
+                config = config.substring(p);
+            }
+            this._config = (0, util_1.parseQueryString)(config);
+        }
+        else {
+            this._config = Object.assign({}, config);
+        }
+    }
+    get type() {
+        return this._type;
+    }
+    getType() {
+        return this.type;
+    }
+    get config() {
+        return this._config;
+    }
+    getConfig() {
+        return this.config;
+    }
+    get configError() {
+        return this._configError;
+    }
+    getConfigError() {
+        return this.configError;
+    }
+    // eslint-disable-next-line
+    get serviceClient() {
+        return this._client;
+    }
+    // eslint-disable-next-line
+    getServiceClient() {
+        return this._client;
+    }
+    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);
+        });
+    }
+}
+exports.AbstractAdapter = AbstractAdapter;
+//# sourceMappingURL=AbstractAdapter.js.map

package/dist/AbstractAdapter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"AbstractAdapter.js","sourceRoot":"","sources":["../../src/AbstractAdapter.ts"],"names":[],"mappings":";;;;;;;;;;;;AAUA,iCAA0C;AAE1C,MAAsB,eAAe;IAMnC,YAAY,MAA8B;QALhC,UAAK,GAAG,kBAAkB,CAAC;QAE3B,iBAAY,GAAkB,IAAI,CAAC;QACnC,YAAO,GAAQ,IAAI,CAAC,CAAC,sBAAsB;QAGnD,IAAI,OAAO,MAAM,KAAK,QAAQ,EAAE,CAAC;YAC/B,MAAM,CAAC,GAAG,MAAM,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;YAChC,IAAI,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC;gBACb,yDAAyD;gBACzD,MAAM,GAAG,MAAM,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC;YAC/B,CAAC;YACD,IAAI,CAAC,OAAO,GAAG,IAAA,uBAAgB,EAAC,MAAM,CAAC,CAAC;QAC1C,CAAC;aAAM,CAAC;YACN,IAAI,CAAC,OAAO,qBAAQ,MAAM,CAAE,CAAC;QAC/B,CAAC;IACH,CAAC;IAED,IAAI,IAAI;QACN,OAAO,IAAI,CAAC,KAAK,CAAC;IACpB,CAAC;IAED,OAAO;QACL,OAAO,IAAI,CAAC,IAAI,CAAC;IACnB,CAAC;IAED,IAAI,MAAM;QACR,OAAO,IAAI,CAAC,OAAO,CAAC;IACtB,CAAC;IAED,SAAS;QACP,OAAO,IAAI,CAAC,MAAM,CAAC;IACrB,CAAC;IAED,IAAI,WAAW;QACb,OAAO,IAAI,CAAC,YAAY,CAAC;IAC3B,CAAC;IAED,cAAc;QACZ,OAAO,IAAI,CAAC,WAAW,CAAC;IAC1B,CAAC;IAED,2BAA2B;IAC3B,IAAI,aAAa;QACf,OAAO,IAAI,CAAC,OAAO,CAAC;IACtB,CAAC;IAED,2BAA2B;IAC3B,gBAAgB;QACd,OAAO,IAAI,CAAC,OAAO,CAAC;IACtB,CAAC;IAEK,eAAe,CAAC,MAAsB;;YAC1C,OAAO,MAAM,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC;QACpC,CAAC;KAAA;IAEK,iBAAiB,CAAC,MAAwB;;YAC9C,OAAO,MAAM,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC;QACpC,CAAC;KAAA;IAEK,iBAAiB,CAAC,MAAwB;;YAC9C,OAAO,MAAM,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC;QACpC,CAAC;KAAA;CAiDF;AAhHD,0CAgHC"}

package/dist/AdapterBackblazeB2.d.ts

@@ -0,0 +1,35 @@
+import B2 from "backblaze-b2";
+import { AbstractAdapter } from "./AbstractAdapter";
+import { Options, StreamOptions, StorageType } from "./types/general";
+import { FileBufferParams, FilePathParams, FileStreamParams } from "./types/add_file_params";
+import { ResultObject, ResultObjectBoolean, ResultObjectBuckets, ResultObjectFiles, ResultObjectNumber, ResultObjectStream } from "./types/result";
+import { AdapterConfigBackblazeB2 } from "./types/adapter_backblaze_b2";
+export declare class AdapterBackblazeB2 extends AbstractAdapter {
+    protected _type: StorageType;
+    protected _config: AdapterConfigBackblazeB2;
+    protected _configError: string | null;
+    protected _client: B2;
+    private authorized;
+    private versioning;
+    constructor(config: string | AdapterConfigBackblazeB2);
+    private authorize;
+    private getBuckets;
+    private getBucket;
+    private getUploadUrl;
+    private getFiles;
+    private getFile;
+    get config(): AdapterConfigBackblazeB2;
+    get serviceClient(): B2;
+    addFile(params: FilePathParams | FileBufferParams | FileStreamParams): Promise<ResultObject>;
+    getFileAsStream(bucketName: string, fileName: string, options?: StreamOptions): Promise<ResultObjectStream>;
+    getFileAsURL(bucketName: string, fileName: string): Promise<ResultObject>;
+    removeFile(bucketName: string, fileName: string): Promise<ResultObject>;
+    createBucket(name: string, options?: Options): Promise<ResultObject>;
+    clearBucket(name: string): Promise<ResultObject>;
+    deleteBucket(name: string): Promise<ResultObject>;
+    listBuckets(): Promise<ResultObjectBuckets>;
+    listFiles(bucketName: string, numFiles?: number): Promise<ResultObjectFiles>;
+    sizeOf(bucketName: string, fileName: string): Promise<ResultObjectNumber>;
+    bucketExists(bucketName: string): Promise<ResultObjectBoolean>;
+    fileExists(bucketName: string, fileName: string): Promise<ResultObjectBoolean>;
+}