files.com 1.0.206 → 1.0.209

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,47 +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:
-                          length += chunk.length;
+                          _context14.prev = 0;
+                          nextLength = length + chunk.length;
+                          excessLength = nextLength - firstFileUploadPart.partsize;
+                          chunkBuffer = _safeBuffer.Buffer.from(chunk);
 
-                          if (!(length > fileUploadPart.partsize)) {
-                            _context14.next = 12;
+                          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 = 6;
-                          return File._continueUpload(destinationPath, ++part, fileUploadPart);
+                          _context14.next = 12;
+                          return File._continueUpload(destinationPath, ++part, firstFileUploadPart);
 
-                        case 6:
+                        case 12:
                           nextFileUploadPart = _context14.sent;
-                          _context14.next = 9;
-                          return _Api.default.sendFilePart(nextFileUploadPart.upload_uri, 'PUT', buffer);
-
-                        case 9:
-                          chunks = [];
-                          length = 0;
+                          concurrentUploads.push(_Api.default.sendFilePart(nextFileUploadPart.upload_uri, 'PUT', buffer));
+                          chunks = [firstChunkForNextPart];
+                          length = 1;
                           readableStream.resume();
+                          _context14.next = 21;
+                          break;
 
-                        case 12:
-                          chunks.push(_safeBuffer.Buffer.from(chunk));
+                        case 19:
+                          chunks.push(chunkBuffer);
+                          length += chunk.length;
 
-                        case 13:
+                        case 21:
+                          _context14.next = 26;
+                          break;
+
+                        case 23:
+                          _context14.prev = 23;
+                          _context14.t0 = _context14["catch"](0);
+                          reject(_context14.t0);
+
+                        case 26:
                         case "end":
                           return _context14.stop();
                       }
                     }
-                  }, _callee14);
+                  }, _callee14, null, [[0, 23]]);
                 }));
 
                 return function (_x14) {
@@ -1090,35 +1106,47 @@ var File = /*#__PURE__*/(0, _createClass2.default)(function File() {
                   while (1) {
                     switch (_context15.prev = _context15.next) {
                       case 0:
+                        _context15.prev = 0;
+
                         if (!(chunks.length > 0)) {
                           _context15.next = 7;
                           break;
                         }
 
                         buffer = _safeBuffer.Buffer.concat(chunks);
-                        _context15.next = 4;
-                        return File._continueUpload(destinationPath, ++part, fileUploadPart);
+                        _context15.next = 5;
+                        return File._continueUpload(destinationPath, ++part, firstFileUploadPart);
 
-                      case 4:
+                      case 5:
                         nextFileUploadPart = _context15.sent;
-                        _context15.next = 7;
-                        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 File._completeUpload(fileUploadPart);
+                        return Promise.all(concurrentUploads);
 
                       case 9:
+                        _context15.next = 11;
+                        return File._completeUpload(firstFileUploadPart);
+
+                      case 11:
                         response = _context15.sent;
                         createdFile = new File(response.data);
                         resolve(createdFile);
+                        _context15.next = 19;
+                        break;
+
+                      case 16:
+                        _context15.prev = 16;
+                        _context15.t0 = _context15["catch"](0);
+                        reject(_context15.t0);
 
-                      case 12:
+                      case 19:
                       case "end":
                         return _context15.stop();
                     }
                   }
-                }, _callee15);
+                }, _callee15, null, [[0, 16]]);
               })));
             });
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "files.com",
-  "version": "1.0.206",
+  "version": "1.0.209",
   "description": "Files.com SDK for JavaScript",
   "keywords": [
     "files.com",

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,41 +91,61 @@ class File {
         let part = 0
         let chunks = []
         let length = 0
+        const concurrentUploads = []
 
         readableStream.on('error', error => { reject(error) })
 
         readableStream.on('data', async chunk => {
-          length += chunk.length
+          try {
+            const nextLength = length + chunk.length
+            const excessLength = nextLength - firstFileUploadPart.partsize
 
-          if (length > fileUploadPart.partsize) {
-            readableStream.pause()
+            const chunkBuffer = Buffer.from(chunk)
 
-            const buffer = Buffer.concat(chunks)
-            const nextFileUploadPart = await File._continueUpload(destinationPath, ++part, fileUploadPart)
+            if (excessLength > 0) {
+              readableStream.pause()
 
-            await Api.sendFilePart(nextFileUploadPart.upload_uri, 'PUT', buffer)
+              const lastChunkForPart = chunkBuffer.subarray(0, excessLength)
+              const firstChunkForNextPart = chunkBuffer.subarray(excessLength)
 
-            chunks = []
-            length = 0
+              chunks.push(lastChunkForPart)
 
-            readableStream.resume()
-          }
+              const buffer = Buffer.concat(chunks)
+              const nextFileUploadPart = await File._continueUpload(destinationPath, ++part, firstFileUploadPart)
+
+              concurrentUploads.push(Api.sendFilePart(nextFileUploadPart.upload_uri, 'PUT', buffer))
+
+              chunks = [firstChunkForNextPart]
+              length = 1
 
-          chunks.push(Buffer.from(chunk))
+              readableStream.resume()
+            } else {
+              chunks.push(chunkBuffer)
+              length += chunk.length
+            }
+          } catch (error) {
+            reject(error)
+          }
         })
 
         readableStream.on('end', async () => {
-          if (chunks.length > 0) {
-            const buffer = Buffer.concat(chunks)
-            const nextFileUploadPart = await File._continueUpload(destinationPath, ++part, fileUploadPart)
+          try {
+            if (chunks.length > 0) {
+              const buffer = Buffer.concat(chunks)
+              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)
-          const createdFile = new File(response.data)
+            await Promise.all(concurrentUploads)
 
-          resolve(createdFile)
+            const response = await File._completeUpload(firstFileUploadPart)
+            const createdFile = new File(response.data)
+
+            resolve(createdFile)
+          } catch (error) {
+            reject(error)
+          }
         })
       })