@adonisjs/http-server 7.0.0-0 → 7.0.0-1

package/build/{main-29eaaee4.d.ts → src/server/main.d.ts}

@@ -1,17 +1,24 @@
-import { Logger } from '@adonisjs/logger';
-import { Emitter } from '@adonisjs/events';
-import { Encryption } from '@adonisjs/encryption';
-import { Server as Server$2 } from 'node:https';
-import { Application } from '@adonisjs/application';
+/// <reference types="node" resolution-mode="require"/>
+/// <reference types="node" resolution-mode="require"/>
+import type { Logger } from '@adonisjs/logger';
+import type { Emitter } from '@adonisjs/events';
+import type { Encryption } from '@adonisjs/encryption';
+import type { Server as HttpsServer } from 'node:https';
+import type { Application } from '@adonisjs/application';
 import { ContainerResolver } from '@adonisjs/fold';
-import { Server as Server$1, IncomingMessage, ServerResponse } from 'node:http';
-import { S as ServerConfig, M as MiddlewareAsClass, T as TestingMiddlewarePipeline, L as LazyImport, E as ErrorHandlerAsAClass, R as Router, a as Request, b as Response, H as HttpContext } from './main-e5b46c83.js';
-
+import type { ServerResponse, IncomingMessage, Server as HttpServer } from 'node:http';
+import type { LazyImport } from '../types/base.js';
+import type { MiddlewareAsClass } from '../types/middleware.js';
+import type { ServerConfig, ErrorHandlerAsAClass, TestingMiddlewarePipeline } from '../types/server.js';
+import { Request } from '../request.js';
+import { Response } from '../response.js';
+import { Router } from '../router/main.js';
+import { HttpContext } from '../http_context/main.js';
 /**
  * The HTTP server implementation to handle incoming requests and respond using the
  * registered routes.
  */
-declare class Server {
+export declare class Server {
     #private;
     /**
      * Know if async local storage is enabled or not.
@@ -43,12 +50,12 @@ declare class Server {
     /**
      * Set the HTTP server instance used to listen for requests.
      */
-    setNodeServer(server: Server$1 | Server$2): void;
+    setNodeServer(server: HttpServer | HttpsServer): void;
     /**
      * Returns reference to the underlying HTTP server
      * in use
      */
-    getNodeServer(): Server$1<typeof IncomingMessage, typeof ServerResponse> | Server$2<typeof IncomingMessage, typeof ServerResponse> | undefined;
+    getNodeServer(): HttpServer<typeof IncomingMessage, typeof ServerResponse> | HttpsServer<typeof IncomingMessage, typeof ServerResponse> | undefined;
     /**
      * Returns reference to the router instance used
      * by the server.
@@ -71,5 +78,3 @@ declare class Server {
      */
     handle(req: IncomingMessage, res: ServerResponse): Promise<any>;
 }
-
-export { Server as S };

package/build/src/server/main.js

@@ -0,0 +1,292 @@
+/*
+ * @adonisjs/http-server
+ *
+ * (c) AdonisJS
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+import onFinished from 'on-finished';
+import Middleware from '@poppinss/middleware';
+import { moduleCaller, moduleImporter } from '@adonisjs/fold';
+import { Qs } from '../qs.js';
+import debug from '../debug.js';
+import { Request } from '../request.js';
+import { Response } from '../response.js';
+import { Router } from '../router/main.js';
+import { HttpContext } from '../http_context/main.js';
+import { finalHandler } from './factories/final_handler.js';
+import { writeResponse } from './factories/write_response.js';
+import { asyncLocalStorage } from '../http_context/local_storage.js';
+import { middlewareHandler } from './factories/middleware_handler.js';
+/**
+ * The HTTP server implementation to handle incoming requests and respond using the
+ * registered routes.
+ */
+export class Server {
+    /**
+     * The default error handler to use
+     */
+    #defaultErrorHandler = {
+        report() { },
+        handle(error, ctx) {
+            ctx.response.status(error.status || 500).send(error.message || 'Internal server error');
+        },
+    };
+    /**
+     * Logger instance, a child logger is added
+     * to the context to have request specific
+     * logging capabilities.
+     */
+    #logger;
+    /**
+     * Registered error handler (if any)
+     */
+    #errorHandler;
+    /**
+     * Resolved error handler is an instance of the lazily imported error
+     * handler class.
+     */
+    #resolvedErrorHandler = this.#defaultErrorHandler;
+    /**
+     * Emitter is required to notify when a request finishes
+     */
+    #emitter;
+    /**
+     * The application instance to be shared with the router
+     */
+    #app;
+    /**
+     * The encryption instance to be shared with the router
+     */
+    #encryption;
+    /**
+     * Server config
+     */
+    #config;
+    /**
+     * Query string parser used by the server
+     */
+    #qsParser;
+    /**
+     * Server middleware stack runs on every incoming HTTP request
+     */
+    #serverMiddlewareStack;
+    /**
+     * Reference to the router used by the server
+     */
+    #router;
+    /**
+     * Reference to the underlying Node HTTP server in use
+     */
+    #nodeHttpServer;
+    /**
+     * Middleware store to be shared with the routes
+     */
+    #middleware = [];
+    /**
+     * The request error response is attached to the middleware
+     * pipeline to intercept errors and invoke the user
+     * registered error handler.
+     *
+     * We share this with the route middleware pipeline as well,
+     * so that it does not throw any exceptions
+     */
+    #requestErrorResponder = (error, ctx) => {
+        this.#resolvedErrorHandler.report(error, ctx);
+        return this.#resolvedErrorHandler.handle(error, ctx);
+    };
+    /**
+     * Know if async local storage is enabled or not.
+     */
+    get usingAsyncLocalStorage() {
+        return asyncLocalStorage.isEnabled;
+    }
+    constructor(app, encryption, emitter, logger, config) {
+        this.#app = app;
+        this.#emitter = emitter;
+        this.#config = config;
+        this.#logger = logger;
+        this.#encryption = encryption;
+        this.#qsParser = new Qs(this.#config.qs);
+        this.#router = new Router(this.#app, this.#encryption, this.#qsParser);
+        this.#createAsyncLocalStore();
+        debug('server config: %O', this.#config);
+    }
+    /**
+     * Create async local storage store when enabled
+     */
+    #createAsyncLocalStore() {
+        if (this.#config.useAsyncLocalStorage) {
+            debug('creating ALS store for HTTP context');
+            asyncLocalStorage.create();
+        }
+        else {
+            asyncLocalStorage.destroy();
+        }
+    }
+    /**
+     * Creates an instance of the server middleware stack
+     */
+    #createServerMiddlewareStack() {
+        this.#serverMiddlewareStack = new Middleware();
+        this.#middleware.forEach((middleware) => this.#serverMiddlewareStack.add(middleware));
+        this.#serverMiddlewareStack.freeze();
+        this.#middleware = [];
+    }
+    /**
+     * Handles the HTTP request
+     */
+    #handleRequest(ctx, resolver) {
+        return this.#serverMiddlewareStack.runner()
+            .errorHandler((error) => this.#requestErrorResponder(error, ctx))
+            .finalHandler(finalHandler(this.#router, resolver, ctx, this.#requestErrorResponder))
+            .run(middlewareHandler(resolver, ctx))
+            .catch((error) => {
+            ctx.logger.fatal({ err: error }, 'Exception raised by error handler');
+            return this.#defaultErrorHandler.handle(error, ctx);
+        })
+            .finally(writeResponse(ctx));
+    }
+    /**
+     * Creates a pipeline of middleware.
+     */
+    pipeline(middleware) {
+        const middlewareStack = new Middleware();
+        middleware.forEach((one) => {
+            middlewareStack.add(moduleCaller(one, 'handle').toHandleMethod());
+        });
+        middlewareStack.freeze();
+        const stackRunner = middlewareStack.runner();
+        return {
+            finalHandler(handler) {
+                stackRunner.finalHandler(handler);
+                return this;
+            },
+            errorHandler(handler) {
+                stackRunner.errorHandler(handler);
+                return this;
+            },
+            run(ctx) {
+                return stackRunner.run((handler, next) => {
+                    return handler.handle(ctx.containerResolver, ctx, next);
+                });
+            },
+        };
+    }
+    /**
+     * Define an array of middleware to use on all the incoming HTTP request.
+     * Calling this method multiple times pushes to the existing list
+     * of middleware
+     */
+    use(middleware) {
+        middleware.forEach((one) => this.#middleware.push(moduleImporter(one, 'handle').toHandleMethod()));
+        return this;
+    }
+    /**
+     * Register a custom error handler for HTTP requests.
+     * All errors will be reported to this method
+     */
+    errorHandler(handler) {
+        this.#errorHandler = handler;
+        return this;
+    }
+    /**
+     * Boot the server. Calling this method performs the following actions.
+     *
+     * - Register routes with the store.
+     * - Resolve and construct the error handler.
+     */
+    async boot() {
+        debug('booting HTTP server');
+        /**
+         * Creates the middleware stack for the server
+         */
+        this.#createServerMiddlewareStack();
+        /**
+         * Commit routes
+         */
+        this.#router.commit();
+        /**
+         * Register custom error handler
+         */
+        if (this.#errorHandler) {
+            if (debug.enabled) {
+                debug('using custom error handler "%s"', this.#errorHandler);
+            }
+            const moduleExports = await this.#errorHandler();
+            this.#resolvedErrorHandler = await this.#app.container.make(moduleExports.default);
+        }
+    }
+    /**
+     * Set the HTTP server instance used to listen for requests.
+     */
+    setNodeServer(server) {
+        this.#nodeHttpServer = server;
+    }
+    /**
+     * Returns reference to the underlying HTTP server
+     * in use
+     */
+    getNodeServer() {
+        return this.#nodeHttpServer;
+    }
+    /**
+     * Returns reference to the router instance used
+     * by the server.
+     */
+    getRouter() {
+        return this.#router;
+    }
+    /**
+     * Creates an instance of the [[Request]] class
+     */
+    createRequest(req, res) {
+        return new Request(req, res, this.#encryption, this.#config, this.#qsParser);
+    }
+    /**
+     * Creates an instance of the [[Response]] class
+     */
+    createResponse(req, res) {
+        return new Response(req, res, this.#encryption, this.#config, this.#router, this.#qsParser);
+    }
+    /**
+     * Creates an instance of the [[HttpContext]] class
+     */
+    createHttpContext(request, response, resolver) {
+        return new HttpContext(request, response, this.#logger.child({ request_id: request.id() }), resolver);
+    }
+    /**
+     * Handle request
+     */
+    handle(req, res) {
+        /**
+         * Setup for the "http:request_finished" event
+         */
+        const hasRequestListener = this.#emitter.hasListeners('http:request_finished');
+        const startTime = hasRequestListener ? process.hrtime() : null;
+        /**
+         * Creating essential instances
+         */
+        const resolver = this.#app.container.createResolver();
+        const ctx = this.createHttpContext(this.createRequest(req, res), this.createResponse(req, res), resolver);
+        /**
+         * Emit event when listening for the request_finished event
+         */
+        if (startTime) {
+            onFinished(res, () => {
+                this.#emitter.emit('http:request_finished', {
+                    ctx: ctx,
+                    duration: process.hrtime(startTime),
+                });
+            });
+        }
+        /**
+         * Handle request
+         */
+        if (this.usingAsyncLocalStorage) {
+            return asyncLocalStorage.storage.run(ctx, () => this.#handleRequest(ctx, resolver));
+        }
+        return this.#handleRequest(ctx, resolver);
+    }
+}

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

@@ -0,0 +1,19 @@
+export type { NextFn } from '@poppinss/middleware/types';
+/**
+ * Accept one or more of the mentioned type
+ */
+export type OneOrMore<T> = T | T[];
+/**
+ * Class constructor type
+ */
+export type Constructor<T> = new (...args: any[]) => T;
+/**
+ * A function that lazily imports a middleware
+ */
+export type LazyImport<DefaultExport> = () => Promise<{
+    default: DefaultExport;
+}>;
+/**
+ * Unwraps default export from a lazy import function
+ */
+export type UnWrapLazyImport<Fn extends LazyImport<any>> = Awaited<ReturnType<Fn>>['default'];

package/build/src/types/base.js

@@ -0,0 +1,9 @@
+/*
+ * @adonisjs/http-server
+ *
+ * (c) AdonisJS
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+export {};

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

@@ -1,14 +1,7 @@
-export { p as CastableHeader, C as Constructor, o as CookieOptions, E as ErrorHandlerAsAClass, r as GetControllerHandlers, G as GetMiddlewareArgs, e as HttpError, V as HttpRequestFinishedPayload, L as LazyImport, N as MakeSignedUrlOptions, K as MakeUrlOptions, s as MatchItRouteToken, A as MatchedRoute, M as MiddlewareAsClass, m as MiddlewareFn, O as OneOrMore, P as ParsedGlobalMiddleware, n as ParsedNamedMiddleware, Q as QSParserConfig, k as RequestConfig, J as ResourceActionNames, l as ResponseConfig, q as ResponseStream, t as RouteFn, I as RouteJSON, D as RouteMatcher, F as RouteMatchers, S as ServerConfig, W as ServerErrorHandler, c as StatusPageRange, d as StatusPageRenderer, y as StoreDomainNode, x as StoreMethodNode, u as StoreRouteHandler, v as StoreRouteMiddleware, w as StoreRouteNode, z as StoreRoutesTree, T as TestingMiddlewarePipeline, U as UnWrapLazyImport } from '../../main-e5b46c83.js';
-export { NextFn } from '@poppinss/middleware/types';
-import '@adonisjs/fold';
-import '@poppinss/macroable';
-import '@adonisjs/logger';
-import 'node:url';
-import '@adonisjs/encryption';
-import 'node:http';
-import 'qs';
-import 'http';
-import 'stream';
-import '@poppinss/middleware';
-import 'node:stream';
-import '@adonisjs/application';
+export * from './base.js';
+export * from './middleware.js';
+export * from './qs.js';
+export * from './request.js';
+export * from './response.js';
+export * from './route.js';
+export * from './server.js';

package/build/src/types/main.js

@@ -0,0 +1,15 @@
+/*
+ * @adonisjs/http-server
+ *
+ * (c) AdonisJS
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+export * from './base.js';
+export * from './middleware.js';
+export * from './qs.js';
+export * from './request.js';
+export * from './response.js';
+export * from './route.js';
+export * from './server.js';

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

@@ -0,0 +1,35 @@
+import type { ContainerResolver } from '@adonisjs/fold';
+import type { Constructor, NextFn } from './base.js';
+import type { HttpContext } from '../http_context/main.js';
+/**
+ * Middleware represented as a class
+ */
+export type MiddlewareAsClass = Constructor<{
+    handle: (ctx: HttpContext, next: NextFn, args?: any) => any;
+}>;
+/**
+ * Check if a union has undefined or null
+ */
+type HasUndefined<T> = T extends NonNullable<T> ? true : false;
+/**
+ * Returns the arguments accepted by the middleware's handle method
+ */
+export type GetMiddlewareArgs<Middleware extends MiddlewareAsClass> = Parameters<InstanceType<Middleware>['handle']>[2] extends undefined ? [] : HasUndefined<Parameters<InstanceType<Middleware>['handle']>[2]> extends true ? [Parameters<InstanceType<Middleware>['handle']>[2]] : [Parameters<InstanceType<Middleware>['handle']>[2]?];
+/**
+ * The middleware defined as a function on the router or the server
+ */
+export type MiddlewareFn = (ctx: HttpContext, next: NextFn) => any;
+/**
+ * Parsed global middleware
+ */
+export type ParsedGlobalMiddleware = {
+    handle: (resolver: ContainerResolver<any>, ...args: [ctx: HttpContext, next: NextFn, params?: any]) => any;
+};
+/**
+ * Parsed named middleware
+ */
+export type ParsedNamedMiddleware = ParsedGlobalMiddleware & {
+    name: string;
+    args: any;
+};
+export {};

package/build/src/types/middleware.js

@@ -0,0 +1,9 @@
+/*
+ * @adonisjs/http-server
+ *
+ * (c) AdonisJS
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+export {};

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

@@ -0,0 +1,68 @@
+export type QSParserConfig = {
+    parse: {
+        /**
+         * Nesting depth till the parameters should be parsed.
+         *
+         * Defaults to 5
+         */
+        depth: number;
+        /**
+         * Number of parameters to parse.
+         *
+         * Defaults to 1000
+         */
+        parameterLimit: number;
+        /**
+         * Allow sparse elements in an array.
+         *
+         * Defaults to false
+         */
+        allowSparse: boolean;
+        /**
+         * The max limimit for the array indices. After the given limit
+         * the array indices will be converted to an object, where the
+         * index is the key.
+         *
+         * Defaults to 20
+         */
+        arrayLimit: number;
+        /**
+         * Join comma seperated query string values to an array
+         *
+         * Defaults to false
+         */
+        comma: boolean;
+    };
+    stringify: {
+        /**
+         * URI encode the stringified query string
+         *
+         * Defaults to true
+         */
+        encode: boolean;
+        /**
+         * URI encode but only the values and not the keys
+         *
+         * Defaults to false
+         */
+        encodeValuesOnly: boolean;
+        /**
+         * Define the format in which arrays should be serialized.
+         *
+         * - indices:   a[0]=b&a[1]=c
+         * - brackets:  a[]=b&a[]=c
+         * - repeat:    a=b&a=c
+         * - comma:     a=b,c
+         *
+         * Defaults to "indices"
+         */
+        arrayFormat: 'indices' | 'brackets' | 'repeat' | 'comma';
+        /**
+         * Whether or not to skip null values when serializing. When set to
+         * false, the null values will be treated as an empty string.
+         *
+         * Defaults to: false
+         */
+        skipNulls: boolean;
+    };
+};

package/build/src/types/qs.js

@@ -0,0 +1,9 @@
+/*
+ * @adonisjs/http-server
+ *
+ * (c) AdonisJS
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+export {};

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

@@ -0,0 +1,39 @@
+/**
+ * Shape of the request config
+ */
+export type RequestConfig = {
+    /**
+     * URL segments to ignore when extracting subdomains from a URL.
+     * Defaults to 2
+     */
+    subdomainOffset: number;
+    /**
+     * Enabling the flag will generated a unique request id from every
+     * HTTP request.
+     *
+     * The request id can be accessed using the "request.id()" method. Also,
+     * the value of `x-request-id` header is used as the id (if it exists).
+     *
+     * Defaults to false
+     */
+    generateRequestId: boolean;
+    /**
+     * Method spoofing allows changing the request method using the query string.
+     * For example: Making a POST request on URL /users/1?_method=PATCH will
+     * be handled by the patch route.
+     *
+     * Defaults to false
+     */
+    allowMethodSpoofing: boolean;
+    /**
+     * A custom implementation to get the request ip address
+     */
+    getIp?: (request: any) => string;
+    /**
+     * A callback function to trust proxy ip addresses. You must use
+     * the `proxy-addr` package to compute this value.
+     *
+     * Defaults to: "proxyAddr.compile('loopback')"
+     */
+    trustProxy: (address: string, distance: number) => boolean;
+};

package/build/src/types/request.js

@@ -0,0 +1,9 @@
+/*
+ * @adonisjs/http-server
+ *
+ * (c) AdonisJS
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+export {};

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

@@ -0,0 +1,45 @@
+/// <reference types="node" resolution-mode="require"/>
+import { Readable } from 'node:stream';
+/**
+ * Cookie options can that can be set on the response
+ */
+export type CookieOptions = {
+    domain: string;
+    expires: Date | (() => Date);
+    httpOnly: boolean;
+    maxAge: number | string;
+    path: string;
+    sameSite: boolean | 'lax' | 'none' | 'strict';
+    secure: boolean;
+};
+/**
+ * Types from which response header can be casted to a
+ * string
+ */
+export type CastableHeader = string | number | boolean | string[] | number[] | boolean[];
+/**
+ * Config accepted by response the class
+ */
+export type ResponseConfig = {
+    /**
+     * Whether or not to generate etags for responses. Etags can be
+     * enabled/disabled when sending response as well.
+     *
+     * Defaults to false
+     */
+    etag: boolean;
+    /**
+     * The callback name for the JSONP response.
+     *
+     * Defaults to 'callback'
+     */
+    jsonpCallbackName: string;
+    /**
+     * Options to set cookies
+     */
+    cookie: Partial<CookieOptions>;
+};
+/**
+ * Stream that can be piped to the "response.stream" method
+ */
+export type ResponseStream = Readable;

package/build/src/types/response.js

@@ -0,0 +1,9 @@
+/*
+ * @adonisjs/http-server
+ *
+ * (c) AdonisJS
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+export {};