@adonisjs/http-server 6.8.2-6 → 6.8.2-8

package/README.md

@@ -2,7 +2,7 @@
 
 <br />
 
-[![gh-workflow-image]][gh-workflow-url] [![npm-image]][npm-url] ![][typescript-image] [![license-image]][license-url] [![synk-image]][synk-url]
+[![gh-workflow-image]][gh-workflow-url] [![npm-image]][npm-url] ![][typescript-image] [![license-image]][license-url]
 
 ## Introduction
 Implementation of HTTP server used by AdonisJS. The package ships with a powerful **Router**, **Middleware pipeline**, helpers to create plain and signed URL for registered routes and much more.
@@ -21,8 +21,8 @@ In order to ensure that the AdonisJS community is welcoming to all, please revie
 ## License
 AdonisJS HTTP server is open-sourced software licensed under the [MIT license](LICENSE.md).
 
-[gh-workflow-image]: https://img.shields.io/github/actions/workflow/status/adonisjs/http-server/test.yml?style=for-the-badge
-[gh-workflow-url]: https://github.com/adonisjs/http-server/actions/workflows/test.yml "Github action"
+[gh-workflow-image]: https://img.shields.io/github/actions/workflow/status/adonisjs/http-server/checks.yml?style=for-the-badge
+[gh-workflow-url]: https://github.com/adonisjs/http-server/actions/workflows/checks.yml "Github action"
 
 [typescript-image]: https://img.shields.io/badge/Typescript-294E80.svg?style=for-the-badge&logo=typescript
 [typescript-url]:  "typescript"
@@ -32,6 +32,3 @@ AdonisJS HTTP server is open-sourced software licensed under the [MIT license](L
 
 [license-image]: https://img.shields.io/npm/l/@adonisjs/http-server?color=blueviolet&style=for-the-badge
 [license-url]: LICENSE.md "license"
-
-[synk-image]: https://img.shields.io/snyk/vulnerabilities/github/adonisjs/http-server?label=Synk%20Vulnerabilities&style=for-the-badge
-[synk-url]: https://snyk.io/test/github/adonisjs/http-server?targetFile=package.json "synk"

package/build/factories/http_context.d.ts

@@ -7,10 +7,19 @@ type FactoryParameters = {
     response: Response;
     logger: Logger;
 };
+/**
+ * HttpContext factory is used to generate Http context class instances for
+ * testing
+ */
 export declare class HttpContextFactory {
     #private;
+    /**
+     * Merge factory params
+     */
     merge(params: Partial<FactoryParameters>): this;
+    /**
+     * Create request
+     */
     create(): HttpContext;
 }
 export {};
-//# sourceMappingURL=http_context.d.ts.map

package/build/factories/http_context.js

@@ -1,23 +1,50 @@
+/*
+ * @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 { Container } from '@adonisjs/fold';
 import { LoggerFactory } from '@adonisjs/logger/factories';
 import { RequestFactory } from './request.js';
 import { ResponseFactory } from './response.js';
 import { HttpContext } from '../src/http_context/main.js';
+/**
+ * HttpContext factory is used to generate Http context class instances for
+ * testing
+ */
 export class HttpContextFactory {
     #parameters = {};
+    /**
+     * Returns the request class instance
+     */
     #createRequest() {
         return this.#parameters.request || new RequestFactory().create();
     }
+    /**
+     * Returns the response class instance
+     */
     #createResponse() {
         return this.#parameters.response || new ResponseFactory().create();
     }
+    /**
+     * Returns an instance of the logger class
+     */
     #createLogger() {
         return this.#parameters.logger || new LoggerFactory().create();
     }
+    /**
+     * Merge factory params
+     */
     merge(params) {
         Object.assign(this.#parameters, params);
         return this;
     }
+    /**
+     * Create request
+     */
     create() {
         return new HttpContext(this.#createRequest(), this.#createResponse(), this.#createLogger(), new Container().createResolver());
     }

package/build/factories/http_server.d.ts

@@ -0,0 +1,8 @@
+import { IncomingMessage, Server, ServerResponse } from 'node:http';
+export declare const httpServer: {
+    create(handler: (req: IncomingMessage, res: ServerResponse) => any | Promise<any>): Promise<{
+        server: Server;
+        url: string;
+        port: number;
+    }>;
+};

package/build/factories/http_server.js

@@ -0,0 +1,26 @@
+/*
+ * @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 getPort from 'get-port';
+import { getActiveTest } from '@japa/runner';
+import { createServer } from 'node:http';
+export const httpServer = {
+    async create(handler) {
+        const server = createServer(handler);
+        const test = getActiveTest();
+        test?.cleanup(() => {
+            server.close();
+        });
+        const port = await getPort({ port: 3000 });
+        return new Promise((resolve) => {
+            server.listen(port, 'localhost', () => {
+                return resolve({ server, port, url: `http://localhost:${port}` });
+            });
+        });
+    },
+};

package/build/factories/main.d.ts

@@ -4,4 +4,3 @@ export { RequestFactory } from './request.js';
 export { ResponseFactory } from './response.js';
 export { RouterFactory } from './router.js';
 export { ServerFactory } from './server_factory.js';
-//# sourceMappingURL=main.d.ts.map

package/build/factories/main.js

@@ -1,3 +1,11 @@
+/*
+ * @adonisjs/http-server
+ *
+ * (c) AdonisJS
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
 export { HttpContextFactory } from './http_context.js';
 export { QsParserFactory } from './qs_parser_factory.js';
 export { RequestFactory } from './request.js';

package/build/factories/qs_parser_factory.d.ts

@@ -1,11 +1,20 @@
 import { Qs } from '../src/qs.js';
 import type { QSParserConfig } from '../src/types/qs.js';
+/**
+ * QS Parser factory is used to generate the query string
+ * parser for testing
+ */
 export declare class QsParserFactory {
     #private;
+    /**
+     * Merge encryption factory options
+     */
     merge(options: Partial<{
         parse: Partial<QSParserConfig['parse']>;
         stringify: Partial<QSParserConfig['stringify']>;
     }>): this;
+    /**
+     * Create instance of the logger class
+     */
     create(): Qs;
 }
-//# sourceMappingURL=qs_parser_factory.d.ts.map

package/build/factories/qs_parser_factory.js

@@ -1,4 +1,16 @@
+/*
+ * @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 { Qs } from '../src/qs.js';
+/**
+ * QS Parser factory is used to generate the query string
+ * parser for testing
+ */
 export class QsParserFactory {
     #options = {
         parse: {
@@ -15,11 +27,17 @@ export class QsParserFactory {
             skipNulls: false,
         },
     };
+    /**
+     * Merge encryption factory options
+     */
     merge(options) {
         Object.assign(this.#options.parse, options.parse);
         Object.assign(this.#options.stringify, options.stringify);
         return this;
     }
+    /**
+     * Create instance of the logger class
+     */
     create() {
         return new Qs(this.#options);
     }

package/build/factories/request.d.ts

@@ -11,10 +11,19 @@ type FactoryParameters = {
     encryption: Encryption;
     config: Partial<RequestConfig>;
 };
+/**
+ * Request factory is used to generate request class instances for
+ * testing
+ */
 export declare class RequestFactory {
     #private;
+    /**
+     * Merge factory params
+     */
     merge(params: Partial<FactoryParameters>): this;
+    /**
+     * Create request
+     */
     create(): Request;
 }
 export {};
-//# sourceMappingURL=request.d.ts.map

package/build/factories/request.js

@@ -1,11 +1,26 @@
+/*
+ * @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 { Socket } from 'node:net';
 import proxyAddr from 'proxy-addr';
 import { IncomingMessage, ServerResponse } from 'node:http';
 import { EncryptionFactory } from '@adonisjs/encryption/factories';
 import { Request } from '../src/request.js';
 import { QsParserFactory } from './qs_parser_factory.js';
+/**
+ * Request factory is used to generate request class instances for
+ * testing
+ */
 export class RequestFactory {
     #parameters = {};
+    /**
+     * Returns the config for the request class
+     */
     #getConfig() {
         return {
             allowMethodSpoofing: false,
@@ -15,6 +30,9 @@ export class RequestFactory {
             ...this.#parameters.config,
         };
     }
+    /**
+     * Returns the HTTP req object
+     */
     #createRequest() {
         const req = this.#parameters.req || new IncomingMessage(new Socket());
         if (this.#parameters.url) {
@@ -25,16 +43,29 @@ export class RequestFactory {
         }
         return req;
     }
+    /**
+     * Returns the HTTP res object
+     */
     #createResponse(req) {
         return this.#parameters.res || new ServerResponse(req);
     }
+    /**
+     * 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 request
+     */
     create() {
         const req = this.#createRequest();
         return new Request(req, this.#createResponse(req), this.#createEncryption(), this.#getConfig(), new QsParserFactory().create());

package/build/factories/response.d.ts

@@ -11,10 +11,19 @@ type FactoryParameters = {
     config: Partial<ResponseConfig>;
     router: Router;
 };
+/**
+ * Response factory is used to generate response class instances for
+ * testing
+ */
 export declare class ResponseFactory {
     #private;
+    /**
+     * Merge factory params
+     */
     merge(params: Partial<FactoryParameters>): this;
+    /**
+     * Create response class instance
+     */
     create(): Response;
 }
 export {};
-//# sourceMappingURL=response.d.ts.map

package/build/factories/response.js

@@ -1,11 +1,26 @@
+/*
+ * @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 { Socket } from 'node:net';
 import { IncomingMessage, ServerResponse } from 'node:http';
 import { EncryptionFactory } from '@adonisjs/encryption/factories';
 import { RouterFactory } from './router.js';
 import { Response } from '../src/response.js';
 import { QsParserFactory } from './qs_parser_factory.js';
+/**
+ * Response factory is used to generate response class instances for
+ * testing
+ */
 export class ResponseFactory {
     #parameters = {};
+    /**
+     * Returns the config for the request class
+     */
     #getConfig() {
         return {
             etag: false,
@@ -20,22 +35,41 @@ export class ResponseFactory {
             ...this.#parameters.config,
         };
     }
+    /**
+     * Returns the HTTP req object
+     */
     #createRequest() {
         return this.#parameters.req || new IncomingMessage(new Socket());
     }
+    /**
+     * Returns an instance of the router
+     */
     #createRouter() {
         return this.#parameters.router || new RouterFactory().create();
     }
+    /**
+     * Returns the HTTP res object
+     */
     #createResponse(req) {
         return this.#parameters.res || new ServerResponse(req);
     }
+    /**
+     * 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 response class instance
+     */
     create() {
         const req = this.#createRequest();
         return new Response(req, this.#createResponse(req), this.#createEncryption(), this.#getConfig(), this.#createRouter(), new QsParserFactory().create());

package/build/factories/router.d.ts

@@ -5,10 +5,19 @@ type FactoryParameters = {
     app: Application<any>;
     encryption: Encryption;
 };
+/**
+ * Router factory is used to generate router class instances for
+ * testing
+ */
 export declare class RouterFactory {
     #private;
+    /**
+     * Merge factory params
+     */
     merge(params: Partial<FactoryParameters>): this;
+    /**
+     * Create router instance
+     */
     create(): Router;
 }
 export {};
-//# sourceMappingURL=router.d.ts.map

package/build/factories/router.js

@@ -1,19 +1,44 @@
+/*
+ * @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

@@ -11,10 +11,19 @@ type FactoryParameters = {
     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 {};
-//# sourceMappingURL=server_factory.d.ts.map

package/build/factories/server_factory.js

@@ -1,30 +1,64 @@
+/*
+ * @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/index.d.ts

@@ -12,4 +12,3 @@ export { CookieClient } from './src/cookies/client.js';
 export { HttpContext } from './src/http_context/main.js';
 export { RouteResource } from './src/router/resource.js';
 export { ExceptionHandler } from './src/exception_handler.js';
-//# sourceMappingURL=index.d.ts.map

package/build/index.js

@@ -1,3 +1,11 @@
+/*
+ * @adonisjs/http-server
+ *
+ * (c) AdonisJS
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
 export { Request } from './src/request.js';
 export { Response } from './src/response.js';
 export { Redirect } from './src/redirect.js';

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

@@ -1,13 +1,37 @@
 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;
 }
-//# sourceMappingURL=client.d.ts.map

package/build/src/cookies/client.js

@@ -1,40 +1,82 @@
+/*
+ * @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);
         }