@adonisjs/http-server 5.11.0 → 6.0.0-0

package/build/src/helpers.js

@@ -1,113 +1,37 @@
-"use strict";
-/**
- * @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.
- */
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.statFn = exports.normalizeMakeSignedUrlOptions = exports.normalizeMakeUrlOptions = exports.trustProxy = exports.useReturnValue = exports.processPattern = exports.toRoutesJSON = exports.dropSlash = void 0;
-/// <reference path="../adonis-typings/index.ts" />
-const tmp_cache_1 = __importDefault(require("tmp-cache"));
-const fs_1 = require("fs");
-const Group_1 = require("./Router/Group");
-const BriskRoute_1 = require("./Router/BriskRoute");
-const Resource_1 = require("./Router/Resource");
-const RouterException_1 = require("./Exceptions/RouterException");
-const proxyCache = new tmp_cache_1.default({ max: 200 });
-/**
- * Makes input string consistent by having only the starting
- * slash
- */
-function dropSlash(input) {
+import Cache from 'tmp-cache';
+import { BriskRoute } from './router/brisk.js';
+import { RouteGroup } from './router/group.js';
+import { RouteResource } from './router/resource.js';
+const proxyCache = new Cache({ max: 200 });
+export function dropSlash(input) {
     if (input === '/') {
         return '/';
     }
     return `/${input.replace(/^\//, '').replace(/\/$/, '')}`;
 }
-exports.dropSlash = dropSlash;
-/**
- * Converts and array of routes or route groups or route resource to a flat
- * list of route defination.
- */
-function toRoutesJSON(routes) {
+export function toRoutesJSON(routes) {
     return routes.reduce((list, route) => {
-        if (route instanceof Group_1.RouteGroup) {
+        if (route instanceof RouteGroup) {
             list = list.concat(toRoutesJSON(route.routes));
             return list;
         }
-        if (route instanceof Resource_1.RouteResource) {
+        if (route instanceof RouteResource) {
             list = list.concat(toRoutesJSON(route.routes));
             return list;
         }
-        if (route instanceof BriskRoute_1.BriskRoute) {
-            if (route.route) {
+        if (route instanceof BriskRoute) {
+            if (route.route && !route.route.isDeleted()) {
                 list.push(route.route.toJSON());
             }
             return list;
         }
-        if (!route.deleted) {
+        if (!route.isDeleted()) {
             list.push(route.toJSON());
         }
         return list;
     }, []);
 }
-exports.toRoutesJSON = toRoutesJSON;
-/**
- * Makes url for a route pattern and params and querystring.
- */
-function processPattern(pattern, data) {
-    let url = pattern;
-    if (url.indexOf(':') > -1) {
-        /*
-         * Split pattern when route has dynamic segments
-         */
-        const tokens = url.split('/');
-        /*
-         * Lookup over the route tokens and replace them the params values
-         */
-        url = tokens
-            .map((token) => {
-            if (!token.startsWith(':')) {
-                return token;
-            }
-            const isOptional = token.endsWith('?');
-            const paramName = token.replace(/^:/, '').replace(/\?$/, '');
-            const param = data[paramName];
-            /*
-             * A required param is always required to make the complete URL
-             */
-            if (!param && !isOptional) {
-                throw RouterException_1.RouterException.cannotMakeRoute(paramName, pattern);
-            }
-            return param;
-        })
-            .join('/');
-    }
-    return url;
-}
-exports.processPattern = processPattern;
-/**
- * Returns a boolean telling if the return value must be used as
- * the response body or not
- */
-function useReturnValue(returnValue, ctx) {
-    return (returnValue !== undefined && // Return value is explicitly defined
-        returnValue !== ctx.response && // Return value is not the instance of response object
-        !ctx.response.hasLazyBody // Lazy body is not set
-    );
-}
-exports.useReturnValue = useReturnValue;
-/**
- * Since finding the trusted proxy based upon the remote address
- * is an expensive function, we cache its result
- */
-function trustProxy(remoteAddress, proxyFn) {
+export function trustProxy(remoteAddress, proxyFn) {
     if (proxyCache.has(remoteAddress)) {
         return proxyCache.get(remoteAddress);
     }
@@ -115,82 +39,3 @@ function trustProxy(remoteAddress, proxyFn) {
     proxyCache.set(remoteAddress, result);
     return result;
 }
-exports.trustProxy = trustProxy;
-/**
- * Invokes a callback if any of the defined keys is part of the values object
- */
-function onIntersect(values, keys, callback) {
-    if (Array.isArray(values)) {
-        return;
-    }
-    const valueKeys = Object.keys(values);
-    const matchingKey = keys.find((key) => valueKeys.includes(key));
-    if (matchingKey) {
-        callback(matchingKey);
-    }
-}
-/**
- * Normalizes the makeURL options to work with the new API and the old
- * one as well
- */
-function normalizeMakeUrlOptions(params, options) {
-    /**
-     * Params used to be options earlier. So we are checking a few properties of it
-     */
-    params = params || {};
-    options = options || {};
-    const normalizedParams = params['params'] ? params['params'] : params;
-    const qs = options.qs || params['qs'];
-    const domain = options.domain;
-    const prefixUrl = options.prefixUrl;
-    const disableRouteLookup = options.disableRouteLookup || false;
-    /**
-     * Using legacy options
-     */
-    onIntersect(params, ['prefixDomain', 'domainParams', 'qs', 'params'], () => {
-        process.emitWarning('DeprecationWarning', 'You are using legacy the API of the "Route.makeUrl". We recommend reading the docs and use the latest API');
-    });
-    return { params: normalizedParams, qs, domain, prefixUrl, disableRouteLookup };
-}
-exports.normalizeMakeUrlOptions = normalizeMakeUrlOptions;
-/**
- * Normalizes the make signed url options by allowing params to appear on
- * top level object with option to nest inside `params` property.
- */
-function normalizeMakeSignedUrlOptions(params, options) {
-    /**
-     * Params used to be options earlier. So we are checking a few properties of it
-     */
-    params = params || {};
-    options = options || {};
-    const normalizedParams = params['params'] ? params['params'] : params;
-    const qs = options.qs || params['qs'];
-    const expiresIn = options.expiresIn || params['expiresIn'];
-    const purpose = options.purpose || params['purpose'];
-    const domain = options.domain;
-    const prefixUrl = options.prefixUrl;
-    const disableRouteLookup = options.disableRouteLookup || false;
-    /**
-     * Using legacy options
-     */
-    onIntersect(params, ['prefixDomain', 'domainParams', 'qs', 'params', 'purpose', 'expiresIn'], () => {
-        process.emitWarning('DeprecationWarning', 'You are using legacy the API of the "Route.makeSignedUrl". We recommend reading the docs and use the latest API');
-    });
-    return { params: normalizedParams, qs, domain, prefixUrl, expiresIn, purpose, disableRouteLookup };
-}
-exports.normalizeMakeSignedUrlOptions = normalizeMakeSignedUrlOptions;
-/**
- * Wraps `fs.stat` to promise interface.
- */
-function statFn(filePath) {
-    return new Promise((resolve, reject) => {
-        (0, fs_1.stat)(filePath, (error, stats) => {
-            if (error) {
-                reject(error);
-                return;
-            }
-            resolve(stats);
-        });
-    });
-}
-exports.statFn = statFn;

package/build/src/http_context/local_storage.d.ts

@@ -0,0 +1,9 @@
+/// <reference types="node" resolution-mode="require"/>
+import { AsyncLocalStorage } from 'node:async_hooks';
+import type { HttpContext } from './main.js';
+export declare const asyncLocalStorage: {
+    isEnabled: boolean;
+    storage: null | AsyncLocalStorage<HttpContext>;
+    create(): AsyncLocalStorage<HttpContext>;
+    destroy(): void;
+};

package/build/src/http_context/local_storage.js

@@ -0,0 +1,14 @@
+import { AsyncLocalStorage } from 'node:async_hooks';
+export const asyncLocalStorage = {
+    isEnabled: false,
+    storage: null,
+    create() {
+        this.isEnabled = true;
+        this.storage = new AsyncLocalStorage();
+        return this.storage;
+    },
+    destroy() {
+        this.isEnabled = false;
+        this.storage = null;
+    },
+};

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

@@ -0,0 +1,20 @@
+import type { Logger } from '@adonisjs/logger';
+import { Macroable } from '@poppinss/macroable';
+import type { Request } from '../request.js';
+import type { Response } from '../response.js';
+import type { StoreRouteNode } from '../types/route.js';
+export declare class HttpContext extends Macroable {
+    request: Request;
+    response: Response;
+    logger: Logger;
+    static get usingAsyncLocalStorage(): boolean;
+    static get(): HttpContext | null;
+    static getOrFail(): HttpContext;
+    static runOutsideContext<T>(callback: (...args: any[]) => T, ...args: any[]): T;
+    route?: StoreRouteNode;
+    routeKey?: string;
+    params: Record<string, any>;
+    subdomains: Record<string, any>;
+    constructor(request: Request, response: Response, logger: Logger);
+    inspect(): string;
+}

package/build/src/http_context/main.js

@@ -0,0 +1,49 @@
+import { inspect } from 'node:util';
+import { Macroable } from '@poppinss/macroable';
+import { RuntimeException } from '@poppinss/utils';
+import { asyncLocalStorage } from './local_storage.js';
+export class HttpContext extends Macroable {
+    request;
+    response;
+    logger;
+    static get usingAsyncLocalStorage() {
+        return asyncLocalStorage.isEnabled;
+    }
+    static get() {
+        if (!this.usingAsyncLocalStorage || !asyncLocalStorage.storage) {
+            return null;
+        }
+        return asyncLocalStorage.storage.getStore() || null;
+    }
+    static getOrFail() {
+        if (!this.usingAsyncLocalStorage || !asyncLocalStorage.storage) {
+            throw new RuntimeException('HTTP context is not available. Enable "useAsyncLocalStorage" inside "config/app.ts" file');
+        }
+        const store = this.get();
+        if (!store) {
+            throw new RuntimeException('Http context is not available outside of an HTTP request');
+        }
+        return store;
+    }
+    static runOutsideContext(callback, ...args) {
+        if (!asyncLocalStorage.storage) {
+            return callback(...args);
+        }
+        return asyncLocalStorage.storage.exit(callback, ...args);
+    }
+    route;
+    routeKey;
+    params = {};
+    subdomains = {};
+    constructor(request, response, logger) {
+        super();
+        this.request = request;
+        this.response = response;
+        this.logger = logger;
+        this.request.ctx = this;
+        this.response.ctx = this;
+    }
+    inspect() {
+        return inspect(this, false, 1, true);
+    }
+}

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

@@ -0,0 +1,11 @@
+import type { LazyImport, UnWrapLazyImport } from '../types/base.js';
+import type { GetMiddlewareArgs, MiddlewareAsClass, ParsedGlobalMiddleware } from '../types/middleware.js';
+export declare class MiddlewareStore<NamedMiddleware extends Record<string, LazyImport<MiddlewareAsClass>>> {
+    #private;
+    constructor(middleware: LazyImport<MiddlewareAsClass>[], namedMiddleware?: NamedMiddleware);
+    get<Name extends keyof NamedMiddleware, Args extends GetMiddlewareArgs<UnWrapLazyImport<NamedMiddleware[Name]>>>(name: Name, ...args: Args): {
+        name: Name;
+        args: any;
+    } & ParsedGlobalMiddleware;
+    list(): ParsedGlobalMiddleware[];
+}

package/build/src/middleware/store.js

@@ -0,0 +1,33 @@
+import { moduleImporter } from '@adonisjs/fold';
+import { RuntimeException } from '@poppinss/utils';
+export class MiddlewareStore {
+    #namedMiddleware;
+    #middleware;
+    #resolvedMiddleware = new Map();
+    constructor(middleware, namedMiddleware) {
+        this.#middleware = middleware.map((one) => moduleImporter(one, 'handle').toHandleMethod());
+        this.#namedMiddleware = namedMiddleware;
+    }
+    get(name, ...args) {
+        if (this.#resolvedMiddleware.has(name)) {
+            return {
+                name,
+                args: args[0],
+                ...this.#resolvedMiddleware.get(name),
+            };
+        }
+        if (!this.#namedMiddleware || !this.#namedMiddleware[name]) {
+            throw new RuntimeException(`Cannot resolve "${String(name)}" middleware. Make sure the middleware is registered before using it`);
+        }
+        const handler = moduleImporter(this.#namedMiddleware[name], 'handle').toHandleMethod();
+        this.#resolvedMiddleware.set(name, handler);
+        return {
+            name,
+            args: args[0],
+            ...handler,
+        };
+    }
+    list() {
+        return this.#middleware;
+    }
+}

package/build/src/qs.d.ts

@@ -0,0 +1,7 @@
+import { QSParserConfig } from './types/qs.js';
+export declare class Qs {
+    #private;
+    constructor(config: QSParserConfig);
+    parse(value: string): import("qs").ParsedQs;
+    stringify(value: any): string;
+}

package/build/src/qs.js

@@ -0,0 +1,13 @@
+import { parse, stringify } from 'qs';
+export class Qs {
+    #config;
+    constructor(config) {
+        this.#config = config;
+    }
+    parse(value) {
+        return parse(value, this.#config.parse);
+    }
+    stringify(value) {
+        return stringify(value, this.#config.stringify);
+    }
+}

package/build/src/redirect.d.ts

@@ -0,0 +1,18 @@
+/// <reference types="node" resolution-mode="require"/>
+import type { IncomingMessage } from 'node:http';
+import type { Qs } from './qs.js';
+import type { Response } from './response.js';
+import type { Router } from './router/main.js';
+import type { MakeUrlOptions } from './types/route.js';
+export declare class Redirect {
+    #private;
+    constructor(request: IncomingMessage, response: Response, router: Router, qs: Qs);
+    status(statusCode: number): this;
+    clearQs(): this;
+    withQs(): this;
+    withQs(values: Record<string, any>): this;
+    withQs(name: string, value: any): this;
+    back(): void;
+    toRoute(routeIdentifier: string, params?: any[] | Record<string, any>, options?: MakeUrlOptions): void;
+    toPath(url: string): void;
+}

package/build/src/redirect.js

@@ -0,0 +1,80 @@
+import { parse } from 'node:url';
+import encodeUrl from 'encodeurl';
+import debug from './debug.js';
+export class Redirect {
+    #forwardQueryString = false;
+    #statusCode = 302;
+    #queryString = {};
+    #request;
+    #response;
+    #router;
+    #qs;
+    constructor(request, response, router, qs) {
+        this.#request = request;
+        this.#response = response;
+        this.#router = router;
+        this.#qs = qs;
+    }
+    #sendResponse(url, query) {
+        const stringified = this.#qs.stringify(query);
+        url = stringified ? `${url}?${stringified}` : url;
+        debug('redirecting to url "%s"', url);
+        this.#response.location(encodeUrl(url));
+        this.#response.safeStatus(this.#statusCode);
+        this.#response.type('text/plain; charset=utf-8');
+        this.#response.send(`Redirecting to ${url}`);
+    }
+    #getReferrerUrl() {
+        let url = this.#request.headers['referer'] || this.#request.headers['referrer'] || '/';
+        return Array.isArray(url) ? url[0] : url;
+    }
+    status(statusCode) {
+        this.#statusCode = statusCode;
+        return this;
+    }
+    clearQs() {
+        this.#forwardQueryString = false;
+        this.#queryString = {};
+        return this;
+    }
+    withQs(name, value) {
+        if (typeof name === 'undefined') {
+            this.#forwardQueryString = true;
+            return this;
+        }
+        if (typeof name === 'string') {
+            this.#queryString[name] = value;
+            return this;
+        }
+        Object.assign(this.#queryString, name);
+        return this;
+    }
+    back() {
+        let query = {};
+        const referrerUrl = this.#getReferrerUrl();
+        const url = parse(referrerUrl);
+        debug('referrer url "%s"', referrerUrl);
+        debug('referrer base url "%s"', url.pathname);
+        if (this.#forwardQueryString) {
+            query = this.#qs.parse(url.query || '');
+        }
+        Object.assign(query, this.#queryString);
+        this.#sendResponse(url.pathname || '', query);
+    }
+    toRoute(routeIdentifier, params, options) {
+        if (options && options.qs) {
+            this.withQs(options.qs);
+            options.qs = undefined;
+        }
+        const url = this.#router.makeUrl(routeIdentifier, params, options);
+        return this.toPath(url);
+    }
+    toPath(url) {
+        let query = {};
+        if (this.#forwardQueryString) {
+            query = this.#qs.parse(parse(this.#request.url).query || '');
+        }
+        Object.assign(query, this.#queryString);
+        this.#sendResponse(url, query);
+    }
+}

package/build/src/request.d.ts

@@ -0,0 +1,81 @@
+/// <reference types="node" resolution-mode="require"/>
+/// <reference types="node" resolution-mode="require"/>
+import { Macroable } from '@poppinss/macroable';
+import type Encryption from '@adonisjs/encryption';
+import { UrlWithStringQuery } from 'node:url';
+import { ServerResponse, IncomingMessage, IncomingHttpHeaders } from 'node:http';
+import type { Qs } from './qs.js';
+import { RequestConfig } from './types/request.js';
+import type { HttpContext } from './http_context/main.js';
+export declare class Request extends Macroable {
+    #private;
+    request: IncomingMessage;
+    response: ServerResponse;
+    parsedUrl: UrlWithStringQuery;
+    ctx?: HttpContext;
+    constructor(request: IncomingMessage, response: ServerResponse, encryption: Encryption, config: RequestConfig, qsParser: Qs);
+    id(): string | undefined;
+    setInitialBody(body: Record<string, any>): void;
+    updateBody(body: Record<string, any>): void;
+    updateRawBody(rawBody: string): void;
+    updateQs(data: Record<string, any>): void;
+    params(): Record<string, any>;
+    qs(): Record<string, any>;
+    body(): Record<string, any>;
+    all(): Record<string, any>;
+    original(): Record<string, any>;
+    raw(): string | null;
+    input(key: string, defaultValue?: any): any;
+    param(key: string, defaultValue?: any): any;
+    except(keys: string[]): Record<string, any>;
+    only<T extends string>(keys: T[]): {
+        [K in T]: any;
+    };
+    intended(): string;
+    method(): string;
+    headers(): IncomingHttpHeaders;
+    header(key: string, defaultValue?: any): string | undefined;
+    ip(): string;
+    ips(): string[];
+    protocol(): string;
+    secure(): boolean;
+    host(): string | null;
+    hostname(): string | null;
+    subdomains(): string[];
+    ajax(): boolean;
+    pjax(): boolean;
+    url(includeQueryString?: boolean): string;
+    completeUrl(includeQueryString?: boolean): string;
+    matchesRoute(routeIdentifier: string | string[]): boolean;
+    is(types: string[]): string | null;
+    accepts<T extends string>(types: T[]): T | null;
+    types(): string[];
+    language<T extends string>(languages: T[]): T | null;
+    languages(): string[];
+    charset<T extends string>(charsets: T[]): T | null;
+    charsets(): string[];
+    encoding<T extends string>(encodings: T[]): T | null;
+    encodings(): string[];
+    hasBody(): boolean;
+    fresh(): boolean;
+    stale(): boolean;
+    cookiesList(): Record<string, any>;
+    cookie(key: string, defaultValue?: string): any;
+    encryptedCookie(key: string, defaultValue?: string): any;
+    plainCookie(key: string, defaultValue?: string, encoded?: boolean): any;
+    hasValidSignature(purpose?: string): boolean;
+    toJSON(): {
+        id: string | undefined;
+        url: string;
+        query: string | null;
+        body: Record<string, any>;
+        params: Record<string, any>;
+        headers: IncomingHttpHeaders;
+        method: string;
+        protocol: string;
+        cookies: Record<string, any>;
+        hostname: string | null;
+        ip: string;
+        subdomains: Record<string, any>;
+    };
+}