framework-do-dede 4.1.0 → 5.2.0

package/README.md

@@ -1,6 +1,6 @@
 # Framework do Dedé
 
-Um framework TypeScript simples para construir APIs HTTP com controllers, use cases e entities, com suporte a Express ou Elysia, DI leve e serialização de entidades.
+Um framework TypeScript simples para construir APIs HTTP com controllers, use cases e entities, com suporte a Express ou Elysia, DI leve e camada de Model.
 
 ## Índice
 
@@ -12,8 +12,8 @@ Um framework TypeScript simples para construir APIs HTTP com controllers, use ca
   - Middlewares
   - Tracing
   - UseCase e Decorators
-  - Entity e Serialização
-  - Hooks Before/After ToEntity
+  - Entity e Model
+  - Event Dispatcher
   - Storage Gateway
   - DI (Container/Inject)
   - Errors
@@ -21,7 +21,7 @@ Um framework TypeScript simples para construir APIs HTTP com controllers, use ca
 - Exemplos
   - Express
   - Elysia
-  - Fila com AfterToEntity
+  - Background com EventDispatcher
 - Testes
 - Benchmark
 
@@ -250,87 +250,57 @@ class CreateUserUseCase extends UseCase<{ name: string }, { id: string }> {
 }
 ```
 
-### Entity e Serializacao
+### Entity e Model
 
-Entities suportam:
-
-- `toEntity()` e `toAsyncEntity()`
-- `toData()` e `toAsyncData()`
-- `@Serialize`, `@Restrict`, `@VirtualProperty`, `@GetterPrefix`
-
-Obs: a serializacao fica na camada de infraestrutura, mas a API continua sendo exposta pelo framework (importe direto de `./src`).
+Entities sao dominio puro. Use `Model` para mapear coluna/property e construir o objeto de persistencia.
 
 ```ts
-import { Entity, Serialize, Restrict, VirtualProperty, GetterPrefix } from './src';
-
-class User extends Entity {
-  @Serialize((value: Email) => value.getValue())
-  private readonly email: Email;
+import { Entity, Model, model, column } from './src';
 
-  @Restrict()
-  private readonly passwordHash: string;
-
-  @GetterPrefix('has')
-  private readonly profile?: Profile;
-
-  @VirtualProperty('displayName')
-  private display() {
-    return 'User ' + this.email.getValue();
-  }
+class Order extends Entity {
+  private readonly id: string;
+  private readonly name: string;
+  private readonly amount: number;
 
-  constructor(email: string, passwordHash: string) {
+  constructor(id: string, name: string, amount: number) {
     super();
-    this.email = new Email(email);
-    this.passwordHash = passwordHash;
+    this.id = id;
+    this.name = name;
+    this.amount = amount;
     this.generateGetters();
   }
 }
 
-const user = new User('a@b.com', 'hash');
-const serialized = user.toEntity();
-```
-
-Regras principais:
-
-- `@Serialize` pode retornar objeto: cada chave vira uma propriedade do resultado
-- `@Restrict` remove campo em `toData`
-- `@VirtualProperty` mapeia metodos para campos virtuais
-- `generateGetters()` cria getters para campos (ex.: `getName`, `isActive`, `hasProfile`)
-
-### Hooks Before/After ToEntity
-
-Use `@BeforeToEntity()` e `@AfterToEntity()` em metodos de Entities.
+type OrderTable = 'orders';
 
-- Before recebe objeto bruto (antes de serializacao)
-- After recebe objeto tratado (resultado final)
-- `toEntity()` executa hooks sem aguardar promessas
-- `toAsyncEntity()` aguarda hooks async
+@model<OrderTable>('orders')
+class OrderModel extends Model<OrderTable> {
+  @column('id')
+  id!: string;
 
-```ts
-import { Entity, AfterToEntity, BeforeToEntity } from './src';
+  @column('name')
+  name!: string;
 
-class FileEntity extends Entity {
-  private readonly name: string;
-  private readonly s3Key: string;
+  @column('amount')
+  amount!: number;
 
-  constructor(name: string, s3Key: string) {
+  constructor(order?: Order) {
     super();
-    this.name = name;
-    this.s3Key = s3Key;
-  }
-
-  @BeforeToEntity()
-  private before(payload: Record<string, any>) {
-    payload.rawTouched = true;
-  }
-
-  @AfterToEntity()
-  private async after(payload: Record<string, any>) {
-    await saveToS3(payload.s3Key);
+    if (order) {
+      this.id = order.getId();
+      this.name = order.getName();
+      this.amount = order.getAmount();
+    }
   }
 }
 ```
 
+Regras principais:
+
+- `Model` guarda metadados de coluna (via `@column`) e nome da tabela (via `@model`)
+- a conversao entity -> model acontece no construtor do Model (ou em um factory)
+- `generateGetters()` cria getters para campos (ex.: `getName`, `isActive`, `hasProfile`)
+
 ### Storage Gateway
 
 Use `@Storage` para injetar gateways com interface `StorageGateway`.
@@ -350,6 +320,25 @@ class FileService {
 }
 ```
 
+### Event Dispatcher
+
+Use `@EventDispatcher` para enfileirar tarefas ou eventos de background com interface `EventDispatcher`.
+
+```ts
+import { EventDispatcher } from './src';
+
+type QueueEvent = { name: string; payload?: Record<string, any> };
+
+class QueueService {
+  @EventDispatcher('QueueDispatcher')
+  private readonly dispatcher!: { dispatch: (event: QueueEvent) => Promise<void> };
+
+  async enqueue(payload: Record<string, any>) {
+    await this.dispatcher.dispatch({ name: 'jobs.create', payload });
+  }
+}
+```
+
 ### DI (Container/Inject)
 
 Registre dependencias ao iniciar o server (usando o container padrão):
@@ -447,49 +436,24 @@ app.registerControllers([ExampleController]);
 app.listen();
 ```
 
-### Fila com AfterToEntity
+### Background com EventDispatcher
 
 ```ts
-import { Entity, AfterToEntity } from './src';
+import { EventDispatcher } from './src';
 
-type QueueJob = { type: string; payload: Record<string, any> };
+type QueueEvent = { name: string; payload: Record<string, any> };
 
-type Queue = { enqueue(job: QueueJob): Promise<void> };
-
-const queue: Queue = {
-  async enqueue(job) {
-    console.log('queued job', job);
-  }
-};
-
-class FileEntity extends Entity {
-  private readonly name: string;
-  private readonly s3Key: string;
-
-  private constructor({ name, s3Key }: { name: string; s3Key: string }) {
-    super();
-    this.name = name;
-    this.s3Key = s3Key;
-  }
+class FileService {
+  @EventDispatcher('QueueDispatcher')
+  private readonly dispatcher!: { dispatch: (event: QueueEvent) => Promise<void> };
 
-  @AfterToEntity()
-  private async enqueueFileSync(payload: Record<string, any>) {
-    await queue.enqueue({
-      type: 'files.create',
-      payload: {
-        name: payload.name,
-        s3Key: payload.s3Key
-      }
+  async enqueueFile(input: { name: string; s3Key: string }) {
+    await this.dispatcher.dispatch({
+      name: 'files.create',
+      payload: input
     });
   }
-
-  static create(input: { name: string; s3Key: string }) {
-    return new FileEntity(input);
-  }
 }
-
-const entity = FileEntity.create({ name: 'report', s3Key: 's3://bucket/report.pdf' });
-const serialized = entity.toEntity();
 ```
 
 ## Testes

package/dist/application/index.d.ts

@@ -1,7 +1,9 @@
 import { Controller, Post, Get, Put, Delete, Patch, UseMiddleware, UseMiddlewares, Tracing, type Middleware, type Input, type Tracer, type TracerData } from './controller';
-import { Entity, Restrict, VirtualProperty, Serialize, GetterPrefix, BeforeToEntity, AfterToEntity } from '../infra/serialization/entity';
+import { Entity, Restrict, VirtualProperty, GetterPrefix, Transform } from '../infra/serialization/entity';
+import { Model, model, column } from '../infra/model/model';
 import { DecorateUseCase, UseCase } from './usecase';
-export { Controller, UseMiddleware, UseMiddlewares, Post, Get, Put, Delete, Patch, Tracing, DecorateUseCase, UseCase, Entity, Restrict, VirtualProperty, Serialize, GetterPrefix, BeforeToEntity, AfterToEntity, };
-export { Storage, CacheGateway } from './services';
+export { Controller, UseMiddleware, UseMiddlewares, Post, Get, Put, Delete, Patch, Tracing, DecorateUseCase, UseCase, Entity, Restrict, VirtualProperty, GetterPrefix, Transform, Model, model, column, };
+export { Storage, CacheGateway, EventDispatcher } from './services';
 export type { Middleware, Input, Tracer, TracerData };
 export type { StorageGateway } from './services';
+export type { Event, EventPayload } from './services';

package/dist/application/index.js

@@ -1,5 +1,6 @@
 import { Controller, Post, Get, Put, Delete, Patch, UseMiddleware, UseMiddlewares, Tracing } from './controller';
-import { Entity, Restrict, VirtualProperty, Serialize, GetterPrefix, BeforeToEntity, AfterToEntity } from '../infra/serialization/entity';
+import { Entity, Restrict, VirtualProperty, GetterPrefix, Transform } from '../infra/serialization/entity';
+import { Model, model, column } from '../infra/model/model';
 import { DecorateUseCase, UseCase } from './usecase';
-export { Controller, UseMiddleware, UseMiddlewares, Post, Get, Put, Delete, Patch, Tracing, DecorateUseCase, UseCase, Entity, Restrict, VirtualProperty, Serialize, GetterPrefix, BeforeToEntity, AfterToEntity, };
-export { Storage, CacheGateway } from './services';
+export { Controller, UseMiddleware, UseMiddlewares, Post, Get, Put, Delete, Patch, Tracing, DecorateUseCase, UseCase, Entity, Restrict, VirtualProperty, GetterPrefix, Transform, Model, model, column, };
+export { Storage, CacheGateway, EventDispatcher } from './services';

package/dist/application/services.d.ts

@@ -10,5 +10,14 @@ export interface CacheGateway {
     set<T = unknown>(key: string, value: T, ttl?: number): Promise<void> | void;
     delete(key: string): Promise<boolean> | boolean;
 }
+export type EventPayload = Record<string, any>;
+export type Event = {
+    name: string;
+    payload?: EventPayload;
+};
+export interface EventDispatcher {
+    dispatch(event: Event): Promise<void> | void;
+}
 export declare function Storage(gatewayName: string, container?: Container): (target: any, propertyKey: string) => void;
 export declare function CacheGateway(gatewayName: string, container?: Container): (target: any, propertyKey?: string) => void;
+export declare function EventDispatcher(dispatcherName: string, container?: Container): (target: any, propertyKey?: string) => void;

package/dist/application/services.js

@@ -30,3 +30,10 @@ export function CacheGateway(gatewayName, container) {
         defineGatewayProperty(resolvedTarget, resolvedProperty, gatewayName, container, (dependency) => !!dependency?.get && !!dependency?.set && !!dependency?.delete, `${gatewayName} is not a valid CacheGateway`);
     };
 }
+export function EventDispatcher(dispatcherName, container) {
+    return function (target, propertyKey) {
+        const resolvedProperty = propertyKey ?? 'eventDispatcher';
+        const resolvedTarget = propertyKey ? target : target.prototype;
+        defineGatewayProperty(resolvedTarget, resolvedProperty, dispatcherName, container, (dependency) => !!dependency?.dispatch, `${dispatcherName} is not a valid EventDispatcher`);
+    };
+}

package/dist/index.d.ts

@@ -1,10 +1,10 @@
-import { Post, Get, Put, Delete, Patch, Controller, Input, Middleware, UseMiddleware, UseMiddlewares, Tracer, Tracing, TracerData, Entity, Restrict, VirtualProperty, GetterPrefix, Serialize, UseCase, DecorateUseCase, Storage, CacheGateway } from "./application";
+import { Post, Get, Put, Delete, Patch, Controller, Input, Middleware, UseMiddleware, UseMiddlewares, Tracer, Tracing, TracerData, Entity, Restrict, VirtualProperty, GetterPrefix, Model, model, column, UseCase, DecorateUseCase, Storage, CacheGateway, EventDispatcher } from "./application";
 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, CustomServerError } from './http/errors/server';
 import { AppError } from './domain/errors/app-error';
 import type { ValidatorDefinition } from './interface/validation/validator';
-import type { StorageGateway } from './application';
+import type { StorageGateway, Event, EventPayload } from './application';
 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, CacheGateway, 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 };
-export type { ValidatorDefinition, StorageGateway };
+export { Controller, Post, Get, Put, Delete, Patch, Input, Middleware, UseMiddleware, UseMiddlewares, Tracer, Tracing, TracerData, Entity, Restrict, VirtualProperty, GetterPrefix, Model, model, column, UseCase, DecorateUseCase, Storage, CacheGateway, EventDispatcher, 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 };
+export type { ValidatorDefinition, StorageGateway, Event, EventPayload };

package/dist/index.js

@@ -3,17 +3,17 @@ import {
 Post, Get, Put, Delete, Patch, Controller, UseMiddleware, UseMiddlewares, Tracing, 
 // controller
 // entity
-Entity, Restrict, VirtualProperty, GetterPrefix, Serialize, 
+Entity, Restrict, VirtualProperty, GetterPrefix, Model, model, column, 
 // entity
 // usecase
 UseCase, DecorateUseCase, 
 // usecase
 // storage
-Storage, CacheGateway
+Storage, CacheGateway, EventDispatcher
 // storage
  } from "./application";
 import { Container, DefaultContainer, Inject, setDefaultContainer } from './infra/di/registry';
 import { Dede } from './dede';
 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, CacheGateway, Inject, Container, DefaultContainer, setDefaultContainer, Dede, ServerError, NotFound, Forbidden, Conflict, Unauthorized, UnprocessableEntity, BadRequest, InternalServerError, CustomServerError, AppError };
+export { Controller, Post, Get, Put, Delete, Patch, UseMiddleware, UseMiddlewares, Tracing, Entity, Restrict, VirtualProperty, GetterPrefix, Model, model, column, UseCase, DecorateUseCase, Storage, CacheGateway, EventDispatcher, Inject, Container, DefaultContainer, setDefaultContainer, Dede, ServerError, NotFound, Forbidden, Conflict, Unauthorized, UnprocessableEntity, BadRequest, InternalServerError, CustomServerError, AppError };

package/dist/infra/model/model.d.ts

@@ -0,0 +1,12 @@
+export type ColumnDefinition = {
+    column: string;
+    property: string;
+};
+export declare abstract class Model<TTable = string> {
+    table: TTable;
+    columns: ColumnDefinition[];
+    [property: string]: any;
+    toPersistence(): Record<string, any>;
+}
+export declare function model<TTable>(table: TTable): (target: any) => void;
+export declare function column(columnName: string): (target: any, propertyKey: string) => void;

package/dist/infra/model/model.js

@@ -0,0 +1,21 @@
+export class Model {
+    toPersistence() {
+        const record = {};
+        const columns = this.columns ?? [];
+        for (const column of columns) {
+            record[column.column] = this[column.property];
+        }
+        return record;
+    }
+}
+export function model(table) {
+    return function (target) {
+        target.prototype.table = table;
+    };
+}
+export function column(columnName) {
+    return function (target, propertyKey) {
+        target.columns = target.columns || [];
+        target.columns.push({ column: columnName, property: propertyKey });
+    };
+}

package/dist/infra/serialization/entity.d.ts

@@ -1,23 +1,11 @@
 import { Entity as DomainEntity } from "../../domain/entity";
-export declare abstract class SerializableEntity extends DomainEntity {
+export declare abstract class Entity extends DomainEntity {
     [x: string]: any;
-    private buildRawEntityObject;
-    private getEntityHooks;
-    private runEntityHooks;
-    toEntity(): Record<string, any>;
-    toAsyncEntity(): Promise<Record<string, any>>;
-    toData({ serialize }?: {
-        serialize?: boolean;
-    }): Record<string, any>;
-    toAsyncData({ serialize }?: {
-        serialize?: boolean;
-    }): Promise<Record<string, any>>;
+    from(): Record<string, any>;
+    to(transform?: boolean): Record<string, any>;
     protected generateGetters(): void;
 }
 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 Transform(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/infra/serialization/entity.js

@@ -1,98 +1,6 @@
 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 = {};
-        for (const [propName] of Object.entries(this)) {
-            let propertyName = propName;
-            let value = this[propName];
-            if (typeof value === 'function')
-                continue;
-            if (value === undefined)
-                continue;
-            // @ts-ignore
-            if (propertiesConfigs && propertiesConfigs[propName]?.serialize && value) {
-                const serializedValue = propertiesConfigs[propName].serialize(value);
-                if (serializedValue && typeof serializedValue === 'object' && !Array.isArray(serializedValue)) {
-                    const entries = Object.entries(serializedValue);
-                    for (const [serializedKey, serializedPropValue] of entries) {
-                        let currentValue = serializedPropValue;
-                        if (!currentValue)
-                            currentValue = null;
-                        result[serializedKey] = currentValue;
-                    }
-                    continue;
-                }
-                else {
-                    value = serializedValue;
-                }
-            }
-            if (value === undefined || value === null)
-                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);
+export class Entity extends DomainEntity {
+    from() {
         // @ts-ignore
         const propertiesConfigs = this.constructor.propertiesConfigs;
         const result = {};
@@ -104,30 +12,29 @@ export class SerializableEntity extends DomainEntity {
             if (value === undefined)
                 continue;
             // @ts-ignore
-            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);
-                    for (const [serializedKey, serializedPropValue] of entries) {
-                        let currentValue = serializedPropValue;
+            if (propertiesConfigs && propertiesConfigs[propName]?.transform && value) {
+                const transformedValue = propertiesConfigs[propName].transform(value);
+                if (transformedValue && typeof transformedValue === 'object' && !Array.isArray(transformedValue)) {
+                    const entries = Object.entries(transformedValue);
+                    for (const [transformedKey, transformedPropValue] of entries) {
+                        let currentValue = transformedPropValue;
                         if (!currentValue)
                             currentValue = null;
-                        result[serializedKey] = currentValue;
+                        result[transformedKey] = currentValue;
                     }
                     continue;
                 }
                 else {
-                    value = serializedValue;
+                    value = transformedValue;
                 }
             }
             if (value === undefined || value === null)
                 value = null;
             result[propertyName] = value;
         }
-        await this.runEntityHooks(AFTER_TO_ENTITY, result, true);
         return result;
     }
-    toData({ serialize = false } = {}) {
+    to(transform = true) {
         // @ts-ignore
         const propertiesConfigs = this.constructor.propertiesConfigs;
         // @ts-ignore
@@ -140,8 +47,8 @@ export class SerializableEntity extends DomainEntity {
                 continue;
             // @ts-ignore
             let value = this[propName];
-            if (serialize && propertiesConfigs && propertiesConfigs[propName]?.serialize && value) {
-                value = propertiesConfigs[propName].serialize(value);
+            if (transform && propertiesConfigs && propertiesConfigs[propName]?.transform && value) {
+                value = propertiesConfigs[propName].transform(value);
             }
             result[propName] = value;
         }
@@ -154,33 +61,6 @@ export class SerializableEntity extends DomainEntity {
         }
         return result;
     }
-    async toAsyncData({ serialize = true } = {}) {
-        // @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 && propertiesConfigs[propName]?.restrict)
-                continue;
-            // @ts-ignore
-            let value = this[propName];
-            if (serialize && propertiesConfigs && 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() {
         super.generateGetters();
     }
@@ -198,10 +78,10 @@ export function VirtualProperty(propertyName) {
         cls.virtualProperties[methodName] = propertyName;
     };
 }
-export function Serialize(callback) {
+export function Transform(callback) {
     return function (target, propertyKey) {
         loadPropertiesConfig(target, propertyKey);
-        target.constructor.propertiesConfigs[propertyKey].serialize = callback;
+        target.constructor.propertiesConfigs[propertyKey].transform = callback;
     };
 }
 export function GetterPrefix(prefix) {
@@ -218,27 +98,3 @@ 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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "framework-do-dede",
-  "version": "4.1.0",
+  "version": "5.2.0",
   "type": "module",
   "main": "./dist/index.cjs",
   "module": "./dist/index.js",