@adonisjs/http-server 5.11.0 → 6.0.0-0

package/build/src/request.js

@@ -0,0 +1,315 @@
+import cuid from 'cuid';
+import fresh from 'fresh';
+import typeIs from 'type-is';
+import accepts from 'accepts';
+import { isIP } from 'node:net';
+import proxyaddr from 'proxy-addr';
+import { safeEqual } from '@poppinss/utils';
+import lodash from '@poppinss/utils/lodash';
+import { Macroable } from '@poppinss/macroable';
+import { parse } from 'node:url';
+import { trustProxy } from './helpers.js';
+import { CookieParser } from './cookies/parser.js';
+export class Request extends Macroable {
+    request;
+    response;
+    #qsParser;
+    #encryption;
+    #config;
+    #requestBody = {};
+    #requestData = {};
+    #originalRequestData = {};
+    #requestQs = {};
+    #rawRequestBody;
+    #lazyAccepts;
+    #cookieParser;
+    parsedUrl;
+    ctx;
+    constructor(request, response, encryption, config, qsParser) {
+        super();
+        this.request = request;
+        this.response = response;
+        this.#qsParser = qsParser;
+        this.#config = config;
+        this.#encryption = encryption;
+        this.parsedUrl = parse(this.request.url, false);
+        this.#parseQueryString();
+    }
+    #parseQueryString() {
+        if (this.parsedUrl.query) {
+            this.updateQs(this.#qsParser.parse(this.parsedUrl.query));
+            this.#originalRequestData = { ...this.#requestData };
+        }
+    }
+    #initiateCookieParser() {
+        if (!this.#cookieParser) {
+            this.#cookieParser = new CookieParser(this.header('cookie'), this.#encryption);
+        }
+    }
+    #initiateAccepts() {
+        this.#lazyAccepts = this.#lazyAccepts || accepts(this.request);
+    }
+    id() {
+        let requestId = this.header('x-request-id');
+        if (!requestId && this.#config.generateRequestId) {
+            requestId = cuid();
+            this.request.headers['x-request-id'] = requestId;
+        }
+        return requestId;
+    }
+    setInitialBody(body) {
+        if (this.#originalRequestData && Object.isFrozen(this.#originalRequestData)) {
+            throw new Error('Cannot re-set initial body. Use "request.updateBody" instead');
+        }
+        this.updateBody(body);
+        this.#originalRequestData = Object.freeze({ ...this.#requestData });
+    }
+    updateBody(body) {
+        this.#requestBody = body;
+        this.#requestData = { ...this.#requestBody, ...this.#requestQs };
+    }
+    updateRawBody(rawBody) {
+        this.#rawRequestBody = rawBody;
+    }
+    updateQs(data) {
+        this.#requestQs = data;
+        this.#requestData = { ...this.#requestBody, ...this.#requestQs };
+    }
+    params() {
+        return this.ctx?.params || {};
+    }
+    qs() {
+        return this.#requestQs;
+    }
+    body() {
+        return this.#requestBody;
+    }
+    all() {
+        return this.#requestData;
+    }
+    original() {
+        return this.#originalRequestData;
+    }
+    raw() {
+        return this.#rawRequestBody || null;
+    }
+    input(key, defaultValue) {
+        return lodash.get(this.#requestData, key, defaultValue);
+    }
+    param(key, defaultValue) {
+        return lodash.get(this.params(), key, defaultValue);
+    }
+    except(keys) {
+        return lodash.omit(this.#requestData, keys);
+    }
+    only(keys) {
+        return lodash.pick(this.#requestData, keys);
+    }
+    intended() {
+        return this.request.method;
+    }
+    method() {
+        if (this.#config.allowMethodSpoofing && this.intended() === 'POST') {
+            return this.input('_method', this.intended()).toUpperCase();
+        }
+        return this.intended();
+    }
+    headers() {
+        return this.request.headers;
+    }
+    header(key, defaultValue) {
+        key = key.toLowerCase();
+        const headers = this.headers();
+        switch (key) {
+            case 'referer':
+            case 'referrer':
+                return headers.referrer || headers.referer || defaultValue;
+            default:
+                return headers[key] || defaultValue;
+        }
+    }
+    ip() {
+        const ipFn = this.#config.getIp;
+        if (typeof ipFn === 'function') {
+            return ipFn(this);
+        }
+        return proxyaddr(this.request, this.#config.trustProxy);
+    }
+    ips() {
+        return proxyaddr.all(this.request, this.#config.trustProxy);
+    }
+    protocol() {
+        if ('encrypted' in this.request.socket) {
+            return 'https';
+        }
+        if (!trustProxy(this.request.socket.remoteAddress, this.#config.trustProxy)) {
+            return this.parsedUrl.protocol || 'http';
+        }
+        const forwardedProtocol = this.header('X-Forwarded-Proto');
+        return forwardedProtocol ? forwardedProtocol.split(/\s*,\s*/)[0] : 'http';
+    }
+    secure() {
+        return this.protocol() === 'https';
+    }
+    host() {
+        let host = this.header('host');
+        if (trustProxy(this.request.socket.remoteAddress, this.#config.trustProxy)) {
+            host = this.header('X-Forwarded-Host') || host;
+        }
+        if (!host) {
+            return null;
+        }
+        return host;
+    }
+    hostname() {
+        const host = this.host();
+        if (!host) {
+            return null;
+        }
+        const offset = host[0] === '[' ? host.indexOf(']') + 1 : 0;
+        const index = host.indexOf(':', offset);
+        return index !== -1 ? host.substring(0, index) : host;
+    }
+    subdomains() {
+        const hostname = this.hostname();
+        if (!hostname || isIP(hostname)) {
+            return [];
+        }
+        const offset = this.#config.subdomainOffset;
+        const subdomains = hostname.split('.').reverse().slice(offset);
+        if (subdomains[subdomains.length - 1] === 'www') {
+            subdomains.splice(subdomains.length - 1, 1);
+        }
+        return subdomains;
+    }
+    ajax() {
+        const xRequestedWith = this.header('X-Requested-With', '');
+        return xRequestedWith.toLowerCase() === 'xmlhttprequest';
+    }
+    pjax() {
+        return !!this.header('X-Pjax');
+    }
+    url(includeQueryString) {
+        const pathname = this.parsedUrl.pathname;
+        return includeQueryString && this.parsedUrl.query
+            ? `${pathname}?${this.parsedUrl.query}`
+            : pathname;
+    }
+    completeUrl(includeQueryString) {
+        const protocol = this.protocol();
+        const hostname = this.host();
+        return `${protocol}://${hostname}${this.url(includeQueryString)}`;
+    }
+    matchesRoute(routeIdentifier) {
+        if (!this.ctx || !this.ctx.route) {
+            return false;
+        }
+        const route = this.ctx.route;
+        return !!(Array.isArray(routeIdentifier) ? routeIdentifier : [routeIdentifier]).find((identifier) => {
+            if (route.pattern === identifier || route.name === identifier) {
+                return true;
+            }
+            if (typeof route.handler === 'function') {
+                return false;
+            }
+            return route.handler.name === identifier;
+        });
+    }
+    is(types) {
+        return typeIs(this.request, types) || null;
+    }
+    accepts(types) {
+        this.#initiateAccepts();
+        return this.#lazyAccepts.type(types) || null;
+    }
+    types() {
+        this.#initiateAccepts();
+        return this.#lazyAccepts.types();
+    }
+    language(languages) {
+        this.#initiateAccepts();
+        return this.#lazyAccepts.language(languages) || null;
+    }
+    languages() {
+        this.#initiateAccepts();
+        return this.#lazyAccepts.languages();
+    }
+    charset(charsets) {
+        this.#initiateAccepts();
+        return this.#lazyAccepts.charset(charsets) || null;
+    }
+    charsets() {
+        this.#initiateAccepts();
+        return this.#lazyAccepts.charsets();
+    }
+    encoding(encodings) {
+        this.#initiateAccepts();
+        return this.#lazyAccepts.encoding(encodings) || null;
+    }
+    encodings() {
+        this.#initiateAccepts();
+        return this.#lazyAccepts.encodings();
+    }
+    hasBody() {
+        return typeIs.hasBody(this.request);
+    }
+    fresh() {
+        if (['GET', 'HEAD'].indexOf(this.intended()) === -1) {
+            return false;
+        }
+        const status = this.response.statusCode;
+        if ((status >= 200 && status < 300) || status === 304) {
+            return fresh(this.headers(), this.response.getHeaders());
+        }
+        return false;
+    }
+    stale() {
+        return !this.fresh();
+    }
+    cookiesList() {
+        this.#initiateCookieParser();
+        return this.#cookieParser.list();
+    }
+    cookie(key, defaultValue) {
+        this.#initiateCookieParser();
+        return this.#cookieParser.unsign(key) || defaultValue;
+    }
+    encryptedCookie(key, defaultValue) {
+        this.#initiateCookieParser();
+        return this.#cookieParser.decrypt(key) || defaultValue;
+    }
+    plainCookie(key, defaultValue, encoded) {
+        this.#initiateCookieParser();
+        return this.#cookieParser.decode(key, encoded) || defaultValue;
+    }
+    hasValidSignature(purpose) {
+        const { signature, ...rest } = this.qs();
+        if (!signature) {
+            return false;
+        }
+        const signedUrl = this.#encryption.verifier.unsign(signature, purpose);
+        if (!signedUrl) {
+            return false;
+        }
+        const queryString = this.#qsParser.stringify(rest);
+        return queryString
+            ? safeEqual(signedUrl, `${this.url()}?${queryString}`)
+            : safeEqual(signedUrl, this.url());
+    }
+    toJSON() {
+        return {
+            id: this.id(),
+            url: this.url(),
+            query: this.parsedUrl.query,
+            body: this.all(),
+            params: this.params(),
+            headers: this.headers(),
+            method: this.method(),
+            protocol: this.protocol(),
+            cookies: this.cookiesList(),
+            hostname: this.hostname(),
+            ip: this.ip(),
+            subdomains: this.ctx?.subdomains || {},
+        };
+    }
+}

package/build/src/response.d.ts

@@ -0,0 +1,108 @@
+/// <reference types="node" resolution-mode="require"/>
+/// <reference types="node" resolution-mode="require"/>
+import { Macroable } from '@poppinss/macroable';
+import type Encryption from '@adonisjs/encryption';
+import { ServerResponse, IncomingMessage } from 'node:http';
+import type { Qs } from './qs.js';
+import { Redirect } from './redirect.js';
+import type { Router } from './router/main.js';
+import type { HttpContext } from './http_context/main.js';
+import type { CastableHeader, CookieOptions, ResponseConfig, ResponseStream } from './types/response.js';
+export declare class Response extends Macroable {
+    #private;
+    request: IncomingMessage;
+    response: ServerResponse;
+    get hasLazyBody(): boolean;
+    get isStreamResponse(): boolean;
+    lazyBody: Partial<{
+        content: [any, boolean, string?];
+        stream: [ResponseStream, ((error: NodeJS.ErrnoException) => [string, number?])?];
+        fileToStream: [string, boolean, ((error: NodeJS.ErrnoException) => [string, number?])?];
+    }>;
+    ctx?: HttpContext;
+    constructor(request: IncomingMessage, response: ServerResponse, encryption: Encryption, config: ResponseConfig, router: Router, qs: Qs);
+    get finished(): boolean;
+    get headersSent(): boolean;
+    get isPending(): boolean;
+    protected writeBody(content: any, generateEtag: boolean, jsonpCallbackName?: string): void;
+    protected streamBody(body: ResponseStream, errorCallback?: (error: NodeJS.ErrnoException) => [string, number?]): Promise<void>;
+    protected streamFileForDownload(filePath: string, generateEtag: boolean, errorCallback?: (error: NodeJS.ErrnoException) => [string, number?]): Promise<void>;
+    flushHeaders(statusCode?: number): this;
+    getHeader(key: string): import("http").OutgoingHttpHeader | undefined;
+    getHeaders(): {
+        [x: string]: import("http").OutgoingHttpHeader | undefined;
+    };
+    header(key: string, value: CastableHeader): this;
+    append(key: string, value: CastableHeader): this;
+    safeHeader(key: string, value: CastableHeader): this;
+    removeHeader(key: string): this;
+    getStatus(): number;
+    status(code: number): this;
+    safeStatus(code: number): this;
+    type(type: string, charset?: string): this;
+    vary(field: string | string[]): this;
+    setEtag(body: any, weak?: boolean): this;
+    fresh(): boolean;
+    getBody(): any;
+    send(body: any, generateEtag?: boolean): void;
+    json(body: any, generateEtag?: boolean): void;
+    jsonp(body: any, callbackName?: string, generateEtag?: boolean): void;
+    stream(body: ResponseStream, errorCallback?: (error: NodeJS.ErrnoException) => [string, number?]): void;
+    download(filePath: string, generateEtag?: boolean, errorCallback?: (error: NodeJS.ErrnoException) => [string, number?]): void;
+    attachment(filePath: string, name?: string, disposition?: string, generateEtag?: boolean, errorCallback?: (error: NodeJS.ErrnoException) => [string, number?]): void;
+    location(url: string): this;
+    redirect(): Redirect;
+    redirect(path: string, forwardQueryString?: boolean, statusCode?: number): void;
+    abort(body: any, status?: number): never;
+    abortIf(condition: unknown, body: any, status?: number): asserts condition is undefined | null | false;
+    abortUnless<T>(condition: T, body: any, status?: number): asserts condition is Exclude<T, undefined | null | false>;
+    cookie(key: string, value: any, options?: Partial<CookieOptions>): this;
+    encryptedCookie(key: string, value: any, options?: Partial<CookieOptions>): this;
+    plainCookie(key: string, value: any, options?: Partial<CookieOptions & {
+        encode: boolean;
+    }>): this;
+    clearCookie(key: string, options?: Partial<CookieOptions>): this;
+    finish(): void;
+    continue(): void;
+    switchingProtocols(): void;
+    ok(body: any, generateEtag?: boolean): void;
+    created(body?: any, generateEtag?: boolean): void;
+    accepted(body: any, generateEtag?: boolean): void;
+    nonAuthoritativeInformation(body: any, generateEtag?: boolean): void;
+    noContent(): void;
+    resetContent(): void;
+    partialContent(body: any, generateEtag?: boolean): void;
+    multipleChoices(body?: any, generateEtag?: boolean): void;
+    movedPermanently(body?: any, generateEtag?: boolean): void;
+    movedTemporarily(body?: any, generateEtag?: boolean): void;
+    seeOther(body?: any, generateEtag?: boolean): void;
+    notModified(body?: any, generateEtag?: boolean): void;
+    useProxy(body?: any, generateEtag?: boolean): void;
+    temporaryRedirect(body?: any, generateEtag?: boolean): void;
+    badRequest(body?: any, generateEtag?: boolean): void;
+    unauthorized(body?: any, generateEtag?: boolean): void;
+    paymentRequired(body?: any, generateEtag?: boolean): void;
+    forbidden(body?: any, generateEtag?: boolean): void;
+    notFound(body?: any, generateEtag?: boolean): void;
+    methodNotAllowed(body?: any, generateEtag?: boolean): void;
+    notAcceptable(body?: any, generateEtag?: boolean): void;
+    proxyAuthenticationRequired(body?: any, generateEtag?: boolean): void;
+    requestTimeout(body?: any, generateEtag?: boolean): void;
+    conflict(body?: any, generateEtag?: boolean): void;
+    gone(body?: any, generateEtag?: boolean): void;
+    lengthRequired(body?: any, generateEtag?: boolean): void;
+    preconditionFailed(body?: any, generateEtag?: boolean): void;
+    requestEntityTooLarge(body?: any, generateEtag?: boolean): void;
+    requestUriTooLong(body?: any, generateEtag?: boolean): void;
+    unsupportedMediaType(body?: any, generateEtag?: boolean): void;
+    requestedRangeNotSatisfiable(body?: any, generateEtag?: boolean): void;
+    expectationFailed(body?: any, generateEtag?: boolean): void;
+    unprocessableEntity(body?: any, generateEtag?: boolean): void;
+    tooManyRequests(body?: any, generateEtag?: boolean): void;
+    internalServerError(body?: any, generateEtag?: boolean): void;
+    notImplemented(body?: any, generateEtag?: boolean): void;
+    badGateway(body?: any, generateEtag?: boolean): void;
+    serviceUnavailable(body?: any, generateEtag?: boolean): void;
+    gatewayTimeout(body?: any, generateEtag?: boolean): void;
+    httpVersionNotSupported(body?: any, generateEtag?: boolean): void;
+}