@adonisjs/core 7.0.0-next.0 → 7.0.0-next.10

package/build/providers/app_provider.d.ts

@@ -1,12 +1,12 @@
 import { Router } from '../modules/http/main.ts';
-import { type TransformFn } from '../types/transformers.ts';
+import { type SerializeFn } from '../types/transformers.ts';
 import type { ApplicationService } from '../src/types.ts';
 /**
  * Extend HTTP request class with the transform method
  */
 declare module '@adonisjs/core/http' {
     interface HttpContext {
-        transform: TransformFn;
+        serialize: SerializeFn;
     }
 }
 /**
@@ -174,32 +174,20 @@ export default class AppServiceProvider {
      */
     protected registerDumper(): void;
     /**
-     * Generates the types needed by the URL builder and writes
-     * them to the ".adonisjs/server/routes.d.ts" file
+     * Generates TypeScript type definitions and JSON representation of routes
      *
-     * This method scans registered routes and generates TypeScript
-     * types for type-safe URL generation in development.
+     * Creates route type definitions for better IDE support and a JSON file
+     * containing all registered routes. This is used in development mode for
+     * tooling integration and type-safety.
      *
-     * @param router - The router instance to generate types from
+     * @param router - The router instance containing registered routes
      *
      * @example
-     * await generateRoutesTypes(router)
-     * // Creates .adonisjs/server/routes.d.ts with route types
-     */
-    protected generateRoutesTypes(router: Router): Promise<void>;
-    /**
-     * Generates the routes JSON needed by the client integration
-     *
-     * Exports all registered routes as JSON for client-side
-     * applications that need route information.
-     *
-     * @param router - The router instance to export routes from
-     *
-     * @example
-     * await generateRoutesJSONFile(router)
-     * // Creates .adonisjs/client/routes.json
+     * const router = await container.make('router')
+     * await this.emitRoutes(router)
+     * // Generates .adonisjs/server/routes.d.ts and routes.json
      */
-    protected generateRoutesJSONFile(router: Router): Promise<void>;
+    protected emitRoutes(router: Router): Promise<void>;
     /**
      * Registers bindings
      *

package/build/providers/app_provider.js

@@ -16,7 +16,7 @@ import { HttpContext } from "../modules/http/main.js";
 import { Encryption } from "../modules/encryption.js";
 import { Router, Server } from "../modules/http/main.js";
 import { BaseEvent, Emitter } from "../modules/events.js";
-import { transform } from "../modules/transformers/main.js";
+import { serialize } from "../modules/transformers/main.js";
 import BodyParserMiddleware from "../modules/bodyparser/bodyparser_middleware.js";
 /**
  * The Application Service provider registers all the baseline
@@ -225,7 +225,7 @@ export default class AppServiceProvider {
      * await middleware.handle(ctx, next)
      */
     registerBodyParserMiddleware() {
-        this.app.container.bind(BodyParserMiddleware, () => {
+        this.app.container.singleton(BodyParserMiddleware, () => {
             const config = this.app.config.get('bodyparser');
             return new BodyParserMiddleware(config, this.app.experimentalFlags);
         });
@@ -256,50 +256,47 @@ export default class AppServiceProvider {
         this.app.container.alias('dumper', Dumper);
     }
     /**
-     * Generates the types needed by the URL builder and writes
-     * them to the ".adonisjs/server/routes.d.ts" file
+     * Generates TypeScript type definitions and JSON representation of routes
      *
-     * This method scans registered routes and generates TypeScript
-     * types for type-safe URL generation in development.
+     * Creates route type definitions for better IDE support and a JSON file
+     * containing all registered routes. This is used in development mode for
+     * tooling integration and type-safety.
      *
-     * @param router - The router instance to generate types from
+     * @param router - The router instance containing registered routes
      *
      * @example
-     * await generateRoutesTypes(router)
-     * // Creates .adonisjs/server/routes.d.ts with route types
-     */
-    async generateRoutesTypes(router) {
-        const types = router.generateTypes(4);
-        const outputPath = this.app.generatedServerPath('routes.d.ts');
-        await mkdir(dirname(outputPath), { recursive: true });
-        await writeFile(outputPath, [
-            `import '@adonisjs/core/types/http'`,
-            '',
-            `declare module '@adonisjs/core/types/http' {`,
-            '  type ScannedRoutes = {',
-            types,
-            '  }',
-            'export interface RoutesList extends ScannedRoutes {}',
-            '}',
-        ].join('\n'));
-    }
-    /**
-     * Generates the routes JSON needed by the client integration
-     *
-     * Exports all registered routes as JSON for client-side
-     * applications that need route information.
-     *
-     * @param router - The router instance to export routes from
-     *
-     * @example
-     * await generateRoutesJSONFile(router)
-     * // Creates .adonisjs/client/routes.json
+     * const router = await container.make('router')
+     * await this.emitRoutes(router)
+     * // Generates .adonisjs/server/routes.d.ts and routes.json
      */
-    async generateRoutesJSONFile(router) {
-        const routes = router.toJSON();
-        const outputPath = this.app.makePath('.adonisjs/client/routes.json');
-        await mkdir(dirname(outputPath), { recursive: true });
-        await writeFile(outputPath, JSON.stringify(routes, null, 2));
+    async emitRoutes(router) {
+        try {
+            const { routes, imports, types } = router.generateTypes(2);
+            const routesTypesPath = this.app.generatedServerPath('routes.d.ts');
+            const routesJsonPath = this.app.generatedServerPath('routes.json');
+            await mkdir(dirname(routesTypesPath), { recursive: true });
+            await Promise.all([
+                writeFile(routesTypesPath, [
+                    `import '@adonisjs/core/types/http'`,
+                    ...imports,
+                    '',
+                    ...types,
+                    '',
+                    'export type ScannedRoutes = {',
+                    routes,
+                    '}',
+                    `declare module '@adonisjs/core/types/http' {`,
+                    '  export interface RoutesList extends ScannedRoutes {}',
+                    '}',
+                ].join('\n')),
+                writeFile(routesJsonPath, JSON.stringify(router.toJSON())),
+            ]);
+            this.app.notify({ isAdonisJS: true, routesFileLocation: routesJsonPath });
+        }
+        catch (error) {
+            console.error("Unable to generate routes types file due to the following error. This won't impact the dev-server");
+            console.error(error);
+        }
     }
     /**
      * Registers bindings
@@ -337,8 +334,8 @@ export default class AppServiceProvider {
      */
     async boot() {
         BaseEvent.useEmitter(await this.app.container.make('emitter'));
-        HttpContext.macro('transform', function (data, transformer, variant) {
-            return transform(data, transformer, variant, this.containerResolver);
+        HttpContext.instanceProperty('serialize', function (value, container) {
+            return serialize(value, container ?? this.containerResolver);
         });
     }
     /**
@@ -355,8 +352,7 @@ export default class AppServiceProvider {
         if (!this.app.inProduction) {
             const router = await this.app.container.make('router');
             if (router.commited) {
-                await this.generateRoutesJSONFile(router);
-                await this.generateRoutesTypes(router);
+                await this.emitRoutes(router);
             }
         }
     }

package/build/providers/edge_provider.js

@@ -8,7 +8,7 @@
  */
 import edge from 'edge.js';
 import { pluginEdgeDumper } from "../modules/dumper/plugins/edge.js";
-import { BriskRoute, HttpContext } from "../modules/http/main.js";
+import { BriskRoute, HttpContext, Qs } from "../modules/http/main.js";
 /**
  * The Edge service provider configures Edge to work within
  * an AdonisJS application environment
@@ -53,6 +53,7 @@ export default class EdgeServiceProvider {
      */
     async boot() {
         const app = this.app;
+        const qs = new Qs(app.config.get('app.http.qs', {}));
         const router = await this.app.container.make('router');
         const dumper = await this.app.container.make('dumper');
         function edgeConfigResolver(key, defaultValue) {
@@ -61,6 +62,25 @@ export default class EdgeServiceProvider {
         edgeConfigResolver.has = function (key) {
             return app.config.has(key);
         };
+        function clientRoutes() {
+            const routes = router.toJSON();
+            return Object.keys(routes).reduce((result, domain) => {
+                result[domain] = routes[domain].reduce((routesResult, route) => {
+                    if (!route.name) {
+                        return routesResult;
+                    }
+                    routesResult.push({
+                        domain: route.domain,
+                        methods: route.methods,
+                        pattern: route.pattern,
+                        tokens: route.tokens,
+                        name: route.name,
+                    });
+                    return routesResult;
+                }, []);
+                return result;
+            }, {});
+        }
         /**
          * Mount the default disk
          */
@@ -71,6 +91,7 @@ export default class EdgeServiceProvider {
         edge.configure({ cache: app.inProduction });
         /**
          * Define Edge global helpers
+         * @deprecated
          */
         edge.global('route', function (...args) {
             return router.makeUrl(...args);
@@ -80,6 +101,46 @@ export default class EdgeServiceProvider {
         });
         edge.global('app', app);
         edge.global('config', edgeConfigResolver);
+        edge.global('routes', function () {
+            return clientRoutes();
+        });
+        edge.global('routesJSON', function () {
+            return JSON.stringify(clientRoutes());
+        });
+        /**
+         * Route helpers
+         */
+        edge.global('urlFor', function (...args) {
+            return router.urlBuilder.urlFor(...args);
+        });
+        edge.global('signedUrlFor', function (...args) {
+            return router.urlBuilder.signedUrlFor(...args);
+        });
+        /**
+         * Sharing qs parser with templates
+         */
+        edge.global('qs', qs);
+        edge.global('formAttributes', function (route, method, params, options) {
+            /**
+             * Normalize method and keep a reference to the original method
+             */
+            options = options ?? {};
+            method = method.toUpperCase();
+            const original = method;
+            /**
+             * If method if not GET and POST, then use the querystring _method
+             * to and force update the method to "POST"
+             */
+            if (method !== 'GET' && method !== 'POST') {
+                method = 'POST';
+                options = { ...options, qs: { _method: original, ...options.qs } };
+            }
+            const { action } = router.urlBuilder.urlFor.method(original, route, params, options).form;
+            return {
+                action,
+                method,
+            };
+        });
         /**
          * Creating a isolated instance of edge renderer
          */

package/build/src/assembler_hooks/index_entities.d.ts

@@ -1,26 +1,10 @@
 import { type IndexEntitiesConfig } from '../types.ts';
-import { type CommonHooks } from '@adonisjs/assembler/types';
 /**
  * Configures the IndexGenerator to create barrel files for "controllers", "events",
  * and "listeners". This function is used as an assembler hook to automatically generate
  * index files that export all modules from specified directories.
  *
  * @param {IndexEntitiesConfig} entities - Configuration object for entities indexing
- * @param {object} [entities.events] - Configuration for events indexing
- * @param {boolean} [entities.events.enabled=true] - Whether to enable events indexing
- * @param {string} [entities.events.source='app/events'] - Source directory for events
- * @param {string} [entities.events.importAlias='#events'] - Import alias for events
- * @param {string} [entities.events.glob] - Glob pattern for matching event files
- * @param {object} [entities.listeners] - Configuration for listeners indexing
- * @param {boolean} [entities.listeners.enabled=true] - Whether to enable listeners indexing
- * @param {string} [entities.listeners.source='app/listeners'] - Source directory for listeners
- * @param {string} [entities.listeners.importAlias='#listeners'] - Import alias for listeners
- * @param {string} [entities.listeners.glob] - Glob pattern for matching listener files
- * @param {object} [entities.controllers] - Configuration for controllers indexing
- * @param {boolean} [entities.controllers.enabled=true] - Whether to enable controllers indexing
- * @param {string} [entities.controllers.source='app/controllers'] - Source directory for controllers
- * @param {string} [entities.controllers.importAlias='#controllers'] - Import alias for controllers
- * @param {string} [entities.controllers.glob] - Glob pattern for matching controller files
  *
  * @example
  * // Basic usage with default configuration
@@ -48,4 +32,6 @@ import { type CommonHooks } from '@adonisjs/assembler/types';
  *   }
  * })
  */
-export declare function indexEntities(entities?: IndexEntitiesConfig): CommonHooks['init'][number];
+export declare function indexEntities(entities?: IndexEntitiesConfig): {
+    run(_: import("@adonisjs/assembler").DevServer | import("@adonisjs/assembler").TestRunner | import("@adonisjs/assembler").Bundler, indexGenerator: import("@adonisjs/assembler/index_generator").IndexGenerator): void;
+};

package/build/src/assembler_hooks/index_entities.js

@@ -6,27 +6,14 @@
  * For the full copyright and license information, please view the LICENSE
  * file that was distributed with this source code.
  */
+import stringHelpers from "../helpers/string.js";
+import { outputTransformerDataObjects } from "../utils.js";
 /**
  * Configures the IndexGenerator to create barrel files for "controllers", "events",
  * and "listeners". This function is used as an assembler hook to automatically generate
  * index files that export all modules from specified directories.
  *
  * @param {IndexEntitiesConfig} entities - Configuration object for entities indexing
- * @param {object} [entities.events] - Configuration for events indexing
- * @param {boolean} [entities.events.enabled=true] - Whether to enable events indexing
- * @param {string} [entities.events.source='app/events'] - Source directory for events
- * @param {string} [entities.events.importAlias='#events'] - Import alias for events
- * @param {string} [entities.events.glob] - Glob pattern for matching event files
- * @param {object} [entities.listeners] - Configuration for listeners indexing
- * @param {boolean} [entities.listeners.enabled=true] - Whether to enable listeners indexing
- * @param {string} [entities.listeners.source='app/listeners'] - Source directory for listeners
- * @param {string} [entities.listeners.importAlias='#listeners'] - Import alias for listeners
- * @param {string} [entities.listeners.glob] - Glob pattern for matching listener files
- * @param {object} [entities.controllers] - Configuration for controllers indexing
- * @param {boolean} [entities.controllers.enabled=true] - Whether to enable controllers indexing
- * @param {string} [entities.controllers.source='app/controllers'] - Source directory for controllers
- * @param {string} [entities.controllers.importAlias='#controllers'] - Import alias for controllers
- * @param {string} [entities.controllers.glob] - Glob pattern for matching controller files
  *
  * @example
  * // Basic usage with default configuration
@@ -58,11 +45,18 @@ export function indexEntities(entities = {}) {
     const events = Object.assign({ enabled: true, source: 'app/events', importAlias: '#events' }, entities.events);
     const listeners = Object.assign({ enabled: true, source: 'app/listeners', importAlias: '#listeners' }, entities.listeners);
     const controllers = Object.assign({ enabled: true, source: 'app/controllers', importAlias: '#controllers' }, entities.controllers);
+    const transformers = Object.assign({
+        enabled: false,
+        source: 'app/transformers',
+        importAlias: '#transformers',
+        withSharedProps: false,
+    }, entities.transformers);
     return {
         run(_, indexGenerator) {
             if (events.enabled) {
                 indexGenerator.add('events', {
                     source: events.source,
+                    disableLazyImports: true,
                     glob: events.glob,
                     as: 'barrelFile',
                     exportName: 'events',
@@ -91,6 +85,28 @@ export function indexEntities(entities = {}) {
                     output: '.adonisjs/server/controllers.ts',
                 });
             }
+            if (transformers.enabled) {
+                indexGenerator.add('transformers', {
+                    source: transformers.source,
+                    glob: transformers.glob,
+                    as(vfs, buffer, __, helpers) {
+                        const transformersList = vfs.asTree({
+                            transformKey(key) {
+                                const segments = key.split('/');
+                                const baseName = segments.pop();
+                                return [
+                                    ...segments.map((segment) => stringHelpers.pascalCase(segment)),
+                                    stringHelpers.create(baseName).removeSuffix('transformer').pascalCase(),
+                                ].join('/');
+                            },
+                            transformValue: helpers.toImportPath,
+                        });
+                        outputTransformerDataObjects(transformersList, buffer, transformers.withSharedProps);
+                    },
+                    importAlias: transformers.importAlias,
+                    output: '.adonisjs/client/data.d.ts',
+                });
+            }
         },
     };
 }

package/build/src/cli_formatters/routes_list.js

@@ -64,7 +64,9 @@ export class RoutesListFormatter {
         this.#router.commit();
     }
     /**
-     * Test if a route clears the applied filters
+     * Test if a route clears the applied filters based on middleware, name, pattern, and handler.
+     *
+     * @param route - The serialized route to test against filters
      */
     #isAllowedByFilters(route) {
         let allowRoute = true;
@@ -124,7 +126,10 @@ export class RoutesListFormatter {
         return false;
     }
     /**
-     * Serializes routes JSON to an object that can be used for pretty printing
+     * Serializes routes JSON to an object that can be used for pretty printing.
+     * Converts RouteJSON into a format suitable for display and filtering.
+     *
+     * @param route - The route JSON object to serialize
      */
     async #serializeRoute(route) {
         let methods = route.methods;
@@ -143,13 +148,17 @@ export class RoutesListFormatter {
         };
     }
     /**
-     * Formats the route method for the ansi list and table
+     * Formats the route method for the ansi list and table with dim styling.
+     *
+     * @param method - The HTTP method to format (GET, POST, etc.)
      */
     #formatRouteMethod(method) {
         return this.#colors.dim(method);
     }
     /**
-     * Formats route pattern for the ansi list and table
+     * Formats route pattern for the ansi list and table with colored parameters and route name.
+     *
+     * @param route - The serialized route containing pattern and name information
      */
     #formatRoutePattern(route) {
         const pattern = this.#router
@@ -170,7 +179,9 @@ export class RoutesListFormatter {
         return `${pattern === '/' ? pattern : `/${pattern}`}${route.name ? ` ${this.#colors.dim(`(${route.name})`)}` : ''} `;
     }
     /**
-     * Formats controller name for the ansi list and table
+     * Formats controller name for the ansi list and table with cyan coloring.
+     *
+     * @param route - The serialized route containing handler information
      */
     #formatControllerName(route) {
         return route.handler.type === 'controller'
@@ -178,7 +189,9 @@ export class RoutesListFormatter {
             : '';
     }
     /**
-     * Formats action name for the ansi list and table
+     * Formats action name for the ansi list and table with cyan coloring and arguments.
+     *
+     * @param route - The serialized route containing handler information
      */
     #formatAction(route) {
         if (route.handler.type === 'controller') {
@@ -191,7 +204,10 @@ export class RoutesListFormatter {
         return functionName;
     }
     /**
-     * Formats route middleware for the ansi list and table
+     * Formats route middleware for the ansi list and table with optional compacting.
+     *
+     * @param route - The serialized route containing middleware information
+     * @param mode - Display mode: 'normal' shows all middleware, 'compact' truncates long lists
      */
     #formatMiddleware(route, mode = 'normal') {
         if (mode === 'compact' && route.middleware.length > 3) {

package/build/src/helpers/http.d.ts

@@ -0,0 +1,20 @@
+/**
+ * HTTP helper utilities re-exported from @adonisjs/http-server. This module
+ * provides a convenient entry point for accessing all HTTP-related utilities
+ * including route helpers, middleware utilities, and request/response helpers.
+ *
+ * @example
+ * // Import specific HTTP helpers
+ * import { middlewareInfo, routeInfo } from '@adonisjs/core/helpers'
+ *
+ * const middleware = middlewareInfo('cors', CorsMiddleware)
+ * const route = routeInfo('users.show', '/users/:id')
+ *
+ * @example
+ * // Access all HTTP helpers
+ * import * as httpHelpers from '@adonisjs/core/helpers/http'
+ *
+ * // Use any helper from the http-server package
+ * const routeData = httpHelpers.routeInfo('api.posts', '/api/posts')
+ */
+export * from '@adonisjs/http-server/helpers';

package/build/src/helpers/http.js

@@ -0,0 +1,28 @@
+/*
+ * @adonisjs/core
+ *
+ * (c) AdonisJS
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+/**
+ * HTTP helper utilities re-exported from @adonisjs/http-server. This module
+ * provides a convenient entry point for accessing all HTTP-related utilities
+ * including route helpers, middleware utilities, and request/response helpers.
+ *
+ * @example
+ * // Import specific HTTP helpers
+ * import { middlewareInfo, routeInfo } from '@adonisjs/core/helpers'
+ *
+ * const middleware = middlewareInfo('cors', CorsMiddleware)
+ * const route = routeInfo('users.show', '/users/:id')
+ *
+ * @example
+ * // Access all HTTP helpers
+ * import * as httpHelpers from '@adonisjs/core/helpers/http'
+ *
+ * // Use any helper from the http-server package
+ * const routeData = httpHelpers.routeInfo('api.posts', '/api/posts')
+ */
+export * from '@adonisjs/http-server/helpers';

package/build/src/helpers/main.d.ts

@@ -37,12 +37,8 @@ export { default as base64 } from '@poppinss/utils/base64';
  * Core utilities including function composition, secret management,
  * safe equality comparison, and message building.
  */
-export { compose, Secret, safeEqual, MessageBuilder } from '@poppinss/utils';
+export { compose, Secret, safeEqual, MessageBuilder, defineStaticProperty } from '@poppinss/utils';
 /**
  * Verification token utility for creating secure tokens.
  */
 export { VerificationToken } from './verification_token.ts';
-/**
- * HTTP server helper functions for middleware and route information.
- */
-export { middlewareInfo, routeInfo } from '@adonisjs/http-server/helpers';

package/build/src/helpers/main.js

@@ -45,12 +45,8 @@ export { default as base64 } from '@poppinss/utils/base64';
  * Core utilities including function composition, secret management,
  * safe equality comparison, and message building.
  */
-export { compose, Secret, safeEqual, MessageBuilder } from '@poppinss/utils';
+export { compose, Secret, safeEqual, MessageBuilder, defineStaticProperty } from '@poppinss/utils';
 /**
  * Verification token utility for creating secure tokens.
  */
 export { VerificationToken } from "./verification_token.js";
-/**
- * HTTP server helper functions for middleware and route information.
- */
-export { middlewareInfo, routeInfo } from '@adonisjs/http-server/helpers';

package/build/src/helpers/string.js

@@ -34,12 +34,30 @@ const stringHelpers = {
     create(value) {
         return new StringBuilder(value);
     },
+    /**
+     * Formats Node.js hrtime output into a human-readable string.
+     *
+     * @param time - Tuple of [seconds, nanoseconds] from process.hrtime()
+     * @param options - Formatting options for output style and precision
+     */
     prettyHrTime(time, options) {
         return prettyHrTime(time, options);
     },
+    /**
+     * Check if a string is empty or contains only whitespace characters.
+     *
+     * @param value - The string to check for emptiness
+     */
     isEmpty(value) {
         return value.trim().length === 0;
     },
+    /**
+     * Escape HTML entities to prevent XSS attacks and display HTML safely.
+     *
+     * @param value - The string containing HTML to escape
+     * @param options - Optional configuration for escaping behavior
+     * @param options.encodeSymbols - Whether to also encode Unicode symbols as HTML entities
+     */
     escapeHTML(value, options) {
         value = he.escape(value);
         if (options && options.encodeSymbols) {
@@ -47,6 +65,12 @@ const stringHelpers = {
         }
         return value;
     },
+    /**
+     * Encode Unicode symbols and special characters as HTML entities.
+     *
+     * @param value - The string containing symbols to encode
+     * @param options - Encoding options from the 'he' library
+     */
     encodeSymbols(value, options) {
         return he.encode(value, options);
     },

package/build/src/helpers/types.d.ts

@@ -104,6 +104,7 @@ declare const types: {
         urlInstance: typeof import("@sindresorhus/is").isUrlInstance;
         urlSearchParams: typeof import("@sindresorhus/is").isUrlSearchParams;
         urlString: typeof import("@sindresorhus/is").isUrlString;
+        optional: typeof import("@sindresorhus/is").isOptional;
         validDate: typeof import("@sindresorhus/is").isValidDate;
         validLength: typeof import("@sindresorhus/is").isValidLength;
         weakMap: typeof import("@sindresorhus/is").isWeakMap;

package/build/src/ignitor/http.js

@@ -32,7 +32,9 @@ export class HttpServerProcess {
         this.#ignitor = ignitor;
     }
     /**
-     * Calling this method closes the underlying HTTP server
+     * Calling this method closes the underlying HTTP server gracefully.
+     *
+     * @param nodeHttpServer - The Node.js HTTP or HTTPS server instance to close
      */
     #close(nodeHttpServer) {
         return new Promise((resolve) => {
@@ -42,7 +44,11 @@ export class HttpServerProcess {
     }
     /**
      * Monitors the app and the server to close the HTTP server when
-     * either one of them goes down
+     * either one of them goes down. Sets up event listeners for graceful shutdown.
+     *
+     * @param nodeHttpServer - The Node.js HTTP or HTTPS server instance to monitor
+     * @param app - The application service instance
+     * @param logger - The logger service for error reporting
      */
     #monitorAppAndServer(nodeHttpServer, app, logger) {
         /**
@@ -64,7 +70,9 @@ export class HttpServerProcess {
         });
     }
     /**
-     * Starts the http server a given host and port
+     * Starts the HTTP server on a given host and port using environment variables.
+     *
+     * @param nodeHttpServer - The Node.js HTTP or HTTPS server instance to start listening
      */
     #listen(nodeHttpServer) {
         return new Promise((resolve, reject) => {
@@ -81,8 +89,13 @@ export class HttpServerProcess {
         });
     }
     /**
-     * Notifies the app and the parent process that the
-     * HTTP server is ready
+     * Notifies the app and the parent process that the HTTP server is ready.
+     * Sends notifications through multiple channels: parent process, logger, and event emitter.
+     *
+     * @param app - The application service instance for parent process notification
+     * @param logger - The logger service for console output
+     * @param emitter - The event emitter for app-level notifications
+     * @param payload - Server startup information including host, port, and duration
      */
     #notifyServerHasStarted(app, logger, emitter, payload) {
         /**