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

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

@@ -1,33 +0,0 @@
-/*
- * @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 { base64, MessageBuilder } from '@poppinss/utils';
-/**
- * Encodes a value into a base64 url encoded string to
- * be set as cookie
- */
-export function pack(value) {
-    if (value === undefined || value === null) {
-        return null;
-    }
-    return base64.urlEncode(new MessageBuilder().build(value));
-}
-/**
- * Returns true when this `unpack` method of this module can attempt
- * to unpack the encode value.
- */
-export function canUnpack(encodedValue) {
-    return typeof encodedValue === 'string';
-}
-/**
- * Attempts to unpack the value by decoding it. Make sure to call, `canUnpack`
- * before calling this method
- */
-export function unpack(encodedValue) {
-    return new MessageBuilder().verify(base64.urlDecode(encodedValue, 'utf-8', false));
-}

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

@@ -1,36 +0,0 @@
-/*
- * @adonisjs/http-server
- *
- * (c) AdonisJS
- *
- * For the full copyright and license information, please view the LICENSE
- * file that was distributed with this source code.
- */
-/**
- * Signs a value to be shared as a cookie. The signed output has a
- * hash to verify tampering with the original value
- */
-export function pack(key, value, encryption) {
-    if (value === undefined || value === null) {
-        return null;
-    }
-    return `s:${encryption.verifier.sign(value, undefined, key)}`;
-}
-/**
- * Returns a boolean, if the unpack method from this module can attempt
- * to unpack the signed value.
- */
-export function canUnpack(signedValue) {
-    return typeof signedValue === 'string' && signedValue.substring(0, 2) === 's:';
-}
-/**
- * Attempts to unpack the signed value. Make sure to call `canUnpack` before
- * calling this method.
- */
-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.js

@@ -1,167 +0,0 @@
-/*
- * @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 cookie from 'cookie';
-import { CookieClient } from './client.js';
-/**
- * Cookie parser parses the HTTP `cookie` header and collects all cookies
- * inside an object of `key-value` pair, but doesn't attempt to decrypt
- * or unsign or decode the individual values.
- *
- * The cookie values are lazily decrypted, or unsigned to avoid unncessary
- * processing, which infact can be used as a means to burden the server
- * by sending too many cookies which even doesn't belongs to the
- * server.
- */
-export class CookieParser {
-    #client;
-    /**
-     * A copy of cached cookies, they are cached during a request after
-     * initial decoding, unsigning or decrypting.
-     */
-    #cachedCookies = {
-        signedCookies: {},
-        plainCookies: {},
-        encryptedCookies: {},
-    };
-    /**
-     * An object of key-value pair collected by parsing
-     * the request cookie header.
-     */
-    #cookies;
-    constructor(cookieHeader, encryption) {
-        this.#client = new CookieClient(encryption);
-        this.#cookies = this.#parse(cookieHeader);
-    }
-    /**
-     * Parses the request `cookie` header
-     */
-    #parse(cookieHeader) {
-        /*
-         * Set to empty object when cookie header is empty string
-         */
-        if (!cookieHeader) {
-            return {};
-        }
-        /*
-         * Parse and store reference
-         */
-        return cookie.parse(cookieHeader);
-    }
-    /**
-     * Attempts to decode a cookie by the name. When calling this method,
-     * you are assuming that the cookie was just encoded in the first
-     * place and not signed or encrypted.
-     */
-    decode(key, encoded = true) {
-        /*
-         * Ignore when initial value is not defined or null
-         */
-        const value = this.#cookies[key];
-        if (value === null || value === undefined) {
-            return null;
-        }
-        /*
-         * Reference to the cache object. Mainly done to avoid typos,
-         * since this object is referenced a handful of times inside
-         * this method.
-         */
-        const cache = this.#cachedCookies.plainCookies;
-        /*
-         * Return from cache, when already parsed
-         */
-        if (cache[key] !== undefined) {
-            return cache[key];
-        }
-        /*
-         * Attempt to unpack and cache it for future. The value is only
-         * when value it is not null.
-         */
-        const parsed = encoded ? this.#client.decode(key, value) : value;
-        if (parsed !== null) {
-            cache[key] = parsed;
-        }
-        return parsed;
-    }
-    /**
-     * Attempts to unsign a cookie by the name. When calling this method,
-     * you are assuming that the cookie was signed in the first place.
-     */
-    unsign(key) {
-        /*
-         * Ignore when initial value is not defined or null
-         */
-        const value = this.#cookies[key];
-        if (value === null || value === undefined) {
-            return null;
-        }
-        /*
-         * Reference to the cache object. Mainly done to avoid typos,
-         * since this object is referenced a handful of times inside
-         * this method.
-         */
-        const cache = this.#cachedCookies.signedCookies;
-        /*
-         * Return from cache, when already parsed
-         */
-        if (cache[key] !== undefined) {
-            return cache[key];
-        }
-        /*
-         * Attempt to unpack and cache it for future. The value is only
-         * when value it is not null.
-         */
-        const parsed = this.#client.unsign(key, value);
-        if (parsed !== null) {
-            cache[key] = parsed;
-        }
-        return parsed;
-    }
-    /**
-     * Attempts to decrypt a cookie by the name. When calling this method,
-     * you are assuming that the cookie was encrypted in the first place.
-     */
-    decrypt(key) {
-        /*
-         * Ignore when initial value is not defined or null
-         */
-        const value = this.#cookies[key];
-        if (value === null || value === undefined) {
-            return null;
-        }
-        /*
-         * Reference to the cache object. Mainly done to avoid typos,
-         * since this object is referenced a handful of times inside
-         * this method.
-         */
-        const cache = this.#cachedCookies.encryptedCookies;
-        /*
-         * Return from cache, when already parsed
-         */
-        if (cache[key] !== undefined) {
-            return cache[key];
-        }
-        /*
-         * Attempt to unpack and cache it for future. The value is only
-         * when value it is not null.
-         */
-        const parsed = this.#client.decrypt(key, value);
-        if (parsed !== null) {
-            cache[key] = parsed;
-        }
-        return parsed;
-    }
-    /**
-     * Returns an object of cookies key-value pair. Do note, the
-     * cookies are not decoded, unsigned or decrypted inside this
-     * list.
-     */
-    list() {
-        return this.#cookies;
-    }
-}

package/build/src/cookies/serializer.js

@@ -1,79 +0,0 @@
-/*
- * @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 cookie from 'cookie';
-import string from '@poppinss/utils/string';
-import { CookieClient } from './client.js';
-/**
- * Cookies serializer is used to serialize a value to be set on the `Set-Cookie`
- * header. You can `encode`, `sign` on `encrypt` cookies using the serializer
- * and then set them individually using the `set-cookie` header.
- */
-export class CookieSerializer {
-    #client;
-    constructor(encryption) {
-        this.#client = new CookieClient(encryption);
-    }
-    /**
-     * Serializes the key-value pair to a string, that can be set on the
-     * `Set-Cookie` header.
-     */
-    #serializeAsCookie(key, value, options) {
-        /**
-         * Invoked expires method to get the date
-         */
-        let expires = options?.expires;
-        if (typeof expires === 'function') {
-            expires = expires();
-        }
-        /**
-         * Parse string based max age to seconds
-         */
-        let maxAge = options?.maxAge ? string.seconds.parse(options?.maxAge) : undefined;
-        const parsedOptions = Object.assign({}, options, { maxAge, expires });
-        return cookie.serialize(key, value, parsedOptions);
-    }
-    /**
-     * Encodes value as a plain cookie. By default, the plain value will be converted
-     * to a string using "JSON.stringify" method and then encoded as a base64 string.
-     *
-     * You can disable encoding of the cookie by setting `options.encoded = false`.
-     *
-     * ```ts
-     *  serializer.encode('name', 'virk')
-     * ```
-     */
-    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 a key-value pair to a signed cookie. The signed value has a
-     * verification hash attached to it to detect data tampering.
-     */
-    sign(key, value, options) {
-        const packedValue = this.#client.sign(key, value);
-        if (packedValue === null) {
-            return null;
-        }
-        return this.#serializeAsCookie(key, packedValue, options);
-    }
-    /**
-     * Encrypts a key-value pair to an encrypted cookie.
-     */
-    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.js

@@ -1,10 +0,0 @@
-/*
- * @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 { debuglog } from 'node:util';
-export default debuglog('adonisjs:http');

package/build/src/define_config.js

@@ -1,68 +0,0 @@
-/*
- * @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 proxyAddr from 'proxy-addr';
-import string from '@poppinss/utils/string';
-/**
- * Define configuration for the HTTP server
- */
-export function defineConfig(config) {
-    const { trustProxy, ...rest } = 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,
-            },
-        },
-        ...rest,
-    };
-    /**
-     * Normalizing maxAge property on cookies to be a number in
-     * seconds
-     */
-    if (normalizedConfig.cookie.maxAge) {
-        normalizedConfig.cookie.maxAge = string.seconds.parse(normalizedConfig.cookie.maxAge);
-    }
-    /**
-     * Normalizing trust proxy setting to allow boolean and
-     * string values
-     */
-    if (typeof trustProxy === 'boolean') {
-        const tpValue = trustProxy;
-        normalizedConfig.trustProxy = (_, __) => tpValue;
-    }
-    else if (typeof trustProxy === 'string') {
-        const tpValue = trustProxy;
-        normalizedConfig.trustProxy = proxyAddr.compile(tpValue);
-    }
-    return normalizedConfig;
-}

package/build/src/define_middleware.js

@@ -1,35 +0,0 @@
-/*
- * @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 { moduleImporter } from '@adonisjs/fold';
-/**
- * Converts a middleware name and its lazy import to a factory function. The function
- * can than later be used to reference the middleware with different arguments
- * every time.
- */
-function middlewareReferenceBuilder(name, middleware) {
-    const handler = moduleImporter(middleware, 'handle').toHandleMethod();
-    return function (...args) {
-        return {
-            name,
-            args: args[0],
-            ...handler,
-        };
-    };
-}
-/**
- * Define an collection of named middleware. The collection gets converted
- * into a collection of factory functions. Calling the function returns
- * a reference to the executable middleware.
- */
-export function defineNamedMiddleware(collection) {
-    return Object.keys(collection).reduce((result, key) => {
-        result[key] = middlewareReferenceBuilder(key, collection[key]);
-        return result;
-    }, {});
-}