framework-do-dede 2.0.21 → 3.0.1

package/dist/http/controller.handler.js

@@ -0,0 +1,160 @@
+import { InternalServerError, ServerError } from "../http";
+import { flushControllers, getControllers } from "../application/controller";
+export default class ControllerHandler {
+    constructor(httpServer, port) {
+        for (const { handler, middlewares, method, route, statusCode, params, query, headers, responseType } of this.registryControllers()) {
+            httpServer.register({
+                method,
+                route,
+                handler,
+                statusCode,
+                params,
+                query,
+                headers,
+                middlewares,
+                responseType
+            }, async (input) => {
+                let requestedAt = new Date();
+                let startTime = 0;
+                let endTime = 0;
+                let mergedParams;
+                let request;
+                let capturedError;
+                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);
+                    mergedParams = { ...filterHeaders, ...filterParams, ...filterQueryParams, ...(input.body || {}) };
+                    request = { data: mergedParams, context: {} };
+                    middlewaresExecuted = await this.executeMiddlewares(middlewares, request);
+                    const response = await handler.instance[handler.methodName](request);
+                    endTime = performance.now();
+                    return response;
+                }
+                catch (error) {
+                    capturedError = this.extractError(error, httpServer);
+                    input.setStatus(capturedError.statusCode);
+                    endTime = performance.now();
+                    return {
+                        message: capturedError.message,
+                        statusCode: capturedError.statusCode
+                    };
+                }
+                finally {
+                    if (handler.tracer) {
+                        const elapsedTime = `${(endTime - startTime).toFixed(2)} ms`;
+                        const controllerData = {
+                            requestedAt,
+                            elapsedTime,
+                            route,
+                            method,
+                            middlewares: middlewaresExecuted,
+                            error: capturedError,
+                            headers: input.headers
+                        };
+                        await handler.tracer.trace(controllerData);
+                    }
+                }
+            });
+        }
+        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() {
+        const controllers = [];
+        for (const controller of getControllers()) {
+            const basePath = Reflect.getMetadata('basePath', controller);
+            const methodNames = Object.getOwnPropertyNames(controller.prototype).filter(method => method !== 'constructor');
+            let tracer = Reflect.getMetadata('tracer', controller) || null;
+            const instance = new controller();
+            for (const methodName of methodNames) {
+                const routeConfig = Reflect.getMetadata('route', controller.prototype, methodName);
+                const middlewares = Reflect.getMetadata('middlewares', controller.prototype, methodName);
+                const responseType = Reflect.getMetadata('responseType', controller.prototype, methodName) || 'json';
+                tracer = Reflect.getMetadata('tracer', controller.prototype, methodName) || tracer;
+                controllers.push({
+                    method: routeConfig.method,
+                    route: basePath + routeConfig.path,
+                    params: routeConfig.params,
+                    query: routeConfig.query,
+                    headers: routeConfig.headers,
+                    statusCode: routeConfig.statusCode,
+                    handler: {
+                        instance,
+                        methodName,
+                        tracer
+                    },
+                    responseType,
+                    middlewares: middlewares ? middlewares.map(middleware => new middleware()) : [],
+                });
+            }
+        }
+        flushControllers();
+        return controllers;
+    }
+    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();
+            filter[paramNameFiltered] = value;
+        }
+        return filter;
+    }
+    extractError(error, httpServer) {
+        if (error instanceof ServerError) {
+            return {
+                message: error.message,
+                statusCode: error.getStatusCode()
+            };
+        }
+        error = new InternalServerError(error.message, httpServer.getDefaultMessageError());
+        return {
+            message: error.message,
+            statusCode: error.getStatusCode(),
+            unexpectedError: error instanceof InternalServerError ? error.getUnexpectedError() : undefined,
+        };
+    }
+}

package/dist/http/{ExpressHttpServer.d.ts → elysia-server.adapter.d.ts}

@@ -1,5 +1,5 @@
-import HttpServer from "./HttpServer";
-export declare class ExpressHttpServer extends HttpServer {
+import HttpServer from "./http-server";
+export declare class ElysiaServerAdapter extends HttpServer {
     close(): Promise<void>;
     constructor(uses?: CallableFunction[]);
     listen(port: number): void;

package/dist/http/{ElysiaHttpServer.js → elysia-server.adapter.js}

@@ -1,7 +1,7 @@
 // @ts-ignore 
 import Elysia from "elysia";
-import HttpServer from "./HttpServer";
-export class ElysiaHttpServer extends HttpServer {
+import HttpServer from "./http-server";
+export class ElysiaServerAdapter extends HttpServer {
     async close() {
         await this.framework.stop();
         console.log('server closed');

package/dist/http/{ElysiaHttpServer.d.ts → express-server.adapter.d.ts}

@@ -1,5 +1,5 @@
-import HttpServer from "./HttpServer";
-export declare class ElysiaHttpServer extends HttpServer {
+import HttpServer from "./http-server";
+export declare class ExpressServerAdapter extends HttpServer {
     close(): Promise<void>;
     constructor(uses?: CallableFunction[]);
     listen(port: number): void;

package/dist/http/express-server.adapter.js

@@ -0,0 +1,25 @@
+// @ts-ignore 
+import express from "express";
+import HttpServer from "./http-server";
+const app = express();
+export class ExpressServerAdapter extends HttpServer {
+    async close() {
+        const shutDown = () => {
+            this.framework.close(() => {
+                console.log("Server closed. Cleanup complete.");
+                process.exit(0);
+            });
+        };
+        process.on("SIGINT", shutDown);
+        process.on("SIGTERM", shutDown);
+    }
+    constructor(uses) {
+        super(app, 'express');
+        this.framework.use(express.json());
+        uses?.forEach(use => this.framework.use(use));
+    }
+    listen(port) {
+        super.listen(port);
+        console.log(`Server listening on port ${port}`);
+    }
+}

package/dist/http/{HttpServer.d.ts → http-server.d.ts}

@@ -1,11 +1,24 @@
+import { Middleware, Tracer } from "../application/controller";
+export type Request = {
+    data: any;
+    context: any;
+};
 export type HttpStatusCode = 200 | 201 | 204 | 401 | 403 | 404 | 409 | 422 | 500;
 export type AllowedMethods = 'get' | 'post' | 'put' | 'delete' | 'patch';
 export type HttpServerParams = {
     method: AllowedMethods;
     route: string;
+    handler: {
+        instance: any;
+        methodName: string;
+        tracer?: Tracer;
+    };
+    responseType: 'json' | 'text' | 'html';
+    middlewares?: Middleware[];
     statusCode?: number;
     params?: string[];
     query?: string[];
+    headers?: string[];
 };
 type FrameworkWeb = {
     listen(port: number): void;

package/dist/http/{HttpServer.js → http-server.js}

@@ -1,4 +1,4 @@
-import { FrameworkError } from "./FrameworkError";
+import { FrameworkError } from "./errors/framework";
 export default class HttpServer {
     framework;
     frameworkName;
@@ -65,7 +65,9 @@ export default class HttpServer {
                 params: request.params,
                 body: method !== 'get' ? request.body : {}
             });
-            return res.json(output);
+            const type = httpServerParams.responseType === 'html' ? 'text' : httpServerParams.responseType;
+            return res[type](output);
         });
     }
+    ;
 }

package/dist/http/index.d.ts

@@ -1,3 +1,3 @@
-import HttpServer from "./HttpServer";
-import { ServerError, NotFound, Forbidden, Conflict, Unauthorized, UnprocessableEntity, BadRequest, InternalServerError } from "./ServerError";
+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 };

package/dist/http/index.js

@@ -1,3 +1,3 @@
-import HttpServer from "./HttpServer";
-import { ServerError, NotFound, Forbidden, Conflict, Unauthorized, UnprocessableEntity, BadRequest, InternalServerError } from "./ServerError";
+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 };

package/dist/index.d.ts

@@ -1,7 +1,2 @@
-import { Dede, Register as DedeRegister, Options as DedeOptions } from './dede';
-import { Controller, Post, Put, Get, Delete, Patch, Validator, Middleware, Middlewares, Context, DecorateUseCase, Inject, Restrict, Metrics, DbColumn, VirtualProperty, OffConsoleLog, Storage, Expose } from './decorators';
-import { BadRequest, Conflict, Forbidden, HttpServer, NotFound, ServerError, Unauthorized, UnprocessableEntity } from './http';
-import { Validation, HttpMiddleware, UseCase, CreateRepository, ExistsBy, NotExistsBy, DeleteRepository, DeleteRepositoryBy, UpdateRepository, RestoreRepository, RestoreRepositoryBy, RestoreManyRepository, RequestMetricsHandler, Request, RequestMetrics, HttpServerError, StorageGateway } from './protocols';
-import { Entity } from './domain/Entity';
-import { UseCaseHandler } from './handlers';
-export { UseCase, HttpMiddleware, Validation, RequestMetricsHandler, RequestMetrics, HttpServerError, CreateRepository, DeleteRepository, DeleteRepositoryBy, UpdateRepository, RestoreRepository, RestoreRepositoryBy, ExistsBy, NotExistsBy, RestoreManyRepository, Request, Dede, DedeRegister, DedeOptions, UseCaseHandler, ServerError, BadRequest, Conflict, Forbidden, HttpServer, NotFound, Unauthorized, UnprocessableEntity, Controller, Post, Put, Get, Delete, Patch, Validator, Middleware, Middlewares, Context, DecorateUseCase, Inject, Entity, Restrict, DbColumn, VirtualProperty, Metrics, OffConsoleLog, StorageGateway, Storage, Expose };
+import { Post, Get, Put, Delete, Patch, Controller, Input, Middleware, UseMiddleware, UseMiddlewares, Tracer, Tracing, TracerData, EntityIdentifier, Entity, Restrict, VirtualProperty, GetterPrefix, Serialize, Id, UseCase, DecorateUseCase, Storage } from "./application";
+export { Controller, Post, Get, Put, Delete, Patch, Input, Middleware, UseMiddleware, UseMiddlewares, Tracer, Tracing, TracerData, EntityIdentifier, Entity, Restrict, VirtualProperty, GetterPrefix, Serialize, Id, UseCase, DecorateUseCase, Storage };

package/dist/index.js

@@ -1,6 +1,9 @@
-import { Dede } from './dede';
-import { Controller, Post, Put, Get, Delete, Patch, Validator, Middleware, Middlewares, Context, DecorateUseCase, Inject, Restrict, Metrics, DbColumn, VirtualProperty, OffConsoleLog, Storage, Expose } from './decorators';
-import { BadRequest, Conflict, Forbidden, HttpServer, NotFound, ServerError, Unauthorized, UnprocessableEntity } from './http';
-import { Entity } from './domain/Entity';
-import { UseCaseHandler } from './handlers';
-export { Dede, UseCaseHandler, ServerError, BadRequest, Conflict, Forbidden, HttpServer, NotFound, Unauthorized, UnprocessableEntity, Controller, Post, Put, Get, Delete, Patch, Validator, Middleware, Middlewares, Context, DecorateUseCase, Inject, Entity, Restrict, DbColumn, VirtualProperty, Metrics, OffConsoleLog, Storage, Expose };
+import { 
+// controller
+Post, Get, Put, Delete, Patch, Controller, UseMiddleware, UseMiddlewares, Tracing, Entity, Restrict, VirtualProperty, GetterPrefix, Serialize, Id, DecorateUseCase, 
+// usecase
+// storage
+Storage
+// storage
+ } from "./application";
+export { Controller, Post, Get, Put, Delete, Patch, UseMiddleware, UseMiddlewares, Tracing, Entity, Restrict, VirtualProperty, GetterPrefix, Serialize, Id, DecorateUseCase, Storage };

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

@@ -0,0 +1,11 @@
+declare class ComponentRegistry {
+    private static instance;
+    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 {};

package/dist/infra/di/registry.js

@@ -0,0 +1,32 @@
+class ComponentRegistry {
+    static instance;
+    dependencies = new Map();
+    static getInstance() {
+        if (!this.instance) {
+            this.instance = new ComponentRegistry();
+        }
+        return this.instance;
+    }
+    load(name, dependency) {
+        this.dependencies.set(name, dependency);
+    }
+    inject(name) {
+        if (!this.dependencies.get(name))
+            throw new Error(`Dependency not found ${name}`);
+        return this.dependencies.get(name);
+    }
+    remove(name) {
+        this.dependencies.delete(name);
+    }
+}
+export const Registry = ComponentRegistry.getInstance();
+export function Inject(name) {
+    return function (target, propertyKey) {
+        target[propertyKey] = new Proxy({}, {
+            get(_, propertyKey) {
+                const dependency = Registry.inject(name);
+                return dependency[propertyKey];
+            }
+        });
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "framework-do-dede",
-  "version": "2.0.21",
+  "version": "3.0.1",
   "type": "module",
   "main": "./dist/index.cjs",
   "module": "./dist/index.js",
@@ -12,7 +12,7 @@
     "require": "./dist/index.cjs"
   },
   "scripts": {
-    "test": "jest",
+    "test": "jest && jest ./example/test",
     "test:watch": "jest --watch",
     "clean": "rimraf dist",
     "build": "npm run clean && tsc -p tsconfig.build.json && tsc-alias",
@@ -36,6 +36,7 @@
     "@babel/core": "^7.26.10",
     "@babel/preset-env": "^7.26.9",
     "@babel/preset-typescript": "^7.27.0",
+    "@types/bun": "^1.2.16",
     "@types/jest": "^29.5.14",
     "@types/reflect-metadata": "^0.1.0",
     "jest": "^29.7.0",
@@ -45,8 +46,8 @@
     "typescript": "^5.8.2"
   },
   "peerDependencies": {
-    "elysia": "^1.2.25",
-    "express": "^4.21.2",
+    "elysia": "^1.3.5",
+    "express": "^5.1.0",
     "typescript": "^5.8.2"
   },
   "dependencies": {

package/dist/decorators/controller.d.ts

@@ -1,38 +0,0 @@
-import { Validation } from "../protocols/Validation";
-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 Middlewares(middlewareClasses: (new (...args: any[]) => HttpMiddleware)[]): (target: any, propertyKey: string, descriptor: PropertyDescriptor) => void;
-export declare function Post(config?: {
-    path?: string;
-    statusCode?: number;
-    params?: string[];
-    query?: string[];
-}): (target: any, propertyKey: string, descriptor: PropertyDescriptor) => void;
-export declare function Get(config?: {
-    path?: string;
-    statusCode?: number;
-    params?: string[];
-    query?: string[];
-}): (target: any, propertyKey: string, descriptor: PropertyDescriptor) => void;
-export declare function Put(config?: {
-    path?: string;
-    statusCode?: number;
-    params?: string[];
-    query?: string[];
-}): (target: any, propertyKey: string, descriptor: PropertyDescriptor) => void;
-export declare function Patch(config?: {
-    path?: string;
-    statusCode?: number;
-    params?: string[];
-    query?: string[];
-}): (target: any, propertyKey: string, descriptor: PropertyDescriptor) => void;
-export declare function Delete(config?: {
-    path?: string;
-    statusCode?: number;
-    params?: string[];
-    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;
-export declare function OffConsoleLog(): (target: any, propertyKey: string, descriptor: PropertyDescriptor) => void;

package/dist/decorators/di.d.ts

@@ -1 +0,0 @@
-export declare function Inject(token: string): (target: any, propertyKey: string | symbol | undefined, parameterIndex: number) => void;

package/dist/decorators/di.js

@@ -1,7 +0,0 @@
-export function Inject(token) {
-    return function (target, propertyKey, parameterIndex) {
-        const injections = Reflect.getMetadata('injections', target) || [];
-        injections[parameterIndex] = token;
-        Reflect.defineMetadata('injections', injections, target);
-    };
-}

package/dist/decorators/entity.d.ts

@@ -1,12 +0,0 @@
-export declare function Restrict(): (target: any, propertyKey: string) => void;
-export type ExposeConfig = {
-    mapping?: string | Record<string, string>;
-    deserialize?: (value: any) => any | Promise<any>;
-};
-export declare function Expose(configOrMapping: ExposeConfig | string): PropertyDecorator;
-export declare function VirtualProperty(propertyName: string): (target: any, methodName: string, descriptor: PropertyDescriptor) => void;
-export type DbColumnConfig<T = any> = {
-    column?: string | Record<string, string>;
-    serialize?: (value: T, data: any) => any | Promise<any>;
-};
-export declare function DbColumn<T>(configOrColumn: DbColumnConfig<T> | string): PropertyDecorator;

package/dist/decorators/entity.js

@@ -1,65 +0,0 @@
-export function Restrict() {
-    return function (target, propertyKey) {
-        if (!target.constructor._restrictedProperties) {
-            target.constructor._restrictedProperties = new Set();
-        }
-        target.constructor._restrictedProperties.add(propertyKey);
-    };
-}
-export function Expose(configOrMapping) {
-    return function (target, propertyKey) {
-        const ctor = target.constructor;
-        const configs = ctor._exposeConfigs || (ctor._exposeConfigs = new Map());
-        if (typeof configOrMapping === "string") {
-            configs.set(propertyKey, [
-                ...(configs.get(propertyKey) || []),
-                {
-                    mapping: configOrMapping,
-                    deserialize: (value) => value
-                }
-            ]);
-        }
-        else {
-            configs.set(propertyKey, [
-                ...(configs.get(propertyKey) || []),
-                {
-                    mapping: configOrMapping.mapping,
-                    deserialize: configOrMapping.deserialize || ((value) => value)
-                }
-            ]);
-        }
-    };
-}
-export function VirtualProperty(propertyName) {
-    return function (target, methodName, descriptor) {
-        const ctor = target.constructor;
-        if (!ctor._virtualProperties) {
-            ctor._virtualProperties = new Map();
-        }
-        ctor._virtualProperties.set(propertyName, methodName);
-    };
-}
-export function DbColumn(configOrColumn) {
-    return function (target, propertyKey) {
-        const ctor = target.constructor;
-        const configs = ctor._dbColumnConfigs || (ctor._dbColumnConfigs = new Map());
-        if (typeof configOrColumn === "string") {
-            configs.set(propertyKey, [
-                ...(configs.get(propertyKey) || []),
-                {
-                    column: configOrColumn,
-                    serialize: (value, constructorProps) => value
-                }
-            ]);
-        }
-        else {
-            configs.set(propertyKey, [
-                ...(configs.get(propertyKey) || []),
-                {
-                    column: configOrColumn.column,
-                    serialize: configOrColumn.serialize || ((value, constructorProps) => value)
-                }
-            ]);
-        }
-    };
-}

package/dist/decorators/index.d.ts

@@ -1,6 +0,0 @@
-import { Controller, Post, Get, Put, Delete, Patch, Validator, Middleware, Middlewares, Metrics, OffConsoleLog } from './controller';
-import { Context, DecorateUseCase } from './usecase';
-import { Inject } from './di';
-import { Restrict, DbColumn, VirtualProperty, Expose } from './entity';
-import { Storage } from './services';
-export { Controller, Middleware, Middlewares, Validator, Metrics, OffConsoleLog, Post, Get, Put, Delete, Patch, Context, DecorateUseCase, Inject, Restrict, DbColumn, Storage, Expose, VirtualProperty };

package/dist/decorators/index.js

@@ -1,6 +0,0 @@
-import { Controller, Post, Get, Put, Delete, Patch, Validator, Middleware, Middlewares, Metrics, OffConsoleLog } from './controller';
-import { Context, DecorateUseCase } from './usecase';
-import { Inject } from './di';
-import { Restrict, DbColumn, VirtualProperty, Expose } from './entity';
-import { Storage } from './services';
-export { Controller, Middleware, Middlewares, Validator, Metrics, OffConsoleLog, Post, Get, Put, Delete, Patch, Context, DecorateUseCase, Inject, Restrict, DbColumn, Storage, Expose, VirtualProperty };

package/dist/decorators/services.d.ts

@@ -1 +0,0 @@
-export declare function Storage(gatewayName: string): (target: any, propertyKey: string) => void;

package/dist/decorators/services.js

@@ -1,27 +0,0 @@
-import { Registry } from "../di/registry";
-export function Storage(gatewayName) {
-    return function (target, propertyKey) {
-        const instanceSymbol = Symbol();
-        Object.defineProperty(target, propertyKey, {
-            get: function () {
-                if (!this[instanceSymbol]) {
-                    // Lazy load the gateway when the property is first accessed
-                    if (!Registry.has(gatewayName)) {
-                        throw new Error(`StorageGateway ${gatewayName} not registered`);
-                    }
-                    const GatewayClass = Registry.resolve(gatewayName);
-                    if (!GatewayClass.save || !GatewayClass.get || !GatewayClass.delete) {
-                        throw new Error(`${gatewayName} is not a valid StorageGateway`);
-                    }
-                    this[instanceSymbol] = GatewayClass;
-                }
-                return this[instanceSymbol];
-            },
-            set: () => {
-                throw new Error('Cannot assign new value to @Storage() property');
-            },
-            enumerable: true,
-            configurable: true
-        });
-    };
-}

package/dist/decorators/usecase.d.ts

@@ -1,4 +0,0 @@
-import { UseCase } from "../protocols";
-export declare const USE_CASE_DECORATORS: unique symbol;
-export declare function Context(middlewareKey: string): (target: any, propertyKey: string) => void;
-export declare function DecorateUseCase(useCases: UseCase<any, any> | (new (...args: any[]) => UseCase<any, any>) | Array<UseCase<any, any> | (new (...args: any[]) => UseCase<any, any>)>): ClassDecorator;

package/dist/decorators/usecase.js

@@ -1,15 +0,0 @@
-export const USE_CASE_DECORATORS = Symbol('useCaseDecorators');
-export function Context(middlewareKey) {
-    return function (target, propertyKey) {
-        const metadata = Reflect.getMetadata('context', target.constructor) || [];
-        metadata.push({ propertyKey, middlewareKey });
-        Reflect.defineMetadata('context', metadata, target.constructor);
-    };
-}
-export function DecorateUseCase(useCases) {
-    return function (target) {
-        const decorators = Array.isArray(useCases) ? useCases : [useCases];
-        Reflect.defineMetadata(USE_CASE_DECORATORS, decorators, target);
-        return target;
-    };
-}

package/dist/di/registry.d.ts

@@ -1,17 +0,0 @@
-import 'reflect-metadata';
-declare class ComponentRegistry {
-    private static instance;
-    private dependencies;
-    private isLoading;
-    static getInstance(): ComponentRegistry;
-    register(token: string, dependency: any): void;
-    has(token: string): boolean;
-    addDependency(token: string, dependency: any): void;
-    resolve<T>(token: string): T;
-    clear(token: string): void;
-    classLoader<T>(target: new (...args: any[]) => T): T;
-    inject(token: string): (target: any, propertyKey: string | symbol | undefined, parameterIndex: number) => void;
-    loaded(): void;
-}
-export declare const Registry: ComponentRegistry;
-export {};

package/dist/di/registry.js

@@ -1,51 +0,0 @@
-import { Inject } from '../decorators';
-import 'reflect-metadata';
-class ComponentRegistry {
-    static instance;
-    dependencies = new Map();
-    isLoading = true;
-    static getInstance() {
-        if (!this.instance) {
-            this.instance = new ComponentRegistry();
-        }
-        return this.instance;
-    }
-    register(token, dependency) {
-        this.dependencies.set(token, dependency);
-    }
-    has(token) {
-        return this.dependencies.has(token);
-    }
-    addDependency(token, dependency) {
-        if (!this.dependencies.has(token))
-            throw new Error(`Dependency ${token} not registered`);
-        if (!Array.isArray(this.dependencies.get(token)))
-            throw new Error("Dependency must be an array");
-        this.dependencies.get(token).push(dependency);
-    }
-    resolve(token) {
-        const dependency = this.dependencies.get(token);
-        if (!dependency) {
-            throw new Error(`Dependency ${token} not registered`);
-        }
-        return dependency;
-    }
-    clear(token) {
-        const dependency = this.dependencies.get(token);
-        if (!dependency)
-            return;
-        this.dependencies.set(token, null);
-    }
-    classLoader(target) {
-        const paramtypes = Reflect.getMetadata('injections', target) || [];
-        const args = paramtypes.map((token) => ComponentRegistry.getInstance().resolve(token));
-        return new target(...args);
-    }
-    inject(token) {
-        return Inject(token);
-    }
-    loaded() {
-        this.isLoading = false;
-    }
-}
-export const Registry = ComponentRegistry.getInstance();