framework-do-dede 5.0.0 → 5.2.0

package/README.md

@@ -252,40 +252,53 @@ class CreateUserUseCase extends UseCase<{ name: string }, { id: string }> {
 
 ### Entity e Model
 
-Entities sao dominio puro. Use `Model` para converter entre Entity e o objeto do banco.
+Entities sao dominio puro. Use `Model` para mapear coluna/property e construir o objeto de persistencia.
 
 ```ts
-import { Entity, Model } from './src';
+import { Entity, Model, model, column } from './src';
 
-class User extends Entity {
+class Order extends Entity {
   private readonly id: string;
-  private readonly email: string;
+  private readonly name: string;
+  private readonly amount: number;
 
-  constructor(id: string, email: string) {
+  constructor(id: string, name: string, amount: number) {
     super();
     this.id = id;
-    this.email = email;
+    this.name = name;
+    this.amount = amount;
     this.generateGetters();
   }
 }
 
-type UserRow = { id: string; email: string };
+type OrderTable = 'orders';
 
-class UserModel extends Model<User, UserRow> {
-  toModel(entity: User): UserRow {
-    return { id: entity.getId(), email: entity.getEmail() };
-  }
+@model<OrderTable>('orders')
+class OrderModel extends Model<OrderTable> {
+  @column('id')
+  id!: string;
+
+  @column('name')
+  name!: string;
 
-  toEntity(model: UserRow): User {
-    return new User(model.id, model.email);
+  @column('amount')
+  amount!: number;
+
+  constructor(order?: Order) {
+    super();
+    if (order) {
+      this.id = order.getId();
+      this.name = order.getName();
+      this.amount = order.getAmount();
+    }
   }
 }
 ```
 
 Regras principais:
 
-- `Model` centraliza conversoes entre dominio e persistencia
-- use `toModel` e `toEntity`
+- `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
@@ -377,16 +390,15 @@ Quando um erro e lancado, o handler padroniza a resposta. Erros de dominio (`App
 
 Interfaces tipadas para padrao de repositorio:
 
-- `RepositoryModel<E extends Entity, M>`
-- `RepositoryCreate<E extends Entity, M>`
-- `RepositoryUpdate<E extends Entity, M>`
+- `RepositoryCreate<T extends Entity>`
+- `RepositoryUpdate<T extends Entity>`
 - `RepositoryRemove`
-- `RepositoryRestore<E extends Entity, M>`
-- `RepositoryRemoveBy<E>`
-- `RepositoryRestoreBy<E>`
-- `RepositoryExistsBy<E>`
-- `RepositoryNotExistsBy<E>`
-- `RepositoryPagination<E extends Entity, M>`
+- `RepositoryRestore<T extends Entity>`
+- `RepositoryRemoveBy<T>`
+- `RepositoryRestoreBy<T>`
+- `RepositoryExistsBy<T>`
+- `RepositoryNotExistsBy<T>`
+- `RepositoryPagination<T>`
 
 ## Exemplos
 

package/dist/application/index.d.ts

@@ -1,8 +1,8 @@
 import { Controller, Post, Get, Put, Delete, Patch, UseMiddleware, UseMiddlewares, Tracing, type Middleware, type Input, type Tracer, type TracerData } from './controller';
-import { Entity, Restrict, VirtualProperty, GetterPrefix, Serialize } from '../infra/serialization/entity';
-import { Model } from '../infra/model/model';
+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, GetterPrefix, Serialize, Model, };
+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';

package/dist/application/index.js

@@ -1,6 +1,6 @@
 import { Controller, Post, Get, Put, Delete, Patch, UseMiddleware, UseMiddlewares, Tracing } from './controller';
-import { Entity, Restrict, VirtualProperty, GetterPrefix, Serialize } from '../infra/serialization/entity';
-import { Model } from '../infra/model/model';
+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, GetterPrefix, Serialize, Model, };
+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/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, Model, UseCase, DecorateUseCase, Storage, CacheGateway, EventDispatcher } 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, 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 };
+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, 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,7 +3,7 @@ import {
 Post, Get, Put, Delete, Patch, Controller, UseMiddleware, UseMiddlewares, Tracing, 
 // controller
 // entity
-Entity, Restrict, VirtualProperty, GetterPrefix, Model, 
+Entity, Restrict, VirtualProperty, GetterPrefix, Model, model, column, 
 // entity
 // usecase
 UseCase, DecorateUseCase, 
@@ -16,4 +16,4 @@ import { Container, DefaultContainer, Inject, setDefaultContainer } from './infr
 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, Model, UseCase, DecorateUseCase, Storage, CacheGateway, EventDispatcher, 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

@@ -1,5 +1,12 @@
-import { Entity } from '../../domain/entity';
-export declare abstract class Model<E extends Entity, D> {
-    abstract toModel(entity: E): D;
-    abstract toEntity(model: D): E;
+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

@@ -1,2 +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,13 +1,11 @@
 import { Entity as DomainEntity } from "../../domain/entity";
 export declare abstract class Entity extends DomainEntity {
     [x: string]: any;
-    toEntity(): Record<string, any>;
-    toData({ serialize }?: {
-        serialize?: boolean;
-    }): 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;

package/dist/infra/serialization/entity.js

@@ -1,6 +1,6 @@
 import { Entity as DomainEntity } from "../../domain/entity";
 export class Entity extends DomainEntity {
-    toEntity() {
+    from() {
         // @ts-ignore
         const propertiesConfigs = this.constructor.propertiesConfigs;
         const result = {};
@@ -12,20 +12,20 @@ export class Entity extends DomainEntity {
             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 (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)
@@ -34,7 +34,7 @@ export class Entity extends DomainEntity {
         }
         return result;
     }
-    toData({ serialize = false } = {}) {
+    to(transform = true) {
         // @ts-ignore
         const propertiesConfigs = this.constructor.propertiesConfigs;
         // @ts-ignore
@@ -47,8 +47,8 @@ export class Entity 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;
         }
@@ -78,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) {

package/dist/protocols/repository.d.ts

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

package/package.json

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