buddy

form_data.js (13628B)

---

 var CombinedStream = require('combined-stream');
 var util = require('util');
 var path = require('path');
 var http = require('http');
 var https = require('https');
 var parseUrl = require('url').parse;
 var fs = require('fs');
 var Stream = require('stream').Stream;
 var mime = require('mime-types');
 var asynckit = require('asynckit');
 var populate = require('./populate.js');
 
 // Public API
 module.exports = FormData;
 
 // make it a Stream
 util.inherits(FormData, CombinedStream);
 
 /**
  * Create readable "multipart/form-data" streams.
  * Can be used to submit forms
  * and file uploads to other web applications.
  *
  * @constructor
  * @param {Object} options - Properties to be added/overriden for FormData and CombinedStream
  */
 function FormData(options) {
   if (!(this instanceof FormData)) {
     return new FormData(options);
   }
 
   this._overheadLength = 0;
   this._valueLength = 0;
   this._valuesToMeasure = [];
 
   CombinedStream.call(this);
 
   options = options || {};
   for (var option in options) {
     this[option] = options[option];
   }
 }
 
 FormData.LINE_BREAK = '\r\n';
 FormData.DEFAULT_CONTENT_TYPE = 'application/octet-stream';
 
 FormData.prototype.append = function(field, value, options) {
 
   options = options || {};
 
   // allow filename as single option
   if (typeof options == 'string') {
     options = {filename: options};
   }
 
   var append = CombinedStream.prototype.append.bind(this);
 
   // all that streamy business can't handle numbers
   if (typeof value == 'number') {
     value = '' + value;
   }
 
   // https://github.com/felixge/node-form-data/issues/38
   if (util.isArray(value)) {
     // Please convert your array into string
     // the way web server expects it
     this._error(new Error('Arrays are not supported.'));
     return;
   }
 
   var header = this._multiPartHeader(field, value, options);
   var footer = this._multiPartFooter();
 
   append(header);
   append(value);
   append(footer);
 
   // pass along options.knownLength
   this._trackLength(header, value, options);
 };
 
 FormData.prototype._trackLength = function(header, value, options) {
   var valueLength = 0;
 
   // used w/ getLengthSync(), when length is known.
   // e.g. for streaming directly from a remote server,
   // w/ a known file a size, and not wanting to wait for
   // incoming file to finish to get its size.
   if (options.knownLength != null) {
     valueLength += +options.knownLength;
   } else if (Buffer.isBuffer(value)) {
     valueLength = value.length;
   } else if (typeof value === 'string') {
     valueLength = Buffer.byteLength(value);
   }
 
   this._valueLength += valueLength;
 
   // @check why add CRLF? does this account for custom/multiple CRLFs?
   this._overheadLength +=
     Buffer.byteLength(header) +
     FormData.LINE_BREAK.length;
 
   // empty or either doesn't have path or not an http response or not a stream
   if (!value || ( !value.path && !(value.readable && value.hasOwnProperty('httpVersion')) && !(value instanceof Stream))) {
     return;
   }
 
   // no need to bother with the length
   if (!options.knownLength) {
     this._valuesToMeasure.push(value);
   }
 };
 
 FormData.prototype._lengthRetriever = function(value, callback) {
 
   if (value.hasOwnProperty('fd')) {
 
     // take read range into a account
     // `end` = Infinity –> read file till the end
     //
     // TODO: Looks like there is bug in Node fs.createReadStream
     // it doesn't respect `end` options without `start` options
     // Fix it when node fixes it.
     // https://github.com/joyent/node/issues/7819
     if (value.end != undefined && value.end != Infinity && value.start != undefined) {
 
       // when end specified
       // no need to calculate range
       // inclusive, starts with 0
       callback(null, value.end + 1 - (value.start ? value.start : 0));
 
     // not that fast snoopy
     } else {
       // still need to fetch file size from fs
       fs.stat(value.path, function(err, stat) {
 
         var fileSize;
 
         if (err) {
           callback(err);
           return;
         }
 
         // update final size based on the range options
         fileSize = stat.size - (value.start ? value.start : 0);
         callback(null, fileSize);
       });
     }
 
   // or http response
   } else if (value.hasOwnProperty('httpVersion')) {
     callback(null, +value.headers['content-length']);
 
   // or request stream http://github.com/mikeal/request
   } else if (value.hasOwnProperty('httpModule')) {
     // wait till response come back
     value.on('response', function(response) {
       value.pause();
       callback(null, +response.headers['content-length']);
     });
     value.resume();
 
   // something else
   } else {
     callback('Unknown stream');
   }
 };
 
 FormData.prototype._multiPartHeader = function(field, value, options) {
   // custom header specified (as string)?
   // it becomes responsible for boundary
   // (e.g. to handle extra CRLFs on .NET servers)
   if (typeof options.header == 'string') {
     return options.header;
   }
 
   var contentDisposition = this._getContentDisposition(value, options);
   var contentType = this._getContentType(value, options);
 
   var contents = '';
   var headers  = {
     // add custom disposition as third element or keep it two elements if not
     'Content-Disposition': ['form-data', 'name="' + field + '"'].concat(contentDisposition || []),
     // if no content type. allow it to be empty array
     'Content-Type': [].concat(contentType || [])
   };
 
   // allow custom headers.
   if (typeof options.header == 'object') {
     populate(headers, options.header);
   }
 
   var header;
   for (var prop in headers) {
     if (!headers.hasOwnProperty(prop)) continue;
     header = headers[prop];
 
     // skip nullish headers.
     if (header == null) {
       continue;
     }
 
     // convert all headers to arrays.
     if (!Array.isArray(header)) {
       header = [header];
     }
 
     // add non-empty headers.
     if (header.length) {
       contents += prop + ': ' + header.join('; ') + FormData.LINE_BREAK;
     }
   }
 
   return '--' + this.getBoundary() + FormData.LINE_BREAK + contents + FormData.LINE_BREAK;
 };
 
 FormData.prototype._getContentDisposition = function(value, options) {
 
   var filename
     , contentDisposition
     ;
 
   if (typeof options.filepath === 'string') {
     // custom filepath for relative paths
     filename = path.normalize(options.filepath).replace(/\\/g, '/');
   } else if (options.filename || value.name || value.path) {
     // custom filename take precedence
     // formidable and the browser add a name property
     // fs- and request- streams have path property
     filename = path.basename(options.filename || value.name || value.path);
   } else if (value.readable && value.hasOwnProperty('httpVersion')) {
     // or try http response
     filename = path.basename(value.client._httpMessage.path || '');
   }
 
   if (filename) {
     contentDisposition = 'filename="' + filename + '"';
   }
 
   return contentDisposition;
 };
 
 FormData.prototype._getContentType = function(value, options) {
 
   // use custom content-type above all
   var contentType = options.contentType;
 
   // or try `name` from formidable, browser
   if (!contentType && value.name) {
     contentType = mime.lookup(value.name);
   }
 
   // or try `path` from fs-, request- streams
   if (!contentType && value.path) {
     contentType = mime.lookup(value.path);
   }
 
   // or if it's http-reponse
   if (!contentType && value.readable && value.hasOwnProperty('httpVersion')) {
     contentType = value.headers['content-type'];
   }
 
   // or guess it from the filepath or filename
   if (!contentType && (options.filepath || options.filename)) {
     contentType = mime.lookup(options.filepath || options.filename);
   }
 
   // fallback to the default content type if `value` is not simple value
   if (!contentType && typeof value == 'object') {
     contentType = FormData.DEFAULT_CONTENT_TYPE;
   }
 
   return contentType;
 };
 
 FormData.prototype._multiPartFooter = function() {
   return function(next) {
     var footer = FormData.LINE_BREAK;
 
     var lastPart = (this._streams.length === 0);
     if (lastPart) {
       footer += this._lastBoundary();
     }
 
     next(footer);
   }.bind(this);
 };
 
 FormData.prototype._lastBoundary = function() {
   return '--' + this.getBoundary() + '--' + FormData.LINE_BREAK;
 };
 
 FormData.prototype.getHeaders = function(userHeaders) {
   var header;
   var formHeaders = {
     'content-type': 'multipart/form-data; boundary=' + this.getBoundary()
   };
 
   for (header in userHeaders) {
     if (userHeaders.hasOwnProperty(header)) {
       formHeaders[header.toLowerCase()] = userHeaders[header];
     }
   }
 
   return formHeaders;
 };
 
 FormData.prototype.getBoundary = function() {
   if (!this._boundary) {
     this._generateBoundary();
   }
 
   return this._boundary;
 };
 
 FormData.prototype.getBuffer = function() {
   var dataBuffer = new Buffer.alloc( 0 );
   var boundary = this.getBoundary();
 
   // Create the form content. Add Line breaks to the end of data.
   for (var i = 0, len = this._streams.length; i < len; i++) {
     if (typeof this._streams[i] !== 'function') {
 
       // Add content to the buffer.
       if(Buffer.isBuffer(this._streams[i])) {
         dataBuffer = Buffer.concat( [dataBuffer, this._streams[i]]);
       }else {
         dataBuffer = Buffer.concat( [dataBuffer, Buffer.from(this._streams[i])]);
       }
 
       // Add break after content.
       if (typeof this._streams[i] !== 'string' || this._streams[i].substring( 2, boundary.length + 2 ) !== boundary) {
         dataBuffer = Buffer.concat( [dataBuffer, Buffer.from(FormData.LINE_BREAK)] );
       }
     }
   }
 
   // Add the footer and return the Buffer object.
   return Buffer.concat( [dataBuffer, Buffer.from(this._lastBoundary())] );
 };
 
 FormData.prototype._generateBoundary = function() {
   // This generates a 50 character boundary similar to those used by Firefox.
   // They are optimized for boyer-moore parsing.
   var boundary = '--------------------------';
   for (var i = 0; i < 24; i++) {
     boundary += Math.floor(Math.random() * 10).toString(16);
   }
 
   this._boundary = boundary;
 };
 
 // Note: getLengthSync DOESN'T calculate streams length
 // As workaround one can calculate file size manually
 // and add it as knownLength option
 FormData.prototype.getLengthSync = function() {
   var knownLength = this._overheadLength + this._valueLength;
 
   // Don't get confused, there are 3 "internal" streams for each keyval pair
   // so it basically checks if there is any value added to the form
   if (this._streams.length) {
     knownLength += this._lastBoundary().length;
   }
 
   // https://github.com/form-data/form-data/issues/40
   if (!this.hasKnownLength()) {
     // Some async length retrievers are present
     // therefore synchronous length calculation is false.
     // Please use getLength(callback) to get proper length
     this._error(new Error('Cannot calculate proper length in synchronous way.'));
   }
 
   return knownLength;
 };
 
 // Public API to check if length of added values is known
 // https://github.com/form-data/form-data/issues/196
 // https://github.com/form-data/form-data/issues/262
 FormData.prototype.hasKnownLength = function() {
   var hasKnownLength = true;
 
   if (this._valuesToMeasure.length) {
     hasKnownLength = false;
   }
 
   return hasKnownLength;
 };
 
 FormData.prototype.getLength = function(cb) {
   var knownLength = this._overheadLength + this._valueLength;
 
   if (this._streams.length) {
     knownLength += this._lastBoundary().length;
   }
 
   if (!this._valuesToMeasure.length) {
     process.nextTick(cb.bind(this, null, knownLength));
     return;
   }
 
   asynckit.parallel(this._valuesToMeasure, this._lengthRetriever, function(err, values) {
     if (err) {
       cb(err);
       return;
     }
 
     values.forEach(function(length) {
       knownLength += length;
     });
 
     cb(null, knownLength);
   });
 };
 
 FormData.prototype.submit = function(params, cb) {
   var request
     , options
     , defaults = {method: 'post'}
     ;
 
   // parse provided url if it's string
   // or treat it as options object
   if (typeof params == 'string') {
 
     params = parseUrl(params);
     options = populate({
       port: params.port,
       path: params.pathname,
       host: params.hostname,
       protocol: params.protocol
     }, defaults);
 
   // use custom params
   } else {
 
     options = populate(params, defaults);
     // if no port provided use default one
     if (!options.port) {
       options.port = options.protocol == 'https:' ? 443 : 80;
     }
   }
 
   // put that good code in getHeaders to some use
   options.headers = this.getHeaders(params.headers);
 
   // https if specified, fallback to http in any other case
   if (options.protocol == 'https:') {
     request = https.request(options);
   } else {
     request = http.request(options);
   }
 
   // get content length and fire away
   this.getLength(function(err, length) {
     if (err && err !== 'Unknown stream') {
       this._error(err);
       return;
     }
 
     // add content length
     if (length) {
       request.setHeader('Content-Length', length);
     }
 
     this.pipe(request);
     if (cb) {
       var onResponse;
 
       var callback = function (error, responce) {
         request.removeListener('error', callback);
         request.removeListener('response', onResponse);
 
         return cb.call(this, error, responce);
       };
 
       onResponse = callback.bind(this, null);
 
       request.on('error', callback);
       request.on('response', onResponse);
     }
   }.bind(this));
 
   return request;
 };
 
 FormData.prototype._error = function(err) {
   if (!this.error) {
     this.error = err;
     this.pause();
     this.emit('error', err);
   }
 };
 
 FormData.prototype.toString = function () {
   return '[object FormData]';
 };