hmpo-model 3.2.1 → 4.0.2

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