framework-do-dede 3.0.39 → 3.1.0

package/dist/application/controller.d.ts

@@ -2,6 +2,9 @@ import 'reflect-metadata';
 export interface Middleware {
     execute(input: Input<any>): Promise<any>;
 }
+export type MiddlewareClass = new (...args: any[]) => Middleware;
+export type MiddlewareFactory = () => Middleware;
+export type MiddlewareDefinition = Middleware | MiddlewareClass | MiddlewareFactory;
 export interface TracerData {
     requestedAt: Date;
     elapsedTime: string;
@@ -26,8 +29,8 @@ export declare function Controller(basePath?: string): (target: any) => void;
 export declare function Tracing<R>(tracer: Tracer<R>): (target: any, propertyKey?: string) => void;
 export declare function getControllers(): any[];
 export declare function flushControllers(): void;
-export declare function UseMiddleware(middlewareClass: new (...args: any[]) => Middleware): (target: any, propertyKey: string, descriptor: PropertyDescriptor) => void;
-export declare function UseMiddlewares(middlewareClasses: (new (...args: any[]) => Middleware)[]): (target: any, propertyKey: string, descriptor: PropertyDescriptor) => void;
+export declare function UseMiddleware(middlewareClass: MiddlewareDefinition): (target: any, propertyKey: string, descriptor: PropertyDescriptor) => void;
+export declare function UseMiddlewares(middlewareClasses: MiddlewareDefinition[]): (target: any, propertyKey: string, descriptor: PropertyDescriptor) => void;
 export declare function Post(config?: {
     path?: string;
     statusCode?: number;

package/dist/application/controller.js

@@ -32,9 +32,15 @@ export function flushControllers() {
 }
 export function UseMiddleware(middlewareClass) {
     return function (target, propertyKey, descriptor) {
-        if (!middlewareClass.prototype.execute) {
+        if (typeof middlewareClass !== 'function' && !middlewareClass?.execute) {
             throw new FrameworkError('Middleware must implement execute()');
         }
+        if (typeof middlewareClass === 'function' && middlewareClass.prototype?.execute) {
+            const middlewares = Reflect.getMetadata('middlewares', target, propertyKey) || [];
+            middlewares.push(middlewareClass);
+            Reflect.defineMetadata('middlewares', middlewares, target, propertyKey);
+            return;
+        }
         const middlewares = Reflect.getMetadata('middlewares', target, propertyKey) || [];
         middlewares.push(middlewareClass);
         Reflect.defineMetadata('middlewares', middlewares, target, propertyKey);
@@ -43,7 +49,7 @@ export function UseMiddleware(middlewareClass) {
 export function UseMiddlewares(middlewareClasses) {
     return function (target, propertyKey, descriptor) {
         for (const middlewareClass of middlewareClasses) {
-            if (!middlewareClass.prototype.execute) {
+            if (typeof middlewareClass !== 'function' && !middlewareClass?.execute) {
                 throw new FrameworkError('Middleware must implement execute()');
             }
         }

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

@@ -3,6 +3,8 @@ export default class ControllerHandler {
     constructor(httpServer: HttpServer, port: number);
     private executeMiddlewares;
     private registryControllers;
+    private resolveMiddleware;
     private filter;
     private extractError;
+    private normalizeBracketNotation;
 }

package/dist/http/controller.handler.js

@@ -1,5 +1,6 @@
 import { InternalServerError, ServerError } from "../http";
 import { flushControllers, getControllers } from "../application/controller";
+import { FrameworkError } from "../http/errors/framework";
 import { CustomServerError } from "./errors/server";
 export default class ControllerHandler {
     constructor(httpServer, port) {
@@ -27,7 +28,11 @@ export default class ControllerHandler {
                     const filterParams = this.filter(input.params, params);
                     const filterQueryParams = this.filter(input.query, query);
                     const filterHeaders = this.filter(input.headers, headers);
-                    mergedParams = { ...filterHeaders, ...filterParams, ...filterQueryParams, ...(input.body || {}) };
+                    let body = input.body || {};
+                    if (Object.keys(body).length > 0) {
+                        body = this.normalizeBracketNotation(body);
+                    }
+                    mergedParams = { ...filterHeaders, ...filterParams, ...filterQueryParams, ...body };
                     request = { data: mergedParams, context: {} };
                     middlewaresExecuted = await this.executeMiddlewares(middlewares, request);
                     const response = await handler.instance[handler.methodName](request);
@@ -122,13 +127,34 @@ export default class ControllerHandler {
                         tracer
                     },
                     responseType,
-                    middlewares: middlewares ? middlewares.map(middleware => new middleware()) : [],
+                    middlewares: middlewares ? middlewares.map(middleware => this.resolveMiddleware(middleware)) : [],
                 });
             }
         }
         flushControllers();
         return controllers;
     }
+    resolveMiddleware(middleware) {
+        if (typeof middleware === 'function') {
+            if (middleware.prototype?.execute) {
+                return new middleware();
+            }
+            try {
+                const instance = middleware();
+                if (!instance?.execute) {
+                    throw new FrameworkError('Middleware must implement execute()');
+                }
+                return instance;
+            }
+            catch (error) {
+                throw new FrameworkError('Middleware must implement execute()');
+            }
+        }
+        if (!middleware?.execute) {
+            throw new FrameworkError('Middleware must implement execute()');
+        }
+        return middleware;
+    }
     filter(params, filterParams) {
         const filter = {};
         for (const paramName of filterParams || []) {
@@ -175,4 +201,24 @@ export default class ControllerHandler {
             ...debugError
         };
     }
+    normalizeBracketNotation(data) {
+        if (!data || typeof data !== "object")
+            return data;
+        const normalized = {};
+        for (const [rawKey, value] of Object.entries(data)) {
+            const key = String(rawKey);
+            const match = key.match(/^([^\[\]]+)\[([^\[\]]+)\]$/);
+            if (match) {
+                const parent = match[1];
+                const child = match[2];
+                if (!normalized[parent] || typeof normalized[parent] !== "object") {
+                    normalized[parent] = {};
+                }
+                normalized[parent][child] = value;
+                continue;
+            }
+            normalized[key] = value;
+        }
+        return normalized;
+    }
 }

package/package.json

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