framework-do-dede 3.4.0 → 4.0.1

package/dist/http/controller.handler.js

@@ -1,10 +1,14 @@
-import { InternalServerError, ServerError } from "../http";
-import { flushControllers, getControllers } from "../application/controller";
 import { FrameworkError } from "../http/errors/framework";
-import { CustomServerError } from "./errors/server";
+import { HttpRequestMapper } from "../interface/http/request-mapper";
+import { MiddlewareExecutor } from "../interface/http/middleware-executor";
+import { HttpErrorMapper } from "../interface/errors/http-error-mapper";
+import { validateWithClassValidator } from "../interface/validation/class-validator";
 export default class ControllerHandler {
-    constructor(httpServer, port) {
-        for (const { handler, middlewares, method, route, statusCode, params, query, headers, body, bodyFilter, responseType } of this.registryControllers()) {
+    constructor(httpServer, controllers = []) {
+        this.requestMapper = new HttpRequestMapper();
+        this.middlewareExecutor = new MiddlewareExecutor();
+        this.errorMapper = new HttpErrorMapper();
+        for (const { handler, middlewares, validator, method, route, statusCode, params, query, headers, body, bodyFilter, responseType } of this.registryControllers(controllers)) {
             httpServer.register({
                 method,
                 route,
@@ -14,6 +18,7 @@ export default class ControllerHandler {
                 query,
                 headers,
                 middlewares,
+                validator,
                 responseType
             }, async (input) => {
                 let requestedAt = new Date();
@@ -25,23 +30,26 @@ export default class ControllerHandler {
                 let middlewaresExecuted = [];
                 try {
                     startTime = performance.now();
-                    const filterParams = this.filter(input.params, params);
-                    const filterQueryParams = this.filter(input.query, query);
-                    const filterHeaders = this.filter(input.headers, headers);
-                    const normalizeBody = this.normalizeBracketNotation(input.body);
-                    let filterBody = this.filter(normalizeBody, body);
-                    if (bodyFilter !== 'restrict') {
-                        filterBody = { ...normalizeBody, ...filterBody };
+                    request = this.requestMapper.map(input, { params, query, headers, body, bodyFilter });
+                    if (validator) {
+                        if (typeof validator === 'function') {
+                            await validateWithClassValidator(validator, request.data);
+                        }
+                        else if (typeof validator.validate === 'function') {
+                            await validator.validate(request.data);
+                        }
+                        else {
+                            throw new FrameworkError('Validator must be a class or implement validate()');
+                        }
                     }
-                    mergedParams = { ...filterHeaders, ...filterParams, ...filterQueryParams, ...filterBody };
-                    request = { data: mergedParams, context: {} };
-                    middlewaresExecuted = await this.executeMiddlewares(middlewares, request);
+                    mergedParams = request.data;
+                    middlewaresExecuted = await this.middlewareExecutor.execute(middlewares, request);
                     const response = await handler.instance[handler.methodName](request);
                     endTime = performance.now();
                     return response;
                 }
                 catch (error) {
-                    capturedError = this.extractError(error, httpServer);
+                    capturedError = this.errorMapper.map(error, httpServer);
                     input.setStatus(capturedError.statusCode);
                     endTime = performance.now();
                     if (capturedError?.custom) {
@@ -70,42 +78,10 @@ export default class ControllerHandler {
                 }
             });
         }
-        httpServer.listen(port);
     }
-    async executeMiddlewares(middlewares = [], request) {
-        const executed = [];
-        if (middlewares && middlewares.length > 0) {
-            for (const middleware of middlewares) {
-                let startTime = 0;
-                let endTime = 0;
-                let elapsedTime;
-                try {
-                    startTime = performance.now();
-                    const middlewareResult = await middleware.execute(request);
-                    request.context = Object.assign(request.context, middlewareResult);
-                    endTime = performance.now();
-                    elapsedTime = `${(endTime - startTime).toFixed(2)} ms`;
-                    executed.push({
-                        elapsedTime,
-                        middleware: middleware.constructor.name
-                    });
-                }
-                catch (error) {
-                    elapsedTime = `${(endTime - startTime).toFixed(2)} ms`;
-                    executed.push({
-                        elapsedTime,
-                        middleware: middleware.constructor.name,
-                        error
-                    });
-                    throw error;
-                }
-            }
-        }
-        return executed;
-    }
-    registryControllers() {
+    registryControllers(controllersList) {
         const controllers = [];
-        for (const controller of getControllers()) {
+        for (const controller of controllersList) {
             const basePath = Reflect.getMetadata('basePath', controller);
             const methodNames = Object.getOwnPropertyNames(controller.prototype).filter(method => method !== 'constructor');
             let tracer = Reflect.getMetadata('tracer', controller) || null;
@@ -124,6 +100,7 @@ export default class ControllerHandler {
                     body: routeConfig.body,
                     bodyFilter: routeConfig.bodyFilter,
                     statusCode: routeConfig.statusCode,
+                    validator: routeConfig.validator,
                     handler: {
                         instance,
                         methodName,
@@ -134,7 +111,6 @@ export default class ControllerHandler {
                 });
             }
         }
-        flushControllers();
         return controllers;
     }
     resolveMiddleware(middleware) {
@@ -158,72 +134,4 @@ export default class ControllerHandler {
         }
         return middleware;
     }
-    filter(params, filterParams) {
-        const filter = {};
-        for (const paramName of filterParams || []) {
-            const [paramNameFiltered, type] = paramName.split('|');
-            let value = params[paramName] || params[paramNameFiltered];
-            if (!value)
-                continue;
-            if (type === 'boolean')
-                value = value === 'true';
-            if (type === 'integer') {
-                value = value.replace(/[^0-9]/g, '');
-                value = value ? parseInt(value) : 0;
-            }
-            if (type === 'string')
-                value = value.toString();
-            if (type === 'number')
-                value = parseFloat(value);
-            filter[paramNameFiltered] = value;
-        }
-        return filter;
-    }
-    extractError(error, httpServer) {
-        if (error instanceof ServerError) {
-            return {
-                message: error.message,
-                statusCode: error.getStatusCode()
-            };
-        }
-        if (error instanceof CustomServerError) {
-            return {
-                ...error.getCustom(),
-                statusCode: error.getStatusCode(),
-                custom: true
-            };
-        }
-        const debugError = {
-            sourceUrl: error.sourceURL,
-            line: error.line,
-            column: error.column,
-        };
-        error = new InternalServerError(error.message, httpServer.getDefaultMessageError());
-        return {
-            message: error.message,
-            statusCode: error.getStatusCode(),
-            unexpectedError: error instanceof InternalServerError ? error.getUnexpectedError() : undefined,
-            ...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/dist/http/errors/server.d.ts

@@ -1,8 +1,5 @@
-export declare abstract class ServerError extends Error {
-    private statusCode;
-    constructor(message: string, statusCode: number);
-    getStatusCode(): number;
-}
+export { AppError as ServerError } from "../../domain/errors/app-error";
+export { BadRequest, NotFound, Forbidden, Conflict, Unauthorized, UnprocessableEntity, InternalServerError } from "../../domain/errors/http-errors";
 export declare class CustomServerError extends Error {
     private statusCode;
     private custom;
@@ -10,26 +7,3 @@ export declare class CustomServerError extends Error {
     getStatusCode(): number;
     getCustom(): any;
 }
-export declare class NotFound extends ServerError {
-    constructor(message: string);
-}
-export declare class Forbidden extends ServerError {
-    constructor(message: string);
-}
-export declare class UnprocessableEntity extends ServerError {
-    constructor(message: string);
-}
-export declare class Conflict extends ServerError {
-    constructor(message: string);
-}
-export declare class Unauthorized extends ServerError {
-    constructor(message: string);
-}
-export declare class BadRequest extends ServerError {
-    constructor(message: string);
-}
-export declare class InternalServerError extends ServerError {
-    private unexpectedError;
-    constructor(unexpectedError: string, defaultMessage?: string);
-    getUnexpectedError(): string;
-}

package/dist/http/errors/server.js

@@ -1,13 +1,5 @@
-export class ServerError extends Error {
-    constructor(message, statusCode) {
-        super(message);
-        this.name = this.constructor.name;
-        this.statusCode = statusCode;
-    }
-    getStatusCode() {
-        return this.statusCode;
-    }
-}
+export { AppError as ServerError } from "../../domain/errors/app-error";
+export { BadRequest, NotFound, Forbidden, Conflict, Unauthorized, UnprocessableEntity, InternalServerError } from "../../domain/errors/http-errors";
 export class CustomServerError extends Error {
     constructor(custom, statusCode, nameError = '') {
         super();
@@ -22,42 +14,3 @@ export class CustomServerError extends Error {
         return this.custom;
     }
 }
-export class NotFound extends ServerError {
-    constructor(message) {
-        super(message, 404);
-    }
-}
-export class Forbidden extends ServerError {
-    constructor(message) {
-        super(message, 403);
-    }
-}
-export class UnprocessableEntity extends ServerError {
-    constructor(message) {
-        super(message, 422);
-    }
-}
-export class Conflict extends ServerError {
-    constructor(message) {
-        super(message, 409);
-    }
-}
-export class Unauthorized extends ServerError {
-    constructor(message) {
-        super(message, 401);
-    }
-}
-export class BadRequest extends ServerError {
-    constructor(message) {
-        super(message, 400);
-    }
-}
-export class InternalServerError extends ServerError {
-    constructor(unexpectedError, defaultMessage = 'Ops, An unexpected error occurred') {
-        super(defaultMessage, 500);
-        this.unexpectedError = unexpectedError;
-    }
-    getUnexpectedError() {
-        return this.unexpectedError;
-    }
-}

package/dist/http/http-server.d.ts

@@ -1,4 +1,5 @@
 import { Middleware, Tracer } from "../application/controller";
+import type { ValidatorLike } from "../interface/validation/validator";
 export type Request = {
     data: any;
     context: any;
@@ -15,6 +16,7 @@ export type HttpServerParams = {
     };
     responseType: 'json' | 'text' | 'html';
     middlewares?: Middleware[];
+    validator?: ValidatorLike;
     statusCode?: number;
     params?: string[];
     query?: string[];

package/dist/http/http-server.js

@@ -53,7 +53,7 @@ export default class HttpServer {
     express(httpServerParams, route, handler) {
         const method = httpServerParams.method;
         this.framework[method](route, async (request, res) => {
-            request.headers['ip'] = request.ipç;
+            request.headers['ip'] = request.ip;
             res.status(httpServerParams.statusCode ?? 200);
             const output = await handler({
                 setStatus: (statusCode) => res.status(statusCode),

package/dist/http/index.d.ts

@@ -1,3 +1,3 @@
 import HttpServer from "./http-server";
-import { ServerError, NotFound, Forbidden, Conflict, Unauthorized, UnprocessableEntity, BadRequest, InternalServerError } from "./errors/server";
-export { ServerError, BadRequest, NotFound, Forbidden, Conflict, Unauthorized, UnprocessableEntity, HttpServer, InternalServerError };
+import { ServerError, NotFound, Forbidden, Conflict, Unauthorized, UnprocessableEntity, BadRequest, InternalServerError, CustomServerError } from "./errors/server";
+export { ServerError, BadRequest, NotFound, Forbidden, Conflict, Unauthorized, UnprocessableEntity, HttpServer, InternalServerError, CustomServerError };

package/dist/http/index.js

@@ -1,3 +1,3 @@
 import HttpServer from "./http-server";
-import { ServerError, NotFound, Forbidden, Conflict, Unauthorized, UnprocessableEntity, BadRequest, InternalServerError } from "./errors/server";
-export { ServerError, BadRequest, NotFound, Forbidden, Conflict, Unauthorized, UnprocessableEntity, HttpServer, InternalServerError };
+import { ServerError, NotFound, Forbidden, Conflict, Unauthorized, UnprocessableEntity, BadRequest, InternalServerError, CustomServerError } from "./errors/server";
+export { ServerError, BadRequest, NotFound, Forbidden, Conflict, Unauthorized, UnprocessableEntity, HttpServer, InternalServerError, CustomServerError };

package/dist/index.d.ts

@@ -1,6 +1,7 @@
 import { Post, Get, Put, Delete, Patch, Controller, Input, Middleware, UseMiddleware, UseMiddlewares, Tracer, Tracing, TracerData, Entity, Restrict, VirtualProperty, GetterPrefix, Serialize, UseCase, DecorateUseCase, Storage, StorageGateway } from "./application";
-import { Inject } from './infra/di/registry';
+import { Container, DefaultContainer, Inject, setDefaultContainer } from './infra/di/registry';
 import { Dede, type Options, Register } from './dede';
-import { ServerError, NotFound, Forbidden, Conflict, Unauthorized, UnprocessableEntity, BadRequest, InternalServerError } from './http/errors/server';
+import { ServerError, NotFound, Forbidden, Conflict, Unauthorized, UnprocessableEntity, BadRequest, InternalServerError, CustomServerError } from './http/errors/server';
+import { AppError } from './domain/errors/app-error';
 import type { RepositoryCreate, RepositoryUpdate, RepositoryRemove, RepositoryRemoveBy, RepositoryExistsBy, RepositoryRestore, RepositoryRestoreBy, RepositoryNotExistsBy, RepositoryPagination } from './protocols/repository';
-export { Controller, Post, Get, Put, Delete, Patch, Input, Middleware, UseMiddleware, UseMiddlewares, Tracer, Tracing, TracerData, Entity, Restrict, VirtualProperty, GetterPrefix, Serialize, UseCase, DecorateUseCase, Storage, StorageGateway, Inject, Dede, Options, Register, ServerError, NotFound, Forbidden, Conflict, Unauthorized, UnprocessableEntity, BadRequest, InternalServerError, RepositoryCreate, RepositoryUpdate, RepositoryRemove, RepositoryRemoveBy, RepositoryRestore, RepositoryExistsBy, RepositoryRestoreBy, RepositoryNotExistsBy, RepositoryPagination };
+export { Controller, Post, Get, Put, Delete, Patch, Input, Middleware, UseMiddleware, UseMiddlewares, Tracer, Tracing, TracerData, Entity, Restrict, VirtualProperty, GetterPrefix, Serialize, UseCase, DecorateUseCase, Storage, StorageGateway, Inject, Container, DefaultContainer, setDefaultContainer, Dede, Options, Register, ServerError, NotFound, Forbidden, Conflict, Unauthorized, UnprocessableEntity, BadRequest, InternalServerError, CustomServerError, AppError, RepositoryCreate, RepositoryUpdate, RepositoryRemove, RepositoryRemoveBy, RepositoryRestore, RepositoryExistsBy, RepositoryRestoreBy, RepositoryNotExistsBy, RepositoryPagination };

package/dist/index.js

@@ -10,7 +10,8 @@ UseCase, DecorateUseCase,
 // usecase
 // storage
 Storage } from "./application";
-import { Inject } from './infra/di/registry';
+import { Container, DefaultContainer, Inject, setDefaultContainer } from './infra/di/registry';
 import { Dede } from './dede';
-import { ServerError, NotFound, Forbidden, Conflict, Unauthorized, UnprocessableEntity, BadRequest, InternalServerError } from './http/errors/server';
-export { Controller, Post, Get, Put, Delete, Patch, UseMiddleware, UseMiddlewares, Tracing, Entity, Restrict, VirtualProperty, GetterPrefix, Serialize, UseCase, DecorateUseCase, Storage, Inject, Dede, ServerError, NotFound, Forbidden, Conflict, Unauthorized, UnprocessableEntity, BadRequest, InternalServerError };
+import { ServerError, NotFound, Forbidden, Conflict, Unauthorized, UnprocessableEntity, BadRequest, InternalServerError, CustomServerError } from './http/errors/server';
+import { AppError } from './domain/errors/app-error';
+export { Controller, Post, Get, Put, Delete, Patch, UseMiddleware, UseMiddlewares, Tracing, Entity, Restrict, VirtualProperty, GetterPrefix, Serialize, UseCase, DecorateUseCase, Storage, Inject, Container, DefaultContainer, setDefaultContainer, Dede, ServerError, NotFound, Forbidden, Conflict, Unauthorized, UnprocessableEntity, BadRequest, InternalServerError, CustomServerError, AppError };

package/dist/infra/di/registry.d.ts

@@ -1,11 +1,9 @@
-declare class ComponentRegistry {
-    private static instance;
+export declare class Container {
     private dependencies;
-    static getInstance(): ComponentRegistry;
     load(name: string, dependency: any): void;
     inject(name: string): any;
     remove(name: string): void;
 }
-export declare const Registry: ComponentRegistry;
-export declare function Inject(name: string): (target: any, propertyKey: string) => void;
-export {};
+export declare let DefaultContainer: Container;
+export declare function setDefaultContainer(container: Container): void;
+export declare function Inject(name: string, container?: Container): (target: any, propertyKey: string) => void;

package/dist/infra/di/registry.js

@@ -1,13 +1,7 @@
-class ComponentRegistry {
+export class Container {
     constructor() {
         this.dependencies = new Map();
     }
-    static getInstance() {
-        if (!this.instance) {
-            this.instance = new ComponentRegistry();
-        }
-        return this.instance;
-    }
     load(name, dependency) {
         this.dependencies.set(name, dependency);
     }
@@ -20,12 +14,16 @@ class ComponentRegistry {
         this.dependencies.delete(name);
     }
 }
-export const Registry = ComponentRegistry.getInstance();
-export function Inject(name) {
+export let DefaultContainer = new Container();
+export function setDefaultContainer(container) {
+    DefaultContainer = container;
+}
+export function Inject(name, container) {
     return function (target, propertyKey) {
         target[propertyKey] = new Proxy({}, {
             get(_, propertyKey) {
-                const dependency = Registry.inject(name);
+                const resolvedContainer = container ?? DefaultContainer;
+                const dependency = resolvedContainer.inject(name);
                 return dependency[propertyKey];
             }
         });

package/dist/{application → infra/serialization}/entity.d.ts

@@ -1,4 +1,5 @@
-export declare abstract class Entity {
+import { Entity as DomainEntity } from "../../domain/entity";
+export declare abstract class SerializableEntity extends DomainEntity {
     [x: string]: any;
     private buildRawEntityObject;
     private getEntityHooks;
@@ -17,5 +18,6 @@ export declare function Restrict(): (target: any, propertyKey: string) => void;
 export declare function VirtualProperty(propertyName: string): (target: any, methodName: string) => void;
 export declare function Serialize(callback: (value: any) => any): PropertyDecorator;
 export declare function GetterPrefix(prefix: string): (target: any, propertyKey: string) => void;
+export { SerializableEntity as Entity };
 export declare function BeforeToEntity(): MethodDecorator;
 export declare function AfterToEntity(): MethodDecorator;

package/dist/{application → infra/serialization}/entity.js

@@ -1,4 +1,5 @@
-export class Entity {
+import { Entity as DomainEntity } from "../../domain/entity";
+export class SerializableEntity extends DomainEntity {
     buildRawEntityObject() {
         const result = {};
         for (const [propName] of Object.entries(this)) {
@@ -14,7 +15,7 @@ export class Entity {
     getEntityHooks(hookKey) {
         const hooks = [];
         let current = this.constructor;
-        while (current && current !== Entity) {
+        while (current && current !== SerializableEntity) {
             const currentHooks = current[hookKey];
             if (currentHooks && currentHooks.length) {
                 hooks.unshift(...currentHooks);
@@ -103,7 +104,7 @@ export class Entity {
             if (value === undefined)
                 continue;
             // @ts-ignore
-            if (propertiesConfigs && propertiesConfigs[propName]?.serialize && (value || valueIsZero)) {
+            if (propertiesConfigs && propertiesConfigs[propName]?.serialize && (value || value === 0)) {
                 const serializedValue = await propertiesConfigs[propName].serialize(value);
                 if (serializedValue && typeof serializedValue === 'object' && !Array.isArray(serializedValue)) {
                     const entries = Object.entries(serializedValue);
@@ -181,27 +182,7 @@ export class Entity {
         return result;
     }
     generateGetters() {
-        for (const property of Object.keys(this)) {
-            if (typeof this[property] === 'function')
-                continue;
-            let prefixName = null;
-            // @ts-ignore
-            if (this.constructor.propertiesConfigs && this.constructor.propertiesConfigs[property] && this.constructor.propertiesConfigs[property].prefix) {
-                // @ts-ignore
-                prefixName = this.constructor.propertiesConfigs[property].prefix;
-            }
-            else {
-                const isBoolean = this[property] ? typeof this[property] === 'boolean' : false;
-                prefixName = isBoolean ? 'is' : 'get';
-            }
-            let getterName = null;
-            if (property[0]) {
-                getterName = `${prefixName}${property[0].toUpperCase()}${property.slice(1)}`;
-                if (this[getterName])
-                    continue;
-                this[getterName] = () => this[property];
-            }
-        }
+        super.generateGetters();
     }
 }
 export function Restrict() {
@@ -240,10 +221,11 @@ const loadPropertiesConfig = (target, propertyKey) => {
 const BEFORE_TO_ENTITY = Symbol('beforeToEntity');
 const AFTER_TO_ENTITY = Symbol('afterToEntity');
 const assertEntityDecoratorTarget = (target, decoratorName) => {
-    if (!Entity.prototype.isPrototypeOf(target)) {
+    if (!SerializableEntity.prototype.isPrototypeOf(target)) {
         throw new Error(`${decoratorName} can only be used on Entity classes`);
     }
 };
+export { SerializableEntity as Entity };
 export function BeforeToEntity() {
     return function (target, propertyKey) {
         assertEntityDecoratorTarget(target, 'BeforeToEntity');

package/dist/interface/errors/http-error-mapper.d.ts

@@ -0,0 +1,10 @@
+import type HttpServer from '../../http/http-server';
+export type MappedError = {
+    message: string;
+    statusCode: number;
+    custom?: boolean;
+    unexpectedError?: string;
+};
+export declare class HttpErrorMapper {
+    map(error: any, httpServer: HttpServer): MappedError;
+}

package/dist/interface/errors/http-error-mapper.js

@@ -0,0 +1,31 @@
+import { AppError } from '../../domain/errors/app-error';
+import { InternalServerError } from '../../domain/errors/http-errors';
+export class HttpErrorMapper {
+    map(error, httpServer) {
+        if (error instanceof AppError) {
+            return {
+                message: error.message,
+                statusCode: error.getStatusCode()
+            };
+        }
+        if (error && typeof error.getStatusCode === 'function' && typeof error.getCustom === 'function') {
+            return {
+                ...error.getCustom(),
+                statusCode: error.getStatusCode(),
+                custom: true
+            };
+        }
+        const debugError = {
+            sourceUrl: error?.sourceURL,
+            line: error?.line,
+            column: error?.column,
+        };
+        const internal = new InternalServerError(error?.message || 'Unexpected error', httpServer.getDefaultMessageError());
+        return {
+            message: internal.message,
+            statusCode: internal.getStatusCode(),
+            unexpectedError: internal.getUnexpectedError(),
+            ...debugError
+        };
+    }
+}

package/dist/interface/http/middleware-executor.d.ts

@@ -0,0 +1,10 @@
+import type { Request } from "../../http/http-server";
+import type { Middleware } from "../../application/controller";
+export type ExecutedMiddleware = {
+    elapsedTime: string;
+    middleware: string;
+    error?: any;
+};
+export declare class MiddlewareExecutor {
+    execute(middlewares: Middleware[] | undefined, request: Request): Promise<ExecutedMiddleware[]>;
+}

package/dist/interface/http/middleware-executor.js

@@ -0,0 +1,33 @@
+export class MiddlewareExecutor {
+    async execute(middlewares = [], request) {
+        const executed = [];
+        if (middlewares && middlewares.length > 0) {
+            for (const middleware of middlewares) {
+                let startTime = 0;
+                let endTime = 0;
+                let elapsedTime;
+                try {
+                    startTime = performance.now();
+                    const middlewareResult = await middleware.execute(request);
+                    request.context = Object.assign(request.context, middlewareResult);
+                    endTime = performance.now();
+                    elapsedTime = `${(endTime - startTime).toFixed(2)} ms`;
+                    executed.push({
+                        elapsedTime,
+                        middleware: middleware.constructor.name,
+                    });
+                }
+                catch (error) {
+                    elapsedTime = `${(endTime - startTime).toFixed(2)} ms`;
+                    executed.push({
+                        elapsedTime,
+                        middleware: middleware.constructor.name,
+                        error,
+                    });
+                    throw error;
+                }
+            }
+        }
+        return executed;
+    }
+}

package/dist/interface/http/request-mapper.d.ts

@@ -0,0 +1,21 @@
+import type { Request } from "../../http/http-server";
+type BodyFilter = 'none' | 'restrict';
+type RouteInputConfig = {
+    params?: string[];
+    query?: string[];
+    headers?: string[];
+    body?: string[];
+    bodyFilter?: BodyFilter;
+};
+type HttpInput = {
+    headers: any;
+    body: any;
+    params: any;
+    query: any;
+};
+export declare class HttpRequestMapper {
+    map(input: HttpInput, config: RouteInputConfig): Request;
+    private filter;
+    private normalizeBracketNotation;
+}
+export {};