hmpo-model 4.0.0 → 4.0.3

package/.github/workflows/ci.yaml

@@ -0,0 +1,27 @@
+name: Node.js CI
+
+on:
+  push:
+    branches: [ master ]
+  pull_request:
+    branches: [ master ]
+
+jobs:
+  build:
+
+    runs-on: ubuntu-latest
+
+    strategy:
+      matrix:
+        node-version: [12.x, 14.x, 15.x]
+
+    steps:
+      - uses: actions/checkout@v2
+      - name: Use Node.js ${{ matrix.node-version }}
+        uses: actions/setup-node@v2
+        with:
+          node-version: ${{ matrix.node-version }}
+      - name: Install dependencies
+        run: npm ci
+      - name: Run tests
+        run: npm test

package/lib/local-model.js

@@ -1,6 +1,5 @@
 'use strict';
 
-const _ = require('underscore');
 const EventEmitter = require('events').EventEmitter;
 
 class LocalModel extends EventEmitter {
@@ -9,8 +8,8 @@ class LocalModel extends EventEmitter {
         super();
 
         this.options = options || {};
-        this.attributes = {};
-        this.set(attributes, {silent: true});
+        this.attributes = Object.create(null);
+        if (attributes) this.set(attributes, {silent: true});
     }
 
     get(key) {
@@ -19,32 +18,35 @@ class LocalModel extends EventEmitter {
 
     set(key, value, options) {
 
-        let attrs = {};
-
-        if (typeof key === 'string') {
+        let attrs = Object.create(null);
+        if (key instanceof Map) {
+            Object.assign(attrs, Object.fromEntries(key));
+            options = value;
+        } else if (typeof key === 'string') {
             attrs[key] = value;
         } else {
-            attrs = key;
+            Object.assign(attrs, key);
             options = value;
         }
-        options = options || {};
 
-        let old = this.toJSON(),
-            changed = {};
+        // silent set
+        if (options && options.silent) {
+            Object.assign(this.attributes, attrs);
+            return this;
+        }
 
-        _.each(attrs, (value, key) => {
-            if (value !== old[key]) {
-                changed[key] = value;
-            }
-        });
+        const changes = [];
+        for (let key in attrs) {
+            const value = attrs[key];
+            const old = this.attributes[key];
+            if (value !== old) changes.push([key, value, old]);
+        }
 
-        _.extend(this.attributes, attrs);
+        Object.assign(this.attributes, attrs);
 
-        if (!options.silent && !_.isEmpty(changed)) {
-            _.each(changed, (value, key) => {
-                this.emit('change:' + key, this.get(key), old[key]);
-            });
-            this.emit('change', changed);
+        if (changes.length) {
+            changes.forEach(([key, value, old]) => this.emit('change:' + key, value, old));
+            if (this.listenerCount('change')) this.emit('change', Object.fromEntries(changes));
         }
 
         return this;
@@ -52,38 +54,32 @@ class LocalModel extends EventEmitter {
 
 
     unset(fields, options) {
-        options = options || {};
         if (typeof fields === 'string') {
             fields = [fields];
         }
-        let old = this.toJSON(),
-            changed = {};
 
-        _.each(fields, (key) => {
-            if (old[key] !== undefined) {
-                changed[key] = undefined;
+        const changes = [];
+        for (let key of fields) {
+            const old = this.attributes[key];
+            if (old !== undefined) {
+                changes.push([key, undefined, old]);
                 delete this.attributes[key];
             }
-        });
+        }
 
-        if (!options.silent && !_.isEmpty(changed)) {
-            _.each(changed, (value, key) => {
-                this.emit('change:' + key, undefined, old[key]);
-            });
-            this.emit('change', changed);
+        if ((!options || !options.silent) && changes.length) {
+            changes.forEach(([key, value, old]) => this.emit('change:' + key, value, old));
+            if (this.listenerCount('change')) this.emit('change', Object.fromEntries(changes));
         }
 
         return this;
     }
 
     reset(options) {
-        options = options || {};
-        let keys = Object.keys(this.attributes);
-        this.attributes = {};
-        if (!options.silent) {
-            _.each(keys, (key) => {
-                this.emit('change:' + key, undefined);
-            });
+        const old = this.attributes;
+        this.attributes = Object.create(null);
+        if (!options || !options.silent) {
+            Object.keys(old).forEach(key => this.emit('change:' + key, undefined, old[key]));
             this.emit('reset');
         }
     }
@@ -97,8 +93,8 @@ class LocalModel extends EventEmitter {
         this.set(property, val + amount);
     }
 
-    toJSON() {
-        return Object.assign({}, this.attributes);
+    toJSON(bare = false) {
+        return Object.assign(bare ? Object.create(null) : {}, this.attributes);
     }
 }
 

package/lib/model-error.js

@@ -0,0 +1,51 @@
+
+class ModelError extends Error {
+    constructor(e) {
+        super(e);
+        Object.defineProperties(this, {
+            original: {
+                value: e,
+                enumerable: false,
+                writable: false,
+                configurable: true,
+            },
+            name: {
+                value: e.name,
+                enumerable: false,
+                writable: true,
+                configurable: true,
+            },
+            code: {
+                value: e.code,
+                enumerable: false,
+                writable: true,
+                configurable: true,
+            },
+            errno: {
+                value: e.errno,
+                enumerable: false,
+                writable: true,
+                configurable: true,
+            },
+            info: {
+                get: () => this.original.info,
+                enumerable: false,
+                configurable: true
+            },
+            stack: {
+                get: () => this.original.stack,
+                enumerable: false,
+                configurable: true
+            },
+        });
+        this.code = e.code;
+
+        if (this.code === 'ETIMEDOUT') {
+            this.message = 'Connection timed out';
+            this.status = 504;
+        }
+        this.status = this.status || (e.response && e.response.statusCode) || 503;
+    }
+}
+
+module.exports = ModelError;

package/lib/remote-model.js

@@ -5,6 +5,7 @@ const LocalModel = require('./local-model');
 const got = require('got');
 const kebabCase = require('lodash.kebabcase');
 const { URL } = require('url');
+const ModelError = require('./model-error');
 
 const DEFAULT_TIMEOUT = 60000;
 
@@ -174,20 +175,19 @@ class RemoteModel extends LocalModel {
         };
 
         this.got(settings)
-            .catch(err => {
-                debug('request got error', err);
-                setResponseTime();
-                if (err.code === 'ETIMEDOUT') {
-                    err.message = 'Connection timed out';
-                    err.status = 504;
-                }
-                err.status = err.status || (err.response && err.response.statusCode) || 503;
-                return _callback(err, null, err.status, err.response);
-            })
             .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 = new ModelError(err);
+                debug('request got error', err);
+                _callback(err, null, err.status);
             });
     }
 
@@ -199,7 +199,7 @@ class RemoteModel extends LocalModel {
         } 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);
     }
@@ -223,7 +223,13 @@ class RemoteModel extends LocalModel {
 
     parse(data) {
         debug('parse', data);
-        if (data && typeof data === 'object') this.set(data);
+        if (data && typeof data === 'object') {
+            if (Array.isArray(data)) {
+                this.set('data', data);
+            } else {
+                this.set(data);
+            }
+        }
         return data;
     }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hmpo-model",
-  "version": "4.0.0",
+  "version": "4.0.3",
   "description": "Simple model for interacting with http/rest apis.",
   "main": "index.js",
   "scripts": {
@@ -28,17 +28,16 @@
     "debug": "^4.3.3",
     "got": "^11.8.3",
     "hpagent": "^0.1.2",
-    "lodash.kebabcase": "^4.1.1",
-    "underscore": "^1.13.1"
+    "lodash.kebabcase": "^4.1.1"
   },
   "devDependencies": {
-    "chai": "^4.3.4",
-    "eslint": "^8.3.0",
-    "hmpo-logger": "^4.1.3",
-    "mocha": "^9.1.3",
+    "chai": "^4.3.6",
+    "eslint": "^8.10.0",
+    "hmpo-logger": "^4.1.4",
+    "mocha": "^9.2.1",
     "nyc": "^15.1.0",
     "proxyquire": "^2.0.0",
-    "sinon": "^12.0.1",
+    "sinon": "^13.0.1",
     "sinon-chai": "^3.7.0"
   },
   "nyc": {

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');
         });
     });
 

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

@@ -1,8 +1,8 @@
 'use strict';
 
 const Model = require('../../lib/remote-model');
+const ModelError = require('../../lib/model-error');
 const BaseModel = require('../../lib/local-model');
-const _ = require('underscore');
 const logger = require('hmpo-logger');
 
 const { HttpProxyAgent, HttpsProxyAgent } = require('hpagent');
@@ -543,7 +543,7 @@ describe('Remote Model', () => {
                 }
             };
 
-            let savedConfig = _.clone(config);
+            let savedConfig = Object.assign({}, config);
 
             let returnedConfig = model.requestConfig(config);
 
@@ -573,7 +573,7 @@ describe('Remote Model', () => {
                 method: 'VERB'
             };
 
-            requestSettings = _.clone(settings);
+            requestSettings = Object.assign({}, settings);
         });
 
         afterEach(() => {
@@ -650,9 +650,16 @@ describe('Remote Model', () => {
                     settings: settings,
                     statusCode: 418,
                     responseTime: sinon.match.number,
-                    err: error,
+                    err: sinon.match.instanceOf(ModelError),
                     data: null
                 });
+                model.logError.args[0][0].err.should.include({
+                    name: 'Error',
+                    message: 'Error: Lorem Ipsum',
+                    status: 418,
+                    info: undefined,
+                });
+                model.logError.args[0][0].err.stack.should.be.a('string');
             });
 
             it('should emit a fail event', () => {
@@ -660,15 +667,17 @@ describe('Remote Model', () => {
 
                 model.emit.should.have.been.calledWithExactly(
                     'fail',
-                    sinon.match({
-                        message: error.message,
-                        status: 418
-                    }),
+                    sinon.match.instanceOf(ModelError),
                     null,
                     settings,
                     418,
                     sinon.match.number
                 );
+                model.emit.args[1][1].should.include({
+                    name: 'Error',
+                    message: 'Error: Lorem Ipsum',
+                    status: 418,
+                });
             });
 
             it('should translate timeout errors with status codes', () => {
@@ -680,11 +689,14 @@ describe('Remote Model', () => {
                     settings: settings,
                     statusCode: 504,
                     responseTime: sinon.match.number,
-                    err: sinon.match({
-                        message: 'Connection timed out'
-                    }),
+                    err: sinon.match.instanceOf(ModelError),
                     data: null
                 });
+                model.logError.args[0][0].err.should.include({
+                    name: 'Error',
+                    message: 'Connection timed out',
+                    status: 504
+                });
             });
 
             it('should translate errors without status codes', () => {
@@ -696,12 +708,14 @@ describe('Remote Model', () => {
                     settings: settings,
                     statusCode: 503,
                     responseTime: sinon.match.number,
-                    err: sinon.match({
-                        message: error.message,
-                        status: 503,
-                    }),
+                    err: sinon.match.instanceOf(ModelError),
                     data: null
                 });
+                model.logError.args[0][0].err.should.include({
+                    name: 'Error',
+                    message: 'Error: Lorem Ipsum',
+                    status: 503
+                });
             });
 
             it('should fire fail hook', () => {
@@ -714,11 +728,44 @@ describe('Remote Model', () => {
                     settings: settings,
                     statusCode: 418,
                     responseTime: sinon.match.number,
-                    err: error,
+                    err: sinon.match.instanceOf(ModelError),
                     data: null
                 });
                 hook.should.have.been.calledOn(model);
             });
+
+            it('should handle response for ERR_NON_2XX_3XX_RESPONSE errors', () => {
+                error.code = 'ERR_NON_2XX_3XX_RESPONSE';
+                error.response = {
+                    'body': JSON.stringify({'data': 'value'}),
+                    'statusCode': 404
+                };
+
+                model.request(settings, cb);
+                console.log(model.logError.args[0][0]);
+                model.logError.should.have.been.calledWithExactly({
+                    settings: settings,
+                    statusCode: 404,
+                    responseTime: sinon.match.number,
+                    err: {
+                        status: 404,
+                        data: 'value'
+                    },
+                    data: { data: 'value' }
+                });
+
+                cb.should.have.been.calledWithExactly(
+                    {
+                        status: 404,
+                        data: 'value'
+                    },
+                    {
+                        data: 'value'
+                    },
+                    sinon.match.number
+                );
+            });
+
         });
 
         context('on success', () => {
@@ -910,6 +957,11 @@ describe('Remote Model', () => {
             model.get('foo').should.equal('bar');
         });
 
+        it('sets the parsed array data to the model as "data"', () => {
+            model.parse([1, 2, 3, 4]);
+            model.get('data').should.eql([1, 2, 3, 4]);
+        });
+
         it('does not set if the data falsey', () => {
             model.set = sinon.stub();
             model.parse(null);

package/.circleci/config.yml

@@ -1,21 +0,0 @@
-# This config is equivalent to both the '.circleci/extended/orb-free.yml' and the base '.circleci/config.yml'
-version: 2.1
-
-# Orbs are reusable packages of CircleCI configuration that you may share across projects, enabling you to create encapsulated, parameterized commands, jobs, and executors that can be used across multiple projects.
-# See: https://circleci.com/docs/2.0/orb-intro/
-orbs:
-  node: circleci/node@4.7
-
-# Invoke jobs via workflows
-# See: https://circleci.com/docs/2.0/configuration-reference/#workflows
-workflows:
-  sample: # This is the name of the workflow, feel free to change it to better match your workflow.
-    # Inside the workflow, you define the jobs you want to run.
-    jobs:
-      - node/test:
-          # This is the node version to use for the `cimg/node` tag
-          # Relevant tags can be found on the CircleCI Developer Hub
-          # https://circleci.com/developer/images/image/cimg/node
-          version: '16.10'
-          # If you are using yarn, change the line below from "npm" to "yarn"
-          pkg-manager: npm