@zyrohub/module-fastify 0.0.1 → 0.0.2

package/README.md

@@ -0,0 +1,83 @@
+<div align="center">
+    <img src="https://i.imgur.com/KVVR2dM.png">
+</div>
+
+## ZyroHub - Fastify Module
+
+This is the Fastify module for ZyroHub ecosystem. It allows you to easily create a Fastify server and integrate it with [`@zyrohub/module-router`](https://www.npmjs.com/package/@zyrohub/module-router).
+
+## Table of Contents
+
+- [ZyroHub - Fastify Module](#zyrohub---fastify-module)
+- [Table of Contents](#table-of-contents)
+- [Getting Started](#getting-started)
+    - [Required Dependencies](#required-dependencies)
+    - [Using Module](#using-module)
+
+## Getting Started
+
+To install the fastify module, use one of the following package managers:
+
+[NPM Repository](https://www.npmjs.com/package/@zyrohub/module-fastify)
+
+```bash
+# npm
+npm install @zyrohub/module-fastify
+# yarn
+yarn add @zyrohub/module-fastify
+# pnpm
+pnpm add @zyrohub/module-fastify
+# bun
+bun add @zyrohub/module-fastify
+```
+
+### Required Dependencies
+
+You also need to install `fastify`, [`@zyrohub/module-router`](https://www.npmjs.com/package/@zyrohub/module-router) and [`@zyrohub/core`](https://www.npmjs.com/package/@zyrohub/core) dependencies:
+
+```bash
+# npm
+npm install fastify @zyrohub/module-router @zyrohub/core
+
+# yarn
+yarn add fastify @zyrohub/module-router @zyrohub/core
+
+# pnpm
+pnpm add fastify @zyrohub/module-router @zyrohub/core
+
+# bun
+bun add fastify @zyrohub/module-router @zyrohub/core
+```
+
+### Using Module
+
+```typescript
+import { Core } from '@zyrohub/core';
+import { FastifyModule } from '@zyrohub/module-fastify';
+import { RouterModule } from '@zyrohub/module-router';
+
+const core = new Core({
+	modules: [
+		RouterModule.mount({
+			// RouterModule options here (see @zyrohub/module-router documentation)
+		}),
+		FastifyModule.mount({
+			port: 3000,
+			host: 'localhost', // optional
+
+			rawOptions: {
+				// Fastify server options here (see https://www.fastify.io/docs/latest/Reference/Server/)
+			},
+			rawListenOptions: {
+				// Fastify listen options here (see https://www.fastify.io/docs/latest/Reference/Server/#listen)
+			},
+
+			onSetup(server, core) {
+				// called once the Fastify server is being set up and before registering routes
+			}
+		})
+	]
+});
+
+core.init();
+```

package/dist/Module.d.ts

@@ -0,0 +1,26 @@
+import { Core, BaseModule } from '@zyrohub/core';
+import { FastifyBaseLogger, FastifyHttpOptions, FastifyInstance, FastifyListenOptions, RawServerDefault } from 'fastify';
+export interface FastifyModuleOptions {
+    port?: number | string;
+    host?: string;
+    rawOptions?: FastifyHttpOptions<RawServerDefault, FastifyBaseLogger> | undefined;
+    rawListenOptions?: FastifyListenOptions;
+    onSetup?(server: FastifyInstance, core: Core): void;
+}
+export declare class FastifyModule extends BaseModule {
+    static options: FastifyModuleOptions;
+    server?: FastifyInstance;
+    port: number;
+    constructor();
+    private handleLoadController;
+    private handleLoadControllers;
+    private handleAddHandlers;
+    init(data: {
+        core: Core;
+        options: FastifyModuleOptions;
+    }): Promise<void>;
+}
+declare const _default: {
+    FastifyModule: typeof FastifyModule;
+};
+export default _default;

package/dist/Module.js

@@ -0,0 +1,149 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+import { BaseModule, Module } from '@zyrohub/core';
+import { HttpResponse, ROUTER_CONTROLLERS_STORAGE_KEY } from '@zyrohub/module-router';
+import { Ansi, Terminal, Validator } from '@zyrohub/utilities';
+import fastify from 'fastify';
+let FastifyModule = class FastifyModule extends BaseModule {
+    static options;
+    server;
+    port = 3000;
+    constructor() {
+        super();
+    }
+    async handleLoadController(controller) {
+        if (!this.core || !this.server)
+            return;
+        const core = this.core;
+        const controllerInstance = core.instantiate(controller.data.constructor);
+        const prefix = controller.data.path || '/';
+        const controllerMiddlewares = controller.data.middlewares || [];
+        for (const route of controller.routes) {
+            const rawUrl = `${prefix}${route.path}`.replace(/\/+/g, '/');
+            const url = rawUrl.length > 1 && rawUrl.endsWith('/') ? rawUrl.slice(0, -1) : rawUrl;
+            const method = route.method.toLowerCase();
+            this.server[method](url, async (request, reply) => {
+                const context = {
+                    request,
+                    response: reply,
+                    body: request.body,
+                    query: request.query,
+                    params: request.params
+                };
+                if (route.schema?.validators.body) {
+                    const result = await Validator.validate(route.schema.validators.body, request.body);
+                    if (!result.success)
+                        return reply
+                            .status(400)
+                            .send(HttpResponse.error(400, 'VALIDATION_ERROR_BODY', result.errors).toObject());
+                    context.body = result.data;
+                }
+                if (route.schema?.validators.query) {
+                    const result = await Validator.validate(route.schema.validators.query, request.query);
+                    if (!result.success)
+                        return reply
+                            .status(400)
+                            .send(HttpResponse.error(400, 'VALIDATION_ERROR_QUERY', result.errors).toObject());
+                    context.query = result.data;
+                }
+                if (route.schema?.validators.params) {
+                    const result = await Validator.validate(route.schema.validators.params, request.params);
+                    if (!result.success)
+                        return reply
+                            .status(400)
+                            .send(HttpResponse.error(400, 'VALIDATION_ERROR_PARAMS', result.errors).toObject());
+                    context.params = result.data;
+                }
+                const allMiddlewares = [...controllerMiddlewares, ...(route.middlewares || [])];
+                for (const middleware of allMiddlewares) {
+                    const middlewareInstance = core.instantiate(middleware.constructor);
+                    if (middlewareInstance && typeof middlewareInstance.execute === 'function') {
+                        let middlewareReturn = await middlewareInstance.execute(context, middleware.options);
+                        if (middlewareReturn !== undefined) {
+                            if (middlewareReturn instanceof HttpResponse) {
+                                return reply.status(middlewareReturn.status).send(middlewareReturn.toObject());
+                            }
+                            reply.send(middlewareReturn);
+                        }
+                    }
+                }
+                const routeHandler = controllerInstance[route.handlerName];
+                const routeReturn = await routeHandler.call(controllerInstance, context);
+                if (reply.sent)
+                    return;
+                if (routeReturn instanceof HttpResponse) {
+                    return reply.status(routeReturn.status).send(routeReturn.toObject());
+                }
+                return reply.send(routeReturn);
+            });
+        }
+    }
+    async handleLoadControllers() {
+        if (!this.core)
+            return;
+        const controllers = this.core.storage.get(ROUTER_CONTROLLERS_STORAGE_KEY) || [];
+        if (controllers.length === 0)
+            return;
+        for (const controller of controllers) {
+            await this.handleLoadController(controller);
+        }
+        Terminal.info('FASTIFY', `Loaded ${Ansi.green(controllers.length)} controller(s) into Fastify module.`);
+    }
+    async handleAddHandlers() {
+        if (!this.server)
+            return;
+        this.server.setNotFoundHandler((request, reply) => {
+            reply.status(404).send({
+                success: false,
+                status: 404,
+                code: 'NOT_FOUND',
+                data: {
+                    message: 'The requested resource was not found.'
+                }
+            });
+        });
+        this.server.setErrorHandler((error, request, reply) => {
+            if (error instanceof HttpResponse)
+                return reply.status(error.status).send(error.toObject());
+            reply.status(500).send({
+                success: false,
+                status: 500,
+                code: 'INTERNAL_SERVER_ERROR',
+                data: {
+                    message: 'An internal server error occurred.'
+                }
+            });
+        });
+    }
+    async init(data) {
+        this.server = fastify({
+            logger: false,
+            ...data.options.rawOptions
+        });
+        if (data.options.onSetup)
+            data.options.onSetup(this.server, data.core);
+        const parsedPort = typeof data.options.port === 'string' ? parseInt(data.options.port, 10) : data.options.port;
+        this.port = parsedPort || 3000;
+        await this.handleLoadControllers();
+        await this.handleAddHandlers();
+        this.server.listen({
+            port: this.port,
+            host: data.options.host,
+            ...data.options.rawListenOptions
+        });
+        Terminal.info('FASTIFY', `Server is listening on port: ${Ansi.green(this.port.toString())}`);
+    }
+};
+FastifyModule = __decorate([
+    Module(),
+    __metadata("design:paramtypes", [])
+], FastifyModule);
+export { FastifyModule };
+export default { FastifyModule };

package/dist/index.d.ts

@@ -0,0 +1 @@
+export * from './Module.js';

package/dist/index.js

@@ -0,0 +1 @@
+export * from './Module.js';

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@zyrohub/module-fastify",
-	"version": "0.0.1",
+	"version": "0.0.2",
 	"author": "DMVMarcio",
 	"type": "module",
 	"main": "./dist/index.js",