files.com 1.0.207 → 1.0.210

package/lib/models/File.js

@@ -986,7 +986,7 @@ var File = /*#__PURE__*/(0, _createClass2.default)(function File() {
   };
 }());
 (0, _defineProperty2.default)(File, "_completeUpload", /*#__PURE__*/function () {
-  var _ref15 = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee13(fileUploadPart) {
+  var _ref15 = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee13(firstFileUploadPart) {
     var params;
     return _regenerator.default.wrap(function _callee13$(_context13) {
       while (1) {
@@ -994,9 +994,9 @@ var File = /*#__PURE__*/(0, _createClass2.default)(function File() {
           case 0:
             params = {
               action: 'end',
-              ref: fileUploadPart.ref
+              ref: firstFileUploadPart.ref
             };
-            return _context13.abrupt("return", _Api.default.sendRequest("/files/".concat(encodeURIComponent(fileUploadPart.path)), 'POST', params));
+            return _context13.abrupt("return", _Api.default.sendRequest("/files/".concat(encodeURIComponent(firstFileUploadPart.path)), 'POST', params));
 
           case 2:
           case "end":
@@ -1012,7 +1012,7 @@ var File = /*#__PURE__*/(0, _createClass2.default)(function File() {
 }());
 (0, _defineProperty2.default)(File, "uploadStream", /*#__PURE__*/function () {
   var _ref16 = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee16(destinationPath, readableStream, params) {
-    var fileUploadPart, file;
+    var firstFileUploadPart, file;
     return _regenerator.default.wrap(function _callee16$(_context16) {
       while (1) {
         switch (_context16.prev = _context16.next) {
@@ -1021,9 +1021,9 @@ var File = /*#__PURE__*/(0, _createClass2.default)(function File() {
             return File._openUpload(destinationPath, params);
 
           case 2:
-            fileUploadPart = _context16.sent;
+            firstFileUploadPart = _context16.sent;
 
-            if (fileUploadPart) {
+            if (firstFileUploadPart) {
               _context16.next = 5;
               break;
             }
@@ -1037,55 +1037,63 @@ var File = /*#__PURE__*/(0, _createClass2.default)(function File() {
               var part = 0;
               var chunks = [];
               var length = 0;
+              var concurrentUploads = [];
               readableStream.on('error', function (error) {
                 reject(error);
               });
               readableStream.on('data', /*#__PURE__*/function () {
                 var _ref17 = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee14(chunk) {
-                  var buffer, nextFileUploadPart;
+                  var nextLength, excessLength, chunkBuffer, lastChunkForPart, firstChunkForNextPart, buffer, nextFileUploadPart;
                   return _regenerator.default.wrap(function _callee14$(_context14) {
                     while (1) {
                       switch (_context14.prev = _context14.next) {
                         case 0:
                           _context14.prev = 0;
-                          length += chunk.length;
+                          nextLength = length + chunk.length;
+                          excessLength = nextLength - firstFileUploadPart.partsize;
+                          chunkBuffer = _safeBuffer.Buffer.from(chunk);
 
-                          if (!(length > fileUploadPart.partsize)) {
-                            _context14.next = 13;
+                          if (!(excessLength > 0)) {
+                            _context14.next = 19;
                             break;
                           }
 
                           readableStream.pause();
+                          lastChunkForPart = chunkBuffer.subarray(0, excessLength);
+                          firstChunkForNextPart = chunkBuffer.subarray(excessLength);
+                          chunks.push(lastChunkForPart);
                           buffer = _safeBuffer.Buffer.concat(chunks);
-                          _context14.next = 7;
-                          return File._continueUpload(destinationPath, ++part, fileUploadPart);
+                          _context14.next = 12;
+                          return File._continueUpload(destinationPath, ++part, firstFileUploadPart);
 
-                        case 7:
+                        case 12:
                           nextFileUploadPart = _context14.sent;
-                          _context14.next = 10;
-                          return _Api.default.sendFilePart(nextFileUploadPart.upload_uri, 'PUT', buffer);
-
-                        case 10:
-                          chunks = [];
-                          length = 0;
+                          concurrentUploads.push(_Api.default.sendFilePart(nextFileUploadPart.upload_uri, 'PUT', buffer));
+                          chunks = [firstChunkForNextPart];
+                          length = 1;
                           readableStream.resume();
+                          _context14.next = 21;
+                          break;
 
-                        case 13:
-                          chunks.push(_safeBuffer.Buffer.from(chunk));
-                          _context14.next = 19;
+                        case 19:
+                          chunks.push(chunkBuffer);
+                          length += chunk.length;
+
+                        case 21:
+                          _context14.next = 26;
                           break;
 
-                        case 16:
-                          _context14.prev = 16;
+                        case 23:
+                          _context14.prev = 23;
                           _context14.t0 = _context14["catch"](0);
                           reject(_context14.t0);
 
-                        case 19:
+                        case 26:
                         case "end":
                           return _context14.stop();
                       }
                     }
-                  }, _callee14, null, [[0, 16]]);
+                  }, _callee14, null, [[0, 23]]);
                 }));
 
                 return function (_x14) {
@@ -1101,41 +1109,44 @@ var File = /*#__PURE__*/(0, _createClass2.default)(function File() {
                         _context15.prev = 0;
 
                         if (!(chunks.length > 0)) {
-                          _context15.next = 8;
+                          _context15.next = 7;
                           break;
                         }
 
                         buffer = _safeBuffer.Buffer.concat(chunks);
                         _context15.next = 5;
-                        return File._continueUpload(destinationPath, ++part, fileUploadPart);
+                        return File._continueUpload(destinationPath, ++part, firstFileUploadPart);
 
                       case 5:
                         nextFileUploadPart = _context15.sent;
-                        _context15.next = 8;
-                        return _Api.default.sendFilePart(nextFileUploadPart.upload_uri, 'PUT', buffer);
+                        concurrentUploads.push(_Api.default.sendFilePart(nextFileUploadPart.upload_uri, 'PUT', buffer));
+
+                      case 7:
+                        _context15.next = 9;
+                        return Promise.all(concurrentUploads);
 
-                      case 8:
-                        _context15.next = 10;
-                        return File._completeUpload(fileUploadPart);
+                      case 9:
+                        _context15.next = 11;
+                        return File._completeUpload(firstFileUploadPart);
 
-                      case 10:
+                      case 11:
                         response = _context15.sent;
                         createdFile = new File(response.data);
                         resolve(createdFile);
-                        _context15.next = 18;
+                        _context15.next = 19;
                         break;
 
-                      case 15:
-                        _context15.prev = 15;
+                      case 16:
+                        _context15.prev = 16;
                         _context15.t0 = _context15["catch"](0);
                         reject(_context15.t0);
 
-                      case 18:
+                      case 19:
                       case "end":
                         return _context15.stop();
                     }
                   }
-                }, _callee15, null, [[0, 15]]);
+                }, _callee15, null, [[0, 16]]);
               })));
             });
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "files.com",
-  "version": "1.0.207",
+  "version": "1.0.210",
   "description": "Files.com SDK for JavaScript",
   "keywords": [
     "files.com",
@@ -20,8 +20,8 @@
   "main": "lib/files.js",
   "dependencies": {
     "@babel/runtime": "^7.10.3",
-    "axios": "^0.19.2",
-    "axios-retry": "^3.1.8",
+    "axios": "0.27.2",
+    "axios-retry": "3.3.1",
     "readable-stream": "^3.6.0",
     "safe-buffer": "^5.1.1",
     "uuid": "^3.3.2"

package/src/Errors.js

@@ -167,6 +167,7 @@ export class NotAuthorized_WritePermissionRequiredError extends NotAuthorizedErr
 export class NotAuthorized_ZipDownloadIpMismatchError extends NotAuthorizedError { constructor(message, code) { super(message, code); this.name = 'NotAuthorized_ZipDownloadIpMismatchError' } } errorClasses.NotAuthorized_ZipDownloadIpMismatchError = NotAuthorized_ZipDownloadIpMismatchError
 export class NotFound_ApiKeyNotFoundError extends NotFoundError { constructor(message, code) { super(message, code); this.name = 'NotFound_ApiKeyNotFoundError' } } errorClasses.NotFound_ApiKeyNotFoundError = NotFound_ApiKeyNotFoundError
 export class NotFound_BundlePathNotFoundError extends NotFoundError { constructor(message, code) { super(message, code); this.name = 'NotFound_BundlePathNotFoundError' } } errorClasses.NotFound_BundlePathNotFoundError = NotFound_BundlePathNotFoundError
+export class NotFound_BundleRegistrationNotFoundError extends NotFoundError { constructor(message, code) { super(message, code); this.name = 'NotFound_BundleRegistrationNotFoundError' } } errorClasses.NotFound_BundleRegistrationNotFoundError = NotFound_BundleRegistrationNotFoundError
 export class NotFound_CodeNotFoundError extends NotFoundError { constructor(message, code) { super(message, code); this.name = 'NotFound_CodeNotFoundError' } } errorClasses.NotFound_CodeNotFoundError = NotFound_CodeNotFoundError
 export class NotFound_FileNotFoundError extends NotFoundError { constructor(message, code) { super(message, code); this.name = 'NotFound_FileNotFoundError' } } errorClasses.NotFound_FileNotFoundError = NotFound_FileNotFoundError
 export class NotFound_FileUploadNotFoundError extends NotFoundError { constructor(message, code) { super(message, code); this.name = 'NotFound_FileUploadNotFoundError' } } errorClasses.NotFound_FileUploadNotFoundError = NotFound_FileUploadNotFoundError

package/src/models/File.js

@@ -67,22 +67,22 @@ class File {
     return new FileUploadPart(partData)
   }
 
-  static _completeUpload = async fileUploadPart => {
+  static _completeUpload = async firstFileUploadPart => {
     const params = {
       action: 'end',
-      ref: fileUploadPart.ref,
+      ref: firstFileUploadPart.ref,
     }
 
-    return Api.sendRequest(`/files/${encodeURIComponent(fileUploadPart.path)}`, 'POST', params)
+    return Api.sendRequest(`/files/${encodeURIComponent(firstFileUploadPart.path)}`, 'POST', params)
   }
 
   /**
    * @note see File.copy() for list of supported params
    */
   static uploadStream = async (destinationPath, readableStream, params) => {
-    const fileUploadPart = await File._openUpload(destinationPath, params)
+    const firstFileUploadPart = await File._openUpload(destinationPath, params)
 
-    if (!fileUploadPart) {
+    if (!firstFileUploadPart) {
       return
     }
 
@@ -91,28 +91,38 @@ class File {
         let part = 0
         let chunks = []
         let length = 0
+        const concurrentUploads = []
 
         readableStream.on('error', error => { reject(error) })
 
         readableStream.on('data', async chunk => {
           try {
-            length += chunk.length
+            const nextLength = length + chunk.length
+            const excessLength = nextLength - firstFileUploadPart.partsize
+
+            const chunkBuffer = Buffer.from(chunk)
 
-            if (length > fileUploadPart.partsize) {
+            if (excessLength > 0) {
               readableStream.pause()
 
+              const lastChunkForPart = chunkBuffer.subarray(0, excessLength)
+              const firstChunkForNextPart = chunkBuffer.subarray(excessLength)
+
+              chunks.push(lastChunkForPart)
+
               const buffer = Buffer.concat(chunks)
-              const nextFileUploadPart = await File._continueUpload(destinationPath, ++part, fileUploadPart)
+              const nextFileUploadPart = await File._continueUpload(destinationPath, ++part, firstFileUploadPart)
 
-              await Api.sendFilePart(nextFileUploadPart.upload_uri, 'PUT', buffer)
+              concurrentUploads.push(Api.sendFilePart(nextFileUploadPart.upload_uri, 'PUT', buffer))
 
-              chunks = []
-              length = 0
+              chunks = [firstChunkForNextPart]
+              length = 1
 
               readableStream.resume()
+            } else {
+              chunks.push(chunkBuffer)
+              length += chunk.length
             }
-
-            chunks.push(Buffer.from(chunk))
           } catch (error) {
             reject(error)
           }
@@ -122,12 +132,14 @@ class File {
           try {
             if (chunks.length > 0) {
               const buffer = Buffer.concat(chunks)
-              const nextFileUploadPart = await File._continueUpload(destinationPath, ++part, fileUploadPart)
+              const nextFileUploadPart = await File._continueUpload(destinationPath, ++part, firstFileUploadPart)
 
-              await Api.sendFilePart(nextFileUploadPart.upload_uri, 'PUT', buffer)
+              concurrentUploads.push(Api.sendFilePart(nextFileUploadPart.upload_uri, 'PUT', buffer))
             }
 
-            const response = await File._completeUpload(fileUploadPart)
+            await Promise.all(concurrentUploads)
+
+            const response = await File._completeUpload(firstFileUploadPart)
             const createdFile = new File(response.data)
 
             resolve(createdFile)