hmpo-model 3.2.1 → 4.0.2

package/lib/remote-model.js

@@ -1,91 +1,165 @@
 'use strict';
 
+const debug = require('debug')('hmpo:model:remote');
 const LocalModel = require('./local-model');
-const requestLib = require('request');
-const _ = require('underscore');
+const got = require('got');
 const kebabCase = require('lodash.kebabcase');
-const hmpoLogger = require('hmpo-logger');
+const { URL } = require('url');
+const ModelError = require('./model-error');
+
+const DEFAULT_TIMEOUT = 60000;
 
 class RemoteModel extends LocalModel {
     constructor(attributes, options) {
         super(attributes, options);
-
+        this.got = got;
         this.options.label = this.options.label || kebabCase(this.constructor.name);
         this.setLogger();
     }
 
     setLogger() {
-        this.logger = hmpoLogger.get(':' + this.options.label);
+        try {
+            const hmpoLogger = require('hmpo-logger');
+            this.logger = hmpoLogger.get(':' + this.options.label);
+        } catch (e) {
+            console.error('Error setting logger, using console instead!', e);
+            this.logger = { outbound: console.log, trimHtml: html => html };
+        }
     }
 
-    fetch(callback) {
-        let config = this.requestConfig({method: 'GET'});
+    fetch(args, callback) {
+        if (typeof args === 'function') {
+            callback = args;
+            args = undefined;
+        }
+        const config = this.requestConfig({method: 'GET'}, args);
         this.request(config, callback);
     }
 
-    save(callback) {
-        this.prepare((err, data) => {
-
-            if (err) { return callback(err); }
-
-            data = JSON.stringify(data);
-
-            let config = this.requestConfig({
-                method: 'POST',
-                headers: {
-                    'Content-Type': 'application/json',
-                    'Content-Length': Buffer.byteLength(data)
-                }
-            });
-
-            this.request(config, data, callback);
-
+    save(args, callback) {
+        if (typeof args === 'function') {
+            callback = args;
+            args = undefined;
+        }
+        this.prepare((err, json) => {
+            if (err) return callback(err);
+            const config = this.requestConfig({method: 'POST', json}, args);
+            this.request(config, callback);
         });
     }
 
-    delete(callback) {
-        let config  = this.requestConfig({method: 'DELETE'});
+    delete(args, callback) {
+        if (typeof args === 'function') {
+            callback = args;
+            args = undefined;
+        }
+        const config  = this.requestConfig({method: 'DELETE'}, args);
         this.request(config, callback);
     }
 
-    requestConfig(config) {
-        let retConfig = _.clone(config);
+    prepare(callback) {
+        debug('prepare');
+        callback(null, this.toJSON());
+    }
+
+    requestConfig(config, args) {
+        const retConfig = Object.assign({}, config);
 
-        retConfig.uri = this.url();
+        retConfig.url = this.url(retConfig.url || retConfig.uri, args);
 
-        let auth = this.auth();
+        retConfig.timeout = this.timeout(retConfig.timeout);
 
+        const auth = this.auth(retConfig.auth);
         if (auth) {
-            retConfig.auth = auth;
+            retConfig.username = auth.username || auth.user;
+            retConfig.password = auth.password || auth.pass;
         }
+        delete retConfig.auth;
 
-        if (this.options.headers) {
-            retConfig.headers = _.defaults(retConfig.headers || {}, this.options.headers);
+        const agent = this.proxy(retConfig.proxy, retConfig.url);
+        if (agent) {
+            retConfig.agent = agent;
         }
+        delete retConfig.proxy;
+
+        const headers = Object.assign({}, this.options.headers, retConfig.headers);
+        if (Object.keys(headers).length) retConfig.headers = headers;
+
+        debug('requestConfig', retConfig);
 
         return retConfig;
     }
 
-    request(settings, body, callback) {
-        if (typeof body === 'function' && arguments.length === 2) {
-            callback = body;
-            body = undefined;
+    url(url = this.options.url) {
+        return url;
+    }
+
+    auth(auth = this.options.auth) {
+        if (typeof auth === 'string') {
+            const splitAuth = auth.split(':');
+            auth = {
+                username: splitAuth.shift(),
+                password: splitAuth.join(':')
+            };
         }
+        return auth;
+    }
 
-        // This is cloned and set so that the post body is not kept around in memory
-        // settings is a shallow object, so the requestSettings is entirely made up of copied properties
-        let requestSettings = _.clone(settings);
-        requestSettings.body = body;
+    timeout(timeout = this.options.timeout || DEFAULT_TIMEOUT) {
+        if (typeof timeout === 'number') {
+            timeout = {
+                lookup: timeout,
+                connect: timeout,
+                secureConnect: timeout,
+                socket: timeout,
+                send: timeout,
+                response: timeout
+            };
+        }
+        return timeout;
+    }
+
+    proxy(proxy = this.options.proxy, url) {
+        if (!proxy || !url) return;
+
+        if (typeof proxy === 'string') proxy = { proxy };
+
+        const isHttps = (new URL(url).protocol === 'https:');
 
-        let startTime = process.hrtime();
+        if (isHttps) {
+            const { HttpsProxyAgent } = require('hpagent');
+            return {
+                https: new HttpsProxyAgent(Object.assign({
+                    keepAlive: false,
+                    maxSockets: 1,
+                    maxFreeSockets: 1,
+                }, proxy))
+            };
+        } else {
+            const { HttpProxyAgent } = require('hpagent');
+            return {
+                http: new HttpProxyAgent(Object.assign({
+                    keepAlive: false,
+                    maxSockets: 1,
+                    maxFreeSockets: 1,
+                }, proxy))
+            };
+        }
+    }
 
-        let _callback = (err, data, statusCode) => {
+    request(settings, callback) {
+        this.hookSync({settings});
+        this.logSync({settings});
+        this.emit('sync', settings);
 
-            // This uses node's "high resolution time" to determine response time.
-            // The calculation is to translate seconds & nanoseconds into a number of format 1.234 seconds
-            let endTime = process.hrtime(startTime);
-            let responseTime = Number((endTime[0]*1000 + endTime[1]/1000000).toFixed(3));
+        let responseTime;
+        const startTime = process.hrtime.bigint();
+        const setResponseTime = () => {
+            const endTime = process.hrtime.bigint();
+            responseTime = Number((Number(endTime - startTime) / 1000000).toFixed(3));
+        };
 
+        const _callback = (err, data, statusCode) => {
             if (err) {
                 this.hookFail({settings, statusCode, responseTime, err, data});
                 this.logError({settings, statusCode, responseTime, err, data});
@@ -100,83 +174,74 @@ class RemoteModel extends LocalModel {
             }
         };
 
-        requestLib(requestSettings, (err, response) => {
-            if (err) {
-                if (err.code === 'ETIMEDOUT') {
-                    err.message = 'Connection timed out';
-                    err.status = 504;
+        this.got(settings)
+            .then(response => {
+                debug('request got response', response);
+                setResponseTime();
+                this.handleResponse(response, _callback);
+            })
+            .catch(err => {
+                setResponseTime();
+                if (err.code === 'ERR_NON_2XX_3XX_RESPONSE' && err.response) {
+                    return this.handleResponse(err.response, _callback);
                 }
-                err.status = err.status || (response && response.statusCode) || 503;
-                return _callback(err, null, err.status);
-            }
-            this.handleResponse(response, _callback);
-        });
-
-        this.hookSync({settings});
-        this.logSync({settings});
-        this.emit('sync', settings);
+                err = new ModelError(err);
+                debug('request got error', err);
+                _callback(err, null, err.status);
+            });
     }
 
     handleResponse(response, callback) {
-        let data = {};
+        debug('handleResponse', response);
+        let data;
         try {
             data = JSON.parse(response.body || '{}');
         } catch (err) {
             err.status = response.statusCode;
             err.body = response.body;
-            return callback(err, null, response.statusCode);
+            return callback(err, null, err.status);
         }
         this.parseResponse(response.statusCode, data, callback);
     }
 
     parseResponse(statusCode, data, callback) {
-        if (statusCode < 400) {
-            try {
-                data = this.parse(data);
-                callback(null, data, statusCode);
-            } catch (err) {
-                callback(err, null, statusCode);
-            }
-        } else {
-            callback(this.parseError(statusCode, data), data, statusCode);
+        debug('parseResponse', statusCode, data);
+
+        if (statusCode >= 400) {
+            const error = this.parseError(statusCode, data);
+            return callback(error, data, statusCode);
         }
-    }
 
-    prepare(callback) {
-        callback(null, this.toJSON());
+        try {
+            data = this.parse(data);
+        } catch (err) {
+            return callback(err, null, statusCode);
+        }
+
+        callback(null, data, statusCode);
     }
 
     parse(data) {
+        debug('parse', data);
+        if (data && typeof data === 'object') {
+            if (Array.isArray(data)) {
+                this.set('data', data);
+            } else {
+                this.set(data);
+            }
+        }
         return data;
     }
 
     parseError(statusCode, data) {
-        return _.extend({ status: statusCode }, data);
-    }
-
-    url() {
-        return this.options.url;
-    }
-
-    auth(credentials) {
-        if (!credentials) return;
-
-        if (typeof credentials === 'string') {
-            let auth = credentials.split(':');
-            credentials = {
-                user: auth.shift(),
-                pass: auth.join(':'),
-                sendImmediately: true
-            };
-        }
-
-        return credentials;
+        debug('parseError, statusCode, data');
+        return Object.assign({ status: statusCode }, data);
     }
 
     logMeta(tokenData) {
         let data = {
             outVerb: tokenData.settings.method,
-            outRequest: tokenData.settings.uri
+            outRequest: tokenData.settings.url
         };
 
         if (tokenData.statusCode) {
@@ -194,7 +259,7 @@ class RemoteModel extends LocalModel {
             data.outErrorBody = this.logger.trimHtml(tokenData.err.body);
         }
 
-        _.extend(data, this.options.logging);
+        Object.assign(data, this.options.logging);
 
         return data;
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hmpo-model",
-  "version": "3.2.1",
+  "version": "4.0.2",
   "description": "Simple model for interacting with http/rest apis.",
   "main": "index.js",
   "scripts": {
@@ -25,22 +25,20 @@
   },
   "homepage": "https://github.com/UKHomeOffice/passports-model",
   "dependencies": {
-    "lodash.kebabcase": "^4.1.1",
-    "request": "^2.88.2",
-    "underscore": "^1.13.1"
+    "debug": "^4.3.3",
+    "got": "^11.8.3",
+    "hpagent": "^0.1.2",
+    "lodash.kebabcase": "^4.1.1"
   },
   "devDependencies": {
     "chai": "^4.3.4",
-    "eslint": "^7.26.0",
+    "eslint": "^8.3.0",
     "hmpo-logger": "^4.1.3",
-    "mocha": "^8.4.0",
+    "mocha": "^9.1.3",
     "nyc": "^15.1.0",
     "proxyquire": "^2.0.0",
-    "sinon": "^10.0.0",
-    "sinon-chai": "^3.6.0"
-  },
-  "peerDependencies": {
-    "hmpo-logger": ">= 4"
+    "sinon": "^12.0.1",
+    "sinon-chai": "^3.7.0"
   },
   "nyc": {
     "all": true,

package/test/lib/spec.local-model.js

@@ -1,13 +1,11 @@
 'use strict';
 
-describe('Local Model', () => {
+const Model = require('../../lib/local-model');
 
+describe('Local Model', () => {
     let model;
 
     beforeEach(() => {
-
-        let Model = require('../../lib/local-model');
-
         model = new Model();
     });
 
@@ -18,7 +16,7 @@ describe('Local Model', () => {
     });
 
     it('has an attributes property of type object', () => {
-        model.attributes.should.be.a('object');
+        expect(model.attributes).to.be.an('object');
     });
 
     describe('constructor', () => {
@@ -54,20 +52,28 @@ describe('Local Model', () => {
     describe('set', () => {
 
         beforeEach(() => {
-            model.attributes = {
-                name: 'Test name'
-            };
+            model = new Model({ name: 'Test name' });
         });
 
         it('adds a key to the model attributes if the key is a string', () => {
-            model.set('age', 20).attributes.should.eql({
+            model.set('age', 20);
+            expect(model.attributes).to.eql({
                 name: 'Test name',
                 age: 20
             });
         });
 
         it('accepts an object as the key', () => {
-            model.set( { placeOfBirth: 'London' } ).attributes.should.eql({
+            model.set( { placeOfBirth: 'London' } );
+            expect(model.attributes).to.eql({
+                name: 'Test name',
+                placeOfBirth: 'London'
+            });
+        });
+
+        it('accepts a Map as the key', () => {
+            model.set( new Map([['placeOfBirth', 'London']]));
+            expect(model.attributes).to.eql({
                 name: 'Test name',
                 placeOfBirth: 'London'
             });
@@ -141,17 +147,17 @@ describe('Local Model', () => {
 
         it('removes properties from model when passed a string', () => {
             model.unset('a');
-            model.toJSON().should.eql({ b: 2, c: 3 });
+            expect(model.toJSON()).to.eql({ b: 2, c: 3 });
         });
 
         it('removes properties from model when passed an array', () => {
             model.unset(['a', 'b']);
-            model.toJSON().should.eql({ c: 3 });
+            expect(model.toJSON()).to.eql({ c: 3 });
         });
 
         it('does nothing if passed a property that does not exist', () => {
             model.unset('foo');
-            model.toJSON().should.eql({ a: 1, b: 2, c: 3 });
+            expect(model.toJSON()).to.eql({ a: 1, b: 2, c: 3 });
         });
 
         it('emits a change event', () => {
@@ -225,7 +231,7 @@ describe('Local Model', () => {
 
         it('clears model attributes', () => {
             model.reset();
-            model.toJSON().should.eql({});
+            expect(model.toJSON()).to.eql({});
             expect(model.get('name')).to.be.undefined;
             expect(model.get('age')).to.be.undefined;
         });
@@ -244,9 +250,9 @@ describe('Local Model', () => {
             model.on('change:age', listener2);
             model.reset();
             listener1.should.have.been.calledOnce;
-            listener1.should.have.been.calledWithExactly(undefined);
+            listener1.should.have.been.calledWithExactly(undefined, 'John');
             listener2.should.have.been.calledOnce;
-            listener2.should.have.been.calledWithExactly(undefined);
+            listener2.should.have.been.calledWithExactly(undefined, 30);
         });
 
         it('emits no events if called with silent: true', () => {
@@ -266,10 +272,22 @@ describe('Local Model', () => {
             };
         });
 
-        it('returns an object that\'s the same as the attributes property', () => {
-            model.toJSON().should.eql({
+        it('returns a bare object that\'s the same as the attributes property', () => {
+            const result = model.toJSON(true);
+            expect(result).to.eql({
                 name: 'Test name'
             });
+
+            expect(result.constructor).to.be.undefined;
+        });
+
+        it('returns an object that\'s the same as the attributes property with object prototype', () => {
+            const result = model.toJSON();
+            expect(result).to.eql({
+                name: 'Test name'
+            });
+
+            expect(result.constructor).to.be.a('function');
         });
     });