@bitfinex/lib-util-err-js 0.2.0 → 1.0.0

package/CHANGELOG.md

@@ -1,3 +1,9 @@
+# 1.0.0
+- breaking: require Node.js >= 22
+- chore: commit package-lock.json and disable install scripts via .npmrc
+- chore: replace standard with @bitfinex/lint-js
+- chore: replace mocha/chai/sinon/nyc with brittle
+
 # 0.2.0
 - feature: prevent adding prefix more than once
 

package/README.md

@@ -4,14 +4,17 @@ The lib includes the utilities that help on resolving errors that should be show
 
 ## Installing
 
+Requires Node.js >= 22.
+
 ```console
-npm install --save https://github.com/bitfinexcom/lib-util-err-js.git
+npm i @bitfinex/lib-util-err-js
 ```
 
 ## Testing
 
 ```console
 npm test
+npm run coverage
 ```
 
 ## Usage

package/package.json

@@ -1,14 +1,18 @@
 {
   "name": "@bitfinex/lib-util-err-js",
-  "version": "0.2.0",
+  "version": "1.0.0",
   "description": "Bitfinex lib utility for handling error messages",
   "main": "index.js",
+  "engines": {
+    "node": ">=22.0"
+  },
   "scripts": {
-    "coverage": "nyc --reporter=html mocha",
-    "format": "standard --fix",
-    "lint": "standard",
-    "test": "npm run lint && npm run unit",
-    "unit": "NODE_ENV=test mocha ./test"
+    "lint": "bfx-lint-js",
+    "lint:fix": "bfx-lint-js --fix",
+    "test": "npm run lint && npm run test:unit",
+    "test:unit": "brittle-node test/*.test.js",
+    "coverage": "npm run lint && npm run coverage:unit",
+    "coverage:unit": "brittle-node --coverage test/*.test.js"
   },
   "keywords": [
     "bitfinex",
@@ -39,11 +43,7 @@
   },
   "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"
+    "@bitfinex/lint-js": "^1.1.0",
+    "brittle": "^4.5.0"
   }
 }

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

@@ -1,98 +1,93 @@
 'use strict'
 
-/* eslint-env mocha */
-
-const sinon = require('sinon')
-const { expect } = require('chai').use(require('dirty-chai'))
+const test = require('brittle')
 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 = ''
-  })
+// Captures console.error output for the test and restores it afterwards
+const stubConsoleError = (t) => {
+  const logs = []
+  const original = console.error
+  console.error = (...params) => logs.push(format(...params))
+  t.teardown(() => { console.error = original })
+  return logs
+}
 
-  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()
-    })
+test('it should hide original error message in case if it\'s not instance of GrcUserError', (t) => {
+  t.plan(3)
+  stubConsoleError(t)
+  apiErrorHandler(new Error('Critical error in db'), 'MY_FUNCTION', {}, (err) => {
+    t.ok(err instanceof GrcGenericError)
+    t.is(err.message, 'MY_FUNCTION: generic error')
+    t.is(err.code, null)
   })
+})
 
-  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()
-    })
+test('it should return original error message in case if it\'s instance of GrcUserError', (t) => {
+  t.plan(3)
+  stubConsoleError(t)
+  apiErrorHandler(new GrcUserError('invalid field', 10001), 'MY_FUNCTION', {}, (err) => {
+    t.ok(err instanceof GrcUserError)
+    t.is(err.message, 'MY_FUNCTION: invalid field')
+    t.is(err.code, 10001)
   })
+})
 
-  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()
-    })
+test('it should return original error message in case if it has force flag', (t) => {
+  t.plan(3)
+  stubConsoleError(t)
+  apiErrorHandler(new Error('Critical error in db'), 'MY_FUNCTION', { force: true }, (err) => {
+    t.ok(err instanceof GrcUserError)
+    t.is(err.message, 'MY_FUNCTION: Critical error in db')
+    t.is(err.code, null) // since it's missing add default one!
   })
+})
 
-  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()
-    })
+test('it should work without optional params', (t) => {
+  t.plan(3)
+  stubConsoleError(t)
+  apiErrorHandler(new Error('Critical error in db'), (err) => {
+    t.ok(err instanceof GrcGenericError)
+    t.is(err.message, 'generic error')
+    t.is(err.code, null)
   })
+})
 
-  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()
-    })
+test('it should work without opts param', (t) => {
+  t.plan(3)
+  stubConsoleError(t)
+  apiErrorHandler(new Error('Critical error in db'), 'MY_FUNCTION', (err) => {
+    t.ok(err instanceof GrcGenericError)
+    t.is(err.message, 'MY_FUNCTION: generic error')
+    t.is(err.code, null)
   })
+})
 
-  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()
-    })
+test('it should always log original error', (t) => {
+  t.plan(2)
+  const logs = stubConsoleError(t)
+  apiErrorHandler(new GrcUserError('invalid field', 10001), () => {
+    t.is(logs.length, 1)
+    t.ok(logs[0].includes('GrcUserError: invalid field'))
   })
+})
 
-  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()
-    })
+test('it should use toString method when error does not have message field', (t) => {
+  t.plan(3)
+  stubConsoleError(t)
+  apiErrorHandler('Critical error in db', 'MY_FUNCTION', { force: true }, (err) => {
+    t.ok(err instanceof GrcUserError)
+    t.is(err.message, 'MY_FUNCTION: Critical error in db')
+    t.is(err.code, null)
   })
+})
 
-  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()
-    })
+test('it should avoid adding prefix more than once', (t) => {
+  t.plan(3)
+  stubConsoleError(t)
+  apiErrorHandler(new GrcUserError('MY_FUNCTION: invalid field'), 'MY_FUNCTION', (err) => {
+    t.ok(err instanceof GrcUserError)
+    t.is(err.message, 'MY_FUNCTION: invalid field')
+    t.is(err.code, null)
   })
 })

package/test/generic.error.test.js

@@ -1,39 +1,35 @@
 'use strict'
 
-/* eslint-env mocha */
-
-const { expect } = require('chai').use(require('dirty-chai'))
+const test = require('brittle')
 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()
-  })
+test('GenericError: it should parse fields properly', (t) => {
+  const err = new GrcGenericError('MY_FUNCTION')
+  t.ok(err instanceof Error)
+  t.is(err.name, 'GrcGenericError')
+  t.is(err.message, 'MY_FUNCTION: generic error')
+  t.is(err.code, null)
+  t.is(typeof err.stack, 'string')
+  t.ok(err.stack.startsWith('GrcGenericError: MY_FUNCTION: generic error'))
+  t.ok(err.stack.includes(' at '))
+})
 
-  it('it should work also without optional params', () => {
-    const err = new GrcGenericError()
+test('GenericError: it should work also without optional params', (t) => {
+  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()
-  })
+  t.is(err.message, 'generic error')
+  t.is(err.code, null)
+  t.ok(err.stack.startsWith('GrcGenericError: generic error'))
+})
 
-  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
-    }
+test('GenericError: it should serialize only specific fields', (t) => {
+  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)
-  })
+  t.alike(deserialized, expected)
 })

package/test/user.error.test.js

@@ -1,40 +1,36 @@
 'use strict'
 
-/* eslint-env mocha */
-
-const { expect } = require('chai').use(require('dirty-chai'))
+const test = require('brittle')
 const { GrcUserError } = require('../')
 
-describe('GrcUserError tests', () => {
-  it('it should parse fields properly', () => {
-    const err = new GrcUserError('invalid user input', 10001)
+test('GrcUserError: it should parse fields properly', (t) => {
+  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()
-  })
+  t.ok(err instanceof Error)
+  t.is(err.name, 'GrcUserError')
+  t.is(err.message, 'invalid user input')
+  t.is(err.code, 10001)
+  t.is(typeof err.stack, 'string')
+  t.ok(err.stack.startsWith('GrcUserError: invalid user input'))
+  t.ok(err.stack.includes(' at '))
+})
 
-  it('it should work also without optional params', () => {
-    const err = new GrcUserError('invalid user input')
+test('GrcUserError: it should work also without optional params', (t) => {
+  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()
-  })
+  t.is(err.message, 'invalid user input')
+  t.is(err.code, null)
+  t.ok(err.stack.startsWith('GrcUserError: invalid user input'))
+})
 
-  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
-    }
+test('GrcUserError: it should serialize only specific fields', (t) => {
+  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)
-  })
+  t.alike(deserialized, expected)
 })