@boo-labs/server 0.0.0-stage → 1.0.0

package/source/application/configurations/ServerConfiguration/Options/CompressOptions/index.mjs

@@ -0,0 +1,81 @@
+// @ts-check
+/**
+ * @file Defines the CompressOptions middleware configuration option.
+ *
+ * @description CompressOptions wraps a normalized CompressOptionsValue into
+ * the middleware configuration option hierarchy.
+ *
+ * @module CompressOptions
+ */
+
+// ━━ IMPORT MODULES ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+// » IMPORT LOCAL MODULES
+import MiddlewareOption from '../MiddlewareOption.mjs';
+import CompressOptionsValue from './CompressOptionsValue.mjs';
+
+// ━━ TYPE DEFINITIONS ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+/**
+ * Represents the compression options accepted by the server configuration.
+ *
+ * @typedef {import('./CompressOptionsValue.mjs').CompressOptionsInput} CompressOptionsInput
+ */
+
+/**
+ * Represents the normalized compression options.
+ *
+ * @typedef {import('./CompressOptionsValue.mjs').CompressOptionsData} CompressOptionsData
+ */
+
+/**
+ * Represents one middleware configuration consumed by the exchange layer builder.
+ *
+ * @typedef {import('../MiddlewareOption.mjs').MiddlewareConfiguration} MiddlewareConfiguration
+ */
+
+// ━━ MODULE ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+/**
+ * Middleware configuration option wrapping a normalized compression
+ * configuration.
+ *
+ * @augments {MiddlewareOption<CompressOptionsData|undefined>}
+ */
+class CompressOptions extends MiddlewareOption {
+  /**
+   * Creates a new {@link CompressOptions}.
+   *
+   * @param {CompressOptionsInput} [options] - The compression middleware options.
+   * @example
+   * ```js
+   * const compressOptions = new CompressOptions({ threshold: 1024, level: 6 });
+   * ```
+   */
+  constructor(options) {
+    super('compress', new CompressOptionsValue(options));
+  }
+
+  /**
+   * Composes the compression middleware configuration consumed by the
+   * exchange layer builder.
+   *
+   * Compression is a cross-cutting concern applied to every response
+   * regardless of pathname or method, so both `pathnamePattern` and `method`
+   * are `undefined`.
+   *
+   * @returns {MiddlewareConfiguration} The composed middleware configuration.
+   * @example
+   * ```js
+   * const configuration = compressOptions.compose();
+   * ```
+   */
+  compose() {
+    return {
+      name: this.name,
+      options: this.value,
+      pathnamePattern: undefined,
+      method: undefined,
+    };
+  }
+}
+
+// ━━ EXPORT MODULE ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+export default CompressOptions;

package/source/application/configurations/ServerConfiguration/Options/CookieParserOptions/CookieParserOptionsValue.mjs

@@ -0,0 +1,107 @@
+// @ts-check
+/**
+ * @file Defines the CookieParserOptionsValue value object.
+ *
+ * @description Normalizes and validates cookie parser middleware
+ * configuration used by CookieParserMiddleware. When options are omitted,
+ * the value is undefined and the middleware is not registered.
+ *
+ * @module CookieParserOptionsValue
+ */
+
+// ━━ IMPORT MODULES ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+// » IMPORT LOCAL MODULES
+import { assertCookieParserOptions } from '#shared/validations/ServerConfiguration/CookieParserOptions';
+
+// ━━ TYPE DEFINITIONS ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+/**
+ * Domain error thrown by server configuration validation.
+ *
+ * @typedef {import('#shared/errors/ServerConfigurationError').default} ServerConfigurationError
+ */
+
+/**
+ * Represents the cookie parser options accepted by the server configuration.
+ *
+ * @typedef  {object}  CookieParserOptionsInput
+ * @property {boolean} [decode]                 - Whether cookie values are decoded with `decodeURIComponent`.
+ */
+
+/**
+ * Represents the normalized cookie parser options.
+ *
+ * @typedef  {object}  CookieParserOptionsData
+ * @property {boolean} decode                  - Whether cookie values are decoded with `decodeURIComponent`.
+ */
+
+// ━━ CONSTANTS ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+/**
+ * Default URI-decoding behavior for cookie values.
+ *
+ * @type {boolean}
+ */
+const DEFAULT_DECODE = true;
+
+// ━━ MODULE ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+/**
+ * Immutable value object representing normalized cookie parser middleware
+ * options.
+ *
+ * @classdesc Validates and normalizes cookie parser middleware options. When
+ * options are provided, defaults are applied for any omitted property. When
+ * options are omitted, the value is undefined.
+ *
+ * @example
+ * ```js
+ * const options = new CookieParserOptionsValue({ decode: false });
+ *
+ * options.value;
+ * // => { decode: false }
+ * ```
+ *
+ * @example
+ * ```js
+ * const options = new CookieParserOptionsValue();
+ *
+ * options.value;
+ * // => undefined
+ * ```
+ */
+class CookieParserOptionsValue {
+  /**
+   * The normalized cookie parser options.
+   *
+   * @type {Readonly<CookieParserOptionsData>|undefined}
+   */
+  #value;
+
+  /**
+   * Creates a new {@link CookieParserOptionsValue}.
+   *
+   * @param {CookieParserOptionsInput} [options] - The cookie parser middleware options.
+   * @throws {ServerConfigurationError} If `options` is invalid.
+   */
+  constructor(options) {
+    assertCookieParserOptions(options);
+
+    this.#value =
+      options === undefined
+        ? options
+        : Object.freeze({
+            decode: options.decode ?? DEFAULT_DECODE,
+          });
+  }
+
+  /**
+   * The normalized cookie parser options.
+   *
+   * @readonly
+   * @type {Readonly<CookieParserOptionsData>|undefined}
+   */
+  get value() {
+    return this.#value;
+  }
+}
+
+// ━━ EXPORT MODULE ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+export default CookieParserOptionsValue;

package/source/application/configurations/ServerConfiguration/Options/CookieParserOptions/index.mjs

@@ -0,0 +1,82 @@
+// @ts-check
+/**
+ * @file Defines the CookieParserOptions middleware configuration option.
+ *
+ * @description CookieParserOptions wraps a normalized
+ * CookieParserOptionsValue into the middleware configuration option
+ * hierarchy.
+ *
+ * @module CookieParserOptions
+ */
+
+// ━━ IMPORT MODULES ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+// » IMPORT LOCAL MODULES
+import MiddlewareOption from '../MiddlewareOption.mjs';
+import CookieParserOptionsValue from './CookieParserOptionsValue.mjs';
+
+// ━━ TYPE DEFINITIONS ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+/**
+ * Represents the cookie parser options accepted by the server configuration.
+ *
+ * @typedef {import('./CookieParserOptionsValue.mjs').CookieParserOptionsInput} CookieParserOptionsInput
+ */
+
+/**
+ * Represents the normalized cookie parser options.
+ *
+ * @typedef {import('./CookieParserOptionsValue.mjs').CookieParserOptionsData} CookieParserOptionsData
+ */
+
+/**
+ * Represents one middleware configuration consumed by the exchange layer builder.
+ *
+ * @typedef {import('../MiddlewareOption.mjs').MiddlewareConfiguration} MiddlewareConfiguration
+ */
+
+// ━━ MODULE ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+/**
+ * Middleware configuration option wrapping a normalized cookie parser
+ * configuration.
+ *
+ * @augments {MiddlewareOption<CookieParserOptionsData|undefined>}
+ */
+class CookieParserOptions extends MiddlewareOption {
+  /**
+   * Creates a new {@link CookieParserOptions}.
+   *
+   * @param {CookieParserOptionsInput} [options] - The cookie parser middleware options.
+   * @example
+   * ```js
+   * const cookieParserOptions = new CookieParserOptions({ decode: true });
+   * ```
+   */
+  constructor(options) {
+    super('cookieParser', new CookieParserOptionsValue(options));
+  }
+
+  /**
+   * Composes the cookie parser middleware configuration consumed by the
+   * exchange layer builder.
+   *
+   * Cookie parsing is a cross-cutting concern applied to every request
+   * regardless of pathname or method, so both `pathnamePattern` and `method`
+   * are `undefined`.
+   *
+   * @returns {MiddlewareConfiguration} The composed middleware configuration.
+   * @example
+   * ```js
+   * const configuration = cookieParserOptions.compose();
+   * ```
+   */
+  compose() {
+    return {
+      name: this.name,
+      options: this.value,
+      pathnamePattern: undefined,
+      method: undefined,
+    };
+  }
+}
+
+// ━━ EXPORT MODULE ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+export default CookieParserOptions;

package/source/application/configurations/ServerConfiguration/Options/CookieSessionOptions/CookieSessionOptionsValue.mjs

@@ -0,0 +1,182 @@
+// @ts-check
+/**
+ * @file Defines the CookieSessionOptionsValue value object.
+ *
+ * @description Normalizes and validates cookie session middleware
+ * configuration used by CookieSessionMiddleware. When options are omitted,
+ * the value is undefined and the middleware is not registered.
+ *
+ * @module CookieSessionOptionsValue
+ */
+
+// ━━ IMPORT MODULES ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+// » IMPORT LOCAL MODULES
+import { assertCookieSessionOptions } from '#shared/validations/ServerConfiguration/CookieSessionOptions';
+
+// ━━ TYPE DEFINITIONS ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+/**
+ * Domain error thrown by server configuration validation.
+ *
+ * @typedef {import('#shared/errors/ServerConfigurationError').default} ServerConfigurationError
+ */
+
+/**
+ * Represents the cookie session options accepted by the server configuration.
+ *
+ * @typedef  {object}                CookieSessionOptionsInput
+ * @property {string}                [name]                    - Name of the session cookie.
+ * @property {string[]}              keys                      - Signing keys. Required when options are provided.
+ * @property {number}                [maxAge]                  - Cookie max-age in milliseconds. When omitted, the cookie is a session cookie.
+ * @property {string}                [path]                    - Cookie path attribute.
+ * @property {string}                [domain]                  - Cookie domain attribute.
+ * @property {boolean}               [secure]                  - Whether the cookie is marked Secure.
+ * @property {boolean}               [httpOnly]                - Whether the cookie is marked HttpOnly.
+ * @property {'Strict'|'Lax'|'None'} [sameSite]                - Cookie SameSite attribute.
+ * @property {boolean}               [overwrite]               - Whether an existing Set-Cookie header with the same name should be overwritten.
+ */
+
+// eslint-disable-next-line jsdoc/check-line-alignment
+/**
+ * Represents the normalized cookie session options.
+ *
+ * @typedef  {object}                          CookieSessionOptionsData
+ * @property {string}                          name                     - Name of the session cookie.
+ * @property {Readonly<string[]>}              keys                     - Signing keys. The first key is used to sign; all keys are tried when verifying.
+ * @property {number|undefined}                maxAge                   - Cookie max-age in milliseconds. When `undefined`, the cookie is a session cookie.
+ * @property {string}                          path                     - Cookie path attribute.
+ * @property {string|undefined}                domain                   - Cookie domain attribute.
+ * @property {boolean}                         secure                   - Whether the cookie is marked Secure.
+ * @property {boolean}                         httpOnly                 - Whether the cookie is marked HttpOnly.
+ * @property {'Strict'|'Lax'|'None'}           sameSite                 - Cookie SameSite attribute.
+ * @property {boolean}                         overwrite                - Whether an existing Set-Cookie header with the same name should be overwritten.
+ */
+
+// ━━ CONSTANTS ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+/**
+ * Default session cookie name.
+ *
+ * @type {string}
+ */
+const DEFAULT_NAME = 'session';
+
+/**
+ * Default cookie path attribute.
+ *
+ * @type {string}
+ */
+const DEFAULT_PATH = '/';
+
+/**
+ * Default Secure attribute.
+ *
+ * @type {boolean}
+ */
+const DEFAULT_SECURE = true;
+
+/**
+ * Default HttpOnly attribute.
+ *
+ * @type {boolean}
+ */
+const DEFAULT_HTTP_ONLY = true;
+
+/**
+ * Default SameSite attribute.
+ *
+ * @type {'Strict'|'Lax'|'None'}
+ */
+const DEFAULT_SAME_SITE = 'Lax';
+
+/**
+ * Default overwrite behavior.
+ *
+ * @type {boolean}
+ */
+const DEFAULT_OVERWRITE = true;
+
+// ━━ MODULE ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+/**
+ * Immutable value object representing normalized cookie session middleware
+ * options.
+ *
+ * @classdesc Validates and normalizes cookie session middleware options.
+ * When options are provided, defaults are applied for any omitted property.
+ * When options are omitted, the value is undefined.
+ *
+ * @example
+ * ```js
+ * const options = new CookieSessionOptionsValue(
+ *   { keys: ['current-secret', 'previous-secret'] },
+ *   true,
+ * );
+ *
+ * options.value;
+ * // => {
+ * //   name: 'session',
+ * //   keys: ['current-secret', 'previous-secret'],
+ * //   maxAge: undefined,
+ * //   path: '/',
+ * //   domain: undefined,
+ * //   secure: true,
+ * //   httpOnly: true,
+ * //   sameSite: 'Lax',
+ * //   overwrite: true,
+ * // }
+ * ```
+ *
+ * @example
+ * ```js
+ * const options = new CookieSessionOptionsValue(undefined, false);
+ *
+ * options.value;
+ * // => undefined
+ * ```
+ */
+class CookieSessionOptionsValue {
+  /**
+   * The normalized cookie session options.
+   *
+   * @type {Readonly<CookieSessionOptionsData>|undefined}
+   */
+  #value;
+
+  /**
+   * Creates a new {@link CookieSessionOptionsValue}.
+   *
+   * @param {CookieSessionOptionsInput} [options] - The cookie session middleware options.
+   * @param {boolean} [hasParser] - Whether a cookie parser is configured.
+   * @throws {ServerConfigurationError} If `options` is invalid.
+   * @throws {ServerConfigurationError} If no cookie parser is configured.
+   */
+  constructor(options, hasParser) {
+    assertCookieSessionOptions(options, hasParser);
+
+    this.#value =
+      options === undefined
+        ? options
+        : Object.freeze({
+            name: options.name ?? DEFAULT_NAME,
+            keys: Object.freeze([...options.keys]),
+            maxAge: options.maxAge,
+            path: options.path ?? DEFAULT_PATH,
+            domain: options.domain,
+            secure: options.secure ?? DEFAULT_SECURE,
+            httpOnly: options.httpOnly ?? DEFAULT_HTTP_ONLY,
+            sameSite: options.sameSite ?? DEFAULT_SAME_SITE,
+            overwrite: options.overwrite ?? DEFAULT_OVERWRITE,
+          });
+  }
+
+  /**
+   * The normalized cookie session options.
+   *
+   * @readonly
+   * @type {Readonly<CookieSessionOptionsData>|undefined}
+   */
+  get value() {
+    return this.#value;
+  }
+}
+
+// ━━ EXPORT MODULE ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+export default CookieSessionOptionsValue;

package/source/application/configurations/ServerConfiguration/Options/CookieSessionOptions/index.mjs

@@ -0,0 +1,86 @@
+// @ts-check
+/**
+ * @file Defines the CookieSessionOptions middleware configuration option.
+ *
+ * @description CookieSessionOptions wraps a normalized
+ * CookieSessionOptionsValue into the middleware configuration option
+ * hierarchy.
+ *
+ * @module CookieSessionOptions
+ */
+
+// ━━ IMPORT MODULES ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+// » IMPORT LOCAL MODULES
+import MiddlewareOption from '../MiddlewareOption.mjs';
+import CookieSessionOptionsValue from './CookieSessionOptionsValue.mjs';
+
+// ━━ TYPE DEFINITIONS ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+/**
+ * Represents the cookie session options accepted by the server configuration.
+ *
+ * @typedef {import('./CookieSessionOptionsValue.mjs').CookieSessionOptionsInput} CookieSessionOptionsInput
+ */
+
+/**
+ * Represents the normalized cookie session options.
+ *
+ * @typedef {import('./CookieSessionOptionsValue.mjs').CookieSessionOptionsData} CookieSessionOptionsData
+ */
+
+/**
+ * Represents one middleware configuration consumed by the exchange layer builder.
+ *
+ * @typedef {import('../MiddlewareOption.mjs').MiddlewareConfiguration} MiddlewareConfiguration
+ */
+
+// ━━ MODULE ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+/**
+ * Middleware configuration option wrapping a normalized cookie session
+ * configuration.
+ *
+ * @augments {MiddlewareOption<CookieSessionOptionsData|undefined>}
+ */
+class CookieSessionOptions extends MiddlewareOption {
+  /**
+   * Creates a new {@link CookieSessionOptions}.
+   *
+   * @param {CookieSessionOptionsInput} [options] - The cookie session middleware options.
+   * @param {boolean} [hasParser] - Whether a cookie parser is configured.
+   * @example
+   * ```js
+   * const cookieSessionOptions = new CookieSessionOptions(
+   *   { keys: ['current-secret'] },
+   *   true,
+   * );
+   * ```
+   */
+  constructor(options, hasParser) {
+    super('cookieSession', new CookieSessionOptionsValue(options, hasParser));
+  }
+
+  /**
+   * Composes the cookie session middleware configuration consumed by the
+   * exchange layer builder.
+   *
+   * Cookie session is a cross-cutting concern applied to every request
+   * regardless of pathname or method, so both `pathnamePattern` and `method`
+   * are `undefined`.
+   *
+   * @returns {MiddlewareConfiguration} The composed middleware configuration.
+   * @example
+   * ```js
+   * const configuration = cookieSessionOptions.compose();
+   * ```
+   */
+  compose() {
+    return {
+      name: this.name,
+      options: this.value,
+      pathnamePattern: undefined,
+      method: undefined,
+    };
+  }
+}
+
+// ━━ EXPORT MODULE ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+export default CookieSessionOptions;

package/source/application/configurations/ServerConfiguration/Options/ListenOptions/ListenOptionsValue.mjs

@@ -0,0 +1,95 @@
+// @ts-check
+/**
+ * @file Defines the ListenOptionsValue value object.
+ *
+ * @description Normalizes and validates listen configuration used by
+ * ServerConfiguration. When no options are provided, the value is
+ * undefined and Node applies its own defaults.
+ *
+ * @module ListenOptionsValue
+ */
+
+// ━━ IMPORT MODULES ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+// » IMPORT LOCAL MODULES
+import { assertListenOptions } from '#shared/validations/ServerConfiguration/ListenOptions';
+
+// ━━ TYPE DEFINITIONS ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+/**
+ * Domain error thrown by server configuration validation.
+ *
+ * @typedef {import('#shared/errors/ServerConfigurationError').default} ServerConfigurationError
+ */
+
+/**
+ * Represents the listen options accepted by the server configuration.
+ *
+ * @typedef  {object} ListenOptionsInput
+ * @property {number} [port]             - The TCP port on which the server listens.
+ * @property {string} [host]             - The hostname or IP address on which the server listens.
+ * @property {number} [backlog]          - The maximum number of pending connections that may be queued.
+ */
+
+/**
+ * Represents the normalized listen options.
+ *
+ * @typedef  {object}           ListenOptionsData
+ * @property {number|undefined} port              - The TCP port on which the server listens.
+ * @property {string|undefined} host              - The hostname or IP address on which the server listens.
+ * @property {number|undefined} backlog           - The maximum number of pending connections that may be queued.
+ */
+
+// ━━ MODULE ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+/**
+ * Immutable value object representing normalized listen options.
+ *
+ * @classdesc Validates and normalizes listen options for the server.
+ * When no options are provided, the value is undefined.
+ */
+class ListenOptionsValue {
+  /**
+   * The normalized listen options.
+   *
+   * @type {Readonly<ListenOptionsData>|undefined}
+   */
+  #value;
+
+  /**
+   * Creates a new {@link ListenOptionsValue}.
+   *
+   * @param {ListenOptionsInput} [options] - The listen options.
+   * @throws {ServerConfigurationError} If `options` is invalid.
+   *
+   * @example
+   * ```js
+   * const options = new ListenOptionsValue({ port: 3000 });
+   *
+   * options.value;
+   * // => { port: 3000, host: undefined, backlog: undefined }
+   * ```
+   */
+  constructor(options) {
+    assertListenOptions(options);
+
+    this.#value =
+      options === undefined
+        ? options
+        : Object.freeze({
+            port: options.port,
+            host: options.host,
+            backlog: options.backlog,
+          });
+  }
+
+  /**
+   * The normalized listen options.
+   *
+   * @readonly
+   * @type {Readonly<ListenOptionsData>|undefined}
+   */
+  get value() {
+    return this.#value;
+  }
+}
+
+// ━━ EXPORT MODULE ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+export default ListenOptionsValue;

package/source/application/configurations/ServerConfiguration/Options/ListenOptions/index.mjs

@@ -0,0 +1,47 @@
+// @ts-check
+/**
+ * @file Defines the ListenOptions server configuration option.
+ *
+ * @description ListenOptions wraps a normalized ListenOptionsValue into the
+ * server configuration option hierarchy.
+ *
+ * @module ListenOptions
+ */
+
+// ━━ IMPORT MODULES ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+// » IMPORT LOCAL MODULES
+import ServerOption from '../ServerOption.mjs';
+import ListenOptionsValue from './ListenOptionsValue.mjs';
+
+// ━━ TYPE DEFINITIONS ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+/**
+ * Represents the listen options accepted by the server configuration.
+ *
+ * @typedef {import('./ListenOptionsValue.mjs').ListenOptionsInput} ListenOptionsInput
+ */
+
+/**
+ * Represents the normalized listen options.
+ *
+ * @typedef {import('./ListenOptionsValue.mjs').ListenOptionsData} ListenOptionsData
+ */
+
+// ━━ MODULE ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+/**
+ * Server configuration option wrapping a normalized listen configuration.
+ *
+ * @augments {ServerOption<ListenOptionsData|undefined>}
+ */
+class ListenOptions extends ServerOption {
+  /**
+   * Creates a new {@link ListenOptions}.
+   *
+   * @param {ListenOptionsInput} [options] - The listen options.
+   */
+  constructor(options) {
+    super('listen', new ListenOptionsValue(options));
+  }
+}
+
+// ━━ EXPORT MODULE ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+export default ListenOptions;