framework-do-dede 3.3.1 → 4.0.0

package/dist/dede.d.ts

@@ -1,3 +1,4 @@
+import { Container } from "./infra/di/registry";
 export type Register = {
     name: string;
     classLoader: any;
@@ -8,15 +9,23 @@ export type Options = {
         port?: number;
         middlewares?: CallableFunction[];
     };
+    controllers?: any[];
     registries: Register[];
     defaultServerError?: string;
+    container?: Container;
 };
 export declare class Dede {
     private readonly framework;
     private readonly defaultServerError?;
+    private readonly container;
     private readonly httpServer;
+    private readonly port?;
+    private controllersRegistered;
     private constructor();
-    static start({ framework, registries, defaultServerError }: Options): Promise<Dede>;
+    static create({ framework, registries, defaultServerError, container }: Options): Promise<Dede>;
+    static start({ framework, registries, defaultServerError, container, controllers }: Options): Promise<Dede>;
     stop(): Promise<void>;
+    registerControllers(controllers: any[]): void;
+    listen(port?: number): void;
     private static loadRegistries;
 }

package/dist/dede.js

@@ -1,11 +1,14 @@
 import ControllerHandler from "./http/controller.handler";
 import { ElysiaServerAdapter } from "./http/elysia-server.adapter";
 import { ExpressServerAdapter } from "./http/express-server.adapter";
-import { Registry } from "./infra/di/registry";
+import { Container, DefaultContainer, setDefaultContainer } from "./infra/di/registry";
 export class Dede {
-    constructor(framework, defaultServerError) {
+    constructor(framework, defaultServerError, container = DefaultContainer) {
         this.framework = framework;
         this.defaultServerError = defaultServerError;
+        this.container = container;
+        this.controllersRegistered = false;
+        this.port = framework.port;
         if (framework.use === 'elysia') {
             this.httpServer = new ElysiaServerAdapter(framework.middlewares || []);
         }
@@ -14,19 +17,37 @@ export class Dede {
         }
         if (defaultServerError)
             this.httpServer.setDefaultMessageError(defaultServerError);
-        new ControllerHandler(this.httpServer, framework.port || 80);
     }
-    static async start({ framework, registries, defaultServerError }) {
-        await this.loadRegistries(registries);
-        return new Dede(framework, defaultServerError);
+    static async create({ framework, registries, defaultServerError, container }) {
+        const appContainer = container ?? new Container();
+        setDefaultContainer(appContainer);
+        await this.loadRegistries(appContainer, registries);
+        return new Dede(framework, defaultServerError, appContainer);
+    }
+    static async start({ framework, registries, defaultServerError, container, controllers }) {
+        const app = await Dede.create({ framework, registries, defaultServerError, container, controllers });
+        if (controllers && controllers.length > 0) {
+            app.registerControllers(controllers);
+        }
+        app.listen();
+        return app;
     }
     async stop() {
         await this.httpServer.close();
     }
-    static async loadRegistries(registries) {
+    registerControllers(controllers) {
+        if (this.controllersRegistered)
+            return;
+        new ControllerHandler(this.httpServer, controllers);
+        this.controllersRegistered = true;
+    }
+    listen(port) {
+        const resolvedPort = port ?? this.port ?? 80;
+        this.httpServer.listen(resolvedPort);
+    }
+    static async loadRegistries(container, registries) {
         registries.forEach(({ classLoader, name }) => {
-            Registry.load(name, classLoader);
+            container.load(name, classLoader);
         });
-        return new Promise(resolve => setTimeout(resolve, 500));
     }
 }

package/dist/domain/entity.d.ts

@@ -0,0 +1,4 @@
+export declare abstract class Entity {
+    [x: string]: any;
+    protected generateGetters(): void;
+}

package/dist/domain/entity.js

@@ -0,0 +1,25 @@
+export class Entity {
+    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];
+            }
+        }
+    }
+}

package/dist/domain/errors/app-error.d.ts

@@ -0,0 +1,12 @@
+export type AppErrorData = {
+    message: string;
+    code?: string;
+    details?: Record<string, any>;
+};
+export declare abstract class AppError extends Error {
+    private readonly statusCode;
+    private readonly data?;
+    constructor(message: string, statusCode: number, data?: AppErrorData);
+    getStatusCode(): number;
+    getData(): AppErrorData | undefined;
+}

package/dist/domain/errors/app-error.js

@@ -0,0 +1,14 @@
+export class AppError extends Error {
+    constructor(message, statusCode, data) {
+        super(message);
+        this.name = this.constructor.name;
+        this.statusCode = statusCode;
+        this.data = data;
+    }
+    getStatusCode() {
+        return this.statusCode;
+    }
+    getData() {
+        return this.data;
+    }
+}

package/dist/domain/errors/http-errors.d.ts

@@ -0,0 +1,42 @@
+import { AppError } from './app-error';
+export declare class BadRequest extends AppError {
+    constructor(message: string, data?: {
+        code?: string;
+        details?: Record<string, any>;
+    });
+}
+export declare class Unauthorized extends AppError {
+    constructor(message: string, data?: {
+        code?: string;
+        details?: Record<string, any>;
+    });
+}
+export declare class Forbidden extends AppError {
+    constructor(message: string, data?: {
+        code?: string;
+        details?: Record<string, any>;
+    });
+}
+export declare class NotFound extends AppError {
+    constructor(message: string, data?: {
+        code?: string;
+        details?: Record<string, any>;
+    });
+}
+export declare class Conflict extends AppError {
+    constructor(message: string, data?: {
+        code?: string;
+        details?: Record<string, any>;
+    });
+}
+export declare class UnprocessableEntity extends AppError {
+    constructor(message: string, data?: {
+        code?: string;
+        details?: Record<string, any>;
+    });
+}
+export declare class InternalServerError extends AppError {
+    private readonly unexpectedError;
+    constructor(unexpectedError: string, defaultMessage?: string);
+    getUnexpectedError(): string;
+}

package/dist/domain/errors/http-errors.js

@@ -0,0 +1,40 @@
+import { AppError } from './app-error';
+export class BadRequest extends AppError {
+    constructor(message, data) {
+        super(message, 400, data ? { message, ...data } : undefined);
+    }
+}
+export class Unauthorized extends AppError {
+    constructor(message, data) {
+        super(message, 401, data ? { message, ...data } : undefined);
+    }
+}
+export class Forbidden extends AppError {
+    constructor(message, data) {
+        super(message, 403, data ? { message, ...data } : undefined);
+    }
+}
+export class NotFound extends AppError {
+    constructor(message, data) {
+        super(message, 404, data ? { message, ...data } : undefined);
+    }
+}
+export class Conflict extends AppError {
+    constructor(message, data) {
+        super(message, 409, data ? { message, ...data } : undefined);
+    }
+}
+export class UnprocessableEntity extends AppError {
+    constructor(message, data) {
+        super(message, 422, data ? { message, ...data } : undefined);
+    }
+}
+export class InternalServerError extends AppError {
+    constructor(unexpectedError, defaultMessage = 'Ops, An unexpected error occurred') {
+        super(defaultMessage, 500, { message: defaultMessage });
+        this.unexpectedError = unexpectedError;
+    }
+    getUnexpectedError() {
+        return this.unexpectedError;
+    }
+}

package/dist/domain/index.d.ts

@@ -0,0 +1,2 @@
+import { Entity } from './entity';
+export { Entity };

package/dist/domain/index.js

@@ -0,0 +1,2 @@
+import { Entity } from './entity';
+export { Entity };

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

@@ -1,10 +1,9 @@
 import HttpServer from "../http/http-server";
 export default class ControllerHandler {
-    constructor(httpServer: HttpServer, port: number);
-    private executeMiddlewares;
+    private readonly requestMapper;
+    private readonly middlewareExecutor;
+    private readonly errorMapper;
+    constructor(httpServer: HttpServer, controllers?: any[]);
     private registryControllers;
     private resolveMiddleware;
-    private filter;
-    private extractError;
-    private normalizeBracketNotation;
 }

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;