framework-do-dede 4.0.5 → 5.0.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,44 @@ 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 converter entre Entity e o objeto do banco.
 
 ```ts
-import { Entity, Serialize, Restrict, VirtualProperty, GetterPrefix } from './src';
+import { Entity, Model } from './src';
 
 class User extends Entity {
-  @Serialize((value: Email) => value.getValue())
-  private readonly email: Email;
-
-  @Restrict()
-  private readonly passwordHash: string;
-
-  @GetterPrefix('has')
-  private readonly profile?: Profile;
-
-  @VirtualProperty('displayName')
-  private display() {
-    return 'User ' + this.email.getValue();
-  }
+  private readonly id: string;
+  private readonly email: string;
 
-  constructor(email: string, passwordHash: string) {
+  constructor(id: string, email: string) {
     super();
-    this.email = new Email(email);
-    this.passwordHash = passwordHash;
+    this.id = id;
+    this.email = email;
     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.
-
-- Before recebe objeto bruto (antes de serializacao)
-- After recebe objeto tratado (resultado final)
-- `toEntity()` executa hooks sem aguardar promessas
-- `toAsyncEntity()` aguarda hooks async
-
-```ts
-import { Entity, AfterToEntity, BeforeToEntity } from './src';
-
-class FileEntity extends Entity {
-  private readonly name: string;
-  private readonly s3Key: string;
+type UserRow = { id: string; email: string };
 
-  constructor(name: string, s3Key: string) {
-    super();
-    this.name = name;
-    this.s3Key = s3Key;
-  }
-
-  @BeforeToEntity()
-  private before(payload: Record<string, any>) {
-    payload.rawTouched = true;
+class UserModel extends Model<User, UserRow> {
+  toModel(entity: User): UserRow {
+    return { id: entity.getId(), email: entity.getEmail() };
   }
 
-  @AfterToEntity()
-  private async after(payload: Record<string, any>) {
-    await saveToS3(payload.s3Key);
+  toEntity(model: UserRow): User {
+    return new User(model.id, model.email);
   }
 }
 ```
 
+Regras principais:
+
+- `Model` centraliza conversoes entre dominio e persistencia
+- use `toModel` e `toEntity`
+- `generateGetters()` cria getters para campos (ex.: `getName`, `isActive`, `hasProfile`)
+
 ### Storage Gateway
 
 Use `@Storage` para injetar gateways com interface `StorageGateway`.
@@ -350,6 +307,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):
@@ -401,15 +377,16 @@ Quando um erro e lancado, o handler padroniza a resposta. Erros de dominio (`App
 
 Interfaces tipadas para padrao de repositorio:
 
-- `RepositoryCreate<T extends Entity>`
-- `RepositoryUpdate<T extends Entity>`
+- `RepositoryModel<E extends Entity, M>`
+- `RepositoryCreate<E extends Entity, M>`
+- `RepositoryUpdate<E extends Entity, M>`
 - `RepositoryRemove`
-- `RepositoryRestore<T extends Entity>`
-- `RepositoryRemoveBy<T>`
-- `RepositoryRestoreBy<T>`
-- `RepositoryExistsBy<T>`
-- `RepositoryNotExistsBy<T>`
-- `RepositoryPagination<T>`
+- `RepositoryRestore<E extends Entity, M>`
+- `RepositoryRemoveBy<E>`
+- `RepositoryRestoreBy<E>`
+- `RepositoryExistsBy<E>`
+- `RepositoryNotExistsBy<E>`
+- `RepositoryPagination<E extends Entity, M>`
 
 ## Exemplos
 
@@ -447,49 +424,24 @@ app.registerControllers([ExampleController]);
 app.listen();
 ```
 
-### Fila com AfterToEntity
+### Background com EventDispatcher
 
 ```ts
-import { Entity, AfterToEntity } from './src';
-
-type QueueJob = { type: string; payload: Record<string, any> };
-
-type Queue = { enqueue(job: QueueJob): Promise<void> };
+import { EventDispatcher } from './src';
 
-const queue: Queue = {
-  async enqueue(job) {
-    console.log('queued job', job);
-  }
-};
-
-class FileEntity extends Entity {
-  private readonly name: string;
-  private readonly s3Key: string;
+type QueueEvent = { name: string; payload: Record<string, any> };
 
-  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,6 +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, Serialize } from '../infra/serialization/entity';
+import { Model } from '../infra/model/model';
 import { DecorateUseCase, UseCase } from './usecase';
-import { Storage, type StorageGateway } from './services';
-export { Controller, UseMiddleware, UseMiddlewares, Post, Get, Put, Delete, Patch, Tracing, DecorateUseCase, UseCase, Storage, Entity, Restrict, VirtualProperty, Serialize, GetterPrefix, BeforeToEntity, AfterToEntity, };
-export type { Middleware, Input, StorageGateway, Tracer, TracerData };
+export { Controller, UseMiddleware, UseMiddlewares, Post, Get, Put, Delete, Patch, Tracing, DecorateUseCase, UseCase, Entity, Restrict, VirtualProperty, GetterPrefix, Serialize, Model, };
+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, Serialize } from '../infra/serialization/entity';
+import { Model } from '../infra/model/model';
 import { DecorateUseCase, UseCase } from './usecase';
-import { Storage } from './services';
-export { Controller, UseMiddleware, UseMiddlewares, Post, Get, Put, Delete, Patch, Tracing, DecorateUseCase, UseCase, Storage, Entity, Restrict, VirtualProperty, Serialize, GetterPrefix, BeforeToEntity, AfterToEntity, };
+export { Controller, UseMiddleware, UseMiddlewares, Post, Get, Put, Delete, Patch, Tracing, DecorateUseCase, UseCase, Entity, Restrict, VirtualProperty, GetterPrefix, Serialize, Model, };
+export { Storage, CacheGateway, EventDispatcher } from './services';

package/dist/application/services.d.ts

@@ -5,4 +5,19 @@ export interface StorageGateway {
     get(key: string): Promise<string>;
     delete(key: string): Promise<boolean>;
 }
+export interface CacheGateway {
+    get<T = unknown>(key: string): Promise<T | null> | T | null;
+    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

@@ -1,22 +1,39 @@
 import { DefaultContainer } from "../infra/di/registry";
 import 'reflect-metadata';
+function defineGatewayProperty(target, propertyKey, gatewayName, container, validator, errorMessage) {
+    Object.defineProperty(target, propertyKey, {
+        get: function () {
+            return new Proxy({}, {
+                get(_, prop) {
+                    const resolvedContainer = container ?? DefaultContainer;
+                    const dependency = resolvedContainer.inject(gatewayName);
+                    if (validator && !validator(dependency)) {
+                        throw new Error(errorMessage ?? `${gatewayName} is not a valid dependency`);
+                    }
+                    return dependency[prop];
+                }
+            });
+        },
+        enumerable: true,
+        configurable: true
+    });
+}
 export function Storage(gatewayName, container) {
     return function (target, propertyKey) {
-        Object.defineProperty(target, propertyKey, {
-            get: function () {
-                return new Proxy({}, {
-                    get(_, prop) {
-                        const resolvedContainer = container ?? DefaultContainer;
-                        const dependency = resolvedContainer.inject(gatewayName);
-                        if (!dependency?.save || !dependency?.get || !dependency?.delete) {
-                            throw new Error(`${gatewayName} is not a valid StorageGateway`);
-                        }
-                        return dependency[prop];
-                    }
-                });
-            },
-            enumerable: true,
-            configurable: true
-        });
+        defineGatewayProperty(target, propertyKey, gatewayName, container, (dependency) => !!dependency?.save && !!dependency?.get && !!dependency?.delete, `${gatewayName} is not a valid StorageGateway`);
+    };
+}
+export function CacheGateway(gatewayName, container) {
+    return function (target, propertyKey) {
+        const resolvedProperty = propertyKey ?? 'cache';
+        const resolvedTarget = propertyKey ? target : target.prototype;
+        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,9 +1,10 @@
-import { Post, Get, Put, Delete, Patch, Controller, Input, Middleware, UseMiddleware, UseMiddlewares, Tracer, Tracing, TracerData, Entity, Restrict, VirtualProperty, GetterPrefix, Serialize, UseCase, DecorateUseCase, Storage, StorageGateway } from "./application";
+import { Post, Get, Put, Delete, Patch, Controller, Input, Middleware, UseMiddleware, UseMiddlewares, Tracer, Tracing, TracerData, Entity, Restrict, VirtualProperty, GetterPrefix, Model, 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 { RepositoryCreate, RepositoryUpdate, RepositoryRemove, RepositoryRemoveBy, RepositoryExistsBy, RepositoryRestore, RepositoryRestoreBy, RepositoryNotExistsBy, RepositoryPagination } from './protocols/repository';
-export { Controller, Post, Get, Put, Delete, Patch, Input, Middleware, UseMiddleware, UseMiddlewares, Tracer, Tracing, TracerData, Entity, Restrict, VirtualProperty, GetterPrefix, Serialize, UseCase, DecorateUseCase, Storage, StorageGateway, Inject, 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 };
+import type { StorageGateway, Event, EventPayload } from './application';
+import type { RepositoryModel, 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, Model, UseCase, DecorateUseCase, Storage, CacheGateway, EventDispatcher, Inject, Container, DefaultContainer, setDefaultContainer, Dede, Options, Register, ServerError, NotFound, Forbidden, Conflict, Unauthorized, UnprocessableEntity, BadRequest, InternalServerError, CustomServerError, AppError, RepositoryModel, RepositoryCreate, RepositoryUpdate, RepositoryRemove, RepositoryRemoveBy, RepositoryRestore, RepositoryExistsBy, RepositoryRestoreBy, RepositoryNotExistsBy, RepositoryPagination };
+export type { ValidatorDefinition, StorageGateway, Event, EventPayload };

package/dist/index.js

@@ -3,15 +3,17 @@ import {
 Post, Get, Put, Delete, Patch, Controller, UseMiddleware, UseMiddlewares, Tracing, 
 // controller
 // entity
-Entity, Restrict, VirtualProperty, GetterPrefix, Serialize, 
+Entity, Restrict, VirtualProperty, GetterPrefix, Model, 
 // entity
 // usecase
 UseCase, DecorateUseCase, 
 // usecase
 // storage
-Storage } from "./application";
+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, 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, 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,5 @@
+import { Entity } from '../../domain/entity';
+export declare abstract class Model<E extends Entity, D> {
+    abstract toModel(entity: E): D;
+    abstract toEntity(model: D): E;
+}

package/dist/infra/model/model.js

@@ -0,0 +1,2 @@
+export class Model {
+}

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

@@ -1,23 +1,13 @@
 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>>;
     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 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,61 +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;
-            }
-        }
-    }
+export class Entity extends DomainEntity {
     toEntity() {
-        const raw = this.buildRawEntityObject();
-        this.runEntityHooks(BEFORE_TO_ENTITY, raw, false);
         // @ts-ignore
         const propertiesConfigs = this.constructor.propertiesConfigs;
         const result = {};
@@ -87,44 +32,6 @@ export class SerializableEntity extends DomainEntity {
                 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 = {};
-        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 || 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 (!currentValue)
-                            currentValue = null;
-                        result[serializedKey] = currentValue;
-                    }
-                    continue;
-                }
-                else {
-                    value = serializedValue;
-                }
-            }
-            if (value === undefined || value === null)
-                value = null;
-            result[propertyName] = value;
-        }
-        await this.runEntityHooks(AFTER_TO_ENTITY, result, true);
         return result;
     }
     toData({ serialize = false } = {}) {
@@ -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();
     }
@@ -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/dist/protocols/repository.d.ts

@@ -1,34 +1,38 @@
 import { Entity } from "../domain";
-export interface RepositoryCreate<T extends Entity> {
-    create(input: T): Promise<void>;
+import { Model } from "../infra/model/model";
+export interface RepositoryModel<E extends Entity, M> {
+    model: Model<E, M>;
 }
-export interface RepositoryUpdate<T extends Entity> {
-    update(input: T): Promise<void>;
+export interface RepositoryCreate<E extends Entity, M> extends RepositoryModel<E, M> {
+    create(input: E): Promise<void>;
+}
+export interface RepositoryUpdate<E extends Entity, M> extends RepositoryModel<E, M> {
+    update(input: E): Promise<void>;
 }
 export interface RepositoryRemove {
     remove(id: string | number): Promise<void>;
 }
-export interface RepositoryRestore<T extends Entity> {
-    restore(id: string | number): Promise<T>;
+export interface RepositoryRestore<E extends Entity, M> extends RepositoryModel<E, M> {
+    restore(id: string | number): Promise<E>;
 }
-export type RepositoryRemoveBy<T> = {
-    [K in keyof T & string as `removeBy${Capitalize<K>}`]: (value: T[K]) => Promise<void>;
+export type RepositoryRemoveBy<E> = {
+    [K in keyof E & string as `removeBy${Capitalize<K>}`]: (value: E[K]) => Promise<void>;
 };
-export type RepositoryRestoreBy<T> = {
-    [K in keyof T & string as `restoreBy${Capitalize<K>}`]: (value: T[K]) => Promise<any>;
+export type RepositoryRestoreBy<E> = {
+    [K in keyof E & string as `restoreBy${Capitalize<K>}`]: (value: E[K]) => Promise<any>;
 };
-export type RepositoryExistsBy<T> = {
-    [K in keyof T & string as `existsBy${Capitalize<K>}`]: (value: T[K]) => Promise<boolean>;
+export type RepositoryExistsBy<E> = {
+    [K in keyof E & string as `existsBy${Capitalize<K>}`]: (value: E[K]) => Promise<boolean>;
 };
-export type RepositoryNotExistsBy<T> = {
-    [K in keyof T & string as `notExistsBy${Capitalize<K>}`]: (value: T[K]) => Promise<boolean>;
+export type RepositoryNotExistsBy<E> = {
+    [K in keyof E & string as `notExistsBy${Capitalize<K>}`]: (value: E[K]) => Promise<boolean>;
 };
-export interface RepositoryPagination<T> {
+export interface RepositoryPagination<E extends Entity, M> extends RepositoryModel<E, M> {
     restoreMany({ filter, pagination }: {
         filter?: Record<string, any>;
         pagination?: {
             offset: number;
             limit: number;
         };
-    }): Promise<T>;
+    }): Promise<E[]>;
 }

package/package.json

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