@super-protocol/sdk-js 0.15.0 → 0.15.2-beta.0

package/build/providers/storage/ChunksDownloadDecorator.js

@@ -1,19 +1,4 @@
 "use strict";
-var __extends = (this && this.__extends) || (function () {
-    var extendStatics = function (d, b) {
-        extendStatics = Object.setPrototypeOf ||
-            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
-            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
-        return extendStatics(d, b);
-    };
-    return function (d, b) {
-        if (typeof b !== "function" && b !== null)
-            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
-        extendStatics(d, b);
-        function __() { this.constructor = d; }
-        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
-    };
-})();
 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) {
@@ -23,33 +8,6 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-var __generator = (this && this.__generator) || function (thisArg, body) {
-    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
-    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
-    function verb(n) { return function (v) { return step([n, v]); }; }
-    function step(op) {
-        if (f) throw new TypeError("Generator is already executing.");
-        while (g && (g = 0, op[0] && (_ = 0)), _) try {
-            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
-            if (y = 0, t) op = [op[0] & 2, t.value];
-            switch (op[0]) {
-                case 0: case 1: t = op; break;
-                case 4: _.label++; return { value: op[1], done: false };
-                case 5: _.label++; y = op[1]; op = [0]; continue;
-                case 7: op = _.ops.pop(); _.trys.pop(); continue;
-                default:
-                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
-                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
-                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
-                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
-                    if (t[2]) _.ops.pop();
-                    _.trys.pop(); continue;
-            }
-            op = body.call(thisArg, _);
-        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
-        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
-    }
-};
 var __asyncValues = (this && this.__asyncValues) || function (o) {
     if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
     var m = o[Symbol.asyncIterator], i;
@@ -59,228 +17,160 @@ var __asyncValues = (this && this.__asyncValues) || function (o) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DownloadDecorator = exports.createDownloadChunkMethodWithRetry = exports.downloadChunkMethod = void 0;
-var stream_1 = require("stream");
-function generateChunks(dataSize, chunkSize, startOffset) {
-    var chunk, offset;
-    if (startOffset === void 0) { startOffset = BigInt(0); }
-    return __generator(this, function (_a) {
-        switch (_a.label) {
-            case 0:
-                chunk = 0;
-                offset = startOffset;
-                _a.label = 1;
-            case 1:
-                if (!(dataSize > offset)) return [3 /*break*/, 3];
-                return [4 /*yield*/, {
-                        offset: offset,
-                        length: chunkSize > dataSize - offset ? Number(dataSize - offset) : chunkSize,
-                        dataSize: dataSize,
-                        chunk: chunk++,
-                        chunksCount: Math.ceil(Number(dataSize / BigInt(chunkSize))),
-                    }];
-            case 2:
-                _a.sent();
-                offset += BigInt(chunkSize);
-                return [3 /*break*/, 1];
-            case 3: return [2 /*return*/];
-        }
-    });
+const stream_1 = require("stream");
+function* generateChunks(dataSize, chunkSize, startOffset = BigInt(0)) {
+    let chunk = 0;
+    let offset = startOffset;
+    while (dataSize > offset) {
+        yield {
+            offset,
+            length: chunkSize > dataSize - offset ? Number(dataSize - offset) : chunkSize,
+            dataSize,
+            chunk: chunk++,
+            chunksCount: Math.ceil(Number(dataSize / BigInt(chunkSize))),
+        };
+        offset += BigInt(chunkSize);
+    }
 }
-var ChunkedReadableTransform = /** @class */ (function (_super) {
-    __extends(ChunkedReadableTransform, _super);
-    function ChunkedReadableTransform(downloadChunk, params) {
-        var _this = _super.call(this, {
+class ChunkedReadableTransform extends stream_1.Transform {
+    constructor(downloadChunk, params) {
+        super({
             objectMode: true,
             highWaterMark: params.concurrency,
-        }) || this;
-        _this.downloadChunk = downloadChunk;
-        return _this;
+        });
+        this.downloadChunk = downloadChunk;
     }
-    ChunkedReadableTransform.prototype._transform = function (chunk, encoding, callback) {
-        var resultPromise = this.downloadChunk(chunk);
+    _transform(chunk, encoding, callback) {
+        const resultPromise = this.downloadChunk(chunk);
         callback(null, {
-            resultPromise: resultPromise,
-            chunk: chunk,
+            resultPromise,
+            chunk,
         });
-    };
-    return ChunkedReadableTransform;
-}(stream_1.Transform));
-var ChainedChunksReadableTransform = /** @class */ (function (_super) {
-    __extends(ChainedChunksReadableTransform, _super);
-    function ChainedChunksReadableTransform(progressListener) {
-        var _this = _super.call(this, {
+    }
+}
+class ChainedChunksReadableTransform extends stream_1.Transform {
+    constructor(progressListener) {
+        super({
             objectMode: true,
             highWaterMark: 1,
-        }) || this;
-        _this.progressListener = progressListener;
-        return _this;
+        });
+        this.progressListener = progressListener;
     }
-    ChainedChunksReadableTransform.prototype._transform = function (obj, encoding, callback) {
-        var _this = this;
-        obj.resultPromise.then(function (data) {
+    _transform(obj, encoding, callback) {
+        obj.resultPromise.then((data) => {
             callback(null, data);
-            if (_this.progressListener) {
-                _this.progressListener(Number(obj.chunk.dataSize), Number(obj.chunk.offset) + obj.chunk.length);
+            if (this.progressListener) {
+                this.progressListener(Number(obj.chunk.dataSize), Number(obj.chunk.offset) + obj.chunk.length);
             }
-        }, function (err) {
+        }, (err) => {
             callback(err);
         });
-    };
-    return ChainedChunksReadableTransform;
-}(stream_1.Transform));
-var downloadChunkMethod = function (provider, objectPath, chunk) { return __awaiter(void 0, void 0, void 0, function () {
-    var position, buffer, dataStream, _a, dataStream_1, dataStream_1_1, data, e_1_1;
-    var _b, e_1, _c, _d;
-    return __generator(this, function (_e) {
-        switch (_e.label) {
-            case 0:
-                position = 0;
-                buffer = Buffer.alloc(chunk.length);
-                return [4 /*yield*/, provider.downloadFile(objectPath, {
-                        offset: Number(chunk.offset),
-                        length: chunk.length,
-                    })];
-            case 1:
-                dataStream = _e.sent();
-                _e.label = 2;
-            case 2:
-                _e.trys.push([2, 7, 8, 13]);
-                _a = true, dataStream_1 = __asyncValues(dataStream);
-                _e.label = 3;
-            case 3: return [4 /*yield*/, dataStream_1.next()];
-            case 4:
-                if (!(dataStream_1_1 = _e.sent(), _b = dataStream_1_1.done, !_b)) return [3 /*break*/, 6];
-                _d = dataStream_1_1.value;
-                _a = false;
-                try {
-                    data = _d;
-                    data.copy(buffer, position);
-                    position += data.length;
-                    if (position > chunk.length) {
-                        throw new Error("Chunk buffer is overflow, read data is more than requested for chunk");
-                    }
-                }
-                finally {
-                    _a = true;
+    }
+}
+const downloadChunkMethod = (provider, objectPath, chunk) => __awaiter(void 0, void 0, void 0, function* () {
+    var _a, e_1, _b, _c;
+    let position = 0;
+    const buffer = Buffer.alloc(chunk.length);
+    const dataStream = yield provider.downloadFile(objectPath, {
+        offset: Number(chunk.offset),
+        length: chunk.length,
+    });
+    try {
+        for (var _d = true, dataStream_1 = __asyncValues(dataStream), dataStream_1_1; dataStream_1_1 = yield dataStream_1.next(), _a = dataStream_1_1.done, !_a;) {
+            _c = dataStream_1_1.value;
+            _d = false;
+            try {
+                const data = _c;
+                data.copy(buffer, position);
+                position += data.length;
+                if (position > chunk.length) {
+                    throw new Error("Chunk buffer is overflow, read data is more than requested for chunk");
                 }
-                _e.label = 5;
-            case 5: return [3 /*break*/, 3];
-            case 6: return [3 /*break*/, 13];
-            case 7:
-                e_1_1 = _e.sent();
-                e_1 = { error: e_1_1 };
-                return [3 /*break*/, 13];
-            case 8:
-                _e.trys.push([8, , 11, 12]);
-                if (!(!_a && !_b && (_c = dataStream_1.return))) return [3 /*break*/, 10];
-                return [4 /*yield*/, _c.call(dataStream_1)];
-            case 9:
-                _e.sent();
-                _e.label = 10;
-            case 10: return [3 /*break*/, 12];
-            case 11:
-                if (e_1) throw e_1.error;
-                return [7 /*endfinally*/];
-            case 12: return [7 /*endfinally*/];
-            case 13: return [2 /*return*/, buffer];
+            }
+            finally {
+                _d = true;
+            }
         }
-    });
-}); };
+    }
+    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+    finally {
+        try {
+            if (!_d && !_a && (_b = dataStream_1.return)) yield _b.call(dataStream_1);
+        }
+        finally { if (e_1) throw e_1.error; }
+    }
+    return buffer;
+});
 exports.downloadChunkMethod = downloadChunkMethod;
-var createDownloadChunkMethodWithRetry = function (downloadChunkMethod, _a) {
-    var _b = _a === void 0 ? {} : _a, _c = _b.retryMaxCount, retryMaxCount = _c === void 0 ? 3 : _c, _d = _b.retryWaitTimeFactory, retryWaitTimeFactory = _d === void 0 ? function () { return function () { return 1000; }; } : _d, onRetry = _b.onRetry;
-    return function (provider, objectPath, chunk) { return __awaiter(void 0, void 0, void 0, function () {
-        var retryWaitTime, retryCount, error_1;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    retryWaitTime = retryWaitTimeFactory();
-                    retryCount = retryMaxCount;
-                    _a.label = 1;
-                case 1:
-                    if (!(retryCount > 0)) return [3 /*break*/, 8];
-                    _a.label = 2;
-                case 2:
-                    _a.trys.push([2, 4, , 5]);
-                    return [4 /*yield*/, downloadChunkMethod(provider, objectPath, chunk)];
-                case 3: return [2 /*return*/, _a.sent()];
-                case 4:
-                    error_1 = _a.sent();
-                    return [3 /*break*/, 5];
-                case 5:
-                    retryCount--;
-                    if (onRetry) {
-                        onRetry(null, chunk, retryCount);
-                    }
-                    if (!(retryCount !== 0)) return [3 /*break*/, 7];
-                    return [4 /*yield*/, new Promise(function (resolve, reject) { return setTimeout(resolve, retryWaitTime()); })];
-                case 6:
-                    _a.sent();
-                    _a.label = 7;
-                case 7: return [3 /*break*/, 1];
-                case 8: throw new Error("Max retry attempts was reached for object path ".concat(objectPath, ", offset ").concat(chunk.offset, ", length ").concat(chunk.length
-                // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                ));
+const createDownloadChunkMethodWithRetry = (downloadChunkMethod, { retryMaxCount = 3, retryWaitTimeFactory = () => () => 1000, onRetry } = {}) => {
+    return (provider, objectPath, chunk) => __awaiter(void 0, void 0, void 0, function* () {
+        const retryWaitTime = retryWaitTimeFactory();
+        //let lastError: unknown = null;
+        let retryCount = retryMaxCount;
+        while (retryCount > 0) {
+            try {
+                return yield downloadChunkMethod(provider, objectPath, chunk);
             }
-        });
-    }); };
+            catch (error) {
+                //lastError = error;
+            }
+            retryCount--;
+            if (onRetry) {
+                onRetry(null, chunk, retryCount);
+            }
+            if (retryCount !== 0) {
+                yield new Promise((resolve, reject) => setTimeout(resolve, retryWaitTime()));
+            }
+        }
+        throw new Error(`Max retry attempts was reached for object path ${objectPath}, offset ${chunk.offset}, length ${chunk.length
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        }`);
+    });
 };
 exports.createDownloadChunkMethodWithRetry = createDownloadChunkMethodWithRetry;
-var DownloadDecorator = /** @class */ (function () {
-    function DownloadDecorator(provider, chunkDownloaderMethod, options) {
+class DownloadDecorator {
+    constructor(provider, chunkDownloaderMethod, options) {
         this.provider = provider;
         this.chunkDownloaderMethod = chunkDownloaderMethod;
         this.options = options;
     }
-    DownloadDecorator.prototype.uploadFile = function (inputStream, remotePath, contentLength, progressListener) {
+    uploadFile(inputStream, remotePath, contentLength, progressListener) {
         return this.provider.uploadFile(inputStream, remotePath, contentLength, progressListener);
-    };
-    DownloadDecorator.prototype.downloadFile = function (remotePath, config, progressListener) {
+    }
+    downloadFile(remotePath, config, progressListener) {
         var _a;
-        return __awaiter(this, void 0, void 0, function () {
-            var offset, objectSize, chunksStream, downloadStream, chainedStream;
-            var _this = this;
-            return __generator(this, function (_b) {
-                switch (_b.label) {
-                    case 0:
-                        if (config === null || config === void 0 ? void 0 : config.length) {
-                            return [2 /*return*/, this.provider.downloadFile(remotePath, config, progressListener)];
-                        }
-                        offset = BigInt((_a = this.options.offset) !== null && _a !== void 0 ? _a : 0);
-                        return [4 /*yield*/, this.provider.getObjectSize(remotePath)];
-                    case 1:
-                        objectSize = _b.sent();
-                        chunksStream = stream_1.Readable.from(generateChunks(BigInt(objectSize), this.options.chunkSize, offset));
-                        downloadStream = new ChunkedReadableTransform(function (chunk) { return __awaiter(_this, void 0, void 0, function () {
-                            return __generator(this, function (_a) {
-                                return [2 /*return*/, this.chunkDownloaderMethod(this.provider, remotePath, chunk)];
-                            });
-                        }); }, {
-                            concurrency: this.options.concurrency,
-                        });
-                        chainedStream = new ChainedChunksReadableTransform(progressListener);
-                        return [2 /*return*/, chunksStream
-                                .pipe(downloadStream)
-                                .on("error", function (error) {
-                                chainedStream.emit("error", error);
-                            })
-                                .pipe(chainedStream)];
-                }
+        return __awaiter(this, void 0, void 0, function* () {
+            if (config === null || config === void 0 ? void 0 : config.length) {
+                return this.provider.downloadFile(remotePath, config, progressListener);
+            }
+            const offset = BigInt((_a = this.options.offset) !== null && _a !== void 0 ? _a : 0);
+            const objectSize = yield this.provider.getObjectSize(remotePath);
+            const chunksStream = stream_1.Readable.from(generateChunks(BigInt(objectSize), this.options.chunkSize, offset));
+            const downloadStream = new ChunkedReadableTransform((chunk) => __awaiter(this, void 0, void 0, function* () {
+                return this.chunkDownloaderMethod(this.provider, remotePath, chunk);
+            }), {
+                concurrency: this.options.concurrency,
             });
+            const chainedStream = new ChainedChunksReadableTransform(progressListener);
+            return chunksStream
+                .pipe(downloadStream)
+                .on("error", (error) => {
+                chainedStream.emit("error", error);
+            })
+                .pipe(chainedStream);
         });
-    };
-    DownloadDecorator.prototype.deleteObject = function (remotePath) {
+    }
+    deleteObject(remotePath) {
         return this.provider.deleteObject(remotePath);
-    };
-    DownloadDecorator.prototype.listObjects = function (remotePath) {
+    }
+    listObjects(remotePath) {
         return this.provider.listObjects(remotePath);
-    };
-    DownloadDecorator.prototype.getObjectSize = function (remotePath) {
+    }
+    getObjectSize(remotePath) {
         return this.provider.getObjectSize(remotePath);
-    };
-    DownloadDecorator.prototype.getLastModified = function (remotePath) {
+    }
+    getLastModified(remotePath) {
         return this.provider.getLastModified(remotePath);
-    };
-    return DownloadDecorator;
-}());
+    }
+}
 exports.DownloadDecorator = DownloadDecorator;

package/build/providers/storage/IStorageProvider.d.ts

@@ -11,5 +11,5 @@ export default interface IStorageProvider {
     deleteObject(remotePath: string): Promise<void>;
     listObjects(remotePath: string): Promise<StorageObject[]>;
     getObjectSize(remotePath: string): Promise<number>;
-    getLastModified(remotePath: string): Promise<Date>;
+    getLastModified(remotePath: string): Promise<Date | null>;
 }