@adonisjs/http-server 5.12.0 → 6.0.0-0

package/README.md

@@ -1,48 +1,25 @@
-<div align="center">
-  <img src="https://res.cloudinary.com/adonisjs/image/upload/q_100/v1558612869/adonis-readme_zscycu.jpg" width="600px">
-</div>
+# @adonisjs/http-server
 
 <br />
 
-<div align="center">
-  <h3>AdonisJS HTTP Server</h3>
-  <p>A fully featured HTTP server with first class support for <strong>Route groups</strong>, <strong>Sub-domain routing</strong>, <strong>Middleware</strong> and <strong>Cookies</strong>.</p>
-</div>
+[![gh-workflow-image]][gh-workflow-url] [![npm-image]][npm-url] ![][typescript-image] [![license-image]][license-url] [![synk-image]][synk-url]
 
-<br />
+## Introduction
+Implementation of HTTP server used by AdonisJS. The package ships with a powerful **Router**, **Middleware pipeline**, helpers to create plain and signed URL for registered routes and much more.
 
-<div align="center">
+## Official Documentation
+The documentation is available on the [AdonisJS website](https://docs.adonisjs.com/guides/context)
 
-[![gh-workflow-image]][gh-workflow-url] [![npm-image]][npm-url] ![][typescript-image] [![license-image]][license-url] [![synk-image]][synk-url]
+## Contributing
+One of the primary goals of AdonisJS is to have a vibrant community of users and contributors who believes in the principles of the framework.
+
+We encourage you to read the [contribution guide](https://github.com/adonisjs/.github/blob/main/docs/CONTRIBUTING.md) before contributing to the framework.
+
+## Code of Conduct
+In order to ensure that the AdonisJS community is welcoming to all, please review and abide by the [Code of Conduct](https://github.com/adonisjs/.github/blob/main/docs/CODE_OF_CONDUCT.md).
 
-</div>
-
-<div align="center">
-  <h3>
-    <a href="https://adonisjs.com">
-      Website
-    </a>
-    <span> | </span>
-    <a href="https://docs.adonisjs.com/guides/context">
-      Guides
-    </a>
-    <span> | </span>
-    <a href="CONTRIBUTING.md">
-      Contributing
-    </a>
-    <span> | </span>
-    <a href="benchmarks.md">
-      Benchmarks
-    </a>
-  </h3>
-</div>
-
-<div align="center">
-  <sub>Built with ❤︎ by <a href="https://twitter.com/AmanVirk1">Harminder Virk</a>
-</div>
-
-[appveyor-image]: https://img.shields.io/appveyor/ci/thetutlage/http-server/master.svg?style=for-the-badge&logo=appveyor
-[appveyor-url]: https://ci.appveyor.com/project/thetutlage/http-server "appveyor"
+## License
+AdonisJS HTTP server is open-sourced software licensed under the [MIT license](LICENSE.md).
 
 [gh-workflow-image]: https://img.shields.io/github/workflow/status/adonisjs/http-server/test?style=for-the-badge
 [gh-workflow-url]: https://github.com/adonisjs/http-server/actions/workflows/test.yml "Github action"

package/build/index.d.ts

@@ -0,0 +1,16 @@
+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 { RouteGroup } from './src/router/group.js';
+export { defineConfig } from './src/define_config.js';
+export { RouteResource } from './src/router/resource.js';
+export { BriskRoute } from './src/router/brisk.js';
+export { HttpContext } from './src/http_context/main.js';
+export { HttpException } from './src/exceptions/http_exception.js';
+export { AbortException } from './src/exceptions/abort_exception.js';
+export { RouteNotFoundException } from './src/exceptions/route_not_found.js';
+export { CannotLookupRouteException } from './src/exceptions/cannot_lookup_route.js';
+export { defineMiddleware, defineNamedMiddleware } from './src/define_middleware.js';

package/build/index.js

@@ -0,0 +1,16 @@
+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 { RouteGroup } from './src/router/group.js';
+export { defineConfig } from './src/define_config.js';
+export { RouteResource } from './src/router/resource.js';
+export { BriskRoute } from './src/router/brisk.js';
+export { HttpContext } from './src/http_context/main.js';
+export { HttpException } from './src/exceptions/http_exception.js';
+export { AbortException } from './src/exceptions/abort_exception.js';
+export { RouteNotFoundException } from './src/exceptions/route_not_found.js';
+export { CannotLookupRouteException } from './src/exceptions/cannot_lookup_route.js';
+export { defineMiddleware, defineNamedMiddleware } from './src/define_middleware.js';

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

@@ -0,0 +1,12 @@
+import type Encryption from '@adonisjs/encryption';
+export declare class CookieClient {
+    #private;
+    constructor(encryption: Encryption);
+    encrypt(key: string, value: any): string | null;
+    sign(key: string, value: any): string | null;
+    encode(_: string, value: any): string | null;
+    unsign(key: string, value: string): any;
+    decrypt(key: string, value: string): any;
+    decode(_: string, value: string): any;
+    parse(key: string, value: any): any;
+}

package/build/src/cookies/client.js

@@ -0,0 +1,42 @@
+import * as plainCookiesDriver from './drivers/plain.js';
+import * as signedCookiesDriver from './drivers/signed.js';
+import * as encryptedCookiesDriver from './drivers/encrypted.js';
+export class CookieClient {
+    #encryption;
+    constructor(encryption) {
+        this.#encryption = encryption;
+    }
+    encrypt(key, value) {
+        return encryptedCookiesDriver.pack(key, value, this.#encryption);
+    }
+    sign(key, value) {
+        return signedCookiesDriver.pack(key, value, this.#encryption);
+    }
+    encode(_, value) {
+        return plainCookiesDriver.pack(value);
+    }
+    unsign(key, value) {
+        return signedCookiesDriver.canUnpack(value)
+            ? signedCookiesDriver.unpack(key, value, this.#encryption)
+            : null;
+    }
+    decrypt(key, value) {
+        return encryptedCookiesDriver.canUnpack(value)
+            ? encryptedCookiesDriver.unpack(key, value, this.#encryption)
+            : null;
+    }
+    decode(_, value) {
+        return plainCookiesDriver.canUnpack(value) ? plainCookiesDriver.unpack(value) : null;
+    }
+    parse(key, value) {
+        if (signedCookiesDriver.canUnpack(value)) {
+            return signedCookiesDriver.unpack(key, value, this.#encryption);
+        }
+        if (encryptedCookiesDriver.canUnpack(value)) {
+            return encryptedCookiesDriver.unpack(key, value, this.#encryption);
+        }
+        if (plainCookiesDriver.canUnpack(value)) {
+            return plainCookiesDriver.unpack(value);
+        }
+    }
+}

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

@@ -0,0 +1,4 @@
+import type Encryption from '@adonisjs/encryption';
+export declare function pack(key: string, value: any, encryption: Encryption): null | string;
+export declare function canUnpack(encryptedValue: string): boolean;
+export declare function unpack(key: string, encryptedValue: string, encryption: Encryption): null | any;

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

@@ -0,0 +1,16 @@
+export function pack(key, value, encryption) {
+    if (value === undefined || value === null) {
+        return null;
+    }
+    return `e:${encryption.encrypt(value, undefined, key)}`;
+}
+export function canUnpack(encryptedValue) {
+    return typeof encryptedValue === 'string' && encryptedValue.substring(0, 2) === 'e:';
+}
+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,3 @@
+export declare function pack(value: any): null | string;
+export declare function canUnpack(encodedValue: string): boolean;
+export declare function unpack(encodedValue: string): null | any;

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

@@ -0,0 +1,13 @@
+import { base64, MessageBuilder } from '@poppinss/utils';
+export function pack(value) {
+    if (value === undefined || value === null) {
+        return null;
+    }
+    return base64.urlEncode(new MessageBuilder().build(value));
+}
+export function canUnpack(encodedValue) {
+    return typeof encodedValue === 'string';
+}
+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,4 @@
+import type Encryption from '@adonisjs/encryption';
+export declare function pack(key: string, value: any, encryption: Encryption): null | string;
+export declare function canUnpack(signedValue: string): boolean;
+export declare function unpack(key: string, signedValue: string, encryption: Encryption): null | any;

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

@@ -0,0 +1,16 @@
+export function pack(key, value, encryption) {
+    if (value === undefined || value === null) {
+        return null;
+    }
+    return `s:${encryption.verifier.sign(value, undefined, key)}`;
+}
+export function canUnpack(signedValue) {
+    return typeof signedValue === 'string' && signedValue.substring(0, 2) === 's:';
+}
+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,9 @@
+import type Encryption from '@adonisjs/encryption';
+export declare class CookieParser {
+    #private;
+    constructor(cookieHeader: string, encryption: Encryption);
+    decode(key: string, encoded?: boolean): any | null;
+    unsign(key: string): null | any;
+    decrypt(key: string): null | any;
+    list(): Record<string, any>;
+}

package/build/src/cookies/parser.js

@@ -0,0 +1,69 @@
+import cookie from 'cookie';
+import { CookieClient } from './client.js';
+export class CookieParser {
+    #client;
+    #cachedCookies = {
+        signedCookies: {},
+        plainCookies: {},
+        encryptedCookies: {},
+    };
+    #cookies;
+    constructor(cookieHeader, encryption) {
+        this.#client = new CookieClient(encryption);
+        this.#cookies = this.#parse(cookieHeader);
+    }
+    #parse(cookieHeader) {
+        if (!cookieHeader) {
+            return {};
+        }
+        return cookie.parse(cookieHeader);
+    }
+    decode(key, encoded = true) {
+        const value = this.#cookies[key];
+        if (value === null || value === undefined) {
+            return null;
+        }
+        const cache = this.#cachedCookies.plainCookies;
+        if (cache[key] !== undefined) {
+            return cache[key];
+        }
+        const parsed = encoded ? this.#client.decode(key, value) : value;
+        if (parsed !== null) {
+            cache[key] = parsed;
+        }
+        return parsed;
+    }
+    unsign(key) {
+        const value = this.#cookies[key];
+        if (value === null || value === undefined) {
+            return null;
+        }
+        const cache = this.#cachedCookies.signedCookies;
+        if (cache[key] !== undefined) {
+            return cache[key];
+        }
+        const parsed = this.#client.unsign(key, value);
+        if (parsed !== null) {
+            cache[key] = parsed;
+        }
+        return parsed;
+    }
+    decrypt(key) {
+        const value = this.#cookies[key];
+        if (value === null || value === undefined) {
+            return null;
+        }
+        const cache = this.#cachedCookies.encryptedCookies;
+        if (cache[key] !== undefined) {
+            return cache[key];
+        }
+        const parsed = this.#client.decrypt(key, value);
+        if (parsed !== null) {
+            cache[key] = parsed;
+        }
+        return parsed;
+    }
+    list() {
+        return this.#cookies;
+    }
+}

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

@@ -0,0 +1,11 @@
+import type Encryption from '@adonisjs/encryption';
+import type { CookieOptions } from '../types/response.js';
+export declare class CookieSerializer {
+    #private;
+    constructor(encryption: Encryption);
+    encode(key: string, value: any, options?: Partial<CookieOptions & {
+        encode: boolean;
+    }>): string | null;
+    sign(key: string, value: any, options?: Partial<CookieOptions>): string | null;
+    encrypt(key: string, value: any, options?: Partial<CookieOptions>): string | null;
+}

package/build/src/cookies/serializer.js

@@ -0,0 +1,39 @@
+import cookie from 'cookie';
+import string from '@poppinss/utils/string';
+import { CookieClient } from './client.js';
+export class CookieSerializer {
+    #client;
+    constructor(encryption) {
+        this.#client = new CookieClient(encryption);
+    }
+    #serializeAsCookie(key, value, options) {
+        let expires = options?.expires;
+        if (typeof expires === 'function') {
+            expires = expires();
+        }
+        let maxAge = options?.maxAge ? string.seconds.parse(options?.maxAge) : undefined;
+        const parsedOptions = Object.assign({}, options, { maxAge, expires });
+        return cookie.serialize(key, value, parsedOptions);
+    }
+    encode(key, value, options) {
+        const packedValue = options?.encode === false ? value : this.#client.encode(key, value);
+        if (packedValue === null || packedValue === undefined) {
+            return null;
+        }
+        return this.#serializeAsCookie(key, packedValue, options);
+    }
+    sign(key, value, options) {
+        const packedValue = this.#client.sign(key, value);
+        if (packedValue === null) {
+            return null;
+        }
+        return this.#serializeAsCookie(key, packedValue, options);
+    }
+    encrypt(key, value, options) {
+        const packedValue = this.#client.encrypt(key, value);
+        if (packedValue === null) {
+            return null;
+        }
+        return this.#serializeAsCookie(key, packedValue, options);
+    }
+}

package/build/src/debug.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="node" resolution-mode="require"/>
+declare const _default: import("util").DebugLogger;
+export default _default;

package/build/src/debug.js

@@ -0,0 +1,2 @@
+import { debuglog } from 'node:util';
+export default debuglog('adonisjs:http');

package/build/src/define_config.d.ts

@@ -0,0 +1,2 @@
+import type { ServerConfig } from './types/server.js';
+export declare function defineConfig(config: Partial<ServerConfig>): ServerConfig;

package/build/src/define_config.js

@@ -0,0 +1,40 @@
+import proxyAddr from 'proxy-addr';
+import string from '@poppinss/utils/string';
+export function defineConfig(config) {
+    const normalizedConfig = {
+        allowMethodSpoofing: false,
+        trustProxy: proxyAddr.compile('loopback'),
+        subdomainOffset: 2,
+        generateRequestId: false,
+        useAsyncLocalStorage: false,
+        etag: false,
+        jsonpCallbackName: 'callback',
+        cookie: {
+            maxAge: '2h',
+            path: '/',
+            httpOnly: true,
+            secure: false,
+            sameSite: false,
+        },
+        qs: {
+            parse: {
+                depth: 5,
+                parameterLimit: 1000,
+                allowSparse: false,
+                arrayLimit: 20,
+                comma: true,
+            },
+            stringify: {
+                encode: true,
+                encodeValuesOnly: false,
+                arrayFormat: 'indices',
+                skipNulls: false,
+            },
+        },
+        ...config,
+    };
+    if (normalizedConfig.cookie.maxAge) {
+        normalizedConfig.cookie.maxAge = string.seconds.parse(normalizedConfig.cookie.maxAge);
+    }
+    return normalizedConfig;
+}

package/build/src/define_middleware.d.ts

@@ -0,0 +1,4 @@
+import type { LazyImport } from './types/base.js';
+import type { MiddlewareAsClass } from './types/middleware.js';
+export declare function defineMiddleware(list: LazyImport<MiddlewareAsClass>[]): LazyImport<MiddlewareAsClass>[];
+export declare function defineNamedMiddleware<NamedMiddleware extends Record<string, LazyImport<MiddlewareAsClass>>>(collection: NamedMiddleware): NamedMiddleware;

package/build/src/define_middleware.js

@@ -0,0 +1,6 @@
+export function defineMiddleware(list) {
+    return list;
+}
+export function defineNamedMiddleware(collection) {
+    return collection;
+}

package/build/src/exceptions/abort_exception.d.ts

@@ -0,0 +1,5 @@
+import { HttpException } from './http_exception.js';
+import type { HttpContext } from '../http_context/main.js';
+export declare class AbortException extends HttpException {
+    handle(error: HttpException, ctx: HttpContext): void;
+}

package/build/src/exceptions/abort_exception.js

@@ -0,0 +1,6 @@
+import { HttpException } from './http_exception.js';
+export class AbortException extends HttpException {
+    handle(error, ctx) {
+        ctx.response.status(error.status).send(error.body);
+    }
+}

package/build/src/exceptions/cannot_lookup_route.d.ts

@@ -0,0 +1,5 @@
+import { Exception } from '@poppinss/utils';
+export declare class CannotLookupRouteException extends Exception {
+    static status: number;
+    static code: string;
+}

package/build/src/exceptions/cannot_lookup_route.js

@@ -0,0 +1,5 @@
+import { Exception } from '@poppinss/utils';
+export class CannotLookupRouteException extends Exception {
+    static status = 500;
+    static code = 'E_CANNOT_LOOKUP_ROUTE';
+}

package/build/src/exceptions/http_exception.d.ts

@@ -0,0 +1,6 @@
+import { Exception } from '@poppinss/utils';
+export declare class HttpException extends Exception {
+    body: any;
+    static code: string;
+    static invoke(body: any, status: number, code?: string): HttpException;
+}

package/build/src/exceptions/http_exception.js

@@ -0,0 +1,20 @@
+import { Exception } from '@poppinss/utils';
+export class HttpException extends Exception {
+    body;
+    static code = 'E_HTTP_EXCEPTION';
+    static invoke(body, status, code = 'E_HTTP_EXCEPTION') {
+        if (body === null || body === undefined) {
+            const error = new this('HTTP Exception', { status, code });
+            error.body = 'Internal server error';
+            return error;
+        }
+        if (typeof body === 'object') {
+            const error = new this(body.message || 'HTTP Exception', { status, code });
+            error.body = body;
+            return error;
+        }
+        const error = new this(body, { status, code });
+        error.body = body;
+        return error;
+    }
+}

package/build/src/exceptions/route_not_found.d.ts

@@ -0,0 +1,5 @@
+import { HttpException } from './http_exception.js';
+export declare class RouteNotFoundException extends HttpException {
+    static status: number;
+    static code: string;
+}

package/build/src/exceptions/route_not_found.js

@@ -0,0 +1,5 @@
+import { HttpException } from './http_exception.js';
+export class RouteNotFoundException extends HttpException {
+    static status = 404;
+    static code = 'E_ROUTE_NOT_FOUND';
+}

package/build/src/helpers.d.ts

@@ -1,69 +1,8 @@
-/**
- * @adonisjs/http-server
- *
- * (c) Harminder Virk <virk@adonisjs.com>
- *
- * For the full copyright and license information, please view the LICENSE
- * file that was distributed with this source code.
- */
-/// <reference path="../adonis-typings/index.d.ts" />
-/// <reference types="node" />
-import { Stats } from 'fs';
-import { Route } from './Router/Route';
-import { RouteGroup } from './Router/Group';
-import { BriskRoute } from './Router/BriskRoute';
-import { RouteResource } from './Router/Resource';
-import { HttpContextContract } from '@ioc:Adonis/Core/HttpContext';
-import { RouteJSON, MakeUrlOptions, MakeSignedUrlOptions } from '@ioc:Adonis/Core/Route';
-/**
- * Makes input string consistent by having only the starting
- * slash
- */
+import { Route } from './router/route.js';
+import { BriskRoute } from './router/brisk.js';
+import { RouteGroup } from './router/group.js';
+import type { RouteJSON } from './types/route.js';
+import { RouteResource } from './router/resource.js';
 export declare function dropSlash(input: string): string;
-/**
- * Converts and array of routes or route groups or route resource to a flat
- * list of route defination.
- */
-export declare function toRoutesJSON(routes: (RouteGroup | RouteResource | Route | BriskRoute)[]): RouteJSON[];
-/**
- * Makes url for a route pattern and params and querystring.
- */
-export declare function processPattern(pattern: string, data: any): string;
-/**
- * Returns a boolean telling if the return value must be used as
- * the response body or not
- */
-export declare function useReturnValue(returnValue: any, ctx: HttpContextContract): boolean;
-/**
- * Since finding the trusted proxy based upon the remote address
- * is an expensive function, we cache its result
- */
+export declare function toRoutesJSON(routes: (RouteGroup | Route | RouteResource | BriskRoute)[]): RouteJSON[];
 export declare function trustProxy(remoteAddress: string, proxyFn: (addr: string, distance: number) => boolean): boolean;
-/**
- * Normalizes the makeURL options to work with the new API and the old
- * one as well
- */
-export declare function normalizeMakeUrlOptions(params?: any[] | MakeUrlOptions, options?: MakeUrlOptions): {
-    params: any;
-    qs: any;
-    domain: string | undefined;
-    prefixUrl: string | undefined;
-    disableRouteLookup: boolean;
-};
-/**
- * Normalizes the make signed url options by allowing params to appear on
- * top level object with option to nest inside `params` property.
- */
-export declare function normalizeMakeSignedUrlOptions(params?: any[] | MakeSignedUrlOptions, options?: MakeSignedUrlOptions): {
-    params: any;
-    qs: any;
-    domain: string | undefined;
-    prefixUrl: string | undefined;
-    expiresIn: any;
-    purpose: any;
-    disableRouteLookup: boolean;
-};
-/**
- * Wraps `fs.stat` to promise interface.
- */
-export declare function statFn(filePath: string): Promise<Stats>;