framework-do-dede 0.0.29 → 0.0.31

package/dist/decorators/controller.d.ts

@@ -1,5 +1,5 @@
 import { Validation } from "../protocols/Validation";
-import { HttpMiddleware } from "../protocols";
+import { HttpMiddleware, RequestMetricsHandler } from "../protocols";
 export declare function Controller(basePath: string): (target: any) => void;
 export declare function Middleware(middlewareClass: new (...args: any[]) => HttpMiddleware): (target: any, propertyKey: string, descriptor: PropertyDescriptor) => void;
 export declare function Post(config?: {
@@ -33,3 +33,4 @@ export declare function Delete(config?: {
     query?: string[];
 }): (target: any, propertyKey: string, descriptor: PropertyDescriptor) => void;
 export declare function Validator(validationClass: new () => Validation): (target: any, propertyKey: string, descriptor: PropertyDescriptor) => void;
+export declare function Metrics(...handlers: (new (...args: any[]) => RequestMetricsHandler)[]): MethodDecorator;

package/dist/decorators/controller.js

@@ -8,20 +8,6 @@ export function Controller(basePath) {
         Registry.addDependency('controllers', target);
     };
 }
-// export function Middleware(middlewareClass: new () => HttpMiddleware) {
-//     return function (target: any, propertyKey: string, descriptor: PropertyDescriptor) {
-//         if (typeof middlewareClass.prototype.execute !== 'function') {
-//             throw new FrameworkError('The concrete class does not implement the Middleware interface.');
-//         }
-//         // Retrieve existing middlewares for this method or initialize an empty array
-//         const middlewares: HttpMiddleware[] = Reflect.getMetadata('middlewares', target, propertyKey) || [];
-//         // Create a new instance of the middleware and add it to the array
-//         const middlewareInstance = new middlewareClass();
-//         middlewares.push(middlewareInstance);
-//         // Update the metadata with the new array of middleware instances
-//         Reflect.defineMetadata('middlewares', middlewares, target, propertyKey);
-//     };
-// }
 export function Middleware(middlewareClass) {
     return function (target, propertyKey, descriptor) {
         if (!middlewareClass.prototype.execute) {
@@ -95,3 +81,8 @@ export function Validator(validationClass) {
         Reflect.defineMetadata('validation', new validationClass(), target, propertyKey);
     };
 }
+export function Metrics(...handlers) {
+    return (target, propertyKey, descriptor) => {
+        Reflect.defineMetadata('metricsHandlers', handlers, target, propertyKey);
+    };
+}

package/dist/handlers/controller.handler.d.ts

@@ -1,4 +1,25 @@
 import HttpServer from "../http/HttpServer";
+export type RequestMetrics = {
+    startTime: number;
+    elapsedTime: number;
+    endTime: number;
+    date: Date;
+    method: string;
+    route: string;
+    agent: string;
+    ip: string;
+    contentLength: string;
+    error?: {
+        stack: string;
+        originalMessage: string;
+        message: string;
+        statusCode: number;
+    };
+    handler: {
+        instance: string;
+        method: string;
+    };
+};
 export default class ControllerHandler {
     constructor(httpServer: HttpServer, port: number);
     private registryControllers;

package/dist/handlers/controller.handler.js

@@ -2,7 +2,7 @@ import { Registry } from "../di/registry";
 import { ServerError } from "../http";
 export default class ControllerHandler {
     constructor(httpServer, port) {
-        for (const { instance, instanceMethod, middlewares, method, route, statusCode, params, query, validation } of this.registryControllers()) {
+        for (const { instance, instanceMethod, middlewares, method, route, statusCode, params, query, validation, offLogs, metricsHandlers } of this.registryControllers()) {
             httpServer.register({
                 method,
                 route,
@@ -10,7 +10,6 @@ export default class ControllerHandler {
                 params,
                 query
             }, async (input) => {
-                console.log('headers = ', input.headers);
                 const requestMetrics = {
                     date: new Date(),
                     startTime: 0,
@@ -49,17 +48,21 @@ export default class ControllerHandler {
                 const request = { headers: input.headers, data: mergedParams, middlewareData };
                 try {
                     const response = await instance[instanceMethod](mergedParams, request);
-                    console.log('\x1b[32m%s\x1b[0m', `✅ [LOG] Finish: "${logger.handler.instance}.${logger.handler.method}:" - ${requestMetrics.elapsedTime}ms`);
+                    if (!offLogs)
+                        console.log('\x1b[32m%s\x1b[0m', `✅ [LOG] Finish: "${logger.handler.instance}.${logger.handler.method}:" - ${requestMetrics.elapsedTime}ms`);
                     return response;
                 }
                 catch (error) {
-                    console.log('\x1b[31m%s\x1b[0m', `❌ [LOG] Erro: "${logger.handler.instance}.${logger.handler.method}:" - error: ${error.message}`);
+                    if (!offLogs)
+                        console.log('\x1b[31m%s\x1b[0m', `❌ [LOG] Erro: "${logger.handler.instance}.${logger.handler.method}:" - error: ${error.message}`);
                     requestMetrics.error = this.extractError(error);
                 }
                 finally {
                     requestMetrics.endTime = performance.now();
                     requestMetrics.elapsedTime = requestMetrics.endTime - requestMetrics.startTime;
-                    console.log('requestMetrics = ', requestMetrics);
+                    if (metricsHandlers?.length) {
+                        await Promise.all(metricsHandlers.map((handler) => handler.handle(requestMetrics)));
+                    }
                 }
             });
         }
@@ -78,6 +81,7 @@ export default class ControllerHandler {
                 const validation = Reflect.getMetadata('validation', controller.prototype, methodName);
                 const routeConfig = Reflect.getMetadata('route', controller.prototype, methodName);
                 const middlewares = Reflect.getMetadata('middlewares', controller.prototype, methodName);
+                const metricsHandlers = Reflect.getMetadata('metricsHandlers', controller.prototype, methodName);
                 controllers.push({
                     method: routeConfig.method,
                     route: basePath + routeConfig.path,
@@ -87,7 +91,8 @@ export default class ControllerHandler {
                     instance,
                     instanceMethod: methodName,
                     middlewares: middlewares ? middlewares.map(middleware => Registry.classLoader(middleware)) : [],
-                    validation
+                    validation,
+                    metricsHandlers: metricsHandlers ? metricsHandlers.map(metricsHandler => Registry.classLoader(metricsHandler)) : [],
                 });
             }
         }

package/dist/index.d.ts

@@ -1,7 +1,7 @@
 import { Dede, Register as DedeRegister, Options as DedeOptions } from './dede';
 import { Controller, Post, Put, Get, Delete, Patch, Validator, Middleware, Auth, Inject, Restrict } from './decorators';
 import { BadRequest, Conflict, Forbidden, HttpServer, NotFound, ServerError, Unauthorized, UnprocessableEntity } from './http';
-import { Validation, HttpMiddleware, UseCase, CreateRepository, DeleteRepository, UpdateRepository, RestoreRepository } from './protocols';
+import { Validation, HttpMiddleware, UseCase, CreateRepository, DeleteRepository, UpdateRepository, RestoreRepository, RequestMetricsHandler } from './protocols';
 import { Entity } from './domain/Entity';
 declare class RequestData {
     headers: any;
@@ -12,4 +12,4 @@ declare class RequestData {
 declare class UseCaseHandler {
     static load<T extends UseCase<any, any>>(useCaseClass: new (...args: any[]) => T, request?: RequestData): T;
 }
-export { UseCase, HttpMiddleware, Validation, CreateRepository, DeleteRepository, UpdateRepository, RestoreRepository, RequestData, Dede, DedeRegister, DedeOptions, UseCaseHandler, ServerError, BadRequest, Conflict, Forbidden, HttpServer, NotFound, Unauthorized, UnprocessableEntity, Controller, Post, Put, Get, Delete, Patch, Validator, Middleware, Auth, Inject, Entity, Restrict };
+export { UseCase, HttpMiddleware, Validation, RequestMetricsHandler, CreateRepository, DeleteRepository, UpdateRepository, RestoreRepository, RequestData, Dede, DedeRegister, DedeOptions, UseCaseHandler, ServerError, BadRequest, Conflict, Forbidden, HttpServer, NotFound, Unauthorized, UnprocessableEntity, Controller, Post, Put, Get, Delete, Patch, Validator, Middleware, Auth, Inject, Entity, Restrict };

package/dist/protocols/Controller.d.ts

@@ -1,6 +1,7 @@
 import type { AllowedMethods, HttpStatusCode } from "../http/HttpServer";
 import type { Validation } from "./Validation";
 import type { HttpMiddleware } from "./HttpMiddleware";
+import { RequestMetricsHandler } from "./RequestMetricsHandler";
 export type Controller = {
     instance: any;
     instanceMethod: string;
@@ -11,4 +12,6 @@ export type Controller = {
     validation?: Validation;
     params?: any;
     query?: any;
+    metricsHandlers?: RequestMetricsHandler[];
+    offLogs?: boolean;
 };

package/dist/protocols/RequestMetricsHandler.d.ts

@@ -0,0 +1,4 @@
+import { RequestMetrics } from "../handlers/controller.handler";
+export interface RequestMetricsHandler {
+    handle(metrics: RequestMetrics): Promise<void> | void;
+}

package/dist/protocols/RequestMetricsHandler.js

@@ -0,0 +1 @@
+export {};

package/dist/protocols/index.d.ts

@@ -5,4 +5,5 @@ import type { CreateRepository } from './CreateRepository';
 import type { DeleteRepository } from './DeleteRepository';
 import type { UpdateRepository } from './UpdateRepository';
 import type { RestoreRepository } from './RestoreRepository';
-export type { HttpMiddleware, UseCase, Validation, CreateRepository, DeleteRepository, UpdateRepository, RestoreRepository };
+import type { RequestMetricsHandler } from './RequestMetricsHandler';
+export type { HttpMiddleware, UseCase, Validation, CreateRepository, DeleteRepository, UpdateRepository, RestoreRepository, RequestMetricsHandler };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "framework-do-dede",
-  "version": "0.0.29",
+  "version": "0.0.31",
   "type": "module",
   "main": "./dist/index.cjs",
   "module": "./dist/index.js",