@athenna/http 3.2.1 → 3.4.0

package/build/Commands/MakeControllerCommand.d.ts

@@ -12,4 +12,16 @@ export declare class MakeControllerCommand extends BaseCommand {
     static signature(): string;
     static description(): string;
     handle(): Promise<void>;
+    /**
+     * Get the file path where it will be generated.
+     */
+    private getFilePath;
+    /**
+     * Get the destination path for the file that will be generated.
+     */
+    private getDestinationPath;
+    /**
+     * Get the import path that should be registered in RC file.
+     */
+    private getImportPath;
 }

package/build/Commands/MakeControllerCommand.js

@@ -13,6 +13,7 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
 import { Path } from '@athenna/common';
+import { sep, resolve, isAbsolute } from 'node:path';
 import { BaseCommand, Argument } from '@athenna/artisan';
 export class MakeControllerCommand extends BaseCommand {
     name;
@@ -25,15 +26,41 @@ export class MakeControllerCommand extends BaseCommand {
     async handle() {
         this.logger.simple('({bold,green} [ MAKING CONTROLLER ])\n');
         const file = await this.generator
-            .path(Path.http(`Controllers/${this.name}.${Path.ext()}`))
+            .path(this.getFilePath())
             .template('controller')
             .setNameProperties(true)
             .make();
         this.logger.success(`Controller ({yellow} "${file.name}") successfully created.`);
-        const importPath = `#app/Http/Controllers/${file.name}`;
+        const importPath = this.getImportPath(file.name);
         await this.rc.pushTo('controllers', importPath).save();
         this.logger.success(`Athenna RC updated: ({dim,yellow} [ controllers += "${importPath}" ])`);
     }
+    /**
+     * Get the file path where it will be generated.
+     */
+    getFilePath() {
+        return this.getDestinationPath().concat(`${sep}${this.name}.${Path.ext()}`);
+    }
+    /**
+     * Get the destination path for the file that will be generated.
+     */
+    getDestinationPath() {
+        let destination = Config.get('rc.commandsManifest.make:controller.destination', Path.http('Controllers'));
+        if (!isAbsolute(destination)) {
+            destination = resolve(Path.pwd(), destination);
+        }
+        return destination;
+    }
+    /**
+     * Get the import path that should be registered in RC file.
+     */
+    getImportPath(fileName) {
+        const destination = this.getDestinationPath();
+        return `${destination
+            .replace(Path.pwd(), '')
+            .replace(/\\/g, '/')
+            .replace('/', '#')}/${fileName}`;
+    }
 }
 __decorate([
     Argument({

package/build/Commands/MakeInterceptorCommand.d.ts

@@ -12,4 +12,16 @@ export declare class MakeInterceptorCommand extends BaseCommand {
     static signature(): string;
     static description(): string;
     handle(): Promise<void>;
+    /**
+     * Get the file path where it will be generated.
+     */
+    private getFilePath;
+    /**
+     * Get the destination path for the file that will be generated.
+     */
+    private getDestinationPath;
+    /**
+     * Get the import path that should be registered in RC file.
+     */
+    private getImportPath;
 }

package/build/Commands/MakeInterceptorCommand.js

@@ -13,6 +13,7 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
 import { Path } from '@athenna/common';
+import { sep, resolve, isAbsolute } from 'node:path';
 import { BaseCommand, Argument } from '@athenna/artisan';
 export class MakeInterceptorCommand extends BaseCommand {
     name;
@@ -25,15 +26,41 @@ export class MakeInterceptorCommand extends BaseCommand {
     async handle() {
         this.logger.simple('({bold,green} [ MAKING INTERCEPTOR ])\n');
         const file = await this.generator
-            .path(Path.http(`Interceptors/${this.name}.${Path.ext()}`))
+            .path(this.getFilePath())
             .template('interceptor')
             .setNameProperties(true)
             .make();
         this.logger.success(`Interceptor ({yellow} "${file.name}") successfully created.`);
-        const importPath = `#app/Http/Interceptors/${file.name}`;
+        const importPath = this.getImportPath(file.name);
         await this.rc.pushTo('middlewares', importPath).save();
         this.logger.success(`Athenna RC updated: ({dim,yellow} [ middlewares += "${importPath}" ])`);
     }
+    /**
+     * Get the file path where it will be generated.
+     */
+    getFilePath() {
+        return this.getDestinationPath().concat(`${sep}${this.name}.${Path.ext()}`);
+    }
+    /**
+     * Get the destination path for the file that will be generated.
+     */
+    getDestinationPath() {
+        let destination = Config.get('rc.commandsManifest.make:interceptor.destination', Path.http('Interceptors'));
+        if (!isAbsolute(destination)) {
+            destination = resolve(Path.pwd(), destination);
+        }
+        return destination;
+    }
+    /**
+     * Get the import path that should be registered in RC file.
+     */
+    getImportPath(fileName) {
+        const destination = this.getDestinationPath();
+        return `${destination
+            .replace(Path.pwd(), '')
+            .replace(/\\/g, '/')
+            .replace('/', '#')}/${fileName}`;
+    }
 }
 __decorate([
     Argument({

package/build/Commands/MakeMiddlewareCommand.d.ts

@@ -12,4 +12,16 @@ export declare class MakeMiddlewareCommand extends BaseCommand {
     static signature(): string;
     static description(): string;
     handle(): Promise<void>;
+    /**
+     * Get the file path where it will be generated.
+     */
+    private getFilePath;
+    /**
+     * Get the destination path for the file that will be generated.
+     */
+    private getDestinationPath;
+    /**
+     * Get the import path that should be registered in RC file.
+     */
+    private getImportPath;
 }

package/build/Commands/MakeMiddlewareCommand.js

@@ -13,6 +13,7 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
 import { Path } from '@athenna/common';
+import { sep, resolve, isAbsolute } from 'node:path';
 import { BaseCommand, Argument } from '@athenna/artisan';
 export class MakeMiddlewareCommand extends BaseCommand {
     name;
@@ -25,15 +26,41 @@ export class MakeMiddlewareCommand extends BaseCommand {
     async handle() {
         this.logger.simple('({bold,green} [ MAKING MIDDLEWARE ])\n');
         const file = await this.generator
-            .path(Path.http(`Middlewares/${this.name}.${Path.ext()}`))
+            .path(this.getFilePath())
             .template('middleware')
             .setNameProperties(true)
             .make();
         this.logger.success(`Middleware ({yellow} "${file.name}") successfully created.`);
-        const importPath = `#app/Http/Middlewares/${file.name}`;
+        const importPath = this.getImportPath(file.name);
         await this.rc.pushTo('middlewares', importPath).save();
         this.logger.success(`Athenna RC updated: ({dim,yellow} [ middlewares += "${importPath}" ])`);
     }
+    /**
+     * Get the file path where it will be generated.
+     */
+    getFilePath() {
+        return this.getDestinationPath().concat(`${sep}${this.name}.${Path.ext()}`);
+    }
+    /**
+     * Get the destination path for the file that will be generated.
+     */
+    getDestinationPath() {
+        let destination = Config.get('rc.commandsManifest.make:middleware.destination', Path.http('Middlewares'));
+        if (!isAbsolute(destination)) {
+            destination = resolve(Path.pwd(), destination);
+        }
+        return destination;
+    }
+    /**
+     * Get the import path that should be registered in RC file.
+     */
+    getImportPath(fileName) {
+        const destination = this.getDestinationPath();
+        return `${destination
+            .replace(Path.pwd(), '')
+            .replace(/\\/g, '/')
+            .replace('/', '#')}/${fileName}`;
+    }
 }
 __decorate([
     Argument({

package/build/Commands/MakeTerminatorCommand.d.ts

@@ -12,4 +12,16 @@ export declare class MakeTerminatorCommand extends BaseCommand {
     static signature(): string;
     static description(): string;
     handle(): Promise<void>;
+    /**
+     * Get the file path where it will be generated.
+     */
+    private getFilePath;
+    /**
+     * Get the destination path for the file that will be generated.
+     */
+    private getDestinationPath;
+    /**
+     * Get the import path that should be registered in RC file.
+     */
+    private getImportPath;
 }

package/build/Commands/MakeTerminatorCommand.js

@@ -13,6 +13,7 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
 import { Path } from '@athenna/common';
+import { sep, resolve, isAbsolute } from 'node:path';
 import { BaseCommand, Argument } from '@athenna/artisan';
 export class MakeTerminatorCommand extends BaseCommand {
     name;
@@ -25,15 +26,41 @@ export class MakeTerminatorCommand extends BaseCommand {
     async handle() {
         this.logger.simple('({bold,green} [ MAKING TERMINATOR ])\n');
         const file = await this.generator
-            .path(Path.http(`Terminators/${this.name}.${Path.ext()}`))
+            .path(this.getFilePath())
             .template('terminator')
             .setNameProperties(true)
             .make();
         this.logger.success(`Terminator ({yellow} "${file.name}") successfully created.`);
-        const importPath = `#app/Http/Terminators/${file.name}`;
+        const importPath = this.getImportPath(file.name);
         await this.rc.pushTo('middlewares', importPath).save();
         this.logger.success(`Athenna RC updated: ({dim,yellow} [ middlewares += "${importPath}" ])`);
     }
+    /**
+     * Get the file path where it will be generated.
+     */
+    getFilePath() {
+        return this.getDestinationPath().concat(`${sep}${this.name}.${Path.ext()}`);
+    }
+    /**
+     * Get the destination path for the file that will be generated.
+     */
+    getDestinationPath() {
+        let destination = Config.get('rc.commandsManifest.make:terminator.destination', Path.http('Terminators'));
+        if (!isAbsolute(destination)) {
+            destination = resolve(Path.pwd(), destination);
+        }
+        return destination;
+    }
+    /**
+     * Get the import path that should be registered in RC file.
+     */
+    getImportPath(fileName) {
+        const destination = this.getDestinationPath();
+        return `${destination
+            .replace(Path.pwd(), '')
+            .replace(/\\/g, '/')
+            .replace('/', '#')}/${fileName}`;
+    }
 }
 __decorate([
     Argument({

package/build/Commands/RouteListCommand.d.ts

@@ -8,8 +8,15 @@
  */
 import { BaseCommand } from '@athenna/artisan';
 export declare class RouteListCommand extends BaseCommand {
-    routeFilePath: any;
     static signature(): string;
     static description(): string;
     handle(): Promise<void>;
+    /**
+     * Resolve the http routes file.
+     */
+    private resolveRoute;
+    /**
+     * Get the http kernel module from RC file or resolve the default one.
+     */
+    private getHttpKernel;
 }

package/build/Commands/RouteListCommand.js

@@ -11,7 +11,6 @@ import { Module } from '@athenna/common';
 import { BaseCommand } from '@athenna/artisan';
 import { Route, HttpKernel, HttpRouteProvider, HttpServerProvider } from '#src';
 export class RouteListCommand extends BaseCommand {
-    routeFilePath = Env('HTTP_ROUTE_FILE_PATH', Path.routes('http.js'));
     static signature() {
         return 'route:list';
     }
@@ -22,10 +21,10 @@ export class RouteListCommand extends BaseCommand {
         this.logger.simple('({bold,green} [ LISTING ROUTES ])\n');
         new HttpServerProvider().register();
         new HttpRouteProvider().register();
-        const kernel = new HttpKernel();
+        const kernel = new (await this.getHttpKernel())();
         await kernel.registerControllers();
         await kernel.registerMiddlewares();
-        await Module.resolve(this.routeFilePath, Config.get('rc.meta'));
+        await this.resolveRoute();
         const routes = Route.list();
         const table = this.logger.table();
         table.head('Methods', 'Route', 'Name', 'Handler');
@@ -42,4 +41,19 @@ export class RouteListCommand extends BaseCommand {
         });
         table.render();
     }
+    /**
+     * Resolve the http routes file.
+     */
+    async resolveRoute() {
+        await Module.resolve(Config.get('rc.commandsManifest.route:list.route', '#routes/http'), Config.get('rc.meta'));
+    }
+    /**
+     * Get the http kernel module from RC file or resolve the default one.
+     */
+    async getHttpKernel() {
+        if (!Config.exists('rc.commandsManifest.route:list.kernel')) {
+            return HttpKernel;
+        }
+        return Module.resolve(Config.get('rc.commandsManifest.route:list.kernel'), Config.get('rc.meta'));
+    }
 }

package/build/Testing/Plugins/Request/TestRequest.d.ts

@@ -0,0 +1,98 @@
+/**
+ * @athenna/http
+ *
+ * (c) João Lenon <lenon@athenna.io>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+import { Assert } from '@japa/assert';
+import { InjectOptions } from 'fastify';
+import { TestResponse } from '#src/Testing/Plugins/Request/TestResponse';
+export declare class TestRequest {
+    /**
+     * Japa assert class instance.
+     */
+    assert: Assert;
+    /**
+     * Instantiate TestResponse class from API response.
+     */
+    createResponse(response: any): TestResponse;
+    /**
+     * Make a GET request to the given URL and options.
+     *
+     * @example
+     * ```js
+     * const response = await request.get('/users')
+     *
+     * response.assertStatusCode(200)
+     * ```
+     */
+    get(url: string, options?: InjectOptions): Promise<TestResponse>;
+    /**
+     * Make a HEAD request to the given URL and options.
+     *
+     * @example
+     * ```js
+     * const response = await request.head('/users')
+     *
+     * response.assertStatusCode(200)
+     * ```
+     */
+    head(url: string, options?: InjectOptions): Promise<TestResponse>;
+    /**
+     * Make a OPTIONS request to the given URL and options.
+     *
+     * @example
+     * ```js
+     * const response = await request.options('/users')
+     *
+     * response.assertStatusCode(200)
+     * ```
+     */
+    options(url: string, options?: InjectOptions): Promise<TestResponse>;
+    /**
+     * Make a POST request to the given URL and options.
+     *
+     * @example
+     * ```js
+     * const response = await request.post('/users')
+     *
+     * response.assertStatusCode(200)
+     * ```
+     */
+    post(url: string, options?: InjectOptions): Promise<TestResponse>;
+    /**
+     * Make a PUT request to the given URL and options.
+     *
+     * @example
+     * ```js
+     * const response = await request.put('/users')
+     *
+     * response.assertStatusCode(200)
+     * ```
+     */
+    put(url: string, options?: InjectOptions): Promise<TestResponse>;
+    /**
+     * Make a PATCH request to the given URL and options.
+     *
+     * @example
+     * ```js
+     * const response = await request.patch('/users')
+     *
+     * response.assertStatusCode(200)
+     * ```
+     */
+    patch(url: string, options?: InjectOptions): Promise<TestResponse>;
+    /**
+     * Make a DELETE request to the given URL and options.
+     *
+     * @example
+     * ```js
+     * const response = await request.delete('/users')
+     *
+     * response.assertStatusCode(200)
+     * ```
+     */
+    delete(url: string, options?: InjectOptions): Promise<TestResponse>;
+}

package/build/Testing/Plugins/Request/TestRequest.js

@@ -0,0 +1,114 @@
+/**
+ * @athenna/http
+ *
+ * (c) João Lenon <lenon@athenna.io>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+import { Server } from '#src';
+import { Assert } from '@japa/assert';
+import { TestResponse } from '#src/Testing/Plugins/Request/TestResponse';
+export class TestRequest {
+    /**
+     * Japa assert class instance.
+     */
+    assert = new Assert();
+    /**
+     * Instantiate TestResponse class from API response.
+     */
+    createResponse(response) {
+        return new TestResponse(this.assert, response);
+    }
+    /**
+     * Make a GET request to the given URL and options.
+     *
+     * @example
+     * ```js
+     * const response = await request.get('/users')
+     *
+     * response.assertStatusCode(200)
+     * ```
+     */
+    async get(url, options = {}) {
+        return Server.request({ url, method: 'GET', ...options }).then(res => this.createResponse(res));
+    }
+    /**
+     * Make a HEAD request to the given URL and options.
+     *
+     * @example
+     * ```js
+     * const response = await request.head('/users')
+     *
+     * response.assertStatusCode(200)
+     * ```
+     */
+    async head(url, options = {}) {
+        return Server.request({ url, method: 'HEAD', ...options }).then(res => this.createResponse(res));
+    }
+    /**
+     * Make a OPTIONS request to the given URL and options.
+     *
+     * @example
+     * ```js
+     * const response = await request.options('/users')
+     *
+     * response.assertStatusCode(200)
+     * ```
+     */
+    async options(url, options = {}) {
+        return Server.request({ url, method: 'OPTIONS', ...options }).then(res => this.createResponse(res));
+    }
+    /**
+     * Make a POST request to the given URL and options.
+     *
+     * @example
+     * ```js
+     * const response = await request.post('/users')
+     *
+     * response.assertStatusCode(200)
+     * ```
+     */
+    async post(url, options = {}) {
+        return Server.request({ url, method: 'POST', ...options }).then(res => this.createResponse(res));
+    }
+    /**
+     * Make a PUT request to the given URL and options.
+     *
+     * @example
+     * ```js
+     * const response = await request.put('/users')
+     *
+     * response.assertStatusCode(200)
+     * ```
+     */
+    async put(url, options = {}) {
+        return Server.request({ url, method: 'PUT', ...options }).then(res => this.createResponse(res));
+    }
+    /**
+     * Make a PATCH request to the given URL and options.
+     *
+     * @example
+     * ```js
+     * const response = await request.patch('/users')
+     *
+     * response.assertStatusCode(200)
+     * ```
+     */
+    async patch(url, options = {}) {
+        return Server.request({ url, method: 'PATCH', ...options }).then(res => this.createResponse(res));
+    }
+    /**
+     * Make a DELETE request to the given URL and options.
+     *
+     * @example
+     * ```js
+     * const response = await request.delete('/users')
+     *
+     * response.assertStatusCode(200)
+     * ```
+     */
+    async delete(url, options = {}) {
+        return Server.request({ url, method: 'DELETE', ...options }).then(res => this.createResponse(res));
+    }
+}