framework-do-dede 2.0.20 → 3.0.0

package/dist/application/controller.d.ts

@@ -0,0 +1,70 @@
+import 'reflect-metadata';
+export interface Middleware {
+    execute(input: Input<any>): Promise<any>;
+}
+export interface TracerData {
+    requestedAt: Date;
+    elapsedTime: string;
+    route: string;
+    method: string;
+    middlewares: {
+        elapsedTime: string;
+        middleware: string;
+        error?: any;
+    }[];
+    error?: any;
+    headers: Record<string, string>;
+}
+export interface Tracer {
+    trace(data: TracerData): Promise<any>;
+}
+export interface Input<T, K = any> {
+    data: T;
+    context?: K;
+}
+export declare function Controller(basePath?: string): (target: any) => void;
+export declare function Tracing(tracer: Tracer): (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 Post(config?: {
+    path?: string;
+    statusCode?: number;
+    params?: string[];
+    query?: string[];
+    headers?: string[];
+    responseType?: 'json' | 'text' | 'html';
+}): (target: any, propertyKey: string, descriptor: PropertyDescriptor) => void;
+export declare function Get(config?: {
+    path?: string;
+    statusCode?: number;
+    params?: string[];
+    query?: string[];
+    headers?: string[];
+    responseType?: 'json' | 'text' | 'html';
+}): (target: any, propertyKey: string, descriptor: PropertyDescriptor) => void;
+export declare function Put(config?: {
+    path?: string;
+    statusCode?: number;
+    params?: string[];
+    query?: string[];
+    headers?: string[];
+    responseType?: 'json' | 'text' | 'html';
+}): (target: any, propertyKey: string, descriptor: PropertyDescriptor) => void;
+export declare function Patch(config?: {
+    path?: string;
+    statusCode?: number;
+    params?: string[];
+    query?: string[];
+    headers?: string[];
+    responseType?: 'json' | 'text' | 'html';
+}): (target: any, propertyKey: string, descriptor: PropertyDescriptor) => void;
+export declare function Delete(config?: {
+    path?: string;
+    statusCode?: number;
+    params?: string[];
+    query?: string[];
+    headers?: string[];
+    responseType?: 'json' | 'text' | 'html';
+}): (target: any, propertyKey: string, descriptor: PropertyDescriptor) => void;

package/dist/{decorators → application}/controller.js

@@ -1,14 +1,36 @@
-import { FrameworkError } from "../http/FrameworkError";
-import { Registry } from "../di/registry";
-export function Controller(basePath) {
+import 'reflect-metadata';
+import { FrameworkError } from "../http/errors/framework";
+import { Registry } from "../infra/di/registry";
+let controllers = [];
+export function Controller(basePath = '/') {
     return function (target) {
+        if (!basePath)
+            throw new FrameworkError('basePath cannot be empty');
         Reflect.defineMetadata('basePath', basePath, target);
-        if (!Registry.has('controllers'))
-            Registry.register('controllers', []);
-        Registry.addDependency('controllers', target);
+        controllers.push(target.name);
+        Registry.load(target.name, target);
     };
 }
-export function Middleware(middlewareClass) {
+export function Tracing(tracer) {
+    return function (target, propertyKey) {
+        if (!propertyKey) {
+            Reflect.defineMetadata('tracer', tracer, target);
+        }
+        else {
+            Reflect.defineMetadata('tracer', tracer, target, propertyKey);
+        }
+    };
+}
+export function getControllers() {
+    return controllers.map((controller) => Registry.inject(controller));
+}
+export function flushControllers() {
+    controllers.map((controller) => {
+        Registry.remove(controller);
+    });
+    controllers = [];
+}
+export function UseMiddleware(middlewareClass) {
     return function (target, propertyKey, descriptor) {
         if (!middlewareClass.prototype.execute) {
             throw new FrameworkError('Middleware must implement execute()');
@@ -18,7 +40,7 @@ export function Middleware(middlewareClass) {
         Reflect.defineMetadata('middlewares', middlewares, target, propertyKey);
     };
 }
-export function Middlewares(middlewareClasses) {
+export function UseMiddlewares(middlewareClasses) {
     return function (target, propertyKey, descriptor) {
         for (const middlewareClass of middlewareClasses) {
             if (!middlewareClass.prototype.execute) {
@@ -26,9 +48,7 @@ export function Middlewares(middlewareClasses) {
             }
         }
         const existingMiddlewares = Reflect.getMetadata('middlewares', target, propertyKey) || [];
-        // Add the new middleware classes to the list
         existingMiddlewares.push(...middlewareClasses);
-        // Update the metadata with the combined list
         Reflect.defineMetadata('middlewares', existingMiddlewares, target, propertyKey);
     };
 }
@@ -39,7 +59,9 @@ export function Post(config = {}) {
             path: config.path || '',
             params: config.params,
             query: config.query,
-            statusCode: config.statusCode || 200
+            headers: config.headers,
+            statusCode: config.statusCode || 200,
+            responseType: config.responseType || 'json'
         }, target, propertyKey);
     };
 }
@@ -50,7 +72,9 @@ export function Get(config = {}) {
             path: config.path || '',
             params: config.params,
             query: config.query,
-            statusCode: config.statusCode || 200
+            headers: config.headers,
+            statusCode: config.statusCode || 200,
+            responseType: config.responseType || 'json'
         }, target, propertyKey);
     };
 }
@@ -61,7 +85,9 @@ export function Put(config = {}) {
             path: config.path || '',
             params: config.params,
             query: config.query,
-            statusCode: config.statusCode || 200
+            headers: config.headers,
+            statusCode: config.statusCode || 200,
+            responseType: config.responseType || 'json'
         }, target, propertyKey);
     };
 }
@@ -72,7 +98,9 @@ export function Patch(config = {}) {
             path: config.path || '',
             params: config.params,
             query: config.query,
-            statusCode: config.statusCode || 200
+            headers: config.headers,
+            statusCode: config.statusCode || 200,
+            responseType: config.responseType || 'json'
         }, target, propertyKey);
     };
 }
@@ -83,25 +111,9 @@ export function Delete(config = {}) {
             path: config.path || '',
             params: config.params,
             query: config.query,
-            statusCode: config.statusCode || 200
+            headers: config.headers,
+            statusCode: config.statusCode || 200,
+            responseType: config.responseType || 'json'
         }, target, propertyKey);
     };
 }
-export function Validator(validationClass) {
-    return function (target, propertyKey, descriptor) {
-        if (typeof validationClass.prototype.validate !== 'function') {
-            throw new FrameworkError('the concrete class does not implement Validation class".');
-        }
-        Reflect.defineMetadata('validation', new validationClass(), target, propertyKey);
-    };
-}
-export function Metrics(...handlers) {
-    return (target, propertyKey, descriptor) => {
-        Reflect.defineMetadata('metricsHandlers', handlers, target, propertyKey);
-    };
-}
-export function OffConsoleLog() {
-    return function (target, propertyKey, descriptor) {
-        Reflect.defineMetadata('offConsoleLog', true, target, propertyKey);
-    };
-}

package/dist/application/entity.d.ts

@@ -0,0 +1,21 @@
+export interface EntityIdentifier<T> {
+    getValue(): T;
+}
+export declare abstract class Entity {
+    [x: string]: any;
+    toEntity(): Record<string, any>;
+    toAsyncEntity(): Promise<Record<string, any>>;
+    toData({ serialize }?: {
+        serialize?: boolean;
+    }): Record<string, any>;
+    toAsyncData({ serialize }?: {
+        serialize?: boolean;
+    }): Promise<Record<string, any>>;
+    protected generateGetters(): void;
+    constructor();
+}
+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 declare function Id(): (target: any, propertyKey: string) => void;

package/dist/application/entity.js

@@ -0,0 +1,161 @@
+export class Entity {
+    toEntity() {
+        // @ts-ignore
+        const propertiesConfigs = this.constructor.propertiesConfigs;
+        const result = {};
+        for (const [propName] of Object.entries(this)) {
+            let value = this[propName];
+            if (typeof value === 'function')
+                continue;
+            if (propertiesConfigs[propName]?.serialize && value) {
+                value = propertiesConfigs[propName].serialize(value);
+            }
+            if (!value)
+                value = null;
+            result[propName] = value;
+        }
+        return result;
+    }
+    async toAsyncEntity() {
+        // @ts-ignore
+        const propertiesConfigs = this.constructor.propertiesConfigs;
+        const result = {};
+        for (const [propName] of Object.entries(this)) {
+            let value = this[propName];
+            if (typeof value === 'function')
+                continue;
+            if (propertiesConfigs[propName]?.serialize && value) {
+                value = await propertiesConfigs[propName].serialize(value);
+            }
+            if (!value)
+                value = null;
+            result[propName] = value;
+        }
+        return result;
+    }
+    toData({ serialize = false } = {}) {
+        // @ts-ignore
+        const propertiesConfigs = this.constructor.propertiesConfigs;
+        // @ts-ignore
+        const virtualProperties = this.constructor.virtualProperties;
+        const result = {};
+        for (const [propName] of Object.entries(this)) {
+            if (propertiesConfigs[propName]?.restrict)
+                continue;
+            if (typeof this[propName] === 'function')
+                continue;
+            let value = this[propName];
+            if (serialize && propertiesConfigs[propName]?.serialize && value) {
+                value = propertiesConfigs[propName].serialize(value);
+            }
+            result[propName] = value;
+        }
+        if (virtualProperties) {
+            for (const [methodName, propName] of Object.entries(virtualProperties)) {
+                if (this.__proto__[methodName]) {
+                    result[propName] = this[methodName]();
+                }
+            }
+        }
+        return result;
+    }
+    async toAsyncData({ serialize = false } = {}) {
+        // @ts-ignore
+        const propertiesConfigs = this.constructor.propertiesConfigs;
+        // @ts-ignore
+        const virtualProperties = this.constructor.virtualProperties;
+        const result = {};
+        for (const [propName] of Object.entries(this)) {
+            if (typeof this[propName] === 'function')
+                continue;
+            if (propertiesConfigs[propName]?.restrict)
+                continue;
+            let value = this[propName];
+            if (serialize && propertiesConfigs[propName]?.serialize && value) {
+                value = await propertiesConfigs[propName].serialize(value);
+            }
+            result[propName] = value;
+        }
+        if (virtualProperties) {
+            for (const [methodName, propName] of Object.entries(virtualProperties)) {
+                if (this.__proto__[methodName]) {
+                    result[propName] = await this[methodName]();
+                }
+            }
+        }
+        return result;
+    }
+    generateGetters() {
+        // @ts-ignore
+        for (const property of Object.keys(this)) {
+            if (typeof property === 'function')
+                continue;
+            // @ts-ignore
+            if (this.constructor.strategyId === property) {
+                this[property] = this[property].getValue();
+                this[`get${property[0].toUpperCase()}${property.slice(1)}`] = () => this[property];
+                continue;
+            }
+            if (!this[property]) {
+                // @ts-ignore
+                const prefixName = this.constructor.propertiesConfigs[property].prefix;
+                const getterName = `${prefixName}${property[0].toUpperCase()}${property.slice(1)}`;
+                if (this[getterName])
+                    continue;
+                this[getterName] = () => this[property];
+            }
+            else {
+                // @ts-ignore
+                const prefixName = this.constructor.propertiesConfigs[property]?.prefix || (typeof this[property] === 'boolean' ? 'is' : 'get');
+                const getterName = `${prefixName}${property[0].toUpperCase()}${property.slice(1)}`;
+                if (this[getterName])
+                    continue;
+                this[getterName] = () => this[property];
+            }
+        }
+    }
+    constructor() {
+        // @ts-ignore
+        if (!this.constructor?.strategyId) {
+            throw new Error('StrategyId must to be implement.');
+        }
+    }
+}
+export function Restrict() {
+    return function (target, propertyKey) {
+        loadPropertiesConfig(target, propertyKey);
+        target.constructor.propertiesConfigs[propertyKey].restrict = true;
+    };
+}
+export function VirtualProperty(propertyName) {
+    return function (target, methodName) {
+        const cls = target.constructor;
+        cls.virtualProperties = cls.virtualProperties || {};
+        cls.virtualProperties[methodName] = propertyName;
+    };
+}
+export function Serialize(callback) {
+    return function (target, propertyKey) {
+        loadPropertiesConfig(target, propertyKey);
+        target.constructor.propertiesConfigs[propertyKey].serialize = callback;
+    };
+}
+export function GetterPrefix(prefix) {
+    return function (target, propertyKey) {
+        loadPropertiesConfig(target, propertyKey);
+        target.constructor.propertiesConfigs[propertyKey].prefix = prefix;
+    };
+}
+export function Id() {
+    return function (target, propertyKey) {
+        target.constructor.strategyId = propertyKey;
+    };
+}
+const loadPropertiesConfig = (target, propertyKey) => {
+    if (!target.constructor.propertiesConfigs) {
+        target.constructor.propertiesConfigs = {};
+    }
+    if (!target.constructor.propertiesConfigs[propertyKey]) {
+        target.constructor.propertiesConfigs[propertyKey] = {};
+    }
+};

package/dist/application/index.d.ts

@@ -0,0 +1,5 @@
+import { Controller, Post, Get, Put, Delete, Patch, UseMiddleware, UseMiddlewares, Tracing, type Middleware, type Input, type Tracer, type TracerData } from './controller';
+import { DecorateUseCase, type UseCase } from './usecase';
+import { Storage } from './services';
+export { Controller, UseMiddleware, UseMiddlewares, Post, Get, Put, Delete, Patch, Tracing, DecorateUseCase, Storage };
+export type { Middleware, Input, UseCase, Tracer, TracerData };

package/dist/application/index.js

@@ -0,0 +1,4 @@
+import { Controller, Post, Get, Put, Delete, Patch, UseMiddleware, UseMiddlewares, Tracing } from './controller';
+import { DecorateUseCase } from './usecase';
+import { Storage } from './services';
+export { Controller, UseMiddleware, UseMiddlewares, Post, Get, Put, Delete, Patch, Tracing, DecorateUseCase, Storage };

package/dist/{protocols/StorageGateway.d.ts → application/services.d.ts}

@@ -1,5 +1,7 @@
+import 'reflect-metadata';
 export interface StorageGateway {
     save(file: File, path: string): Promise<void>;
     get(key: string): Promise<string>;
     delete(key: string): Promise<boolean>;
 }
+export declare function Storage(gatewayName: string): (target: any, propertyKey: string) => void;

package/dist/application/services.js

@@ -0,0 +1,20 @@
+import { Registry } from "../infra/di/registry";
+import 'reflect-metadata';
+export function Storage(gatewayName) {
+    return function (target, propertyKey) {
+        let dependency;
+        Object.defineProperty(target, propertyKey, {
+            get: function () {
+                if (!dependency) {
+                    dependency = Registry.inject(gatewayName);
+                }
+                if (!dependency.save || !dependency.get || !dependency.delete) {
+                    throw new Error(`${gatewayName} is not a valid StorageGateway`);
+                }
+                return dependency;
+            },
+            enumerable: true,
+            configurable: true
+        });
+    };
+}

package/dist/application/usecase.d.ts

@@ -0,0 +1,11 @@
+import { Input } from "./controller";
+export declare const USE_CASE_DECORATORS: unique symbol;
+export declare abstract class UseCase<UseCaseInput, UseCaseOutput, UseCaseContext = any> {
+    private readonly data;
+    private readonly context?;
+    constructor(input: Input<UseCaseInput>);
+    protected getData(): UseCaseInput;
+    protected getContext(): UseCaseContext;
+    abstract execute(): Promise<UseCaseOutput>;
+}
+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/application/usecase.js

@@ -0,0 +1,24 @@
+export const USE_CASE_DECORATORS = Symbol('USE_CASE_DECORATORS');
+export class UseCase {
+    data;
+    context;
+    constructor(input) {
+        this.data = input.data;
+        if (input.context) {
+            this.context = input.context;
+        }
+    }
+    getData() {
+        return this.data;
+    }
+    getContext() {
+        return this?.context;
+    }
+}
+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/dede.d.ts

@@ -1,7 +1,6 @@
 export type Register = {
     name: string;
     classLoader: any;
-    autoLoad?: boolean;
 };
 export type Options = {
     framework: {
@@ -13,9 +12,11 @@ export type Options = {
     defaultServerError?: string;
 };
 export declare class Dede {
-    private static httpServer;
+    private readonly framework;
+    private readonly defaultServerError?;
+    private readonly httpServer;
+    private constructor();
     static start({ framework, registries, defaultServerError }: Options): Promise<Dede>;
-    static stop(): Promise<void>;
-    private static clearControllers;
+    stop(): Promise<void>;
     private static loadRegistries;
 }

package/dist/dede.js

@@ -1,39 +1,35 @@
-import { Registry } from "./di/registry";
-import { ControllerHandler } from "./handlers";
-import { ElysiaHttpServer } from "./http/ElysiaHttpServer";
-import { ExpressHttpServer } from "./http/ExpressHttpServer";
+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";
 export class Dede {
-    static httpServer;
-    static async start({ framework, registries, defaultServerError }) {
-        await this.loadRegistries(registries);
+    framework;
+    defaultServerError;
+    httpServer;
+    constructor(framework, defaultServerError) {
+        this.framework = framework;
+        this.defaultServerError = defaultServerError;
         if (framework.use === 'elysia') {
-            Dede.httpServer = new ElysiaHttpServer(framework.middlewares || []);
+            this.httpServer = new ElysiaServerAdapter(framework.middlewares || []);
         }
         if (framework.use === 'express') {
-            Dede.httpServer = new ExpressHttpServer(framework.middlewares || []);
+            this.httpServer = new ExpressServerAdapter(framework.middlewares || []);
         }
         if (defaultServerError)
-            Dede.httpServer.setDefaultMessageError(defaultServerError);
-        if (!Registry.has('controllers')) {
-            throw new Error("No controllers registered");
-        }
-        new ControllerHandler(Dede.httpServer, framework.port || 80);
-        this.clearControllers();
-        return Dede;
+            this.httpServer.setDefaultMessageError(defaultServerError);
+        new ControllerHandler(this.httpServer, framework.port || 80);
     }
-    static async stop() {
-        await Dede.httpServer.close();
+    static async start({ framework, registries, defaultServerError }) {
+        await this.loadRegistries(registries);
+        return new Dede(framework, defaultServerError);
     }
-    static clearControllers() {
-        Registry.clear('controllers');
+    async stop() {
+        await this.httpServer.close();
     }
     static async loadRegistries(registries) {
-        registries.forEach(({ classLoader, name, autoLoad = true }) => {
-            if (autoLoad)
-                Registry.register(name, Registry.classLoader(classLoader));
-            else
-                Registry.register(name, classLoader);
+        registries.forEach(({ classLoader, name }) => {
+            Registry.load(name, classLoader);
         });
-        Registry.loaded();
+        return new Promise(resolve => setTimeout(resolve, 500));
     }
 }

package/dist/{handlers → http}/controller.handler.d.ts

@@ -1,7 +1,7 @@
-import HttpServer from "../http/HttpServer";
+import HttpServer from "../http/http-server";
 export default class ControllerHandler {
     constructor(httpServer: HttpServer, port: number);
-    private transformErrorOnJSON;
+    private executeMiddlewares;
     private registryControllers;
     private filter;
     private extractError;