@sendsafely/sendsafely 1.1.0 → 1.1.2

package/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

@@ -0,0 +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;
+    }
+}
+
+module.exports = {FileUtil};