feat: createNodeError

Signed-off-by: Lexus Drumgold <[email protected]>

Author: unicornware

src/__tests__/create-node-error.spec.ts

@@ -0,0 +1,41 @@
+/**
+ * @file Unit Tests - createNodeError
+ * @module create-node-error/tests/unit/createNodeError
+ */
+
+import { ErrorCode } from '#src/enums'
+import type { NodeError } from '#src/types'
+import { format } from 'node-inspect-extracted'
+import { resolve } from 'node:path'
+import testSubject from '../create-node-error'
+
+describe('unit:createNodeError', () => {
+  it('should return NodeErrorConstructor', () => {
+    expect(testSubject(ErrorCode.ERR_INVALID_ARG_TYPE, TypeError, vi.fn()))
+      .to.be.a('function')
+      .with.property('name')
+      .that.equals('NodeError')
+  })
+
+  describe('NodeError', () => {
+    it('should return NodeError instance', () => {
+      // Arrange
+      const code: ErrorCode = ErrorCode.ERR_UNSUPPORTED_DIR_IMPORT
+      const s1: string = resolve('src/interfaces')
+      const s2: string = resolve('src/index.ts')
+      const message: string = `Directory import "%s" is not supported resolving ES modules imported from %s`
+
+      // Act
+      const ERR_UNSUPPORTED_DIR_IMPORT = testSubject(code, Error, message)
+      const err: NodeError = new ERR_UNSUPPORTED_DIR_IMPORT(s1, s2)
+      const errstr: string = err.toString()
+
+      // Expect
+      expect(err).to.have.property('code').equal(code)
+      expect(err).to.have.property('message').equal(format(message, s1, s2))
+      expect(err).to.have.property('name').equal('Error')
+      expect(err).to.have.property('stack').startWith(errstr)
+      expect(errstr).to.equal(`${err.name} [${code}]: ${err.message}`)
+    })
+  })
+})

src/create-node-error.ts

@@ -0,0 +1,102 @@
+/**
+ * @file createNodeError
+ * @module create-node-error/createNodeError
+ * @see https://github.com/nodejs/node/blob/v19.3.0/lib/internal/errors.js#L367-L404
+ */
+
+import type { ErrorCode } from '#src/enums'
+import formatMessage from '#src/internal/format-message'
+import kIsNodeError from '#src/internal/k-is-node-error'
+import prepareStackTrace from '#src/internal/prepare-stack-trace'
+import type { MessageFn, NodeError, NodeErrorConstructor } from '#src/types'
+
+/**
+ * Creates a Node.js error constructor.
+ *
+ * @template B - Error base class type
+ * @template M - Error message type
+ * @template T - Error base type
+ *
+ * @constructs NodeError<T>
+ *
+ * @param {ErrorCode} code - Node.js error code
+ * @param {B} Base - Error base class
+ * @param {M} message - Error message or message function
+ * @return {NodeErrorConstructor<B, M>} `NodeError` constructor
+ */
+function createNodeError<
+  B extends ErrorConstructor = ErrorConstructor,
+  M extends MessageFn | string = MessageFn | string,
+  T extends B['prototype'] = B['prototype']
+>(code: ErrorCode, Base: B, message: M): NodeErrorConstructor<B, M, T> {
+  /**
+   * Creates a Node.js error.
+   *
+   * [1]: https://nodejs.org/api/util.html#utilformatformat-args
+   *
+   * @class
+   * @implements {NodeError<T>}
+   *
+   * @param {any[] | Parameters<M>} args - `message` params if `message` is a
+   * function; [`util.format`][1] arguments if `message` is a string
+   * @return {NodeError<T>} Node.js error instance
+   */
+  function NodeError(
+    ...args: M extends MessageFn ? Parameters<M> : any[]
+  ): NodeError<T> {
+    /**
+     * Node.js error instance.
+     *
+     * @const {NodeError<T>} error
+     */
+    const error: NodeError<T> = new Base() as NodeError<T>
+
+    // define error symbol
+    Object.defineProperty(error, kIsNodeError, {
+      configurable: true,
+      enumerable: false,
+      value: true,
+      writable: false
+    })
+
+    // define instance properties and methods
+    Object.defineProperties(error, {
+      code: {
+        configurable: true,
+        enumerable: false,
+        value: code,
+        writable: true
+      },
+      message: {
+        configurable: true,
+        enumerable: false,
+        value: formatMessage(code, message, args, error),
+        writable: true
+      },
+      toString: {
+        configurable: true,
+        enumerable: false,
+        /**
+         * Returns a string representation of the error.
+         *
+         * @this {NodeError<T>}
+         *
+         * @return {string} String representation of error
+         */
+        value(this: NodeError<T>): string {
+          return `${this.name} [${this.code}]: ${this.message}`
+        },
+        writable: true
+      }
+    })
+
+    // add stack trace
+    prepareStackTrace(error)
+
+    return error
+  }
+
+  return NodeError as NodeErrorConstructor<B, M, T>
+}
+
+export default createNodeError

src/index.ts

@@ -3,6 +3,7 @@
  * @module create-node-error
  */
 
+export { default as createNodeError } from './create-node-error'
 export { default as determineSpecificType } from './determine-specific-type'
 export * from './enums'
 export * from './types'

src/types/__tests__/node-error-constructor.spec-d.ts

@@ -21,6 +21,15 @@ describe('unit-d:types/NodeErrorConstructor', () => {
     expectTypeOf<TestSubject<B, M>>().constructorParameters.toEqualTypeOf<P>()
   })
 
+  it('should match [prototype: NodeError<T>]', () => {
+    expectTypeOf<TestSubject>()
+      .toHaveProperty('prototype')
+      .toEqualTypeOf<NodeError>()
+    expectTypeOf<TestSubject<SyntaxErrorConstructor>>()
+      .toHaveProperty('prototype')
+      .toEqualTypeOf<NodeError<SyntaxError>>()
+  })
+
   it('should return NodeError<T>', () => {
     expectTypeOf<TestSubject>().returns.toEqualTypeOf<NodeError>()
     expectTypeOf<TestSubject<TypeErrorConstructor>>().returns.toEqualTypeOf<

src/types/node-error-constructor.ts

@@ -10,7 +10,7 @@ import type NodeError from './node-error'
 /**
  * Node.js error constructor type.
  *
- * @template B - Error constructor type
+ * @template B - Error base class type
  * @template M - Error message type
  * @template T - Error base type
  *
@@ -21,6 +21,8 @@ type NodeErrorConstructor<
   M extends MessageFn | string = string,
   T extends B['prototype'] = B['prototype']
 > = Overwrite<B, B> & {
+  readonly prototype: NodeError<T>
+
   new (...args: M extends MessageFn ? Parameters<M> : any[]): NodeError<T>
   (...args: M extends MessageFn ? Parameters<M> : any[]): NodeError<T>
 }