@bitfinex/lib-util-err-js 0.0.0-stage → 0.2.0

package/CHANGELOG.md

@@ -0,0 +1,7 @@
+# 0.2.0
+- feature: prevent adding prefix more than once
+
+# 0.1.0
+- feature: user error
+- feature: generic error
+- feature: api error handler

package/README.md

@@ -1,3 +1,36 @@
-# Temporary Holding Version
+# lib-util-err-js
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+The lib includes the utilities that help on resolving errors that should be shown to the endusers.
+
+## Installing
+
+```console
+npm install --save https://github.com/bitfinexcom/lib-util-err-js.git
+```
+
+## Testing
+
+```console
+npm test
+```
+
+## Usage
+
+```javascript
+const { apiErrorHandler, GrcUserError, constants: { ERR_CODES } } = require('..')
+
+const err = new Error('ERR_CONNECTION_FAILED')
+const userErr = new GrcUserError('ERR_INVALID_CREDENTIALS', 'AUTH_ACTION', ERR_CODES.ERR_AUTH_FAIL)
+
+const cb = (err) => {
+  console.error('- Response from action')
+  console.error(err)
+}
+
+apiErrorHandler(err, 'AUTH_FUNCTION', cb)
+apiErrorHandler(userErr, 'AUTH_FUNC', cb)
+
+```
+
+## Authors
+- vigan.abd

package/examples/index.js

@@ -0,0 +1,14 @@
+'use strict'
+
+const { apiErrorHandler, GrcUserError, constants: { ERR_CODES } } = require('..')
+
+const err = new Error('ERR_CONNECTION_FAILED')
+const userErr = new GrcUserError('ERR_INVALID_CREDENTIALS', 'AUTH_ACTION', ERR_CODES.ERR_AUTH_FAIL)
+
+const cb = (err) => {
+  console.error('- Response from action')
+  console.error(err)
+}
+
+apiErrorHandler(err, 'AUTH_FUNCTION', cb)
+apiErrorHandler(userErr, 'AUTH_FUNC', cb)

package/index.js

@@ -0,0 +1,11 @@
+'use strict'
+
+const GrcUserError = require('./src/errors/grc.user.error')
+const GrcGenericError = require('./src/errors/grc.generic.error')
+const apiErrorHandler = require('./src/api.error.handler')
+
+module.exports = {
+  GrcUserError,
+  GrcGenericError,
+  apiErrorHandler
+}

package/package.json

@@ -1,6 +1,49 @@
 {
   "name": "@bitfinex/lib-util-err-js",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.2.0",
+  "description": "Bitfinex lib utility for handling error messages",
+  "main": "index.js",
+  "scripts": {
+    "coverage": "nyc --reporter=html mocha",
+    "format": "standard --fix",
+    "lint": "standard",
+    "test": "npm run lint && npm run unit",
+    "unit": "NODE_ENV=test mocha ./test"
+  },
+  "keywords": [
+    "bitfinex",
+    "utils",
+    "error"
+  ],
+  "author": {
+    "name": "vigan.abd",
+    "email": "vigan.abdurrahmani@bitfinex.com"
+  },
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/bitfinexcom/lib-util-err-js.git"
+  },
+  "maintainers": [
+    {
+      "name": "prdn",
+      "email": "paolo@bitfinex.com"
+    },
+    {
+      "name": "vigan.abd",
+      "email": "vigan.abdurrahmani@bitfinex.com"
+    }
+  ],
+  "bugs": {
+    "url": "https://github.com/bitfinexcom/lib-util-err-js/issues"
+  },
+  "homepage": "https://github.com/bitfinexcom/lib-util-err-js#readme",
+  "devDependencies": {
+    "chai": "^4.3.4",
+    "dirty-chai": "^2.0.1",
+    "mocha": "^9.1.3",
+    "nyc": "^15.1.0",
+    "sinon": "^12.0.1",
+    "standard": "^16.0.4"
+  }
+}

package/src/api.error.handler.js

@@ -0,0 +1,49 @@
+'use strict'
+
+const GrcUserError = require('./errors/grc.user.error')
+const GrcGenericError = require('./errors/grc.generic.error')
+
+/**
+ * @callback ErrorCallbackFunction
+ * @param {Error} err
+ * @returns {void}
+ */
+
+/**
+ * Error handler utility that is useful for hiding internal errors from endusers
+ *
+ * @param {Error} err - Original error
+ * @param {string} [basename] - Optional, error base message
+ * @param {Object} [opts] - Optional, error handling options
+ * @param {boolean} [opts.force] - Optional, force original error message
+ * @param {ErrorCallbackFunction} cb - Callback function in format: `(err) => void`
+ */
+
+const apiErrorHandler = (err, basename, opts, cb) => {
+  if (typeof basename === 'function') {
+    cb = basename
+    basename = null
+    opts = { force: false }
+  }
+
+  if (typeof opts === 'function') {
+    cb = opts
+    opts = { force: false }
+  }
+
+  console.error(new Date().toISOString(), basename, err)
+
+  if (err instanceof GrcUserError || opts.force) {
+    // in case if force flag is used, debugging purposes
+    let message = err.message || err.toString()
+    const prefix = basename && !message.startsWith(basename) ? `${basename}: ` : ''
+    message = prefix + message // wrap error with basename
+    const code = err.code || null
+
+    cb(new GrcUserError(message, code))
+  } else {
+    cb(new GrcGenericError(basename))
+  }
+}
+
+module.exports = apiErrorHandler

package/src/errors/grc.generic.error.js

@@ -0,0 +1,20 @@
+'use strict'
+
+const GrcUserError = require('./grc.user.error')
+
+/**
+ * Generic api error, useful for hiding errors like connection failures
+ */
+class GrcGenericError extends GrcUserError {
+  /**
+   * @param {string} [basename] - Optional, error message prefix
+   */
+  constructor (basename = null) {
+    super((basename ? `${basename}: ` : '') + 'generic error')
+
+    this.name = this.constructor.name
+    Error.captureStackTrace(this, this.constructor)
+  }
+}
+
+module.exports = GrcGenericError

package/src/errors/grc.user.error.js

@@ -0,0 +1,33 @@
+'use strict'
+
+/**
+ * User friendly error that is shown directly to endusers
+ */
+class GrcUserError extends Error {
+  /**
+   * @param {string} message - Error message
+   * @param {number} [code] - Optional, error code
+   */
+  constructor (message, code = null) {
+    super(message)
+
+    this.name = this.constructor.name
+    this.code = code
+
+    Error.captureStackTrace(this, this.constructor)
+  }
+
+  /**
+   * This method is called from JSON.stringify function when serializing object
+   * @returns {{ message: string, code: number, name: string }}
+   */
+  toJSON () {
+    return {
+      name: this.name,
+      message: this.message,
+      code: this.code
+    }
+  }
+}
+
+module.exports = GrcUserError

package/test/api.error.handler.test.js

@@ -0,0 +1,98 @@
+'use strict'
+
+/* eslint-env mocha */
+
+const sinon = require('sinon')
+const { expect } = require('chai').use(require('dirty-chai'))
+const { format } = require('util')
+const { GrcGenericError, GrcUserError, apiErrorHandler } = require('../')
+
+describe('apiErrorHandler tests', () => {
+  let storedLog = ''
+  const logStub = sinon.stub(console, 'error')
+
+  before(() => {
+    logStub.callsFake((...params) => {
+      storedLog = format(...params)
+    })
+  })
+
+  after(() => {
+    logStub.restore()
+  })
+
+  beforeEach(() => {
+    storedLog = ''
+  })
+
+  it('it should hide original error message in case if it\'s not instance of GrcUserError', (done) => {
+    apiErrorHandler(new Error('Critical error in db'), 'MY_FUNCTION', {}, (err) => {
+      expect(err).to.be.instanceOf(GrcGenericError)
+      expect(err.message).to.be.equal('MY_FUNCTION: generic error')
+      expect(err.code).to.be.equal(null)
+      done()
+    })
+  })
+
+  it('it should return original error message in case if it\'s instance of GrcUserError', (done) => {
+    apiErrorHandler(new GrcUserError('invalid field', 10001), 'MY_FUNCTION', {}, (err) => {
+      expect(err).to.be.instanceOf(GrcUserError)
+      expect(err.message).to.be.equal('MY_FUNCTION: invalid field')
+      expect(err.code).to.be.equal(10001)
+      done()
+    })
+  })
+
+  it('it should return original error message in case if it has force flag', (done) => {
+    apiErrorHandler(new Error('Critical error in db'), 'MY_FUNCTION', { force: true }, (err) => {
+      expect(err).to.be.instanceOf(GrcUserError)
+      expect(err.message).to.be.equal('MY_FUNCTION: Critical error in db')
+      expect(err.code).to.be.equal(null) // since it's missing add default one!
+      done()
+    })
+  })
+
+  it('it should work without optional params', (done) => {
+    apiErrorHandler(new Error('Critical error in db'), (err) => {
+      expect(err).to.be.instanceOf(GrcGenericError)
+      expect(err.message).to.be.equal('generic error')
+      expect(err.code).to.be.equal(null)
+      done()
+    })
+  })
+
+  it('it should work without opts param', (done) => {
+    apiErrorHandler(new Error('Critical error in db'), 'MY_FUNCTION', (err) => {
+      expect(err).to.be.instanceOf(GrcGenericError)
+      expect(err.message).to.be.equal('MY_FUNCTION: generic error')
+      expect(err.code).to.be.equal(null)
+      done()
+    })
+  })
+
+  it('it should always log original error', (done) => {
+    apiErrorHandler(new GrcUserError('invalid field', 10001), (err) => {
+      expect(storedLog).not.to.be.null()
+      expect(storedLog.includes(err.trace))
+      done()
+    })
+  })
+
+  it('it should use toString method when error does not have message field', (done) => {
+    apiErrorHandler('Critical error in db', 'MY_FUNCTION', { force: true }, (err) => {
+      expect(err).to.be.instanceOf(GrcUserError)
+      expect(err.message).to.be.equal('MY_FUNCTION: Critical error in db')
+      expect(err.code).to.be.equal(null)
+      done()
+    })
+  })
+
+  it('it should avoid adding prefix more than once', (done) => {
+    apiErrorHandler(new GrcUserError('MY_FUNCTION: invalid field'), 'MY_FUNCTION', (err) => {
+      expect(err).to.be.instanceOf(GrcUserError)
+      expect(err.message).to.be.equal('MY_FUNCTION: invalid field')
+      expect(err.code).to.be.equal(null)
+      done()
+    })
+  })
+})

package/test/generic.error.test.js

@@ -0,0 +1,39 @@
+'use strict'
+
+/* eslint-env mocha */
+
+const { expect } = require('chai').use(require('dirty-chai'))
+const { GrcGenericError } = require('../')
+
+describe('GenericError tests', () => {
+  it('it should parse fields properly', () => {
+    const err = new GrcGenericError('MY_FUNCTION')
+    expect(err).to.be.instanceOf(Error)
+    expect(err.name).to.be.equal('GrcGenericError')
+    expect(err.message).to.be.equal('MY_FUNCTION: generic error')
+    expect(err.code).to.be.equal(null)
+    expect(err.stack).to.be.a('string')
+    expect(err.stack.startsWith('GrcGenericError: MY_FUNCTION: generic error')).to.be.true()
+    expect(err.stack.includes(' at ')).to.be.true()
+  })
+
+  it('it should work also without optional params', () => {
+    const err = new GrcGenericError()
+
+    expect(err.message).to.be.equal('generic error')
+    expect(err.code).to.be.equal(null)
+    expect(err.stack.startsWith('GrcGenericError: generic error')).to.be.true()
+  })
+
+  it('it should serialize only specific fields', () => {
+    const serialized = JSON.stringify(new GrcGenericError('MY_FUNC'))
+    const deserialized = JSON.parse(serialized)
+    const expected = {
+      name: 'GrcGenericError',
+      message: 'MY_FUNC: generic error',
+      code: null
+    }
+
+    expect(deserialized).to.be.eqls(expected)
+  })
+})

package/test/user.error.test.js

@@ -0,0 +1,40 @@
+'use strict'
+
+/* eslint-env mocha */
+
+const { expect } = require('chai').use(require('dirty-chai'))
+const { GrcUserError } = require('../')
+
+describe('GrcUserError tests', () => {
+  it('it should parse fields properly', () => {
+    const err = new GrcUserError('invalid user input', 10001)
+
+    expect(err).to.be.instanceOf(Error)
+    expect(err.name).to.be.equal('GrcUserError')
+    expect(err.message).to.be.equal('invalid user input')
+    expect(err.code).to.be.equal(10001)
+    expect(err.stack).to.be.a('string')
+    expect(err.stack.startsWith('GrcUserError: invalid user input')).to.be.true()
+    expect(err.stack.includes(' at ')).to.be.true()
+  })
+
+  it('it should work also without optional params', () => {
+    const err = new GrcUserError('invalid user input')
+
+    expect(err.message).to.be.equal('invalid user input')
+    expect(err.code).to.be.null()
+    expect(err.stack.startsWith('GrcUserError: invalid user input')).to.be.true()
+  })
+
+  it('it should serialize only specific fields', () => {
+    const serialized = JSON.stringify(new GrcUserError('invalid user input', 10001))
+    const deserialized = JSON.parse(serialized)
+    const expected = {
+      name: 'GrcUserError',
+      message: 'invalid user input',
+      code: 10001
+    }
+
+    expect(deserialized).to.be.eqls(expected)
+  })
+})