feat(errors): ERR_MISSING_ARGS

Signed-off-by: Lexus Drumgold <unicornware@flexdevelopment.llc>

Author: unicornware

README.md

@@ -165,6 +165,7 @@ This package exports the following identifiers:
   - `ERR_INVALID_URL_SCHEME`
   - `ERR_INVALID_URL`
   - `ERR_METHOD_NOT_IMPLEMENTED`
+  - `ERR_MISSING_ARGS`
   - `ERR_MISSING_OPTION`
   - `ERR_MODULE_NOT_FOUND`
   - `ERR_NETWORK_IMPORT_DISALLOWED`

src/__snapshots__/errors.integration.snap

@@ -44,6 +44,8 @@ exports[`integration:errors > ERR_INVALID_URL_SCHEME > #toString > should return
 
 exports[`integration:errors > ERR_METHOD_NOT_IMPLEMENTED > #toString > should return string representation of error 1`] = `Error [ERR_METHOD_NOT_IMPLEMENTED]: The _transform() method is not implemented`;
 
+exports[`integration:errors > ERR_MISSING_ARGS > #toString > should return string representation of error 1`] = `TypeError [ERR_MISSING_ARGS]: The "address", "port", and "callback" arguments must be specified`;
+
 exports[`integration:errors > ERR_MISSING_OPTION > #toString > should return string representation of error 1`] = `TypeError [ERR_MISSING_OPTION]: init.highWaterMark is required`;
 
 exports[`integration:errors > ERR_MODULE_NOT_FOUND > #toString > should return string representation of error 1`] = `Error [ERR_MODULE_NOT_FOUND]: Cannot find module '\${process.cwd()}/missing-file' imported from \${process.cwd()}/src/__tests__/errors.integration.spec.ts`;

src/__snapshots__/index.e2e.snap

@@ -27,6 +27,7 @@ exports[`e2e:errnode > should expose public api 1`] = `
   "ERR_INVALID_URL",
   "ERR_INVALID_URL_SCHEME",
   "ERR_METHOD_NOT_IMPLEMENTED",
+  "ERR_MISSING_ARGS",
   "ERR_MISSING_OPTION",
   "ERR_MODULE_NOT_FOUND",
   "ERR_NETWORK_IMPORT_DISALLOWED",

src/__tests__/errors.integration.spec.ts

@@ -88,6 +88,7 @@ describe('integration:errors', () => {
     [codes.ERR_INVALID_URL, TypeError, pathe.sep, 'http://[127.0.0.1]:8000'],
     [codes.ERR_INVALID_URL_SCHEME, TypeError, 'file'],
     [codes.ERR_METHOD_NOT_IMPLEMENTED, Error, '_transform()'],
+    [codes.ERR_MISSING_ARGS, TypeError, 'address', 'port', 'callback'],
     [codes.ERR_MISSING_OPTION, TypeError, 'init.highWaterMark'],
     [
       codes.ERR_MODULE_NOT_FOUND,

src/errors/__snapshots__/err-missing-args.snap

@@ -0,0 +1,5 @@
+// Vitest Snapshot v1, https://vitest.dev/guide/snapshot.html
+
+exports[`unit:errors/ERR_MISSING_ARGS > should build message from parameters (0) 1`] = `"The "domain" argument must be specified"`;
+
+exports[`unit:errors/ERR_MISSING_ARGS > should build message from parameters (1) 1`] = `"The "name" and "value" arguments must be specified"`;

src/errors/__tests__/err-missing-args.spec-d.ts

@@ -0,0 +1,41 @@
+/**
+ * @file Type Tests - ERR_MISSING_ARGS
+ * @module errnode/errors/tests/unit-d/ERR_MISSING_ARGS
+ */
+
+import { codes } from '#src/enums'
+import type { NodeError, NodeErrorConstructor } from '#src/interfaces'
+import type * as TestSubject from '../err-missing-args'
+
+describe('unit-d:errors/ERR_MISSING_ARGS', () => {
+  describe('ERR_MISSING_ARGS', () => {
+    it('should be ErrMissingArgsConstructor', () => {
+      expectTypeOf<typeof TestSubject.default>()
+        .toEqualTypeOf<TestSubject.ErrMissingArgsConstructor>()
+    })
+  })
+
+  describe('ErrMissingArgs', () => {
+    it('should extend NodeError<codes.ERR_MISSING_ARGS>', () => {
+      expectTypeOf<TestSubject.ErrMissingArgs>()
+        .toMatchTypeOf<NodeError<codes.ERR_MISSING_ARGS>>()
+    })
+
+    it('should extend TypeError', () => {
+      expectTypeOf<TestSubject.ErrMissingArgs>()
+        .toMatchTypeOf<TypeError>()
+    })
+  })
+
+  describe('ErrMissingArgsConstructor', () => {
+    it('should match NodeErrorConstructor', () => {
+      // Arrange
+      type T = TestSubject.ErrMissingArgs
+      type Args = TestSubject.ErrMissingArgsArgs
+
+      // Expect
+      expectTypeOf<TestSubject.ErrMissingArgsConstructor>()
+        .toMatchTypeOf<NodeErrorConstructor<T, Args>>()
+    })
+  })
+})

src/errors/__tests__/err-missing-args.spec.ts

@@ -0,0 +1,20 @@
+/**
+ * @file Unit Tests - ERR_MISSING_ARGS
+ * @module errnode/errors/tests/unit/ERR_MISSING_ARGS
+ */
+
+import TestSubject, { type ErrMissingArgs } from '../err-missing-args'
+
+describe('unit:errors/ERR_MISSING_ARGS', () => {
+  it.each<Parameters<typeof TestSubject>>([
+    ['domain'],
+    ['name', 'value']
+  ])('should build message from parameters (%#)', (...args) => {
+    // Act
+    const subject: ErrMissingArgs = new TestSubject(...args)
+
+    // Expect
+    expect(subject).to.have.property('message').be.a('string').that.is.not.empty
+    expect(subject.message).toMatchSnapshot()
+  })
+})

src/errors/err-missing-args.ts

@@ -0,0 +1,109 @@
+/**
+ * @file Errors - ERR_MISSING_ARGS
+ * @module errnode/errors/ERR_MISSING_ARGS
+ * @see https://github.com/nodejs/node/blob/v22.8.0/lib/internal/errors.js#L1565-L1579
+ */
+
+import E from '#e'
+import { codes } from '#src/enums'
+import type { NodeError, NodeErrorConstructor } from '#src/interfaces'
+import { formatList } from '#src/utils'
+import { ok } from 'devlop'
+
+/**
+ * `ERR_MISSING_ARGS` schema.
+ *
+ * @see {@linkcode NodeError}
+ * @see https://nodejs.org/api/errors.html#err_missing_args
+ *
+ * @extends {NodeError<codes.ERR_MISSING_ARGS>}
+ * @extends {TypeError}
+ */
+interface ErrMissingArgs extends NodeError<codes.ERR_MISSING_ARGS>, TypeError {}
+
+/**
+ * `ERR_MISSING_ARGS` message arguments.
+ */
+type Args = [name: string | string[], ...names: (string | string[])[]]
+
+/**
+ * `ERR_MISSING_ARGS` constructor.
+ *
+ * @see {@linkcode Args}
+ * @see {@linkcode ErrMissingArgs}
+ * @see {@linkcode NodeErrorConstructor}
+ *
+ * @extends {NodeErrorConstructor<ErrMissingArgs,Args>}
+ */
+interface ErrMissingArgsConstructor
+  extends NodeErrorConstructor<ErrMissingArgs, Args> {
+  /**
+   * Create a new `ERR_MISSING_ARGS` error.
+   *
+   * @see {@linkcode ErrMissingArgs}
+   *
+   * @param {string} name
+   *  Name of missing argument
+   * @param {(string | string[])[]} names
+   *  List of missing arguments
+   * @return {ErrMissingArgs}
+   */
+  new (name: string, ...names: (string | string[])[]): ErrMissingArgs
+}
+
+/**
+ * `ERR_MISSING_ARGS` model.
+ *
+ * Thrown when a required argument of a Node.js API was not passed.
+ *
+ * @see {@linkcode ErrMissingArgsConstructor}
+ *
+ * @type {ErrMissingArgsConstructor}
+ *
+ * @class
+ */
+const ERR_MISSING_ARGS: ErrMissingArgsConstructor = E(
+  codes.ERR_MISSING_ARGS,
+  TypeError,
+  /**
+   * @param {(string | string[])[]} names
+   *  List of missing arguments
+   * @return {string}
+   *  Error message
+   */
+  function message(...names: (string | string[])[]): string {
+    ok(names.length, 'At least one arg needs to be specified')
+
+    /**
+     * Wrap a string in quotes.
+     *
+     * @param {string} a
+     *  String to wrap
+     * @return {string}
+     *  Wrapped string
+     */
+    const wrap = (a: string): string => `"${a}"`
+
+    /**
+     * Error message.
+     *
+     * @var {string} message
+     */
+    let message: string = 'The '
+
+    message += formatList(names.map(a => {
+      /* c8 ignore next 2 */ return Array.isArray(a)
+        ? a.map(wrap).join(' or ')
+        : wrap(a)
+    }))
+
+    return `${message} argument${names.length > 1 ? 's' : ''} must be specified`
+  }
+)
+
+export {
+  ERR_MISSING_ARGS as default,
+  type ErrMissingArgs,
+  type Args as ErrMissingArgsArgs,
+  type ErrMissingArgsConstructor
+}

src/errors/index.ts

@@ -136,6 +136,12 @@ export {
   type ErrMethodNotImplementedArgs,
   type ErrMethodNotImplementedConstructor
 } from './err-method-not-implemented'
+export {
+  default as ERR_MISSING_ARGS,
+  type ErrMissingArgs,
+  type ErrMissingArgsArgs,
+  type ErrMissingArgsConstructor
+} from './err-missing-args'
 export {
   default as ERR_MISSING_OPTION,
   type ErrMissingOption,