partial-uploader 0.0.6 → 0.0.7

package/dist/index.d.ts

@@ -1,4 +1,9 @@
-declare const uploadWithPartialFile: (url: string, file: any, headers?: any, chunkSize?: number) => Promise<{
+type RefreshResult = {
+    headers?: any;
+    url?: string;
+};
+type UnauthorizedCallback = (error: Response) => Promise<RefreshResult | null>;
+declare const uploadWithPartialFile: (url: string, file: any, headers?: any, chunkSize?: number, delay_number?: number, concurrency?: number, onUnauthorized?: UnauthorizedCallback) => Promise<{
     success: boolean;
     id: string;
     message: string;

package/dist/index.js

@@ -1,4 +1,15 @@
 "use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
 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) {
@@ -8,85 +19,172 @@ 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 };
+    }
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.uploadWithPartialFile = void 0;
-const uploadWithPartialFile = (url, file, headers, chunkSize = 26214400) => __awaiter(void 0, void 0, void 0, function* () {
-    yield delay(50);
-    const id = generateGuid();
-    if (file.size <= chunkSize) {
-        // small file
-        let res = yield upload(url, file, 1, file.size, file.name, id, 0, headers);
-        if (!res)
-            return { success: false, id, message: "file could not be loaded" };
-    }
-    else {
-        // big file
-        const chunks = splitFileIntoChunks(file, chunkSize);
-        for (let i = 0; i < chunks.length; i++) {
-            let chunk = chunks[i];
-            if (!chunk)
-                return { success: false, id, message: "chunk is undefined" };
-            let res = yield upload(url, chunk, chunks.length, file.size, file.name, id, i, headers);
-            if (!res)
-                return { success: false, id, message: "file could not be loaded" };
-            yield delay(550);
-        }
-        ;
-    }
-    ;
-    return { success: true, id, message: "file uploaded successfully" };
-});
-exports.uploadWithPartialFile = uploadWithPartialFile;
-const upload = (url, chunk, chunksLength, fileSize, filename, fileGuid, index, headers) => __awaiter(void 0, void 0, void 0, function* () {
-    let formData = new FormData();
-    formData.append('file', chunk, `${filename}_chunk_${index}`);
-    formData.append('fileGuid', fileGuid);
-    let isDone = chunksLength === index + 1;
-    formData.append('isDone', isDone.toString());
-    formData.append('totalSize', fileSize.toString());
-    formData.append('totalChunks', chunksLength.toString());
-    formData.append('filename', filename);
-    formData.append('index', index.toString());
-    return getRes(url, formData, headers);
-});
-const getRes = (url, formData, headers) => __awaiter(void 0, void 0, void 0, function* () {
-    try {
-        let res = yield uploadSubscribe(url, formData, headers);
-        if (res.status === 406 || res.status === 401)
-            return false;
-    }
-    catch (e) {
-        yield delay(500);
-        let res = yield uploadSubscribe(url, formData, headers);
-        if (!res.ok)
-            return false;
-    }
-    ;
-    return true;
-});
-const delay = (ms) => __awaiter(void 0, void 0, void 0, function* () {
-    yield new Promise(f => setTimeout(f, ms));
-});
-const uploadSubscribe = (url, formData, headers) => __awaiter(void 0, void 0, void 0, function* () { return (yield fetch(url, { method: 'POST', body: formData, headers: headers ? headers : {} })); });
-const splitFileIntoChunks = (file, chunkSize) => {
-    const chunks = [];
-    let start = 0;
-    while (start < file.size) {
-        const end = Math.min(start + chunkSize, file.size);
-        const chunk = file.slice(start, end);
-        chunks.push(chunk);
-        start = end;
-    }
-    ;
-    return chunks;
+var uploadWithPartialFile = function (url, file, headers, chunkSize, delay_number, concurrency, onUnauthorized) {
+    if (headers === void 0) { headers = {}; }
+    if (chunkSize === void 0) { chunkSize = 26214400; }
+    if (delay_number === void 0) { delay_number = 50; }
+    if (concurrency === void 0) { concurrency = 1; }
+    return __awaiter(void 0, void 0, void 0, function () {
+        var sharedContext, id, fileName, totalSize, totalChunks, uploadChunk, queue_1, workers, e_1;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    sharedContext = {
+                        url: url,
+                        headers: __assign({}, headers)
+                    };
+                    return [4 /*yield*/, delay(delay_number)];
+                case 1:
+                    _a.sent();
+                    id = generateGuid();
+                    fileName = file.name || 'file';
+                    totalSize = file.size;
+                    totalChunks = Math.ceil(totalSize / chunkSize) || 1;
+                    uploadChunk = function (index) { return __awaiter(void 0, void 0, void 0, function () {
+                        var start, end, chunk, retry, formData, res, refreshData, e_2;
+                        return __generator(this, function (_a) {
+                            switch (_a.label) {
+                                case 0:
+                                    start = index * chunkSize;
+                                    end = Math.min(start + chunkSize, totalSize);
+                                    chunk = file.slice(start, end);
+                                    retry = 0;
+                                    _a.label = 1;
+                                case 1:
+                                    if (!(retry < 3)) return [3 /*break*/, 9];
+                                    _a.label = 2;
+                                case 2:
+                                    _a.trys.push([2, 6, , 8]);
+                                    formData = new FormData();
+                                    formData.append('file', chunk, "".concat(fileName, "_chunk_").concat(index));
+                                    formData.append('fileGuid', id);
+                                    formData.append('isDone', (index === totalChunks - 1).toString());
+                                    formData.append('totalSize', totalSize.toString());
+                                    formData.append('totalChunks', totalChunks.toString());
+                                    formData.append('filename', fileName);
+                                    formData.append('index', index.toString());
+                                    return [4 /*yield*/, fetch(sharedContext.url, {
+                                            method: 'POST',
+                                            body: formData,
+                                            headers: sharedContext.headers
+                                        })];
+                                case 3:
+                                    res = _a.sent();
+                                    if (!(res.status === 401 && onUnauthorized)) return [3 /*break*/, 5];
+                                    return [4 /*yield*/, onUnauthorized(res)];
+                                case 4:
+                                    refreshData = _a.sent();
+                                    if (refreshData) {
+                                        if (refreshData.headers) {
+                                            sharedContext.headers = __assign(__assign({}, sharedContext.headers), refreshData.headers);
+                                        }
+                                        if (refreshData.url) {
+                                            sharedContext.url = refreshData.url;
+                                        }
+                                        // Token yenilendi, bu retry hakkından düşmeden aynı parçayı tekrar dene
+                                        retry--;
+                                        return [3 /*break*/, 8];
+                                    }
+                                    _a.label = 5;
+                                case 5:
+                                    if (res.ok)
+                                        return [2 /*return*/, true];
+                                    // Diğer hatalarda (500 vb.) retry devam etsin
+                                    if (retry === 2)
+                                        throw new Error("Server error: ".concat(res.status));
+                                    return [3 /*break*/, 8];
+                                case 6:
+                                    e_2 = _a.sent();
+                                    if (retry === 2)
+                                        throw e_2;
+                                    // Ağ hatalarında bekleme süresini artır
+                                    return [4 /*yield*/, delay(delay_number + (retry + 1) * 1000)];
+                                case 7:
+                                    // Ağ hatalarında bekleme süresini artır
+                                    _a.sent();
+                                    return [3 /*break*/, 8];
+                                case 8:
+                                    retry++;
+                                    return [3 /*break*/, 1];
+                                case 9: return [2 /*return*/, false];
+                            }
+                        });
+                    }); };
+                    _a.label = 2;
+                case 2:
+                    _a.trys.push([2, 4, , 5]);
+                    queue_1 = Array.from({ length: totalChunks }, function (_, i) { return i; });
+                    workers = Array(Math.min(concurrency, totalChunks)).fill(null).map(function () { return __awaiter(void 0, void 0, void 0, function () {
+                        var index, success;
+                        return __generator(this, function (_a) {
+                            switch (_a.label) {
+                                case 0:
+                                    if (!(queue_1.length > 0)) return [3 /*break*/, 4];
+                                    index = queue_1.shift();
+                                    return [4 /*yield*/, uploadChunk(index)];
+                                case 1:
+                                    success = _a.sent();
+                                    if (!success)
+                                        throw new Error("file could not be loaded");
+                                    if (!(delay_number > 0)) return [3 /*break*/, 3];
+                                    return [4 /*yield*/, delay(delay_number)];
+                                case 2:
+                                    _a.sent();
+                                    _a.label = 3;
+                                case 3: return [3 /*break*/, 0];
+                                case 4: return [2 /*return*/];
+                            }
+                        });
+                    }); });
+                    return [4 /*yield*/, Promise.all(workers)];
+                case 3:
+                    _a.sent();
+                    return [2 /*return*/, { success: true, id: id, message: "file uploaded successfully" }];
+                case 4:
+                    e_1 = _a.sent();
+                    return [2 /*return*/, { success: false, id: id, message: e_1.message || "file could not be loaded" }];
+                case 5: return [2 /*return*/];
+            }
+        });
+    });
 };
-const generateGuid = () => {
+exports.uploadWithPartialFile = uploadWithPartialFile;
+var delay = function (ms) { return new Promise(function (f) { return setTimeout(f, ms); }); };
+var generateGuid = function () {
     var chars = '0123456789abcdef';
     var guid = '';
     for (var i = 0; i < 40; i++) {
         var randomIndex = Math.floor(Math.random() * chars.length);
         guid += chars.charAt(randomIndex);
     }
-    ;
     return guid;
 };

package/dist/index.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/index.test.js

@@ -0,0 +1,190 @@
+"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 __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 };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var vitest_1 = require("vitest");
+var index_1 = require("./index");
+// @vitest-environment happy-dom
+(0, vitest_1.describe)('uploadWithPartialFile', function () {
+    var mockUrl = 'https://api.example.com/upload';
+    var mockFile = new File(['hello world'], 'test.txt', { type: 'text/plain' });
+    (0, vitest_1.beforeEach)(function () {
+        vitest_1.vi.stubGlobal('fetch', vitest_1.vi.fn());
+        vitest_1.vi.useFakeTimers();
+    });
+    (0, vitest_1.it)('should upload a small file in a single chunk successfully', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var resultPromise, result, formData;
+        var _a;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    fetch.mockResolvedValue({
+                        ok: true,
+                        status: 200
+                    });
+                    resultPromise = (0, index_1.uploadWithPartialFile)(mockUrl, mockFile, {}, 1024, 0);
+                    // Fast-forward any delays
+                    return [4 /*yield*/, vitest_1.vi.runAllTimersAsync()];
+                case 1:
+                    // Fast-forward any delays
+                    _b.sent();
+                    return [4 /*yield*/, resultPromise];
+                case 2:
+                    result = _b.sent();
+                    (0, vitest_1.expect)(result.success).toBe(true);
+                    (0, vitest_1.expect)(fetch).toHaveBeenCalledTimes(1);
+                    formData = (_a = vitest_1.vi.mocked(fetch).mock.calls[0][1]) === null || _a === void 0 ? void 0 : _a.body;
+                    (0, vitest_1.expect)(formData.get('isDone')).toBe('true');
+                    (0, vitest_1.expect)(formData.get('totalChunks')).toBe('1');
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    (0, vitest_1.it)('should upload a large file in multiple chunks', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var largeFile, resultPromise, result;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    fetch.mockResolvedValue({
+                        ok: true,
+                        status: 200
+                    });
+                    largeFile = new File(['0123456789a'], 'large.txt');
+                    resultPromise = (0, index_1.uploadWithPartialFile)(mockUrl, largeFile, {}, 5, 0, 1);
+                    return [4 /*yield*/, vitest_1.vi.runAllTimersAsync()];
+                case 1:
+                    _a.sent();
+                    return [4 /*yield*/, resultPromise];
+                case 2:
+                    result = _a.sent();
+                    (0, vitest_1.expect)(result.success).toBe(true);
+                    (0, vitest_1.expect)(fetch).toHaveBeenCalledTimes(3);
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    (0, vitest_1.it)('should retry on network error and succeed', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var resultPromise, result;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    fetch
+                        .mockRejectedValueOnce(new Error('Network error'))
+                        .mockResolvedValueOnce({ ok: true, status: 200 });
+                    resultPromise = (0, index_1.uploadWithPartialFile)(mockUrl, mockFile, {}, 1024, 10);
+                    // First attempt fails, wait for delay
+                    return [4 /*yield*/, vitest_1.vi.runAllTimersAsync()];
+                case 1:
+                    // First attempt fails, wait for delay
+                    _a.sent();
+                    return [4 /*yield*/, resultPromise];
+                case 2:
+                    result = _a.sent();
+                    (0, vitest_1.expect)(result.success).toBe(true);
+                    (0, vitest_1.expect)(fetch).toHaveBeenCalledTimes(2);
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    (0, vitest_1.it)('should refresh token on 401 and retry successfully', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var onUnauthorized, resultPromise, result, secondCallHeaders;
+        var _a;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    fetch
+                        .mockResolvedValueOnce({ ok: false, status: 401 }) // First attempt: 401
+                        .mockResolvedValueOnce({ ok: true, status: 200 }); // Second attempt: Success
+                    onUnauthorized = vitest_1.vi.fn().mockResolvedValue({
+                        headers: { 'Authorization': 'Bearer new-token' }
+                    });
+                    resultPromise = (0, index_1.uploadWithPartialFile)(mockUrl, mockFile, { 'Authorization': 'Bearer old' }, 1024, 0, 1, onUnauthorized);
+                    return [4 /*yield*/, vitest_1.vi.runAllTimersAsync()];
+                case 1:
+                    _b.sent();
+                    return [4 /*yield*/, resultPromise];
+                case 2:
+                    result = _b.sent();
+                    (0, vitest_1.expect)(onUnauthorized).toHaveBeenCalled();
+                    (0, vitest_1.expect)(result.success).toBe(true);
+                    (0, vitest_1.expect)(fetch).toHaveBeenCalledTimes(2);
+                    secondCallHeaders = (_a = vitest_1.vi.mocked(fetch).mock.calls[1][1]) === null || _a === void 0 ? void 0 : _a.headers;
+                    (0, vitest_1.expect)(secondCallHeaders['Authorization']).toBe('Bearer new-token');
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    (0, vitest_1.it)('should fail after maximum retries', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var resultPromise, result;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    fetch.mockRejectedValue(new Error('Persistent error'));
+                    resultPromise = (0, index_1.uploadWithPartialFile)(mockUrl, mockFile, {}, 1024, 0);
+                    return [4 /*yield*/, vitest_1.vi.runAllTimersAsync()];
+                case 1:
+                    _a.sent();
+                    return [4 /*yield*/, resultPromise];
+                case 2:
+                    result = _a.sent();
+                    (0, vitest_1.expect)(result.success).toBe(false);
+                    (0, vitest_1.expect)(fetch).toHaveBeenCalledTimes(3); // Retry limit is 3 in code
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    (0, vitest_1.it)('should handle concurrency correctly', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var largeFile, resultPromise, result;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    fetch.mockResolvedValue({ ok: true, status: 200 });
+                    largeFile = new File(['a'.repeat(100)], 'concurrency.txt');
+                    resultPromise = (0, index_1.uploadWithPartialFile)(mockUrl, largeFile, {}, 10, 0, 5);
+                    return [4 /*yield*/, vitest_1.vi.runAllTimersAsync()];
+                case 1:
+                    _a.sent();
+                    return [4 /*yield*/, resultPromise];
+                case 2:
+                    result = _a.sent();
+                    (0, vitest_1.expect)(result.success).toBe(true);
+                    (0, vitest_1.expect)(fetch).toHaveBeenCalledTimes(10);
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "partial-uploader",
-	"version": "0.0.6",
+	"version": "0.0.7",
 	"description": "",
 	"main": "dist/index.js",
 	"types": "dist/index.d.ts",
@@ -8,7 +8,8 @@
 		"/dist"
 	],
 	"scripts": {
-		"build": "tsc src/index.ts"
+		"build": "tsc src/index.ts",
+		"test": "vitest run"
 	},
 	"author": "Yusuf Unal <theunal9@gmail.com> (https://github.com/theunal)",
 	"license": "MIT",
@@ -23,6 +24,8 @@
 		"upload"
 	],
 	"devDependencies": {
-		"typescript": "^5.1.3"
+		"happy-dom": "^20.3.4",
+		"typescript": "^5.1.3",
+		"vitest": "^4.0.17"
 	}
 }