@adonisjs/http-server 7.7.0 → 8.0.0-next.0

package/build/factories/main.js

@@ -6,16 +6,11 @@ import {
   Router,
   Server,
   defineConfig
-} from "../chunk-6FSCILWX.js";
+} from "../chunk-VYBTM3NC.js";
+import "../chunk-ASX56VAK.js";
 
-// factories/http_context.ts
-import { Container } from "@adonisjs/fold";
-import { LoggerFactory } from "@adonisjs/logger/factories";
-
-// factories/request.ts
-import { Socket } from "net";
-import proxyAddr from "proxy-addr";
-import { IncomingMessage, ServerResponse } from "http";
+// factories/router.ts
+import { AppFactory } from "@adonisjs/application/factories";
 import { EncryptionFactory } from "@adonisjs/encryption/factories";
 
 // factories/qs_parser_factory.ts
@@ -51,7 +46,43 @@ var QsParserFactory = class {
   }
 };
 
+// factories/router.ts
+var RouterFactory = class {
+  #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());
+  }
+};
+
 // factories/request.ts
+import { Socket } from "net";
+import proxyAddr from "proxy-addr";
+import { randomUUID } from "crypto";
+import { IncomingMessage, ServerResponse } from "http";
+import { EncryptionFactory as EncryptionFactory2 } from "@adonisjs/encryption/factories";
 var RequestFactory = class {
   #parameters = {};
   /**
@@ -63,6 +94,9 @@ var RequestFactory = class {
       trustProxy: proxyAddr.compile("loopback"),
       subdomainOffset: 2,
       generateRequestId: false,
+      createRequestId() {
+        return randomUUID();
+      },
       ...this.#parameters.config
     };
   }
@@ -90,7 +124,7 @@ var RequestFactory = class {
    * signed URLs
    */
   #createEncryption() {
-    return this.#parameters.encryption || new EncryptionFactory().create();
+    return this.#parameters.encryption || new EncryptionFactory2().create();
   }
   /**
    * Merge factory params
@@ -118,41 +152,6 @@ var RequestFactory = class {
 import { Socket as Socket2 } from "net";
 import { IncomingMessage as IncomingMessage2, ServerResponse as ServerResponse2 } from "http";
 import { EncryptionFactory as EncryptionFactory3 } from "@adonisjs/encryption/factories";
-
-// factories/router.ts
-import { AppFactory } from "@adonisjs/application/factories";
-import { EncryptionFactory as EncryptionFactory2 } from "@adonisjs/encryption/factories";
-var RouterFactory = class {
-  #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 EncryptionFactory2().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());
-  }
-};
-
-// factories/response.ts
 var ResponseFactory = class {
   #parameters = {};
   /**
@@ -220,47 +219,6 @@ var ResponseFactory = class {
   }
 };
 
-// factories/http_context.ts
-var HttpContextFactory = class {
-  #parameters = {};
-  /**
-   * Returns the request class instance
-   */
-  #createRequest() {
-    return this.#parameters.request || new RequestFactory().create();
-  }
-  /**
-   * Returns the response class instance
-   */
-  #createResponse() {
-    return this.#parameters.response || new ResponseFactory().create();
-  }
-  /**
-   * Returns an instance of the logger class
-   */
-  #createLogger() {
-    return this.#parameters.logger || new LoggerFactory().create();
-  }
-  /**
-   * Merge factory params
-   */
-  merge(params) {
-    Object.assign(this.#parameters, params);
-    return this;
-  }
-  /**
-   * Create request
-   */
-  create() {
-    return new HttpContext(
-      this.#createRequest(),
-      this.#createResponse(),
-      this.#createLogger(),
-      new Container().createResolver()
-    );
-  }
-};
-
 // factories/server_factory.ts
 import { Logger } from "@adonisjs/logger";
 import { Emitter } from "@adonisjs/events";
@@ -319,6 +277,49 @@ var ServerFactory = class {
     );
   }
 };
+
+// factories/http_context.ts
+import { Container } from "@adonisjs/fold";
+import { LoggerFactory } from "@adonisjs/logger/factories";
+var HttpContextFactory = class {
+  #parameters = {};
+  /**
+   * Returns the request class instance
+   */
+  #createRequest() {
+    return this.#parameters.request || new RequestFactory().create();
+  }
+  /**
+   * Returns the response class instance
+   */
+  #createResponse() {
+    return this.#parameters.response || new ResponseFactory().create();
+  }
+  /**
+   * Returns an instance of the logger class
+   */
+  #createLogger() {
+    return this.#parameters.logger || new LoggerFactory().create();
+  }
+  /**
+   * Merge factory params
+   */
+  merge(params) {
+    Object.assign(this.#parameters, params);
+    return this;
+  }
+  /**
+   * Create request
+   */
+  create() {
+    return new HttpContext(
+      this.#createRequest(),
+      this.#createResponse(),
+      this.#createLogger(),
+      new Container().createResolver()
+    );
+  }
+};
 export {
   HttpContextFactory,
   QsParserFactory,
@@ -327,4 +328,3 @@ export {
   RouterFactory,
   ServerFactory
 };
-//# sourceMappingURL=main.js.map

package/build/factories/request.d.ts

@@ -1,7 +1,7 @@
 import type { Encryption } from '@adonisjs/encryption';
 import { IncomingMessage, ServerResponse } from 'node:http';
 import { Request } from '../src/request.js';
-import { RequestConfig } from '../src/types/request.js';
+import { type RequestConfig } from '../src/types/request.js';
 type FactoryParameters = {
     url: string;
     method: string;

package/build/factories/response.d.ts

@@ -1,8 +1,8 @@
 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';
+import { type Router } from '../src/router/main.js';
+import { type ResponseConfig } from '../src/types/response.js';
 type FactoryParameters = {
     req: IncomingMessage;
     res: ServerResponse;

package/build/factories/url_builder_factory.d.ts

@@ -0,0 +1,25 @@
+import type { Encryption } from '@adonisjs/encryption';
+import type { Router } from '../src/router/main.ts';
+import { type LookupList } from '../src/client/types.ts';
+type FactoryParameters = {
+    router: Router;
+    encryption: Encryption;
+};
+/**
+ * URLBuilderFactory is used to create route and signed route helpers
+ */
+export declare class URLBuilderFactory<Routes extends LookupList> {
+    #private;
+    /**
+     * Merge factory params
+     */
+    merge(params: Partial<FactoryParameters>): this;
+    /**
+     * Create URL builder helpers
+     */
+    create(): {
+        urlFor: import("../src/client/types.ts").UrlFor<Routes>;
+        signedUrlFor: import("../src/client/types.ts").UrlFor<Routes, import("../src/client/types.ts").SignedURLOptions>;
+    };
+}
+export {};

package/build/index.d.ts

@@ -1,15 +1,16 @@
+export * as errors from './src/errors.js';
 export { Request } from './src/request.js';
 export { Response } from './src/response.js';
-export { ResponseStatus } from './src/response_status.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 { ResponseStatus } from './src/response_status.js';
 export { ExceptionHandler } from './src/exception_handler.js';
+export * as tracingChannels from './src/tracing_channels.js';

package/build/index.js

@@ -15,10 +15,13 @@ import {
   RouteResource,
   Router,
   Server,
+  canWriteResponseBody,
   defineConfig,
-  exceptions_exports,
-  parseRange
-} from "./chunk-6FSCILWX.js";
+  errors_exports,
+  parseRange,
+  tracing_channels_exports
+} from "./chunk-VYBTM3NC.js";
+import "./chunk-ASX56VAK.js";
 
 // src/exception_handler.ts
 import is from "@sindresorhus/is";
@@ -149,9 +152,9 @@ var ExceptionHandler = class extends Macroable {
    */
   async renderErrorAsJSON(error, ctx) {
     if (this.isDebuggingEnabled(ctx)) {
-      const { default: Youch } = await import("youch");
-      const json = await new Youch(error, ctx.request.request).toJSON();
-      ctx.response.status(error.status).send(json.error);
+      const { Youch } = await import("youch");
+      const json = await new Youch().toJSON(error);
+      ctx.response.status(error.status).send(json);
       return;
     }
     ctx.response.status(error.status).send({ message: error.message });
@@ -161,9 +164,9 @@ var ExceptionHandler = class extends Macroable {
    */
   async renderErrorAsJSONAPI(error, ctx) {
     if (this.isDebuggingEnabled(ctx)) {
-      const { default: Youch } = await import("youch");
-      const json = await new Youch(error, ctx.request.request).toJSON();
-      ctx.response.status(error.status).send(json.error);
+      const { Youch } = await import("youch");
+      const json = await new Youch().toJSON(error);
+      ctx.response.status(error.status).send(json);
       return;
     }
     ctx.response.status(error.status).send({
@@ -180,9 +183,18 @@ var ExceptionHandler = class extends Macroable {
    * Renders an error to HTML response
    */
   async renderErrorAsHTML(error, ctx) {
+    const statusPages = this.#expandStatusPages();
+    if (this.renderStatusPages && statusPages[error.status]) {
+      const statusPageResponse = await statusPages[error.status](error, ctx);
+      if (canWriteResponseBody(statusPageResponse, ctx)) {
+        return ctx.response.safeStatus(error.status).send(statusPageResponse);
+      }
+      return statusPageResponse;
+    }
     if (this.isDebuggingEnabled(ctx)) {
-      const { default: Youch } = await import("youch");
-      const html = await new Youch(error, ctx.request.request).toHTML({
+      const { Youch } = await import("youch");
+      const html = await new Youch().toHTML(error, {
+        request: ctx.request.request,
         cspNonce: "nonce" in ctx.response ? ctx.response.nonce : void 0
       });
       ctx.response.status(error.status).send(html);
@@ -288,16 +300,6 @@ var ExceptionHandler = class extends Macroable {
     if (httpError.code === "E_VALIDATION_ERROR" && "messages" in httpError) {
       return this.renderValidationError(httpError, ctx);
     }
-    const statusPages = this.#expandStatusPages();
-    if (this.renderStatusPages && statusPages[httpError.status]) {
-      const statusPageResponse = await statusPages[httpError.status](httpError, ctx);
-      if (statusPageResponse !== void 0 && // Return value is explicitly defined
-      !ctx.response.hasLazyBody && // Lazy body is not set
-      statusPageResponse !== ctx.response) {
-        return ctx.response.safeStatus(httpError.status).send(statusPageResponse);
-      }
-      return statusPageResponse;
-    }
     return this.renderError(httpError, ctx);
   }
 };
@@ -316,6 +318,6 @@ export {
   Router,
   Server,
   defineConfig,
-  exceptions_exports as errors
+  errors_exports as errors,
+  tracing_channels_exports as tracingChannels
 };
-//# sourceMappingURL=index.js.map

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

@@ -0,0 +1,3 @@
+export * from './types.ts';
+export { RouterClient } from './router.ts';
+export { createUrlBuilder } from './url_builder.ts';

package/build/src/client/router.d.ts

@@ -0,0 +1,68 @@
+import { type ClientRouteJSON } from './types.ts';
+/**
+ * The router client contains the shared logic for finding routes
+ * used by the server and the client.
+ */
+export declare class RouterClient<T extends ClientRouteJSON> {
+    /**
+     * List of route references kept for lookup.
+     */
+    protected routes: {
+        [domain: string]: T[];
+    };
+    /**
+     * The lookup strategies to follow when generating URL builder
+     * types and client
+     */
+    lookupStrategies: ('name' | 'pattern' | 'controller')[];
+    constructor(routes?: {
+        [domain: string]: T[];
+    });
+    /**
+     * Register route JSON payload
+     */
+    protected register(route: T): void;
+    /**
+     * Define the lookup strategies to follow when generating URL builder
+     * types and client.
+     */
+    updateLookupStrategies(strategies: ('name' | 'pattern' | 'controller')[]): this;
+    /**
+     * Finds a route by its identifier. The identifier can be the
+     * route name, controller.method name or the route pattern
+     * itself.
+     *
+     * When "followLookupStrategy" is enabled, the lookup will be performed
+     * on the basis of the lookup strategy enabled via the "lookupStrategies"
+     * method. The default lookupStrategy is "name" and "pattern".
+     */
+    find(routeIdentifier: string, domain?: string, method?: string, followLookupStrategy?: boolean): T | null;
+    /**
+     * Finds a route by its identifier. The identifier can be the
+     * route name, controller.method name or the route pattern
+     * itself.
+     *
+     * An error is raised when unable to find the route.
+     *
+     * When "followLookupStrategy" is enabled, the lookup will be performed
+     * on the basis of the lookup strategy enabled via the "lookupStrategies"
+     * method. The default lookupStrategy is "name" and "pattern".
+     */
+    findOrFail(routeIdentifier: string, domain?: string, method?: string, followLookupStrategy?: boolean): T;
+    /**
+     * Check if a route exists. The identifier can be the
+     * route name, controller.method name or the route pattern
+     * itself.
+     *
+     * When "followLookupStrategy" is enabled, the lookup will be performed
+     * on the basis of the lookup strategy enabled via the "lookupStrategies"
+     * method. The default lookupStrategy is "name" and "pattern".
+     */
+    has(routeIdentifier: string, domain?: string, method?: string, followLookupStrategy?: boolean): boolean;
+    /**
+     * Returns a list of routes grouped by their domain names
+     */
+    toJSON(): {
+        [domain: string]: T[];
+    };
+}

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

@@ -0,0 +1,181 @@
+/**
+ * Types shared with the client. These should never import other types
+ */
+import { type Prettify } from '@poppinss/utils/types';
+/**
+ * Options accepted by "url" and "route" helper methods
+ */
+export type URLOptions = {
+    qs?: Record<string, any>;
+    prefixUrl?: string;
+};
+/**
+ * Options accepted by "signedUrl" and "signedRoute" helper methods
+ */
+export type SignedURLOptions = URLOptions & {
+    expiresIn?: string | number;
+    purpose?: string;
+};
+/**
+ * Returns params for a route identifier
+ */
+export type RouteBuilderArguments<Routes, Method extends keyof Routes, Identifier extends keyof Routes[Method], Options extends any = URLOptions> = Routes extends LookupList ? Prettify<undefined extends Routes[Method][Identifier]['params'] ? [identifier: Identifier, params?: undefined, options?: Options] : [undefined] extends [Routes[Method][Identifier]['params']] ? [
+    identifier: Identifier,
+    params?: Routes[Method][Identifier]['params'] | Routes[Method][Identifier]['paramsTuple'],
+    options?: Options
+] : [
+    identifier: Identifier,
+    params: Routes[Method][Identifier]['params'] | Routes[Method][Identifier]['paramsTuple'],
+    options?: Options
+]> : never;
+/**
+ * Shape of a route param matcher
+ */
+export type RouteMatcher = {
+    match?: RegExp;
+    cast?: (value: string) => any;
+};
+/**
+ * Route token stored by matchit library
+ */
+export type MatchItRouteToken = RouteMatcher & {
+    old: string;
+    type: 0 | 1 | 2 | 3;
+    val: string;
+    end: string;
+};
+/**
+ * Representation of route shared with the client
+ */
+export type ClientRouteJSON = {
+    /**
+     * A unique name for the route
+     */
+    name?: string;
+    /**
+     * Route URI pattern
+     */
+    pattern: string;
+    /**
+     * HTTP methods, the route responds to.
+     */
+    methods: string[];
+    /**
+     * Route domain
+     */
+    domain: string;
+    /**
+     * Reference to the route handler
+     */
+    handler: {
+        reference?: any;
+    } | Function;
+    /**
+     * Tokens to be used to construct the route URL
+     */
+    tokens: MatchItRouteToken[];
+};
+/**
+ * LookupList type is used by the URLBuilder to provide
+ * type-safety when creating URLs.
+ *
+ * There is no runtime property that matches this type. Its
+ * purely for type-inference.
+ */
+export type LookupList = {
+    [method: string]: {
+        [identifier: string]: {
+            paramsTuple?: [...any[]];
+            params?: {
+                [name: string]: any;
+            };
+        };
+    };
+};
+/**
+ * The urlFor helper is used to make URLs for pre-existing known routes. You can
+ * make a URL using the route name, route pattern, or the route controller
+ * reference (depends upon enabled lookupStrategies)
+ *
+ * ```ts
+ * urlFor('users.show', [1]) // /users/1
+ *
+ * // Lookup inside a specific domain
+ * urlFor('blog.adonisjs.com@posts.show', [1]) // /posts/1
+ * ```
+ */
+export type UrlFor<Routes extends LookupList, Options extends any = URLOptions> = (<Identifier extends keyof Routes['ALL'] & string>(...[identifier, params, options]: RouteBuilderArguments<Routes, 'ALL', Identifier, Options>) => string) & {
+    /**
+     * Make URL for a GET route. An error will be raised if the route doesn't
+     * exist.
+     *
+     * ```ts
+     * urlFor.get('users.show', [1]) // { method: 'get', url: '/users/1' }
+     * urlFor.get('users.store', [1]) // Error: Route not found GET@users/store
+     * ```
+     */
+    get<RouteIdentifier extends keyof Routes['GET'] & string>(...[identifier, params, options]: RouteBuilderArguments<Routes, 'GET', RouteIdentifier, Options>): {
+        method: 'get';
+        url: string;
+    };
+    /**
+     * Make URL for a POST route. An error will be raised if the route doesn't
+     * exist.
+     *
+     * ```ts
+     * urlFor.post('users.store') // { method: 'post', url: '/users' }
+     * urlFor.post('users.show', [1]) // Error: Route not found POST@users.show
+     * ```
+     */
+    post<RouteIdentifier extends keyof Routes['POST'] & string>(...[identifier, params, options]: RouteBuilderArguments<Routes, 'POST', RouteIdentifier, Options>): {
+        method: 'post';
+        url: string;
+    };
+    /**
+     * Make URL for a PUT route. An error will be raised if the route doesn't
+     * exist.
+     *
+     * ```ts
+     * urlFor.put('users.update', [1]) // { method: 'put', url: '/users/1' }
+     * urlFor.put('users.show', [1]) // Error: Route not found PUT@users.show
+     * ```
+     */
+    put<RouteIdentifier extends keyof Routes['PUT'] & string>(...[identifier, params, options]: RouteBuilderArguments<Routes, 'PUT', RouteIdentifier, Options>): {
+        method: 'put';
+        url: string;
+    };
+    /**
+     * Make URL for a PATCH route. An error will be raised if the route doesn't
+     * exist.
+     *
+     * ```ts
+     * urlFor.put('users.update', [1]) // { method: 'patch', url: '/users/1' }
+     * urlFor.put('users.show', [1]) // Error: Route not found PATCH@users.show
+     * ```
+     */
+    patch<RouteIdentifier extends keyof Routes['PATCH'] & string>(...[identifier, params, options]: RouteBuilderArguments<Routes, 'PATCH', RouteIdentifier, Options>): {
+        method: 'patch';
+        url: string;
+    };
+    /**
+     * Make URL for a DELETE route. An error will be raised if the route doesn't
+     * exist.
+     *
+     * ```ts
+     * urlFor.delete('users.destroy', [1]) // { method: 'delete', url: '/users/1' }
+     * urlFor.delete('users.show', [1]) // Error: Route not found DELETE@users.show
+     * ```
+     */
+    delete<RouteIdentifier extends keyof Routes['DELETE'] & string>(...[identifier, params, options]: RouteBuilderArguments<Routes, 'DELETE', RouteIdentifier, Options>): {
+        method: 'delete';
+        url: string;
+    };
+    /**
+     * Make URL for a custom route method. An error will be raised if the route doesn't
+     * exist for the same method.
+     */
+    method<Method extends keyof Routes & string, RouteIdentifier extends keyof Routes[Method] & string>(method: Method, ...[identifier, params, options]: RouteBuilderArguments<Routes, Method, RouteIdentifier, Options>): {
+        method: Method;
+        url: string;
+    };
+};

package/build/src/client/url_builder.d.ts

@@ -0,0 +1,13 @@
+import { type RouterClient } from './router.ts';
+import { type UrlFor, type LookupList, type URLOptions, type ClientRouteJSON, type MatchItRouteToken } from './types.ts';
+/**
+ * Makes URL for a given route pattern. The route pattern could be an
+ * identifier or an array of tokens.
+ */
+export declare function createURL(identifier: string, tokens: Pick<MatchItRouteToken, 'val' | 'type' | 'end'>[], searchParamsStringifier: (qs: Record<string, any>) => string, params?: any[] | {
+    [param: string]: any;
+}, options?: URLOptions): string;
+/**
+ * Creates the URLBuilder helper
+ */
+export declare function createUrlBuilder<Routes extends LookupList>(router: RouterClient<ClientRouteJSON>, searchParamsStringifier: (qs: Record<string, any>) => string): UrlFor<Routes>;

package/build/src/cookies/client.d.ts

@@ -17,7 +17,7 @@ export declare class CookieClient {
     /**
      * Encode a key value pair to be sent in the cookie header
      */
-    encode(_: string, value: any): string | null;
+    encode(_: string, value: any, stringify?: boolean): string | null;
     /**
      * Unsign a signed cookie value
      */
@@ -29,7 +29,7 @@ export declare class CookieClient {
     /**
      * Decode an encoded cookie value
      */
-    decode(_: string, value: string): any;
+    decode(_: string, value: string, stringified?: boolean): any;
     /**
      * Parse response cookie
      */

package/build/src/cookies/parser.d.ts

@@ -14,10 +14,10 @@ export declare class CookieParser {
     constructor(cookieHeader: string, encryption: Encryption);
     /**
      * Attempts to decode a cookie by the name. When calling this method,
-     * you are assuming that the cookie was just encoded in the first
+     * you are assuming that the cookie was just stringified in the first
      * place and not signed or encrypted.
      */
-    decode(key: string, encoded?: boolean): any | null;
+    decode(key: string, stringified?: boolean): any | null;
     /**
      * Attempts to unsign a cookie by the name. When calling this method,
      * you are assuming that the cookie was signed in the first place.