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

package/build/src/http_context/main.js

@@ -0,0 +1,105 @@
+/*
+ * @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 { inspect } from 'node:util';
+import Macroable from '@poppinss/macroable';
+import { RuntimeException } from '@poppinss/utils';
+import { asyncLocalStorage } from './local_storage.js';
+/**
+ * Http context encapsulates properties for a given HTTP request. The
+ * context class can be extended using macros and getters.
+ */
+export class HttpContext extends Macroable {
+    request;
+    response;
+    logger;
+    containerResolver;
+    /**
+     * Find if async localstorage is enabled for HTTP requests
+     * or not
+     */
+    static get usingAsyncLocalStorage() {
+        return asyncLocalStorage.isEnabled;
+    }
+    /**
+     * Get access to the HTTP context. Available only when
+     * "usingAsyncLocalStorage" is true
+     */
+    static get() {
+        if (!this.usingAsyncLocalStorage || !asyncLocalStorage.storage) {
+            return null;
+        }
+        return asyncLocalStorage.storage.getStore() || null;
+    }
+    /**
+     * Get the HttpContext instance or raise an exception if not
+     * available
+     */
+    static getOrFail() {
+        /**
+         * Localstorage is not enabled
+         */
+        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;
+    }
+    /**
+     * Run a method that doesn't have access to HTTP context from
+     * the async local storage.
+     */
+    static runOutsideContext(callback, ...args) {
+        if (!asyncLocalStorage.storage) {
+            return callback(...args);
+        }
+        return asyncLocalStorage.storage.exit(callback, ...args);
+    }
+    /**
+     * Reference to the current route. Not available inside
+     * server middleware
+     */
+    route;
+    /**
+     * A unique key for the current route
+     */
+    routeKey;
+    /**
+     * Route params
+     */
+    params = {};
+    /**
+     * Route subdomains
+     */
+    subdomains = {};
+    constructor(request, response, logger, containerResolver) {
+        super();
+        this.request = request;
+        this.response = response;
+        this.logger = logger;
+        this.containerResolver = containerResolver;
+        /*
+         * Creating the circular reference. We do this, since request and response
+         * are meant to be extended and at times people would want to access
+         * other ctx properties like `logger`, `profiler` inside those
+         * extended methods.
+         */
+        this.request.ctx = this;
+        this.response.ctx = this;
+    }
+    /**
+     * A helper to see top level properties on the context object
+     */
+    /* c8 ignore next 3 */
+    inspect() {
+        return inspect(this, false, 1, true);
+    }
+}

package/build/src/qs.d.ts

@@ -0,0 +1,11 @@
+import { QSParserConfig } from './types/qs.js';
+/**
+ * Query string parser used to parse and stringify query
+ * strings.
+ */
+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,25 @@
+/*
+ * @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 { parse, stringify } from 'qs';
+/**
+ * Query string parser used to parse and stringify query
+ * strings.
+ */
+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,42 @@
+/// <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';
+/**
+ * Exposes the API to construct redirect routes
+ */
+export declare class Redirect {
+    #private;
+    constructor(request: IncomingMessage, response: Response, router: Router, qs: Qs);
+    /**
+     * Set a custom status code.
+     */
+    status(statusCode: number): this;
+    /**
+     * Clearing query string values added using the
+     * "withQs" method
+     */
+    clearQs(): this;
+    /**
+     * Define query string for the redirect. Not passing
+     * any value will forward the current request query
+     * string.
+     */
+    withQs(): this;
+    withQs(values: Record<string, any>): this;
+    withQs(name: string, value: any): this;
+    /**
+     * Redirect to the previous path.
+     */
+    back(): void;
+    /**
+     * Redirect the request using a route identifier.
+     */
+    toRoute(routeIdentifier: string, params?: any[] | Record<string, any>, options?: MakeUrlOptions): void;
+    /**
+     * Redirect the request using a path.
+     */
+    toPath(url: string): void;
+}

package/build/src/redirect.js

@@ -0,0 +1,140 @@
+/*
+ * @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 { parse } from 'node:url';
+import encodeUrl from 'encodeurl';
+import debug from './debug.js';
+/**
+ * Exposes the API to construct redirect routes
+ */
+export class Redirect {
+    /**
+     * A boolean to forward the existing query string
+     */
+    #forwardQueryString = false;
+    /**
+     * The status code for the redirect
+     */
+    #statusCode = 302;
+    /**
+     * A custom query string to forward
+     */
+    #queryString = {};
+    #request;
+    #response;
+    #router;
+    #qs;
+    constructor(request, response, router, qs) {
+        this.#request = request;
+        this.#response = response;
+        this.#router = router;
+        this.#qs = qs;
+    }
+    /**
+     * Sends response by setting require headers
+     */
+    #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}`);
+    }
+    /**
+     * Returns the referrer url
+     */
+    #getReferrerUrl() {
+        let url = this.#request.headers['referer'] || this.#request.headers['referrer'] || '/';
+        return Array.isArray(url) ? url[0] : url;
+    }
+    /**
+     * Set a custom status code.
+     */
+    status(statusCode) {
+        this.#statusCode = statusCode;
+        return this;
+    }
+    /**
+     * Clearing query string values added using the
+     * "withQs" method
+     */
+    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;
+    }
+    /**
+     * Redirect to the previous path.
+     */
+    back() {
+        let query = {};
+        const referrerUrl = this.#getReferrerUrl();
+        const url = parse(referrerUrl);
+        debug('referrer url "%s"', referrerUrl);
+        debug('referrer base url "%s"', url.pathname);
+        /**
+         * Parse query string from the referrer url
+         */
+        if (this.#forwardQueryString) {
+            query = this.#qs.parse(url.query || '');
+        }
+        /**
+         * Append custom query string
+         */
+        Object.assign(query, this.#queryString);
+        /**
+         * Redirect
+         */
+        this.#sendResponse(url.pathname || '', query);
+    }
+    /**
+     * Redirect the request using a route identifier.
+     */
+    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);
+    }
+    /**
+     * Redirect the request using a path.
+     */
+    toPath(url) {
+        let query = {};
+        /**
+         * Extract query string from the current URL
+         */
+        if (this.#forwardQueryString) {
+            query = this.#qs.parse(parse(this.#request.url).query || '');
+        }
+        /**
+         * Assign custom query string
+         */
+        Object.assign(query, this.#queryString);
+        /**
+         * Redirect
+         */
+        this.#sendResponse(url, query);
+    }
+}