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

package/build/factories/request.js

@@ -0,0 +1,73 @@
+/*
+ * @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 { Socket } from 'node:net';
+import proxyAddr from 'proxy-addr';
+import { IncomingMessage, ServerResponse } from 'node:http';
+import { EncryptionFactory } from '@adonisjs/encryption/factories';
+import { Request } from '../src/request.js';
+import { QsParserFactory } from './qs_parser_factory.js';
+/**
+ * Request factory is used to generate request class instances for
+ * testing
+ */
+export class RequestFactory {
+    #parameters = {};
+    /**
+     * Returns the config for the request class
+     */
+    #getConfig() {
+        return {
+            allowMethodSpoofing: false,
+            trustProxy: proxyAddr.compile('loopback'),
+            subdomainOffset: 2,
+            generateRequestId: false,
+            ...this.#parameters.config,
+        };
+    }
+    /**
+     * Returns the HTTP req object
+     */
+    #createRequest() {
+        const req = this.#parameters.req || new IncomingMessage(new Socket());
+        if (this.#parameters.url) {
+            req.url = this.#parameters.url;
+        }
+        if (this.#parameters.method) {
+            req.method = this.#parameters.method;
+        }
+        return req;
+    }
+    /**
+     * Returns the HTTP res object
+     */
+    #createResponse(req) {
+        return this.#parameters.res || new ServerResponse(req);
+    }
+    /**
+     * Returns an instance of the encryptor to encrypt
+     * signed URLs
+     */
+    #createEncryption() {
+        return this.#parameters.encryption || new EncryptionFactory().create();
+    }
+    /**
+     * Merge factory params
+     */
+    merge(params) {
+        Object.assign(this.#parameters, params);
+        return this;
+    }
+    /**
+     * Create request
+     */
+    create() {
+        const req = this.#createRequest();
+        return new Request(req, this.#createResponse(req), this.#createEncryption(), this.#getConfig(), new QsParserFactory().create());
+    }
+}

package/build/factories/response.d.ts

@@ -0,0 +1,29 @@
+/// <reference types="node" resolution-mode="require"/>
+import type { Encryption } from '@adonisjs/encryption';
+import { IncomingMessage, ServerResponse } from 'node:http';
+import { Response } from '../src/response.js';
+import { Router } from '../src/router/main.js';
+import { ResponseConfig } from '../src/types/response.js';
+type FactoryParameters = {
+    req: IncomingMessage;
+    res: ServerResponse;
+    encryption: Encryption;
+    config: Partial<ResponseConfig>;
+    router: Router;
+};
+/**
+ * Response factory is used to generate response class instances for
+ * testing
+ */
+export declare class ResponseFactory {
+    #private;
+    /**
+     * Merge factory params
+     */
+    merge(params: Partial<FactoryParameters>): this;
+    /**
+     * Create response class instance
+     */
+    create(): Response;
+}
+export {};

package/build/factories/response.js

@@ -0,0 +1,77 @@
+/*
+ * @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 { Socket } from 'node:net';
+import { IncomingMessage, ServerResponse } from 'node:http';
+import { EncryptionFactory } from '@adonisjs/encryption/factories';
+import { RouterFactory } from './router.js';
+import { Response } from '../src/response.js';
+import { QsParserFactory } from './qs_parser_factory.js';
+/**
+ * Response factory is used to generate response class instances for
+ * testing
+ */
+export class ResponseFactory {
+    #parameters = {};
+    /**
+     * Returns the config for the request class
+     */
+    #getConfig() {
+        return {
+            etag: false,
+            jsonpCallbackName: 'callback',
+            cookie: {
+                maxAge: 90,
+                path: '/',
+                httpOnly: true,
+                sameSite: false,
+                secure: false,
+            },
+            ...this.#parameters.config,
+        };
+    }
+    /**
+     * Returns the HTTP req object
+     */
+    #createRequest() {
+        return this.#parameters.req || new IncomingMessage(new Socket());
+    }
+    /**
+     * Returns an instance of the router
+     */
+    #createRouter() {
+        return this.#parameters.router || new RouterFactory().create();
+    }
+    /**
+     * Returns the HTTP res object
+     */
+    #createResponse(req) {
+        return this.#parameters.res || new ServerResponse(req);
+    }
+    /**
+     * Returns an instance of the encryptor to encrypt
+     * signed URLs
+     */
+    #createEncryption() {
+        return this.#parameters.encryption || new EncryptionFactory().create();
+    }
+    /**
+     * Merge factory params
+     */
+    merge(params) {
+        Object.assign(this.#parameters, params);
+        return this;
+    }
+    /**
+     * Create response class instance
+     */
+    create() {
+        const req = this.#createRequest();
+        return new Response(req, this.#createResponse(req), this.#createEncryption(), this.#getConfig(), this.#createRouter(), new QsParserFactory().create());
+    }
+}

package/build/factories/router.d.ts

@@ -0,0 +1,23 @@
+import type { Encryption } from '@adonisjs/encryption';
+import type { Application } from '@adonisjs/application';
+import { Router } from '../src/router/main.js';
+type FactoryParameters = {
+    app: Application<any>;
+    encryption: Encryption;
+};
+/**
+ * Router factory is used to generate router class instances for
+ * testing
+ */
+export declare class RouterFactory {
+    #private;
+    /**
+     * Merge factory params
+     */
+    merge(params: Partial<FactoryParameters>): this;
+    /**
+     * Create router instance
+     */
+    create(): Router;
+}
+export {};

package/build/factories/router.js

@@ -0,0 +1,45 @@
+/*
+ * @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 { AppFactory } from '@adonisjs/application/factories';
+import { EncryptionFactory } from '@adonisjs/encryption/factories';
+import { Router } from '../src/router/main.js';
+import { QsParserFactory } from './qs_parser_factory.js';
+/**
+ * Router factory is used to generate router class instances for
+ * testing
+ */
+export class RouterFactory {
+    #parameters = {};
+    /**
+     * Returns an instance of the application class
+     */
+    #getApp() {
+        return (this.#parameters.app || new AppFactory().create(new URL('./app/', import.meta.url), () => { }));
+    }
+    /**
+     * Returns an instance of the encryptor to encrypt
+     * signed URLs
+     */
+    #createEncryption() {
+        return this.#parameters.encryption || new EncryptionFactory().create();
+    }
+    /**
+     * Merge factory params
+     */
+    merge(params) {
+        Object.assign(this.#parameters, params);
+        return this;
+    }
+    /**
+     * Create router instance
+     */
+    create() {
+        return new Router(this.#getApp(), this.#createEncryption(), new QsParserFactory().create());
+    }
+}

package/build/factories/server_factory.d.ts

@@ -0,0 +1,29 @@
+import { Logger } from '@adonisjs/logger';
+import { Emitter } from '@adonisjs/events';
+import type { Encryption } from '@adonisjs/encryption';
+import type { Application } from '@adonisjs/application';
+import { Server } from '../src/server/main.js';
+import type { ServerConfig } from '../src/types/server.js';
+type FactoryParameters = {
+    app: Application<any>;
+    logger: Logger;
+    encryption: Encryption;
+    emitter: Emitter<any>;
+    config: Partial<ServerConfig>;
+};
+/**
+ * Server factory is used to generate server class instances for
+ * testing
+ */
+export declare class ServerFactory {
+    #private;
+    /**
+     * Merge factory params
+     */
+    merge(params: Partial<FactoryParameters>): this;
+    /**
+     * Create server instance
+     */
+    create(): Server;
+}
+export {};

package/build/factories/server_factory.js

@@ -0,0 +1,65 @@
+/*
+ * @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 { Logger } from '@adonisjs/logger';
+import { Emitter } from '@adonisjs/events';
+import { AppFactory } from '@adonisjs/application/factories';
+import { EncryptionFactory } from '@adonisjs/encryption/factories';
+import { Server } from '../src/server/main.js';
+import { defineConfig } from '../src/define_config.js';
+/**
+ * Server factory is used to generate server class instances for
+ * testing
+ */
+export class ServerFactory {
+    #parameters = {};
+    /**
+     * Returns the emitter instance
+     */
+    #getEmitter() {
+        return this.#parameters.emitter || new Emitter(this.#getApp());
+    }
+    /**
+     * Returns the logger instance
+     */
+    #getLogger() {
+        return this.#parameters.logger || new Logger({ enabled: false });
+    }
+    /**
+     * Returns the config for the server class
+     */
+    #getConfig() {
+        return defineConfig(this.#parameters.config || {});
+    }
+    /**
+     * Returns an instance of the application class
+     */
+    #getApp() {
+        return (this.#parameters.app || new AppFactory().create(new URL('./app/', import.meta.url), () => { }));
+    }
+    /**
+     * Returns an instance of the encryptor to encrypt
+     * signed URLs
+     */
+    #createEncryption() {
+        return this.#parameters.encryption || new EncryptionFactory().create();
+    }
+    /**
+     * Merge factory params
+     */
+    merge(params) {
+        Object.assign(this.#parameters, params);
+        return this;
+    }
+    /**
+     * Create server instance
+     */
+    create() {
+        return new Server(this.#getApp(), this.#createEncryption(), this.#getEmitter(), this.#getLogger(), this.#getConfig());
+    }
+}

package/build/index.d.ts

@@ -1,272 +1,14 @@
-import { H as HttpContext, S as ServerConfig, c as StatusPageRange, d as StatusPageRenderer, e as HttpError } from './main-e5b46c83.js';
-export { B as BriskRoute, f as Redirect, a as Request, b as Response, g as Route, h as RouteGroup, i as RouteResource, R as Router } from './main-e5b46c83.js';
-export { S as Server } from './main-29eaaee4.js';
-import { Exception } from '@poppinss/utils';
-import { Encryption } from '@adonisjs/encryption';
-import Macroable from '@poppinss/macroable';
-import { Level } from '@adonisjs/logger/types';
-import '@adonisjs/fold';
-import '@adonisjs/logger';
-import 'node:url';
-import 'node:http';
-import 'qs';
-import 'http';
-import 'stream';
-import '@poppinss/middleware';
-import '@poppinss/middleware/types';
-import 'node:stream';
-import '@adonisjs/application';
-import '@adonisjs/events';
-import 'node:https';
-
-declare const E_ROUTE_NOT_FOUND: new (args: [method: string, url: string], options?: ErrorOptions | undefined) => Exception;
-declare const E_CANNOT_LOOKUP_ROUTE: new (args: [routeIdentifier: string], options?: ErrorOptions | undefined) => Exception;
-declare const E_HTTP_EXCEPTION: {
-    new (message?: string | undefined, options?: (ErrorOptions & {
-        code?: string | undefined;
-        status?: number | undefined;
-    }) | undefined): {
-        body: any;
-        name: string;
-        help?: string | undefined;
-        code?: string | undefined;
-        status: number;
-        toString(): string;
-        readonly [Symbol.toStringTag]: string;
-        message: string;
-        stack?: string | undefined;
-        cause?: unknown;
-    };
-    code: string;
-    /**
-     * This method returns an instance of the exception class
-     */
-    invoke(body: any, status: number, code?: string): {
-        body: any;
-        name: string;
-        help?: string | undefined;
-        code?: string | undefined;
-        status: number;
-        toString(): string;
-        readonly [Symbol.toStringTag]: string;
-        message: string;
-        stack?: string | undefined;
-        cause?: unknown;
-    };
-    help?: string | undefined;
-    status?: number | undefined;
-    message?: string | undefined;
-    captureStackTrace(targetObject: object, constructorOpt?: Function | undefined): void;
-    prepareStackTrace?: ((err: Error, stackTraces: NodeJS.CallSite[]) => any) | undefined;
-    stackTraceLimit: number;
-};
-declare const E_HTTP_REQUEST_ABORTED: {
-    new (message?: string | undefined, options?: (ErrorOptions & {
-        code?: string | undefined;
-        status?: number | undefined;
-    }) | undefined): {
-        handle(error: any, ctx: HttpContext): void;
-        body: any;
-        name: string;
-        help?: string | undefined;
-        code?: string | undefined;
-        status: number;
-        toString(): string;
-        readonly [Symbol.toStringTag]: string;
-        message: string;
-        stack?: string | undefined;
-        cause?: unknown;
-    };
-    code: string;
-    /**
-     * This method returns an instance of the exception class
-     */
-    invoke(body: any, status: number, code?: string): {
-        body: any;
-        name: string;
-        help?: string | undefined;
-        code?: string | undefined;
-        status: number;
-        toString(): string;
-        readonly [Symbol.toStringTag]: string;
-        message: string;
-        stack?: string | undefined;
-        cause?: unknown;
-    };
-    help?: string | undefined;
-    status?: number | undefined;
-    message?: string | undefined;
-    captureStackTrace(targetObject: object, constructorOpt?: Function | undefined): void;
-    prepareStackTrace?: ((err: Error, stackTraces: NodeJS.CallSite[]) => any) | undefined;
-    stackTraceLimit: number;
-};
-
-declare const exceptions_E_CANNOT_LOOKUP_ROUTE: typeof E_CANNOT_LOOKUP_ROUTE;
-declare const exceptions_E_HTTP_EXCEPTION: typeof E_HTTP_EXCEPTION;
-declare const exceptions_E_HTTP_REQUEST_ABORTED: typeof E_HTTP_REQUEST_ABORTED;
-declare const exceptions_E_ROUTE_NOT_FOUND: typeof E_ROUTE_NOT_FOUND;
-declare namespace exceptions {
-  export {
-    exceptions_E_CANNOT_LOOKUP_ROUTE as E_CANNOT_LOOKUP_ROUTE,
-    exceptions_E_HTTP_EXCEPTION as E_HTTP_EXCEPTION,
-    exceptions_E_HTTP_REQUEST_ABORTED as E_HTTP_REQUEST_ABORTED,
-    exceptions_E_ROUTE_NOT_FOUND as E_ROUTE_NOT_FOUND,
-  };
-}
-
-type UserDefinedServerConfig = Partial<Omit<ServerConfig, 'trustProxy'> & {
-    trustProxy: ((address: string, distance: number) => boolean) | boolean | string;
-}>;
-/**
- * Define configuration for the HTTP server
- */
-declare function defineConfig(config: UserDefinedServerConfig): ServerConfig;
-
-/**
- * Cookie client exposes the API to parse/set AdonisJS cookies
- * as a client.
- */
-declare class CookieClient {
-    #private;
-    constructor(encryption: Encryption);
-    /**
-     * Encrypt a key value pair to be sent in the cookie header
-     */
-    encrypt(key: string, value: any): string | null;
-    /**
-     * Sign a key value pair to be sent in the cookie header
-     */
-    sign(key: string, value: any): string | null;
-    /**
-     * Encode a key value pair to be sent in the cookie header
-     */
-    encode(_: string, value: any): string | null;
-    /**
-     * Unsign a signed cookie value
-     */
-    unsign(key: string, value: string): any;
-    /**
-     * Decrypt an encrypted cookie value
-     */
-    decrypt(key: string, value: string): any;
-    /**
-     * Decode an encoded cookie value
-     */
-    decode(_: string, value: string): any;
-    /**
-     * Parse response cookie
-     */
-    parse(key: string, value: any): any;
-}
-
-/**
- * The base HTTP exception handler one can inherit from to handle
- * HTTP exceptions.
- *
- * The HTTP exception handler has support for
- *
- * - Ability to render exceptions by calling the render method on the exception.
- * - Rendering status pages
- * - Pretty printing errors during development
- * - Transforming errors to JSON or HTML using content negotiation
- * - Reporting errors
- */
-declare class ExceptionHandler extends Macroable {
-    #private;
-    /**
-     * Whether or not to render debug info. When set to true, the errors
-     * will have the complete error stack.
-     */
-    protected debug: boolean;
-    /**
-     * Whether or not to render status pages. When set to true, the unhandled
-     * errors with matching status codes will be rendered using a status
-     * page.
-     */
-    protected renderStatusPages: boolean;
-    /**
-     * A collection of error status code range and the view to render.
-     */
-    protected statusPages: Record<StatusPageRange, StatusPageRenderer>;
-    /**
-     * Enable/disable errors reporting
-     */
-    protected reportErrors: boolean;
-    /**
-     * An array of exception classes to ignore when
-     * reporting an error
-     */
-    protected ignoreExceptions: any[];
-    /**
-     * An array of HTTP status codes to ignore when reporting
-     * an error
-     */
-    protected ignoreStatuses: number[];
-    /**
-     * An array of error codes to ignore when reporting
-     * an error
-     */
-    protected ignoreCodes: string[];
-    /**
-     * Error reporting context
-     */
-    protected context(ctx: HttpContext): any;
-    /**
-     * Returns the log level for an error based upon the error
-     * status code.
-     */
-    protected getErrorLogLevel(error: HttpError): Level;
-    /**
-     * A boolean to control if errors should be rendered with
-     * all the available debugging info.
-     */
-    protected isDebuggingEnabled(_: HttpContext): boolean;
-    /**
-     * Returns a boolean by checking if an error should be reported.
-     */
-    protected shouldReport(error: HttpError): boolean;
-    /**
-     * Renders an error to JSON response
-     */
-    renderErrorAsJSON(error: HttpError, ctx: HttpContext): Promise<void>;
-    /**
-     * Renders an error to JSON API response
-     */
-    renderErrorAsJSONAPI(error: HttpError, ctx: HttpContext): Promise<void>;
-    /**
-     * Renders an error to HTML response
-     */
-    renderErrorAsHTML(error: HttpError, ctx: HttpContext): Promise<void>;
-    /**
-     * Renders the validation error message to a JSON
-     * response
-     */
-    renderValidationErrorAsJSON(error: HttpError, ctx: HttpContext): Promise<void>;
-    /**
-     * Renders the validation error message as per JSON API
-     * spec
-     */
-    renderValidationErrorAsJSONAPI(error: HttpError, ctx: HttpContext): Promise<void>;
-    /**
-     * Renders the validation error as an HTML string
-     */
-    renderValidationErrorAsHTML(error: HttpError, ctx: HttpContext): Promise<void>;
-    /**
-     * Renders the error to response
-     */
-    renderError(error: HttpError, ctx: HttpContext): Promise<void>;
-    /**
-     * Renders the validation error to response
-     */
-    renderValidationError(error: HttpError, ctx: HttpContext): Promise<void>;
-    /**
-     * Reports an error during an HTTP request
-     */
-    report(error: unknown, ctx: HttpContext): Promise<void>;
-    /**
-     * Handles the error during the HTTP request.
-     */
-    handle(error: unknown, ctx: HttpContext): Promise<any>;
-}
-
-export { CookieClient, ExceptionHandler, HttpContext, defineConfig, exceptions as errors };
+export { Request } from './src/request.js';
+export { Response } from './src/response.js';
+export { Redirect } from './src/redirect.js';
+export { Server } from './src/server/main.js';
+export { Router } from './src/router/main.js';
+export { Route } from './src/router/route.js';
+export * as errors from './src/exceptions.js';
+export { BriskRoute } from './src/router/brisk.js';
+export { RouteGroup } from './src/router/group.js';
+export { defineConfig } from './src/define_config.js';
+export { CookieClient } from './src/cookies/client.js';
+export { HttpContext } from './src/http_context/main.js';
+export { RouteResource } from './src/router/resource.js';
+export { ExceptionHandler } from './src/exception_handler.js';