@adonisjs/http-server 6.8.2-9 → 7.0.0-0

package/build/factories/router.js

@@ -1,45 +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 { AppFactory } from '@adonisjs/application/factories';
-import { EncryptionFactory } from '@adonisjs/encryption/factories';
-import { Router } from '../src/router/main.js';
-import { QsParserFactory } from './qs_parser_factory.js';
-/**
- * Router factory is used to generate router class instances for
- * testing
- */
-export class RouterFactory {
-    #parameters = {};
-    /**
-     * Returns an instance of the application class
-     */
-    #getApp() {
-        return (this.#parameters.app || new AppFactory().create(new URL('./app/', import.meta.url), () => { }));
-    }
-    /**
-     * Returns an instance of the encryptor to encrypt
-     * signed URLs
-     */
-    #createEncryption() {
-        return this.#parameters.encryption || new EncryptionFactory().create();
-    }
-    /**
-     * Merge factory params
-     */
-    merge(params) {
-        Object.assign(this.#parameters, params);
-        return this;
-    }
-    /**
-     * Create router instance
-     */
-    create() {
-        return new Router(this.#getApp(), this.#createEncryption(), new QsParserFactory().create());
-    }
-}

package/build/factories/server_factory.d.ts

@@ -1,29 +0,0 @@
-import { Logger } from '@adonisjs/logger';
-import { Emitter } from '@adonisjs/events';
-import type { Encryption } from '@adonisjs/encryption';
-import type { Application } from '@adonisjs/application';
-import { Server } from '../src/server/main.js';
-import type { ServerConfig } from '../src/types/server.js';
-type FactoryParameters = {
-    app: Application<any>;
-    logger: Logger;
-    encryption: Encryption;
-    emitter: Emitter<any>;
-    config: Partial<ServerConfig>;
-};
-/**
- * Server factory is used to generate server class instances for
- * testing
- */
-export declare class ServerFactory {
-    #private;
-    /**
-     * Merge factory params
-     */
-    merge(params: Partial<FactoryParameters>): this;
-    /**
-     * Create server instance
-     */
-    create(): Server;
-}
-export {};

package/build/factories/server_factory.js

@@ -1,65 +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 { Logger } from '@adonisjs/logger';
-import { Emitter } from '@adonisjs/events';
-import { AppFactory } from '@adonisjs/application/factories';
-import { EncryptionFactory } from '@adonisjs/encryption/factories';
-import { Server } from '../src/server/main.js';
-import { defineConfig } from '../src/define_config.js';
-/**
- * Server factory is used to generate server class instances for
- * testing
- */
-export class ServerFactory {
-    #parameters = {};
-    /**
-     * Returns the emitter instance
-     */
-    #getEmitter() {
-        return this.#parameters.emitter || new Emitter(this.#getApp());
-    }
-    /**
-     * Returns the logger instance
-     */
-    #getLogger() {
-        return this.#parameters.logger || new Logger({ enabled: false });
-    }
-    /**
-     * Returns the config for the server class
-     */
-    #getConfig() {
-        return defineConfig(this.#parameters.config || {});
-    }
-    /**
-     * Returns an instance of the application class
-     */
-    #getApp() {
-        return (this.#parameters.app || new AppFactory().create(new URL('./app/', import.meta.url), () => { }));
-    }
-    /**
-     * Returns an instance of the encryptor to encrypt
-     * signed URLs
-     */
-    #createEncryption() {
-        return this.#parameters.encryption || new EncryptionFactory().create();
-    }
-    /**
-     * Merge factory params
-     */
-    merge(params) {
-        Object.assign(this.#parameters, params);
-        return this;
-    }
-    /**
-     * Create server instance
-     */
-    create() {
-        return new Server(this.#getApp(), this.#createEncryption(), this.#getEmitter(), this.#getLogger(), this.#getConfig());
-    }
-}

package/build/src/cookies/client.d.ts

@@ -1,37 +0,0 @@
-import type { Encryption } from '@adonisjs/encryption';
-/**
- * Cookie client exposes the API to parse/set AdonisJS cookies
- * as a client.
- */
-export declare class CookieClient {
-    #private;
-    constructor(encryption: Encryption);
-    /**
-     * Encrypt a key value pair to be sent in the cookie header
-     */
-    encrypt(key: string, value: any): string | null;
-    /**
-     * Sign a key value pair to be sent in the cookie header
-     */
-    sign(key: string, value: any): string | null;
-    /**
-     * Encode a key value pair to be sent in the cookie header
-     */
-    encode(_: string, value: any): string | null;
-    /**
-     * Unsign a signed cookie value
-     */
-    unsign(key: string, value: string): any;
-    /**
-     * Decrypt an encrypted cookie value
-     */
-    decrypt(key: string, value: string): any;
-    /**
-     * Decode an encoded cookie value
-     */
-    decode(_: string, value: string): any;
-    /**
-     * Parse response cookie
-     */
-    parse(key: string, value: any): any;
-}

package/build/src/cookies/client.js

@@ -1,84 +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 * as plainCookiesDriver from './drivers/plain.js';
-import * as signedCookiesDriver from './drivers/signed.js';
-import * as encryptedCookiesDriver from './drivers/encrypted.js';
-/**
- * Cookie client exposes the API to parse/set AdonisJS cookies
- * as a client.
- */
-export class CookieClient {
-    #encryption;
-    constructor(encryption) {
-        this.#encryption = encryption;
-    }
-    /**
-     * Encrypt a key value pair to be sent in the cookie header
-     */
-    encrypt(key, value) {
-        return encryptedCookiesDriver.pack(key, value, this.#encryption);
-    }
-    /**
-     * Sign a key value pair to be sent in the cookie header
-     */
-    sign(key, value) {
-        return signedCookiesDriver.pack(key, value, this.#encryption);
-    }
-    /**
-     * Encode a key value pair to be sent in the cookie header
-     */
-    encode(_, value) {
-        return plainCookiesDriver.pack(value);
-    }
-    /**
-     * Unsign a signed cookie value
-     */
-    unsign(key, value) {
-        return signedCookiesDriver.canUnpack(value)
-            ? signedCookiesDriver.unpack(key, value, this.#encryption)
-            : null;
-    }
-    /**
-     * Decrypt an encrypted cookie value
-     */
-    decrypt(key, value) {
-        return encryptedCookiesDriver.canUnpack(value)
-            ? encryptedCookiesDriver.unpack(key, value, this.#encryption)
-            : null;
-    }
-    /**
-     * Decode an encoded cookie value
-     */
-    decode(_, value) {
-        return plainCookiesDriver.canUnpack(value) ? plainCookiesDriver.unpack(value) : null;
-    }
-    /**
-     * Parse response cookie
-     */
-    parse(key, value) {
-        /**
-         * Unsign signed cookie
-         */
-        if (signedCookiesDriver.canUnpack(value)) {
-            return signedCookiesDriver.unpack(key, value, this.#encryption);
-        }
-        /**
-         * Decrypted encrypted cookie
-         */
-        if (encryptedCookiesDriver.canUnpack(value)) {
-            return encryptedCookiesDriver.unpack(key, value, this.#encryption);
-        }
-        /**
-         * Decode encoded cookie
-         */
-        if (plainCookiesDriver.canUnpack(value)) {
-            return plainCookiesDriver.unpack(value);
-        }
-    }
-}

package/build/src/cookies/drivers/encrypted.d.ts

@@ -1,16 +0,0 @@
-import type { Encryption } from '@adonisjs/encryption';
-/**
- * Encrypt a value to be set as cookie
- */
-export declare function pack(key: string, value: any, encryption: Encryption): null | string;
-/**
- * Returns a boolean, if the unpack method from this module can attempt
- * to unpack encrypted value.
- */
-export declare function canUnpack(encryptedValue: string): boolean;
-/**
- * Attempts to unpack the encrypted cookie value. Returns null, when fails to do so.
- * Only call this method, when `canUnpack` returns true, otherwise runtime
- * exceptions can be raised.
- */
-export declare function unpack(key: string, encryptedValue: string, encryption: Encryption): null | any;

package/build/src/cookies/drivers/encrypted.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.
- */
-/**
- * Encrypt a value to be set as cookie
- */
-export function pack(key, value, encryption) {
-    if (value === undefined || value === null) {
-        return null;
-    }
-    return `e:${encryption.encrypt(value, undefined, key)}`;
-}
-/**
- * Returns a boolean, if the unpack method from this module can attempt
- * to unpack encrypted value.
- */
-export function canUnpack(encryptedValue) {
-    return typeof encryptedValue === 'string' && encryptedValue.substring(0, 2) === 'e:';
-}
-/**
- * Attempts to unpack the encrypted cookie value. Returns null, when fails to do so.
- * Only call this method, when `canUnpack` returns true, otherwise runtime
- * exceptions can be raised.
- */
-export function unpack(key, encryptedValue, encryption) {
-    const value = encryptedValue.slice(2);
-    if (!value) {
-        return null;
-    }
-    return encryption.decrypt(value, key);
-}

package/build/src/cookies/drivers/plain.d.ts

@@ -1,15 +0,0 @@
-/**
- * Encodes a value into a base64 url encoded string to
- * be set as cookie
- */
-export declare function pack(value: any): null | string;
-/**
- * Returns true when this `unpack` method of this module can attempt
- * to unpack the encode value.
- */
-export declare function canUnpack(encodedValue: string): boolean;
-/**
- * Attempts to unpack the value by decoding it. Make sure to call, `canUnpack`
- * before calling this method
- */
-export declare function unpack(encodedValue: string): null | any;

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.d.ts

@@ -1,16 +0,0 @@
-import type { Encryption } from '@adonisjs/encryption';
-/**
- * Signs a value to be shared as a cookie. The signed output has a
- * hash to verify tampering with the original value
- */
-export declare function pack(key: string, value: any, encryption: Encryption): null | string;
-/**
- * Returns a boolean, if the unpack method from this module can attempt
- * to unpack the signed value.
- */
-export declare function canUnpack(signedValue: string): boolean;
-/**
- * Attempts to unpack the signed value. Make sure to call `canUnpack` before
- * calling this method.
- */
-export declare function unpack(key: string, signedValue: string, encryption: Encryption): null | any;

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.d.ts

@@ -1,37 +0,0 @@
-import type { Encryption } from '@adonisjs/encryption';
-/**
- * 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 declare class CookieParser {
-    #private;
-    constructor(cookieHeader: string, encryption: Encryption);
-    /**
-     * 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: string, encoded?: boolean): any | null;
-    /**
-     * 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: string): null | any;
-    /**
-     * 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: string): null | any;
-    /**
-     * Returns an object of cookies key-value pair. Do note, the
-     * cookies are not decoded, unsigned or decrypted inside this
-     * list.
-     */
-    list(): Record<string, any>;
-}

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.d.ts

@@ -1,33 +0,0 @@
-import type { Encryption } from '@adonisjs/encryption';
-import type { CookieOptions } from '../types/response.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 declare class CookieSerializer {
-    #private;
-    constructor(encryption: Encryption);
-    /**
-     * 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: string, value: any, options?: Partial<CookieOptions & {
-        encode: boolean;
-    }>): string | null;
-    /**
-     * 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: string, value: any, options?: Partial<CookieOptions>): string | null;
-    /**
-     * Encrypts a key-value pair to an encrypted cookie.
-     */
-    encrypt(key: string, value: any, options?: Partial<CookieOptions>): string | null;
-}