@adonisjs/http-server 5.12.0 → 6.0.1-0

package/build/adonis-typings/index.js

@@ -1,16 +0,0 @@
-/**
- * @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="./container.ts" />
-/// <reference path="./context.ts" />
-/// <reference path="./http-server.ts" />
-/// <reference path="./middleware.ts" />
-/// <reference path="./request.ts" />
-/// <reference path="./response.ts" />
-/// <reference path="./route.ts" />
-/// <reference path="./cookie-client.ts" />

package/build/adonis-typings/middleware.d.ts

@@ -1,95 +0,0 @@
-/**
- * @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.
- */
-declare module '@ioc:Adonis/Core/Middleware' {
-    import { IocContract } from '@adonisjs/fold';
-    import { HttpContextContract } from '@ioc:Adonis/Core/HttpContext';
-    export type DefaultExport<T> = Promise<{
-        default: T;
-    }>;
-    /**
-     * Shape of the middleware class
-     */
-    export interface MiddlewareConstructorContract {
-        new (...args: any[]): {
-            handle(ctx: HttpContextContract, next: () => any, ...options: any[]): any;
-        };
-    }
-    /**
-     * Input middleware node must be function or a string pointing
-     * to the IoC container
-     */
-    export type MiddlewareHandler = string | (() => DefaultExport<MiddlewareConstructorContract>);
-    /**
-     * Shape of resolved middleware. This information is
-     * enough to execute the middleware
-     */
-    export type ResolvedMiddlewareHandler = {
-        type: 'function';
-        value: (ctx: HttpContextContract, next: () => void, ...options: any[]) => any;
-        args: string[];
-    } | {
-        type: 'lazy-import';
-        value: Exclude<MiddlewareHandler, string>;
-        args: string[];
-    } | {
-        type: 'alias' | 'binding';
-        namespace: string;
-        method: string;
-        args: string[];
-    };
-    /**
-     * Shape of middleware store to store and fetch middleware
-     * at runtime
-     */
-    export interface MiddlewareStoreContract {
-        /**
-         * Register an array of global middleware. These middleware are read
-         * by HTTP server and executed on every request
-         */
-        register(middleware: MiddlewareHandler[]): this;
-        /**
-         * Register named middleware that can be referenced later on routes
-         */
-        registerNamed(middleware: {
-            [alias: string]: MiddlewareHandler;
-        }): this;
-        /**
-         * Return all middleware registered using [[MiddlewareStore.register]]
-         * method
-         */
-        get(): ResolvedMiddlewareHandler[];
-        /**
-         * Removes all the global middleware
-         */
-        clear(): void;
-        /**
-         * Removes all/select named middleware
-         */
-        clearNamed(names: string[]): void;
-        /**
-         * Returns a single middleware by it's name registered
-         * using [[MiddlewareStore.registerNamed]] method.
-         */
-        getNamed(name: string): null | ResolvedMiddlewareHandler;
-        /**
-         * Invokes a resolved middleware.
-         */
-        invokeMiddleware(middleware: ResolvedMiddlewareHandler, params: [HttpContextContract, () => Promise<void>]): Promise<void>;
-    }
-    /**
-     * The shape of the middleware store constructor. We default export the
-     * constructor, since the store instance must be pulled from the
-     * server to register/fetch middleware
-     */
-    export interface MiddlewareStoreConstructorContract {
-        new (container: IocContract): MiddlewareStoreContract;
-    }
-    const MiddlewareStore: MiddlewareStoreConstructorContract;
-    export default MiddlewareStore;
-}

package/build/adonis-typings/middleware.js

@@ -1,8 +0,0 @@
-/**
- * @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.
- */

package/build/adonis-typings/request.d.ts

@@ -1,556 +0,0 @@
-/**
- * @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 types="node" />
-/// <reference types="node" />
-declare module '@ioc:Adonis/Core/Request' {
-    import { UrlWithStringQuery } from 'url';
-    import { MacroableConstructorContract } from 'macroable';
-    import { EncryptionContract } from '@ioc:Adonis/Core/Encryption';
-    import { HttpContextContract } from '@ioc:Adonis/Core/HttpContext';
-    import { IncomingHttpHeaders, IncomingMessage, ServerResponse } from 'http';
-    /**
-     * Shape of the request class instance
-     */
-    export interface RequestContract {
-        /**
-         * Parses copy of the URL with query string as a string and not
-         * object. This is done to build URL's with query string without
-         * stringifying the object
-         */
-        parsedUrl: UrlWithStringQuery;
-        request: IncomingMessage;
-        response: ServerResponse;
-        /**
-         * The ctx will be set by the context itself. It creates a circular
-         * reference
-         */
-        ctx?: HttpContextContract;
-        /**
-         * Returns the request id from the `x-request-id` header. The
-         * header is untoched, if it already exists.
-         */
-        id(): string | undefined;
-        /**
-         * Set initial request body. A copy of the input will be maintained as the original
-         * request body. Since the request body and query string is subject to mutations, we
-         * keep one original reference to flash old data (whenever required).
-         *
-         * This method is supposed to be invoked by the body parser and must be called only
-         * once. For further mutations make use of `updateBody` method.
-         */
-        setInitialBody(body: Record<string, any>): void;
-        /**
-         * Update the request body with new data object. The `all` property
-         * will be re-computed by merging the query string and request
-         * body.
-         */
-        updateBody(body: Record<string, any>): void;
-        /**
-         * Update the request raw body. Bodyparser sets this when unable to parse
-         * the request body or when request is multipart/form-data.
-         */
-        updateRawBody(body: string): void;
-        /**
-         * Update route params
-         */
-        updateParams(body: Record<string, any>): void;
-        /**
-         * Update the query string with the new data object. The `all` property
-         * will be re-computed by merging the query and the request body.
-         */
-        updateQs(data: Record<string, any>): void;
-        /**
-         * Returns route params
-         */
-        params(): Record<string, any>;
-        /**
-         * Returns reference to the query string object
-         * @deprecated: Use ".qs()" instead
-         */
-        get(): Record<string, any>;
-        /**
-         * Returns the query string object by reference
-         */
-        qs(): Record<string, any>;
-        /**
-         * Returns the request body object by reference
-         * @deprecated: Use ".body()" instead
-         */
-        post(): Record<string, any>;
-        /**
-         * Returns the request body object by reference
-         */
-        body(): Record<string, any>;
-        /**
-         * Returns reference to the merged copy of original request
-         * query string and body
-         */
-        original(): Record<string, any>;
-        /**
-         * Returns reference to the merged copy of request body
-         * and query string
-         */
-        all(): Record<string, any>;
-        /**
-         * Returns the request raw body (if exists), or returns `null`.
-         *
-         * Ideally you must be dealing with the parsed body accessed using [[input]], [[all]] or
-         * [[post]] methods. The `raw` body is always a string.
-         */
-        raw(): string | null;
-        /**
-         * Returns value for a given key from the request body or query string.
-         * The `defaultValue` is used when original value is `undefined`.
-         *
-         * @example
-         * ```js
-         * request.input('username')
-         *
-         * // with default value
-         * request.input('username', 'virk')
-         * ```
-         */
-        input(key: string, defaultValue?: any): any;
-        /**
-         * Returns value for a given key from route params
-         *
-         * @example
-         * ```js
-         * request.param('id')
-         *
-         * // with default value
-         * request.param('id', 1)
-         * ```
-         */
-        param(key: string, defaultValue?: any): any;
-        /**
-         * Get everything from the request body except the given keys.
-         *
-         * @example
-         * ```js
-         * request.except(['_csrf'])
-         * ```
-         */
-        except(keys: string[]): Record<string, any>;
-        /**
-         * Get value for specified keys.
-         *
-         * @example
-         * ```js
-         * request.only(['username', 'age'])
-         * ```
-         */
-        only<T extends string>(keys: T[]): {
-            [K in T]: any;
-        };
-        /**
-         * Returns the request HTTP method by taking method spoofing into account.
-         *
-         * Method spoofing works when all of the following are true.
-         *
-         * 1. `app.http.allowMethodSpoofing` config value is true.
-         * 2. request query string has `_method`.
-         * 3. The [[intended]] request method is `POST`.
-         *
-         * @example
-         * ```js
-         * request.method()
-         * ```
-         */
-        method(): string;
-        /**
-         * Returns the HTTP request method. This is the original
-         * request method. For spoofed request method, make
-         * use of [[method]].
-         *
-         * @example
-         * ```js
-         * request.intended()
-         * ```
-         */
-        intended(): string;
-        /**
-         * Returns a copy of headers as an object
-         */
-        headers(): IncomingHttpHeaders;
-        /**
-         * Returns value for a given header key. The default value is
-         * used when original value is `undefined`.
-         */
-        header(key: string): string | undefined;
-        header<T>(key: string, defaultValue?: T): string | T;
-        /**
-         * Returns the ip address of the user. This method is optimize to fetch
-         * ip address even when running your AdonisJs app behind a proxy.
-         *
-         * You can also define your own custom function to compute the ip address by
-         * defining `app.http.getIp` as a function inside the config file.
-         *
-         * ```js
-         * {
-         *   http: {
-         *     getIp (request) {
-         *       // I am using nginx as a proxy server and want to trust 'x-real-ip'
-         *       return request.header('x-real-ip')
-         *     }
-         *   }
-         * }
-         * ```
-         *
-         * You can control the behavior of trusting the proxy values by defining it
-         * inside the `config/app.js` file.
-         *
-         * ```js
-         * {
-         *   http: {
-         *    trustProxy: '127.0.0.1'
-         *   }
-         * }
-         * ```
-         *
-         * The value of trustProxy is passed directly to [proxy-addr](https://www.npmjs.com/package/proxy-addr)
-         */
-        ip(): string;
-        /**
-         * Returns an array of ip addresses from most to least trusted one.
-         * This method is optimize to fetch ip address even when running
-         * your AdonisJs app behind a proxy.
-         *
-         * You can control the behavior of trusting the proxy values by defining it
-         * inside the `config/app.js` file.
-         *
-         * ```js
-         * {
-         *   http: {
-         *    trustProxy: '127.0.0.1'
-         *   }
-         * }
-         * ```
-         *
-         * The value of trustProxy is passed directly to [proxy-addr](https://www.npmjs.com/package/proxy-addr)
-         */
-        ips(): string[];
-        /**
-         * Returns the request protocol by checking for the URL protocol or
-         * `X-Forwarded-Proto` header.
-         *
-         * If the `trust` is evaluated to `false`, then URL protocol is returned,
-         * otherwise `X-Forwarded-Proto` header is used (if exists).
-         *
-         * You can control the behavior of trusting the proxy values by defining it
-         * inside the `config/app.js` file.
-         *
-         * ```js
-         * {
-         *   http: {
-         *    trustProxy: '127.0.0.1'
-         *   }
-         * }
-         * ```
-         *
-         * The value of trustProxy is passed directly to [proxy-addr](https://www.npmjs.com/package/proxy-addr)
-         */
-        protocol(): string;
-        /**
-         * Returns a boolean telling if request is served over `https`
-         * or not. Check [[protocol]] method to know how protocol is
-         * fetched.
-         */
-        secure(): boolean;
-        /**
-         * Returns an array of subdomains for the given host. An empty array is
-         * returned if [[hostname]] is `null` or is an IP address.
-         *
-         * Also `www` is not considered as a subdomain
-         */
-        subdomains(): string[];
-        /**
-         * Returns the request host. If proxy headers are trusted, then
-         * `X-Forwarded-Host` is given priority over the `Host` header.
-         *
-         * You can control the behavior of trusting the proxy values by defining it
-         * inside the `config/app.js` file.
-         *
-         * ```js
-         * {
-         *   http: {
-         *    trustProxy: '127.0.0.1'
-         *   }
-         * }
-         * ```
-         *
-         * The value of trustProxy is passed directly to [proxy-addr](https://www.npmjs.com/package/proxy-addr)
-         */
-        host(): string | null;
-        /**
-         * Returns the request hostname. The hostname value does not include the
-         * port.
-         */
-        hostname(): string | null;
-        /**
-         * Returns a boolean telling, if request `X-Requested-With === 'xmlhttprequest'`
-         * or not.
-         */
-        ajax(): boolean;
-        /**
-         * Returns a boolean telling, if request has `X-Pjax` header
-         * set or not
-         */
-        pjax(): boolean;
-        /**
-         * Returns the request relative URL.
-         *
-         * @example
-         * ```js
-         * request.url()
-         *
-         * // include query string
-         * request.url(true)
-         * ```
-         */
-        url(includeQueryString?: boolean): string;
-        /**
-         * Returns the complete HTTP url by combining
-         * [[protocol]]://[[hostname]]/[[url]]
-         *
-         * @example
-         * ```js
-         * request.completeUrl()
-         *
-         * // include query string
-         * request.completeUrl(true)
-         * ```
-         */
-        completeUrl(includeQueryString?: boolean): string;
-        /**
-         * Find if the current HTTP request is for the given route or the routes
-         */
-        matchesRoute(routeIdentifier: string | string[]): boolean;
-        /**
-         * Returns the best matching content type of the request by
-         * matching against the given types.
-         *
-         * The content type is picked from the `content-type` header and request
-         * must have body.
-         *
-         * The method response highly depends upon the types array values. Described below:
-         *
-         * | Type(s) | Return value |
-         * |----------|---------------|
-         * | ['json'] | json |
-         * | ['application/*'] | application/json |
-         * | ['vnd+json'] | application/json |
-         *
-         * @example
-         * ```js
-         * const bodyType = request.is(['json', 'xml'])
-         *
-         * if (bodyType === 'json') {
-         *  // process JSON
-         * }
-         *
-         * if (bodyType === 'xml') {
-         *  // process XML
-         * }
-         * ```
-         */
-        is(types: string[]): string | null;
-        /**
-         * Returns the best type using `Accept` header and
-         * by matching it against the given types.
-         *
-         * If nothing is matched, then `null` will be returned
-         *
-         * Make sure to check [accepts](https://www.npmjs.com/package/accepts) package
-         * docs too.
-         *
-         * @example
-         * ```js
-         * switch (request.accepts(['json', 'html'])) {
-         *   case 'json':
-         *     return response.json(user)
-         *   case 'html':
-         *     return view.render('user', { user })
-         *   default:
-         *     // decide yourself
-         * }
-         * ```
-         */
-        accepts<T extends string>(types: T[]): T | null;
-        /**
-         * Return the types that the request accepts, in the order of the
-         * client's preference (most preferred first).
-         *
-         * Make sure to check [accepts](https://www.npmjs.com/package/accepts) package
-         * docs too.
-         */
-        types(): string[];
-        /**
-         * Returns the best language using `Accept-language` header
-         * and by matching it against the given languages.
-         *
-         * If nothing is matched, then `null` will be returned
-         *
-         * Make sure to check [accepts](https://www.npmjs.com/package/accepts) package
-         * docs too.
-         *
-         * @example
-         * ```js
-         * switch (request.language(['fr', 'de'])) {
-         *   case 'fr':
-         *     return view.render('about', { lang: 'fr' })
-         *   case 'de':
-         *     return view.render('about', { lang: 'de' })
-         *   default:
-         *     return view.render('about', { lang: 'en' })
-         * }
-         * ```
-         */
-        language<T extends string>(languages: T[]): T | null;
-        /**
-         * Return the languages that the request accepts, in the order of the
-         * client's preference (most preferred first).
-         *
-         * Make sure to check [accepts](https://www.npmjs.com/package/accepts) package
-         * docs too.
-         */
-        languages(): string[];
-        /**
-         * Returns the best encoding using `Accept-encoding` header
-         * and by matching it against the given encodings.
-         *
-         * If nothing is matched, then `null` will be returned
-         *
-         * Make sure to check [accepts](https://www.npmjs.com/package/accepts) package
-         * docs too.
-         */
-        encoding<T extends string>(encodings: T[]): T | null;
-        /**
-         * Return the charsets that the request accepts, in the order of the
-         * client's preference (most preferred first).
-         *
-         * Make sure to check [accepts](https://www.npmjs.com/package/accepts) package
-         * docs too.
-         */
-        encodings(): string[];
-        /**
-         * Returns the best charset using `Accept-charset` header
-         * and by matching it against the given charsets.
-         *
-         * If nothing is matched, then `null` will be returned
-         *
-         * Make sure to check [accepts](https://www.npmjs.com/package/accepts) package
-         * docs too.
-         *
-         * @example
-         * ```js
-         * switch (request.charset(['utf-8', 'ISO-8859-1'])) {
-         *   case 'utf-8':
-         *     // make utf-8 friendly response
-         *   case 'ISO-8859-1':
-         *     // make ISO-8859-1 friendly response
-         * }
-         * ```
-         */
-        charset<T extends string>(charsets: T[]): T | null;
-        /**
-         * Return the charsets that the request accepts, in the order of the
-         * client's preference (most preferred first).
-         *
-         * Make sure to check [accepts](https://www.npmjs.com/package/accepts) package
-         * docs too.
-         */
-        charsets(): string[];
-        /**
-         * Returns a boolean telling if request has body
-         */
-        hasBody(): boolean;
-        /**
-         * Returns a boolean telling if the new response etag evaluates same
-         * as the request header `if-none-match`. In case of `true`, the
-         * server must return `304` response, telling the browser to
-         * use the client cache.
-         *
-         * You won't have to deal with this method directly, since AdonisJs will
-         * handle this for you when `http.etag = true` inside `config/app.js` file.
-         *
-         * However, this is how you can use it manually.
-         *
-         * @example
-         * ```js
-         * const responseBody = view.render('some-view')
-         *
-         * // sets the HTTP etag header for response
-         * response.setEtag(responseBody)
-         *
-         * if (request.fresh()) {
-         *   response.sendStatus(304)
-         * } else {
-         *   response.send(responseBody)
-         * }
-         * ```
-         */
-        fresh(): boolean;
-        /**
-         * Opposite of [[fresh]]
-         */
-        stale(): boolean;
-        /**
-         * Returns all parsed and signed cookies. Signed cookies ensures
-         * that their value isn't tampered.
-         */
-        cookiesList(): Record<string, any>;
-        /**
-         * Returns value for a given key from signed cookies. Optional
-         * defaultValue is returned when actual value is undefined.
-         */
-        cookie(key: string, defaultValue?: any): any;
-        /**
-         * Returns value for a given key from signed cookies. Optional
-         * defaultValue is returned when actual value is undefined.
-         */
-        encryptedCookie(key: string, defaultValue?: any): any;
-        /**
-         * Returns value for a given key from unsigned cookies. Optional
-         * defaultValue is returned when actual value is undefined.
-         */
-        plainCookie(key: string, defaultValue?: any, encoded?: boolean): any;
-        /**
-         * Returns a boolean telling if a signed url as a valid signature
-         * or not.
-         */
-        hasValidSignature(purpose?: string): boolean;
-        /**
-         * toJSON copy of the request
-         */
-        toJSON(): any;
-    }
-    /**
-     * Shape of the request config
-     */
-    export type RequestConfig = {
-        forceContentNegotiationTo?: string | ((ctx: HttpContextContract) => string);
-        subdomainOffset: number;
-        generateRequestId: boolean;
-        allowMethodSpoofing: boolean;
-        getIp?: (request: RequestContract) => string;
-        trustProxy: (address: string, distance: number) => boolean;
-        useAsyncLocalStorage?: boolean;
-    };
-    /**
-     * Shape of request constructor, we export the constructor for others to
-     * add macros to the request class. Since, the instance is passed
-     * to the http request cycle
-     */
-    export interface RequestConstructorContract extends MacroableConstructorContract<RequestContract> {
-        new (request: IncomingMessage, response: ServerResponse, encryption: EncryptionContract, config: RequestConfig): RequestContract;
-    }
-    const Request: RequestConstructorContract;
-    export default Request;
-}

package/build/adonis-typings/request.js

@@ -1,8 +0,0 @@
-/**
- * @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.
- */