framework-do-dede 3.3.1 → 4.0.0

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,15 @@ 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 = DefaultContainer) {
     return function (target, propertyKey) {
         target[propertyKey] = new Proxy({}, {
             get(_, propertyKey) {
-                const dependency = Registry.inject(name);
+                const dependency = container.inject(name);
                 return dependency[propertyKey];
             }
         });

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

@@ -1,5 +1,9 @@
-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;
+    private runEntityHooks;
     toEntity(): Record<string, any>;
     toAsyncEntity(): Promise<Record<string, any>>;
     toData({ serialize }?: {
@@ -14,3 +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,5 +1,61 @@
-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)) {
+            let value = this[propName];
+            if (typeof value === 'function')
+                continue;
+            if (value === undefined)
+                continue;
+            result[propName] = value;
+        }
+        return result;
+    }
+    getEntityHooks(hookKey) {
+        const hooks = [];
+        let current = this.constructor;
+        while (current && current !== SerializableEntity) {
+            const currentHooks = current[hookKey];
+            if (currentHooks && currentHooks.length) {
+                hooks.unshift(...currentHooks);
+            }
+            current = Object.getPrototypeOf(current);
+        }
+        return hooks;
+    }
+    runEntityHooks(hookKey, payload, awaitHooks) {
+        const hooks = this.getEntityHooks(hookKey);
+        if (!hooks.length)
+            return;
+        if (awaitHooks) {
+            return (async () => {
+                for (const hookName of hooks) {
+                    const hook = this[hookName];
+                    if (typeof hook !== 'function')
+                        continue;
+                    await hook.call(this, payload);
+                }
+            })();
+        }
+        for (const hookName of hooks) {
+            const hook = this[hookName];
+            if (typeof hook !== 'function')
+                continue;
+            try {
+                const result = hook.call(this, payload);
+                if (result && typeof result.then === 'function') {
+                    void result.catch(() => undefined);
+                }
+            }
+            catch (error) {
+                throw error;
+            }
+        }
+    }
     toEntity() {
+        const raw = this.buildRawEntityObject();
+        this.runEntityHooks(BEFORE_TO_ENTITY, raw, false);
         // @ts-ignore
         const propertiesConfigs = this.constructor.propertiesConfigs;
         const result = {};
@@ -31,9 +87,12 @@ export class Entity {
                 value = null;
             result[propertyName] = value;
         }
+        this.runEntityHooks(AFTER_TO_ENTITY, result, false);
         return result;
     }
     async toAsyncEntity() {
+        const raw = this.buildRawEntityObject();
+        await this.runEntityHooks(BEFORE_TO_ENTITY, raw, true);
         // @ts-ignore
         const propertiesConfigs = this.constructor.propertiesConfigs;
         const result = {};
@@ -45,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);
@@ -65,6 +124,7 @@ export class Entity {
                 value = null;
             result[propertyName] = value;
         }
+        await this.runEntityHooks(AFTER_TO_ENTITY, result, true);
         return result;
     }
     toData({ serialize = false } = {}) {
@@ -122,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() {
@@ -178,3 +218,27 @@ const loadPropertiesConfig = (target, propertyKey) => {
         target.constructor.propertiesConfigs[propertyKey] = {};
     }
 };
+const BEFORE_TO_ENTITY = Symbol('beforeToEntity');
+const AFTER_TO_ENTITY = Symbol('afterToEntity');
+const assertEntityDecoratorTarget = (target, decoratorName) => {
+    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');
+        const cls = target.constructor;
+        cls[BEFORE_TO_ENTITY] = cls[BEFORE_TO_ENTITY] || [];
+        cls[BEFORE_TO_ENTITY].push(propertyKey);
+    };
+}
+export function AfterToEntity() {
+    return function (target, propertyKey) {
+        assertEntityDecoratorTarget(target, 'AfterToEntity');
+        const cls = target.constructor;
+        cls[AFTER_TO_ENTITY] = cls[AFTER_TO_ENTITY] || [];
+        cls[AFTER_TO_ENTITY].push(propertyKey);
+    };
+}

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 {};

package/dist/interface/http/request-mapper.js

@@ -0,0 +1,55 @@
+export class HttpRequestMapper {
+    map(input, config) {
+        const filterParams = this.filter(input.params, config.params);
+        const filterQueryParams = this.filter(input.query, config.query);
+        const filterHeaders = this.filter(input.headers, config.headers);
+        const normalizeBody = this.normalizeBracketNotation(input.body);
+        let filterBody = this.filter(normalizeBody, config.body);
+        if (config.bodyFilter !== 'restrict') {
+            filterBody = { ...normalizeBody, ...filterBody };
+        }
+        const mergedParams = { ...filterHeaders, ...filterParams, ...filterQueryParams, ...filterBody };
+        return { data: mergedParams, context: {} };
+    }
+    filter(params, filterParams) {
+        const filter = {};
+        for (const paramName of filterParams || []) {
+            const [paramNameFiltered, type] = paramName.split('|');
+            let value = params[paramName] ?? params[paramNameFiltered];
+            if (value === undefined || value === null)
+                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;
+    }
+    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/interface/validation/class-validator.d.ts

@@ -0,0 +1,6 @@
+export type ValidationErrorDetail = {
+    path: string;
+    message: string;
+    rule: string;
+};
+export declare function validateWithClassValidator<T extends object>(dtoClass: new () => T, input: T): Promise<void>;

package/dist/interface/validation/class-validator.js

@@ -0,0 +1,28 @@
+import { UnprocessableEntity } from '../../domain/errors/http-errors';
+import { validate } from 'class-validator';
+export async function validateWithClassValidator(dtoClass, input) {
+    const instance = Object.assign(new dtoClass(), input);
+    const errors = await validate(instance);
+    if (errors.length === 0)
+        return;
+    const details = flattenErrors(errors);
+    throw new UnprocessableEntity('Validation error', {
+        code: 'validation_error',
+        details
+    });
+}
+function flattenErrors(errors, parentPath = '') {
+    const output = [];
+    for (const error of errors) {
+        const path = parentPath ? `${parentPath}.${error.property}` : error.property;
+        if (error.constraints) {
+            for (const [rule, message] of Object.entries(error.constraints)) {
+                output.push({ path, rule, message });
+            }
+        }
+        if (error.children && error.children.length > 0) {
+            output.push(...flattenErrors(error.children, path));
+        }
+    }
+    return output;
+}

package/dist/interface/validation/validator.d.ts

@@ -0,0 +1,5 @@
+export interface Validator<T = any> {
+    validate(input: T): void | Promise<void>;
+}
+export type ValidatorClass<T = any> = new () => T;
+export type ValidatorLike<T = any> = Validator<T> | ValidatorClass<T>;

package/dist/interface/validation/validator.js

@@ -0,0 +1 @@
+export {};

package/dist/protocols/repository.d.ts

@@ -1,4 +1,4 @@
-import { Entity } from "../application";
+import { Entity } from "../domain";
 export interface RepositoryCreate<T extends Entity> {
     create(input: T): Promise<void>;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "framework-do-dede",
-  "version": "3.3.1",
+  "version": "4.0.0",
   "type": "module",
   "main": "./dist/index.cjs",
   "module": "./dist/index.js",
@@ -16,7 +16,9 @@
     "test:watch": "jest --watch",
     "clean": "rimraf dist",
     "build": "npm run clean && tsc -p tsconfig.build.json && tsc-alias",
-    "prepare": "npm run build"
+    "prepare": "npm run build",
+    "bench": "node bench/benchmark.mjs",
+    "bench:compare": "node bench/run.mjs"
   },
   "files": [
     "dist"
@@ -46,6 +48,7 @@
     "typescript": "^5.8.2"
   },
   "peerDependencies": {
+    "class-validator": "^0.14.3",
     "elysia": "^1.3.5",
     "express": "^5.1.0",
     "typescript": "^5.8.2"