hmpo-model 3.2.0 → 4.0.1

package/.circleci/config.yml

@@ -0,0 +1,21 @@
+# 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

package/README.md

@@ -2,88 +2,134 @@
 * localModel - Simple model for data persistance
 * remoteModel - Simple model for interacting with http/rest apis.
 
+## Upgrading
+
+The deprecated `request` library has been replaced with `got`. The API is very similar, and some args are translated, like auth, and proxy.
+The new `got` library doesn't automativally use the proxy environment variables so you would need to use something like `global-agent` in your
+app if you need to specify proxies by environment arguments.
+
+The `request` method no longer takes a body. This should be inserted as `json`, `body`, or `form` into the `requestConfig` method.
+
 ## Local Model Usage
-### get
+### `get(name)`
 * gets a model property via a key
 
-### set
+### `set(name, value)` or `set({ name: value })`
 * sets a property on the model to a value and dispatches events
 
-### unset
+### `unset(name)`
 * unsets a property
 
-### reset
+### `reset([options])`
 * resets a model
 * suppresses `change` event notifications if `options.silent` is set
 
-### increment
+### `increment(name)`
 * Increments a property
 
-### toJSON
+### `toJSON()`
 * returns a JSON representation of the data in the model
 
 ## Remote Model Usage
 
 Normally this would be used as an abstract class and extended with your own implementation.
 
-Implementations would normally define at least a `url` method to define the target of API calls.
-
-There are three methods for API interaction corresponding to GET, POST, and DELETE http methods:
-
-### `fetch`
+Implementations would normally define at least a `url():url` method to define the target of API calls.
 
+Example implimentation:
 ```javascript
-var model = new Model();
-model.fetch(function (err, data, responseTime) {
+class MyModel extends HmpoModel {
+    url() {
+        return super.url('https://my.example.com/url')
+    }
+
+    auth() {
+        return super.auth('username:password');
+    }
+
+    requestConfig(config) {
+        config.proxy = 'http://proxy.example.com:3128'
+        return super.requestConfig(config);
+    }
+
+    // add data to JSON post body
+    prepare(callback) {
+        super.prepare((err, data) => {
+            if (err) return callback(err);
+            data.foo = 'bar';
+            callback(null, data);
+        });
+    }
+
+    // transform returned data
+    parse(data) {
+        data.additionalItem = true;
+        return super.parse(data);
+    }
+}
+
+const model = new MyModel();
+model.set('boo', 'baz');
+model.save((err, data, responseTime) => {
+    if (err) return console.error(err);
     console.log(data);
 });
 ```
 
-### `save`
+There are three methods for API interaction corresponding to GET, POST, and DELETE http methods:
+
+### `fetch([args, ][callback])`
+
+`fetch` performs a `GET` request on the url
 
 ```javascript
-var model = new Model();
-model.set({
-    property: 'properties are sent as JSON request body by default'
-});
-model.save(function (err, data, responseTime) {
+const model = new Model();
+model.fetch((err, data, responseTime) => {
     console.log(data);
 });
 ```
+#### Request
+- Request args for the `got` library, can be set by overriding the `requestConfig({}):{}` method.
+
+- The `url` can be configured either by setting a default in the model options or `requestConfig()` data, or by overriding the `url(default, args):url` method.
+
+- `proxy`, `timeout`, and basic `auth` can be set in the same way, using model options, setting in `requestConfig()`, or by overriding a method.
+- Specifying a `proxy` will set up a proxy tunneling `agent` for the request.
+- Specifying a numeric `timeout` will set the same timeout for all `got` timeout values.
+- Basic `auth` can be a colon separated string, or a `{username, password}` or `{user, pass}` object.
+
+#### Response
+- The returned body will be expected to be in JSON format.
+- If `statusCode < 400` the JSON response will be set to the model.
+This behaviour can be changed by overriding the `parse(data):data` method.
+- If `statusCode >= 400` the data will be passed to the `parseError(statusCode, data):error` method, and the `fetch` callback will be called with the returned error.
+- If response statuses need to be treated differently than the above, the `parseResponse(statusCode, data, cb)` method can be overridden.
+- If the response body is not going to be JSON, the `handleResponse(response, cb)` method can be overridden.
+
+### `save([args, ][callback])`
 
-The method can also be overwritten by passing options
+`save` performs a `POST` request on the url
 
 ```javascript
-var model = new Model();
+const model = new Model();
 model.set({
-    property: 'this will be sent as a PUT request'
+    property: 'properties are sent as JSON request body by default'
 });
-model.save({ method: 'PUT' }, function (err, data, responseTime) {
+model.save((err, data, responseTime) => {
     console.log(data);
 });
 ```
 
-### `delete`
+- By default the post body will be a JSON encoded object containing all attributes set to the model using, extracted using `model.toJSON()`. This behaviour can be changed by overriding the `prepare(callback(err, data))` method.
+- The response and body will be treated the same way as the `fetch` request above.
 
-```javascript
-var model = new Model();
-model.delete(function (err, data) {
-    console.log(data);
-});
-```
+### `delete([args, ][callback])`
 
-If no `url` method is defined then the model will use the options parameter and [Node's url.format method](https://nodejs.org/api/url.html#url_url_format_urlobj) to construct a URL.
+`delete` performs a `DELETE` request on the url
 
 ```javascript
-var model = new Model();
-
-// make a GET request to http://example.com:3000/foo/bar
-model.fetch({
-    protocol: 'http',
-    hostname: 'example.com',
-    port: 3000,
-    path: '/foo/bar'
-}, function (err, data, responseTime) {
+const model = new Model();
+model.delete((err, data, responseTime) => {
     console.log(data);
 });
 ```

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 _.clone(this.attributes);
+    toJSON(bare = false) {
+        return Object.assign(bare ? Object.create(null) : {}, this.attributes);
     }
 }
 

package/lib/remote-model.js

@@ -1,91 +1,164 @@
 '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 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,25 +173,27 @@ class RemoteModel extends LocalModel {
             }
         };
 
-        requestLib(requestSettings, (err, response) => {
-            if (err) {
+        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 || (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.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);
+            });
     }
 
     handleResponse(response, callback) {
-        let data = {};
+        debug('handleResponse', response);
+        let data;
         try {
             data = JSON.parse(response.body || '{}');
         } catch (err) {
@@ -130,53 +205,43 @@ class RemoteModel extends LocalModel {
     }
 
     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;
     }