files.com 1.0.205 → 1.0.208

package/_VERSION

@@ -1 +1 @@
-1.0.205
+1.0.208

package/lib/models/File.js

@@ -900,15 +900,15 @@ var File = /*#__PURE__*/(0, _createClass2.default)(function File() {
   this.options = _objectSpread({}, options);
 });
 (0, _defineProperty2.default)(File, "_openUpload", /*#__PURE__*/function () {
-  var _ref13 = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee11(path) {
+  var _ref13 = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee11(path, paramsRaw) {
     var params, response, partData;
     return _regenerator.default.wrap(function _callee11$(_context11) {
       while (1) {
         switch (_context11.prev = _context11.next) {
           case 0:
-            params = {
+            params = _objectSpread(_objectSpread({}, paramsRaw), {}, {
               action: 'put'
-            };
+            });
             _context11.next = 3;
             return _Api.default.sendRequest("/files/".concat(encodeURIComponent(path)), 'POST', params);
 
@@ -937,7 +937,7 @@ var File = /*#__PURE__*/(0, _createClass2.default)(function File() {
     }, _callee11);
   }));
 
-  return function (_x5) {
+  return function (_x5, _x6) {
     return _ref13.apply(this, arguments);
   };
 }());
@@ -981,12 +981,12 @@ var File = /*#__PURE__*/(0, _createClass2.default)(function File() {
     }, _callee12);
   }));
 
-  return function (_x6, _x7, _x8) {
+  return function (_x7, _x8, _x9) {
     return _ref14.apply(this, arguments);
   };
 }());
 (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":
@@ -1006,24 +1006,24 @@ var File = /*#__PURE__*/(0, _createClass2.default)(function File() {
     }, _callee13);
   }));
 
-  return function (_x9) {
+  return function (_x10) {
     return _ref15.apply(this, arguments);
   };
 }());
 (0, _defineProperty2.default)(File, "uploadStream", /*#__PURE__*/function () {
-  var _ref16 = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee16(destinationPath, readableStream) {
-    var fileUploadPart, file;
+  var _ref16 = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee16(destinationPath, readableStream, params) {
+    var firstFileUploadPart, file;
     return _regenerator.default.wrap(function _callee16$(_context16) {
       while (1) {
         switch (_context16.prev = _context16.next) {
           case 0:
             _context16.next = 2;
-            return File._openUpload(destinationPath);
+            return File._openUpload(destinationPath, params);
 
           case 2:
-            fileUploadPart = _context16.sent;
+            firstFileUploadPart = _context16.sent;
 
-            if (fileUploadPart) {
+            if (firstFileUploadPart) {
               _context16.next = 5;
               break;
             }
@@ -1037,50 +1037,66 @@ 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 21:
+                          _context14.next = 26;
+                          break;
 
-                        case 13:
+                        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 (_x12) {
+                return function (_x14) {
                   return _ref17.apply(this, arguments);
                 };
               }());
@@ -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]]);
               })));
             });
 
@@ -1139,12 +1167,12 @@ var File = /*#__PURE__*/(0, _createClass2.default)(function File() {
     }, _callee16, null, [[5, 12]]);
   }));
 
-  return function (_x10, _x11) {
+  return function (_x11, _x12, _x13) {
     return _ref16.apply(this, arguments);
   };
 }());
 (0, _defineProperty2.default)(File, "uploadData", /*#__PURE__*/function () {
-  var _ref19 = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee17(destinationPath, data) {
+  var _ref19 = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee17(destinationPath, data, params) {
     return _regenerator.default.wrap(function _callee17$(_context17) {
       while (1) {
         switch (_context17.prev = _context17.next) {
@@ -1157,7 +1185,7 @@ var File = /*#__PURE__*/(0, _createClass2.default)(function File() {
             throw new errors.MissingParameterError('Upload data was not provided');
 
           case 2:
-            return _context17.abrupt("return", File.uploadStream(destinationPath, _readableStream.default.from(data)));
+            return _context17.abrupt("return", File.uploadStream(destinationPath, _readableStream.default.from(data), params));
 
           case 3:
           case "end":
@@ -1167,12 +1195,12 @@ var File = /*#__PURE__*/(0, _createClass2.default)(function File() {
     }, _callee17);
   }));
 
-  return function (_x13, _x14) {
+  return function (_x15, _x16, _x17) {
     return _ref19.apply(this, arguments);
   };
 }());
 (0, _defineProperty2.default)(File, "uploadFile", /*#__PURE__*/function () {
-  var _ref20 = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee18(destinationPath, sourceFilePath) {
+  var _ref20 = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee18(destinationPath, sourceFilePath, params) {
     var _require3, openDiskFileReadStream, stream;
 
     return _regenerator.default.wrap(function _callee18$(_context18) {
@@ -1189,7 +1217,7 @@ var File = /*#__PURE__*/(0, _createClass2.default)(function File() {
           case 2:
             _require3 = require('../isomorphic/File.node.js'), openDiskFileReadStream = _require3.openDiskFileReadStream;
             stream = openDiskFileReadStream(sourceFilePath);
-            return _context18.abrupt("return", File.uploadStream(destinationPath, stream));
+            return _context18.abrupt("return", File.uploadStream(destinationPath, stream, params));
 
           case 5:
           case "end":
@@ -1199,7 +1227,7 @@ var File = /*#__PURE__*/(0, _createClass2.default)(function File() {
     }, _callee18);
   }));
 
-  return function (_x15, _x16) {
+  return function (_x18, _x19, _x20) {
     return _ref20.apply(this, arguments);
   };
 }());
@@ -1329,7 +1357,7 @@ var File = /*#__PURE__*/(0, _createClass2.default)(function File() {
     }, _callee19);
   }));
 
-  return function (_x17) {
+  return function (_x21) {
     return _ref21.apply(this, arguments);
   };
 }());
@@ -1395,7 +1423,7 @@ var File = /*#__PURE__*/(0, _createClass2.default)(function File() {
     }, _callee20);
   }));
 
-  return function (_x18) {
+  return function (_x22) {
     return _ref22.apply(this, arguments);
   };
 }());

package/package.json

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

package/src/models/File.js

@@ -28,8 +28,8 @@ class File {
   }
 
   isLoaded = () => !!this.attributes.path
-  static _openUpload = async path => {
-    const params = { action: 'put' }
+  static _openUpload = async (path, paramsRaw) => {
+    const params = { ...paramsRaw, action: 'put' }
     const response = await Api.sendRequest(`/files/${encodeURIComponent(path)}`, 'POST', params)
 
     if (!response) {
@@ -67,19 +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)
   }
 
-  static uploadStream = async (destinationPath, readableStream) => {
-    const fileUploadPart = await File._openUpload(destinationPath)
+  /**
+   * @note see File.copy() for list of supported params
+   */
+  static uploadStream = async (destinationPath, readableStream, params) => {
+    const firstFileUploadPart = await File._openUpload(destinationPath, params)
 
-    if (!fileUploadPart) {
+    if (!firstFileUploadPart) {
       return
     }
 
@@ -88,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))
+            }
+
+            await Promise.all(concurrentUploads)
 
-          const response = await File._completeUpload(fileUploadPart)
-          const createdFile = new File(response.data)
+            const response = await File._completeUpload(firstFileUploadPart)
+            const createdFile = new File(response.data)
 
-          resolve(createdFile)
+            resolve(createdFile)
+          } catch (error) {
+            reject(error)
+          }
         })
       })
 
@@ -134,16 +157,20 @@ class File {
 
   /**
    * data - string, Buffer, Stream, any object implementing Symbol.iterator or Symbol.asyncIterator
+   * @note see File.copy() for list of supported params
    */
-  static uploadData = async (destinationPath, data) => {
+  static uploadData = async (destinationPath, data, params) => {
     if (!data) {
       throw new errors.MissingParameterError('Upload data was not provided')
     }
 
-    return File.uploadStream(destinationPath, Readable.from(data))
+    return File.uploadStream(destinationPath, Readable.from(data), params)
   }
 
-  static uploadFile = async (destinationPath, sourceFilePath) => {
+  /**
+   * @note see File.copy() for list of supported params
+   */
+  static uploadFile = async (destinationPath, sourceFilePath, params) => {
     if (isBrowser()) {
       throw new errors.NotImplementedError('Disk file uploads are only available in a NodeJS environment')
     }
@@ -151,7 +178,7 @@ class File {
     const { openDiskFileReadStream } = require('../isomorphic/File.node.js')
     const stream = openDiskFileReadStream(sourceFilePath)
 
-    return File.uploadStream(destinationPath, stream)
+    return File.uploadStream(destinationPath, stream, params)
   }
 
   downloadToStream = async writableStream => {