@sendsafely/sendsafely 1.1.1 → 1.1.3

package/{Dropzone.js → lib/Dropzone.js}

@@ -1,120 +1,120 @@
-const URL = require('url').URL;
-const Window = require('window');
-const window = new Window();
-const $ = require('jquery')(window);
-const XMLHttpRequest = require('xmlhttprequest').XMLHttpRequest;
-
-/**
- * @param eventHandler
- * @param {string} url
- * @param {string} dropzoneId
- * @param {string} requestAPI
- * @constructor
- */
-function AnonymousRequest(eventHandler, url, dropzoneId, requestAPI) {
-	const myself = this;
-
-	this.apiPrefix = '/drop-zone/v2.0';
-	this.url = url;
-	this.dropzoneId = dropzoneId;
-	this.eventHandler = eventHandler;
-	this.requestAPI = requestAPI;
-
-	this.sendRequest = function (requestType, messageData, a_sync) {
-
-		if (typeof a_sync === 'undefined') {
-			a_sync = true;
-		}
-
-		return $.ajax({
-			url: myself.url + myself.apiPrefix + requestType.url,
-			type: requestType.HTTPMethod,
-			timeout: 25000,
-			data: messageData == null ? null : JSON.stringify(messageData),
-			contentType: requestType.mimetype,
-			headers: {
-				'ss-api-key': myself.dropzoneId,
-				'ss-request-api' : myself.requestAPI
-			},
-			crossDomain: true,
-			async: a_sync,
-			retryCount: 2, //Need to Implement.
-		});
-	};
-
-	this.getHTTPSOptionForFileUpload = function (uri, method, messageData, boundary, isEC2Proxy) {
-		let headers = {
-			'Content-Type': 'multipart/form-data; boundary=' + boundary,
-			'ss-api-key': myself.dropzoneId,
-			'ss-request-api' : myself.requestAPI
-		};
-		let url = new URL(myself.url + myself.apiPrefix + uri);
-
-		if (!isEC2Proxy) {
-			headers = {};
-			url = new URL(uri);
-		}
-
-		return {
-			hostname: url.hostname,
-			port: url.port,
-			path: url.pathname + url.search,
-			headers: headers,
-			method: method,
-		};
-	};
-
-	this.getHTTPObjForFileUpload = function (uri, messageData, boundary, a_sync) {
-		const xhr = new XMLHttpRequest();
-		const url = myself.url + myself.apiPrefix + uri;
-
-		xhr.open('POST', url, a_sync);
-
-		xhr.setRequestHeader('Content-Type', 'multipart/form-data; boundary=' + boundary);
-		xhr.setRequestHeader('ss-api-key', myself.dropzoneId);
-		xhr.setRequestHeader('ss-request-api', myself.requestAPI);
-
-		return xhr;
-	};
-
-	/**
-	 * Function used to deal with Errors, and callbacks for AJAX Requests.
-	 * Progress callback cannot be done when async is false.
-	 * @ignore
-	 * @param {promise} ajax AJAX Promise
-	 * @param {function} error_callback Function is called when there is an error with the function or when there is an
-	 *     error in the response.
-	 * @param {function} success_callback Function is called when data is received from the server with no errors.
-	 * @param {function} progress_callback Function is called when the data is being uploaded.
-	 */
-	this.processAjaxData = function (ajax, success_callback) {
-		ajax.fail(function (xhr, status, error) {
-			// Wrap the error to a format we recognize.
-			myself.eventHandler.raiseError(this.NETWORK_ERROR, error.message);
-		})
-			.done(function (data) {
-				if (typeof data == 'string') {
-					data = JSON.parse(data);
-				}
-				if (data.response === 'SUCCESS') {
-					if (success_callback !== undefined) {
-						success_callback(data);
-					}
-				} else {
-					myself.eventHandler.raiseError(data.response, data.message);
-				}
-			});
-	};
-
-	this.extend = function (a, b) {
-		for (const key in b) {
-			if (b.hasOwnProperty(key)) {
-				a[key] = b[key];
-			}
-		}
-		return a;
-	};
-}
-
-
-module.exports = {AnonymousRequest};
+const URL = require('url').URL;
+const Window = require('window');
+const window = new Window();
+const $ = require('jquery')(window);
+const XMLHttpRequest = require('xmlhttprequest').XMLHttpRequest;
+
+/**
+ * @param eventHandler
+ * @param {string} url
+ * @param {string} dropzoneId
+ * @param {string} requestAPI
+ * @constructor
+ */
+function AnonymousRequest(eventHandler, url, dropzoneId, requestAPI) {
+	const myself = this;
+
+	this.apiPrefix = '/drop-zone/v2.0';
+	this.url = url;
+	this.dropzoneId = dropzoneId;
+	this.eventHandler = eventHandler;
+	this.requestAPI = requestAPI;
+
+	this.sendRequest = function (requestType, messageData, a_sync) {
+
+		if (typeof a_sync === 'undefined') {
+			a_sync = true;
+		}
+
+		return $.ajax({
+			url: myself.url + myself.apiPrefix + requestType.url,
+			type: requestType.HTTPMethod,
+			timeout: 25000,
+			data: messageData == null ? null : JSON.stringify(messageData),
+			contentType: requestType.mimetype,
+			headers: {
+				'ss-api-key': myself.dropzoneId,
+				'ss-request-api' : myself.requestAPI
+			},
+			crossDomain: true,
+			async: a_sync,
+			retryCount: 2, //Need to Implement.
+		});
+	};
+
+	this.getHTTPSOptionForFileUpload = function (uri, method, messageData, boundary, isEC2Proxy) {
+		let headers = {
+			'Content-Type': 'multipart/form-data; boundary=' + boundary,
+			'ss-api-key': myself.dropzoneId,
+			'ss-request-api' : myself.requestAPI
+		};
+		let url = new URL(myself.url + myself.apiPrefix + uri);
+
+		if (!isEC2Proxy) {
+			headers = {};
+			url = new URL(uri);
+		}
+
+		return {
+			hostname: url.hostname,
+			port: url.port,
+			path: url.pathname + url.search,
+			headers: headers,
+			method: method,
+		};
+	};
+
+	this.getHTTPObjForFileUpload = function (uri, messageData, boundary, a_sync) {
+		const xhr = new XMLHttpRequest();
+		const url = myself.url + myself.apiPrefix + uri;
+
+		xhr.open('POST', url, a_sync);
+
+		xhr.setRequestHeader('Content-Type', 'multipart/form-data; boundary=' + boundary);
+		xhr.setRequestHeader('ss-api-key', myself.dropzoneId);
+		xhr.setRequestHeader('ss-request-api', myself.requestAPI);
+
+		return xhr;
+	};
+
+	/**
+	 * Function used to deal with Errors, and callbacks for AJAX Requests.
+	 * Progress callback cannot be done when async is false.
+	 * @ignore
+	 * @param {promise} ajax AJAX Promise
+	 * @param {function} error_callback Function is called when there is an error with the function or when there is an
+	 *     error in the response.
+	 * @param {function} success_callback Function is called when data is received from the server with no errors.
+	 * @param {function} progress_callback Function is called when the data is being uploaded.
+	 */
+	this.processAjaxData = function (ajax, success_callback) {
+		ajax.fail(function (xhr, status, error) {
+			// Wrap the error to a format we recognize.
+			myself.eventHandler.raiseError(this.NETWORK_ERROR, error.message);
+		})
+			.done(function (data) {
+				if (typeof data == 'string') {
+					data = JSON.parse(data);
+				}
+				if (data.response === 'SUCCESS') {
+					if (success_callback !== undefined) {
+						success_callback(data);
+					}
+				} else {
+					myself.eventHandler.raiseError(data.response, data.message);
+				}
+			});
+	};
+
+	this.extend = function (a, b) {
+		for (const key in b) {
+			if (b.hasOwnProperty(key)) {
+				a[key] = b[key];
+			}
+		}
+		return a;
+	};
+}
+
+
+module.exports = {AnonymousRequest};

package/lib/FetchRequest.js

@@ -0,0 +1,99 @@
+const fetch = require('make-fetch-happen');
+const sjcl = require("sjcl");
+const URL = require('url').URL;
+
+function FetchRequest(param) {
+    if(!param.hasOwnProperty('signedRequest')) {
+        if(typeof param !== 'object') {
+            throw new Error('FetchRequest: Invalid parameters');
+        }
+        if(!param.hasOwnProperty('url')) {
+            throw new Error('FetchRequest: url is missing');
+        }
+        if(!param.hasOwnProperty('apiKey')) {
+            throw new Error('FetchRequest: apiKey is missing');
+        }
+        if(!param.hasOwnProperty('apiKeySecret')) {
+            throw new Error('FetchRequest: apiKeySecret is missing');
+        }
+    }
+
+    let myself = this;
+    myself.url = param.url; // scheme + domain + port for signed request, full url for non signed request
+    myself.apiPrefix = '/api/v2.0';
+    myself.apiKey = param.apiKey;
+    myself.apiKeySecret = param.apiKeySecret;
+    myself.requestAPI = param.hasOwnProperty('requestAPI') ? param.requestAPI: 'NODE_API';
+    myself.options = {};
+
+    myself.sendRequest = function (url, options) {
+        return fetch(url, options);
+    }
+    
+    myself.sendSignedRequest = function (endpoint, data) {
+        buildHttpsOptions(endpoint, data);
+        return fetch(myself.url + myself.apiPrefix + endpoint.url, myself.options);
+    };
+    
+    let buildHttpsOptions = function(endpoint, data) {
+        if(typeof endpoint !== 'object') {
+            throw new Error('FetchRequest: Invalid endpoint parameters');
+        }
+        if(!endpoint.hasOwnProperty('url')) {
+            throw new Error('FetchRequest: url is missing');
+        }
+        if(!endpoint.hasOwnProperty('HTTPMethod')) {
+            throw new Error('FetchRequest: HTTPMethod is missing');
+        }
+        if(!endpoint.hasOwnProperty('mimetype')) {
+            throw new Error('FetchRequest: mimetype is missing');
+        }
+
+        let timestamp = dateString();
+        let signature = myself.apiKey + myself.apiPrefix + endpoint.url.split("?")[0] + timestamp;
+        if(endpoint.hasOwnProperty('messageData')) {
+            signature += JSON.stringify(endpoint.messageData);
+        } else if(data !== '' && data !== null) {
+            signature += JSON.stringify(data);
+        }
+        signature = signMessage(signature);
+
+        let method = endpoint.HTTPMethod;
+        let headers = {
+            'Content-Type': endpoint.mimetype,
+            'ss-api-key':myself.apiKey,
+            'ss-request-timestamp': timestamp,
+            'ss-request-signature': signature,
+            'ss-request-api': myself.requestAPI,
+        };
+
+        let options = {
+            headers: headers,
+            method: method,
+        }
+
+        if(data !== null) {
+            if(endpoint.mimetype.includes('multipart/form-data')) {
+                options.headers['Content-Length'] = Buffer.from(data).length;
+                options.body = data;
+            } else {
+                options.body = JSON.stringify(data);
+            }
+        }
+
+        myself.options = options;
+    }
+    
+    
+    let dateString = function() {
+        let time = new Date().toISOString();
+        return time.substr(0, 19) + "+0000";
+    }
+    
+    let signMessage = function(messageString) {
+        let hmacFunction = new sjcl.misc.hmac(sjcl.codec.utf8String.toBits(myself.apiKeySecret), sjcl.hash.sha256);// Key, Hash
+        return sjcl.codec.hex.fromBits(hmacFunction.encrypt(messageString));
+    }
+}
+
+module.exports = {FetchRequest};

package/{FileUtil.js → lib/FileUtil.js}

@@ -1,110 +1,110 @@
-const fs = require('fs');
-const path = require("path");
-
-function FileUtil(param) {
-
-    if(param === undefined || typeof param !== 'object') {
-        throw new Error('FileUtil: Invalid parameters');
-    }
-
-    if(!param.hasOwnProperty('filePath')) {
-        throw new Error('FileUtil: filePath is needed');
-    }
-
-    if(!param.hasOwnProperty('callback')) {
-        throw new Error('FileUtil: callback is needed');
-    }
-
-    if(param.hasOwnProperty('callback') && typeof param.callback !== 'function') {
-        throw new Error('FileUtil: callback must be a function');
-    }
-
-    let myself = this;
-    this.SEGMENT_SIZE = 2621440;
-    this.filePath = param.filePath;
-    this.callback = param.callback;
-    this.file = {size: 0, name: '', totalParts: 0};
-    this.readableStream = fs.createReadStream(myself.filePath);
-    this.reading = false;
-    this.eof = false;
-    this.data = [];
-    this.tempSize = 0;
-
-    this.init = function() {
-        return new Promise(function(resolve) {
-            fs.stat(myself.filePath, (err, stats) => {
-                if (err) {
-                    throw new Error('FileUtil: File does not exist, ' + myself.filePath);
-                } else {
-                    myself.file.size = stats.size;
-                    myself.file.name =  path.basename(myself.filePath);
-
-                    if(myself.file.size > (myself.SEGMENT_SIZE/4)) {
-                        myself.file.totalParts = Math.ceil((myself.file.size-(myself.SEGMENT_SIZE/4))/myself.SEGMENT_SIZE);
-                    } else {
-                        myself.file.totalParts = 1;
-                    }
-
-                    resolve(myself.file);
-
-                    myself.readableStream.on('readable', function() {
-                        // keep reading chunk until it reaches SEGMENT_SIZE
-                        if(myself.reading && !myself.eof) {
-                            processChunk();
-                        }
-                    });
-
-                    myself.readableStream.on('end', function() {
-                        // done reading file
-                        if(!myself.eof) {
-                            myself.eof = true;
-                            callback(true);
-                        }
-                    });
-                }
-            });
-
-        });
-    }
-
-    this.read = function() {
-        if(!myself.reading && !myself.eof) {
-            myself.reading = true;
-            processChunk();
-        }
-    }
-
-    function processChunk() {
-        if(myself.tempSize === myself.SEGMENT_SIZE) {
-            // callback when data size reaches SEGMENT_SIZE
-            callback(false);
-        } else {
-            let chunk = myself.readableStream.read();
-            if(chunk !== null) {
-                myself.data.push(new Uint8Array(chunk));
-                myself.tempSize += chunk.length;
-            }
-        }
-    }
-
-    function callback(isComplete) {
-        myself.tempSize = 0;
-        myself.reading = false;
-        myself.callback({data: concatenate(myself.data), complete: isComplete});
-        myself.data = [];
-    }
-
-    function concatenate(arrays) {
-        var totalLength = arrays.reduce(function(total, arr) {
-            return total + arr.length
-        }, 0);
-        var result = new Uint8Array(totalLength);
-        arrays.reduce(function(offset, arr){
-            result.set(arr, offset);
-            return offset + arr.length;
-        }, 0);
-        return result;
-    }
-}
-
+const fs = require('fs');
+const path = require("path");
+
+function FileUtil(param) {
+
+    if(param === undefined || typeof param !== 'object') {
+        throw new Error('FileUtil: Invalid parameters');
+    }
+
+    if(!param.hasOwnProperty('filePath')) {
+        throw new Error('FileUtil: filePath is needed');
+    }
+
+    if(!param.hasOwnProperty('callback')) {
+        throw new Error('FileUtil: callback is needed');
+    }
+
+    if(param.hasOwnProperty('callback') && typeof param.callback !== 'function') {
+        throw new Error('FileUtil: callback must be a function');
+    }
+
+    let myself = this;
+    this.SEGMENT_SIZE = 2621440;
+    this.filePath = param.filePath;
+    this.callback = param.callback;
+    this.file = {size: 0, name: '', totalParts: 0};
+    this.readableStream = fs.createReadStream(myself.filePath);
+    this.reading = false;
+    this.eof = false;
+    this.data = [];
+    this.tempSize = 0;
+
+    this.init = function() {
+        return new Promise(function(resolve) {
+            fs.stat(myself.filePath, (err, stats) => {
+                if (err) {
+                    throw new Error('FileUtil: File does not exist, ' + myself.filePath);
+                } else {
+                    myself.file.size = stats.size;
+                    myself.file.name =  path.basename(myself.filePath);
+
+                    if(myself.file.size > (myself.SEGMENT_SIZE/4)) {
+                        myself.file.totalParts = Math.ceil((myself.file.size-(myself.SEGMENT_SIZE/4))/myself.SEGMENT_SIZE);
+                    } else {
+                        myself.file.totalParts = 1;
+                    }
+
+                    resolve(myself.file);
+
+                    myself.readableStream.on('readable', function() {
+                        // keep reading chunk until it reaches SEGMENT_SIZE
+                        if(myself.reading && !myself.eof) {
+                            processChunk();
+                        }
+                    });
+
+                    myself.readableStream.on('end', function() {
+                        // done reading file
+                        if(!myself.eof) {
+                            myself.eof = true;
+                            callback(true);
+                        }
+                    });
+                }
+            });
+
+        });
+    }
+
+    this.read = function() {
+        if(!myself.reading && !myself.eof) {
+            myself.reading = true;
+            processChunk();
+        }
+    }
+
+    function processChunk() {
+        if(myself.tempSize === myself.SEGMENT_SIZE) {
+            // callback when data size reaches SEGMENT_SIZE
+            callback(false);
+        } else {
+            let chunk = myself.readableStream.read();
+            if(chunk !== null) {
+                myself.data.push(new Uint8Array(chunk));
+                myself.tempSize += chunk.length;
+            }
+        }
+    }
+
+    function callback(isComplete) {
+        myself.tempSize = 0;
+        myself.reading = false;
+        myself.callback({data: concatenate(myself.data), complete: isComplete});
+        myself.data = [];
+    }
+
+    function concatenate(arrays) {
+        var totalLength = arrays.reduce(function(total, arr) {
+            return total + arr.length
+        }, 0);
+        var result = new Uint8Array(totalLength);
+        arrays.reduce(function(offset, arr){
+            result.set(arr, offset);
+            return offset + arr.length;
+        }, 0);
+        return result;
+    }
+}
+
 module.exports = {FileUtil};