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

package/build/index.js

@@ -1,308 +1,22 @@
-import {
-  BriskRoute,
-  CookieClient,
-  E_CANNOT_LOOKUP_ROUTE,
-  E_HTTP_EXCEPTION,
-  E_HTTP_REQUEST_ABORTED,
-  E_ROUTE_NOT_FOUND,
-  HttpContext,
-  Redirect,
-  Request,
-  Response,
-  Route,
-  RouteGroup,
-  RouteResource,
-  Router,
-  Server,
-  defineConfig,
-  exceptions_exports,
-  parseRange
-} from "./chunk-XX72ATFY.js";
-
-// src/exception_handler.ts
-import is from "@sindresorhus/is";
-import Macroable from "@poppinss/macroable";
-var ExceptionHandler = class extends Macroable {
-  /**
-   * Computed from the status pages property
-   */
-  #expandedStatusPages;
-  /**
-   * Whether or not to render debug info. When set to true, the errors
-   * will have the complete error stack.
-   */
-  debug = process.env.NODE_ENV !== "production";
-  /**
-   * 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.
-   */
-  renderStatusPages = process.env.NODE_ENV === "production";
-  /**
-   * A collection of error status code range and the view to render.
-   */
-  statusPages = {};
-  /**
-   * Enable/disable errors reporting
-   */
-  reportErrors = true;
-  /**
-   * An array of exception classes to ignore when
-   * reporting an error
-   */
-  ignoreExceptions = [
-    E_HTTP_EXCEPTION,
-    E_ROUTE_NOT_FOUND,
-    E_CANNOT_LOOKUP_ROUTE,
-    E_HTTP_REQUEST_ABORTED
-  ];
-  /**
-   * An array of HTTP status codes to ignore when reporting
-   * an error
-   */
-  ignoreStatuses = [400, 422, 401];
-  /**
-   * An array of error codes to ignore when reporting
-   * an error
-   */
-  ignoreCodes = [];
-  /**
-   * Expands status pages
-   */
-  #expandStatusPages() {
-    if (!this.#expandedStatusPages) {
-      this.#expandedStatusPages = Object.keys(this.statusPages).reduce(
-        (result, range) => {
-          const renderer = this.statusPages[range];
-          result = Object.assign(result, parseRange(range, renderer));
-          return result;
-        },
-        {}
-      );
-    }
-    return this.#expandedStatusPages;
-  }
-  /**
-   * Forcefully tweaking the type of the error object to
-   * have known properties.
-   */
-  #toHttpError(error) {
-    const httpError = is.object(error) ? error : new Error(String(error));
-    httpError.message = httpError.message || "Internal server error";
-    httpError.status = httpError.status || 500;
-    return httpError;
-  }
-  /**
-   * Error reporting context
-   */
-  context(ctx) {
-    const requestId = ctx.request.id();
-    return requestId ? {
-      "x-request-id": requestId
-    } : {};
-  }
-  /**
-   * Returns the log level for an error based upon the error
-   * status code.
-   */
-  getErrorLogLevel(error) {
-    if (error.status >= 500) {
-      return "error";
-    }
-    if (error.status >= 400) {
-      return "warn";
-    }
-    return "info";
-  }
-  /**
-   * A boolean to control if errors should be rendered with
-   * all the available debugging info.
-   */
-  isDebuggingEnabled(_) {
-    return this.debug;
-  }
-  /**
-   * Returns a boolean by checking if an error should be reported.
-   */
-  shouldReport(error) {
-    if (this.reportErrors === false) {
-      return false;
-    }
-    if (this.ignoreStatuses.includes(error.status)) {
-      return false;
-    }
-    if (error.code && this.ignoreCodes.includes(error.code)) {
-      return false;
-    }
-    if (this.ignoreExceptions.find((exception) => error instanceof exception)) {
-      return false;
-    }
-    return true;
-  }
-  /**
-   * Renders an error to JSON response
-   */
-  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);
-      return;
-    }
-    ctx.response.status(error.status).send({ message: error.message });
-  }
-  /**
-   * Renders an error to JSON API response
-   */
-  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);
-      return;
-    }
-    ctx.response.status(error.status).send({
-      errors: [
-        {
-          title: error.message,
-          code: error.code,
-          status: error.status
-        }
-      ]
-    });
-  }
-  /**
-   * Renders an error to HTML response
-   */
-  async renderErrorAsHTML(error, ctx) {
-    if (this.isDebuggingEnabled(ctx)) {
-      const { default: Youch } = await import("youch");
-      const html = await new Youch(error, ctx.request.request).toHTML({
-        cspNonce: "nonce" in ctx.response ? ctx.response.nonce : void 0
-      });
-      ctx.response.status(error.status).send(html);
-      return;
-    }
-    ctx.response.status(error.status).send(`<p> ${error.message} </p>`);
-  }
-  /**
-   * Renders the validation error message to a JSON
-   * response
-   */
-  async renderValidationErrorAsJSON(error, ctx) {
-    ctx.response.status(error.status).send({
-      errors: error.messages
-    });
-  }
-  /**
-   * Renders the validation error message as per JSON API
-   * spec
-   */
-  async renderValidationErrorAsJSONAPI(error, ctx) {
-    ctx.response.status(error.status).send({
-      errors: error.messages.map((message) => {
-        return {
-          title: message.message,
-          code: message.rule,
-          source: {
-            pointer: message.field
-          },
-          meta: message.meta
-        };
-      })
-    });
-  }
-  /**
-   * Renders the validation error as an HTML string
-   */
-  async renderValidationErrorAsHTML(error, ctx) {
-    ctx.response.status(error.status).type("html").send(
-      error.messages.map((message) => {
-        return `${message.field} - ${message.message}`;
-      }).join("<br />")
-    );
-  }
-  /**
-   * Renders the error to response
-   */
-  renderError(error, ctx) {
-    switch (ctx.request.accepts(["html", "application/vnd.api+json", "json"])) {
-      case "application/vnd.api+json":
-        return this.renderErrorAsJSONAPI(error, ctx);
-      case "json":
-        return this.renderErrorAsJSON(error, ctx);
-      case "html":
-      default:
-        return this.renderErrorAsHTML(error, ctx);
-    }
-  }
-  /**
-   * Renders the validation error to response
-   */
-  renderValidationError(error, ctx) {
-    switch (ctx.request.accepts(["html", "application/vnd.api+json", "json"])) {
-      case "application/vnd.api+json":
-        return this.renderValidationErrorAsJSONAPI(error, ctx);
-      case "json":
-        return this.renderValidationErrorAsJSON(error, ctx);
-      case "html":
-      default:
-        return this.renderValidationErrorAsHTML(error, ctx);
-    }
-  }
-  /**
-   * Reports an error during an HTTP request
-   */
-  async report(error, ctx) {
-    const httpError = this.#toHttpError(error);
-    if (!this.shouldReport(httpError)) {
-      return;
-    }
-    if (typeof httpError.report === "function") {
-      httpError.report(httpError, ctx);
-      return;
-    }
-    const level = this.getErrorLogLevel(httpError);
-    ctx.logger.log(
-      level,
-      {
-        ...level === "error" || level === "fatal" ? { err: httpError } : {},
-        ...this.context(ctx)
-      },
-      httpError.message
-    );
-  }
-  /**
-   * Handles the error during the HTTP request.
-   */
-  async handle(error, ctx) {
-    const httpError = this.#toHttpError(error);
-    if (typeof httpError.handle === "function") {
-      return httpError.handle(httpError, ctx);
-    }
-    if (httpError.code === "E_VALIDATION_ERROR" && "messages" in httpError) {
-      return this.renderValidationError(httpError, ctx);
-    }
-    const statusPages = this.#expandStatusPages();
-    if (this.renderStatusPages && statusPages[httpError.status]) {
-      return statusPages[httpError.status](httpError, ctx);
-    }
-    return this.renderError(httpError, ctx);
-  }
-};
-export {
-  BriskRoute,
-  CookieClient,
-  ExceptionHandler,
-  HttpContext,
-  Redirect,
-  Request,
-  Response,
-  Route,
-  RouteGroup,
-  RouteResource,
-  Router,
-  Server,
-  defineConfig,
-  exceptions_exports as errors
-};
+/*
+ * @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 { 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';

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

@@ -0,0 +1,37 @@
+import type { Encryption } from '@adonisjs/encryption';
+/**
+ * Cookie client exposes the API to parse/set AdonisJS cookies
+ * as a client.
+ */
+export 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;
+}

package/build/src/cookies/client.js

@@ -0,0 +1,84 @@
+/*
+ * @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 * as plainCookiesDriver from './drivers/plain.js';
+import * as signedCookiesDriver from './drivers/signed.js';
+import * as encryptedCookiesDriver from './drivers/encrypted.js';
+/**
+ * Cookie client exposes the API to parse/set AdonisJS cookies
+ * as a client.
+ */
+export class CookieClient {
+    #encryption;
+    constructor(encryption) {
+        this.#encryption = encryption;
+    }
+    /**
+     * Encrypt a key value pair to be sent in the cookie header
+     */
+    encrypt(key, value) {
+        return encryptedCookiesDriver.pack(key, value, this.#encryption);
+    }
+    /**
+     * Sign a key value pair to be sent in the cookie header
+     */
+    sign(key, value) {
+        return signedCookiesDriver.pack(key, value, this.#encryption);
+    }
+    /**
+     * Encode a key value pair to be sent in the cookie header
+     */
+    encode(_, value) {
+        return plainCookiesDriver.pack(value);
+    }
+    /**
+     * Unsign a signed cookie value
+     */
+    unsign(key, value) {
+        return signedCookiesDriver.canUnpack(value)
+            ? signedCookiesDriver.unpack(key, value, this.#encryption)
+            : null;
+    }
+    /**
+     * Decrypt an encrypted cookie value
+     */
+    decrypt(key, value) {
+        return encryptedCookiesDriver.canUnpack(value)
+            ? encryptedCookiesDriver.unpack(key, value, this.#encryption)
+            : null;
+    }
+    /**
+     * Decode an encoded cookie value
+     */
+    decode(_, value) {
+        return plainCookiesDriver.canUnpack(value) ? plainCookiesDriver.unpack(value) : null;
+    }
+    /**
+     * Parse response cookie
+     */
+    parse(key, value) {
+        /**
+         * Unsign signed cookie
+         */
+        if (signedCookiesDriver.canUnpack(value)) {
+            return signedCookiesDriver.unpack(key, value, this.#encryption);
+        }
+        /**
+         * Decrypted encrypted cookie
+         */
+        if (encryptedCookiesDriver.canUnpack(value)) {
+            return encryptedCookiesDriver.unpack(key, value, this.#encryption);
+        }
+        /**
+         * Decode encoded cookie
+         */
+        if (plainCookiesDriver.canUnpack(value)) {
+            return plainCookiesDriver.unpack(value);
+        }
+    }
+}

package/build/src/cookies/drivers/encrypted.d.ts

@@ -0,0 +1,16 @@
+import type { Encryption } from '@adonisjs/encryption';
+/**
+ * Encrypt a value to be set as cookie
+ */
+export declare function pack(key: string, value: any, encryption: Encryption): null | string;
+/**
+ * Returns a boolean, if the unpack method from this module can attempt
+ * to unpack encrypted value.
+ */
+export declare function canUnpack(encryptedValue: string): boolean;
+/**
+ * Attempts to unpack the encrypted cookie value. Returns null, when fails to do so.
+ * Only call this method, when `canUnpack` returns true, otherwise runtime
+ * exceptions can be raised.
+ */
+export declare function unpack(key: string, encryptedValue: string, encryption: Encryption): null | any;

package/build/src/cookies/drivers/encrypted.js

@@ -0,0 +1,36 @@
+/*
+ * @adonisjs/http-server
+ *
+ * (c) AdonisJS
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+/**
+ * Encrypt a value to be set as cookie
+ */
+export function pack(key, value, encryption) {
+    if (value === undefined || value === null) {
+        return null;
+    }
+    return `e:${encryption.encrypt(value, undefined, key)}`;
+}
+/**
+ * Returns a boolean, if the unpack method from this module can attempt
+ * to unpack encrypted value.
+ */
+export function canUnpack(encryptedValue) {
+    return typeof encryptedValue === 'string' && encryptedValue.substring(0, 2) === 'e:';
+}
+/**
+ * Attempts to unpack the encrypted cookie value. Returns null, when fails to do so.
+ * Only call this method, when `canUnpack` returns true, otherwise runtime
+ * exceptions can be raised.
+ */
+export function unpack(key, encryptedValue, encryption) {
+    const value = encryptedValue.slice(2);
+    if (!value) {
+        return null;
+    }
+    return encryption.decrypt(value, key);
+}

package/build/src/cookies/drivers/plain.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Encodes a value into a base64 url encoded string to
+ * be set as cookie
+ */
+export declare function pack(value: any): null | string;
+/**
+ * Returns true when this `unpack` method of this module can attempt
+ * to unpack the encode value.
+ */
+export declare function canUnpack(encodedValue: string): boolean;
+/**
+ * Attempts to unpack the value by decoding it. Make sure to call, `canUnpack`
+ * before calling this method
+ */
+export declare function unpack(encodedValue: string): null | any;

package/build/src/cookies/drivers/plain.js

@@ -0,0 +1,33 @@
+/*
+ * @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 { base64, MessageBuilder } from '@poppinss/utils';
+/**
+ * Encodes a value into a base64 url encoded string to
+ * be set as cookie
+ */
+export function pack(value) {
+    if (value === undefined || value === null) {
+        return null;
+    }
+    return base64.urlEncode(new MessageBuilder().build(value));
+}
+/**
+ * Returns true when this `unpack` method of this module can attempt
+ * to unpack the encode value.
+ */
+export function canUnpack(encodedValue) {
+    return typeof encodedValue === 'string';
+}
+/**
+ * Attempts to unpack the value by decoding it. Make sure to call, `canUnpack`
+ * before calling this method
+ */
+export function unpack(encodedValue) {
+    return new MessageBuilder().verify(base64.urlDecode(encodedValue, 'utf-8', false));
+}

package/build/src/cookies/drivers/signed.d.ts

@@ -0,0 +1,16 @@
+import type { Encryption } from '@adonisjs/encryption';
+/**
+ * Signs a value to be shared as a cookie. The signed output has a
+ * hash to verify tampering with the original value
+ */
+export declare function pack(key: string, value: any, encryption: Encryption): null | string;
+/**
+ * Returns a boolean, if the unpack method from this module can attempt
+ * to unpack the signed value.
+ */
+export declare function canUnpack(signedValue: string): boolean;
+/**
+ * Attempts to unpack the signed value. Make sure to call `canUnpack` before
+ * calling this method.
+ */
+export declare function unpack(key: string, signedValue: string, encryption: Encryption): null | any;

package/build/src/cookies/drivers/signed.js

@@ -0,0 +1,36 @@
+/*
+ * @adonisjs/http-server
+ *
+ * (c) AdonisJS
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+/**
+ * Signs a value to be shared as a cookie. The signed output has a
+ * hash to verify tampering with the original value
+ */
+export function pack(key, value, encryption) {
+    if (value === undefined || value === null) {
+        return null;
+    }
+    return `s:${encryption.verifier.sign(value, undefined, key)}`;
+}
+/**
+ * Returns a boolean, if the unpack method from this module can attempt
+ * to unpack the signed value.
+ */
+export function canUnpack(signedValue) {
+    return typeof signedValue === 'string' && signedValue.substring(0, 2) === 's:';
+}
+/**
+ * Attempts to unpack the signed value. Make sure to call `canUnpack` before
+ * calling this method.
+ */
+export function unpack(key, signedValue, encryption) {
+    const value = signedValue.slice(2);
+    if (!value) {
+        return null;
+    }
+    return encryption.verifier.unsign(value, key);
+}

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

@@ -0,0 +1,37 @@
+import type { Encryption } from '@adonisjs/encryption';
+/**
+ * Cookie parser parses the HTTP `cookie` header and collects all cookies
+ * inside an object of `key-value` pair, but doesn't attempt to decrypt
+ * or unsign or decode the individual values.
+ *
+ * The cookie values are lazily decrypted, or unsigned to avoid unncessary
+ * processing, which infact can be used as a means to burden the server
+ * by sending too many cookies which even doesn't belongs to the
+ * server.
+ */
+export declare class CookieParser {
+    #private;
+    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
+     * place and not signed or encrypted.
+     */
+    decode(key: string, encoded?: 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.
+     */
+    unsign(key: string): null | any;
+    /**
+     * Attempts to decrypt a cookie by the name. When calling this method,
+     * you are assuming that the cookie was encrypted in the first place.
+     */
+    decrypt(key: string): null | any;
+    /**
+     * Returns an object of cookies key-value pair. Do note, the
+     * cookies are not decoded, unsigned or decrypted inside this
+     * list.
+     */
+    list(): Record<string, any>;
+}