framework-do-dede 5.5.5 → 6.0.0

package/README.md

@@ -40,7 +40,7 @@ bun run example/express_app/server.ts
 ## Quickstart
 
 ```ts
-import { Controller, Get, Post, UseCase, Dede } from './src';
+import { Controller, Get, Post, UseCase, Dede, Optional } from './src';
 
 @Controller('/hello')
 class HelloController {
@@ -63,6 +63,9 @@ class HelloUseCase extends UseCase<{ name?: string }, { message: string }> {
   }
 }
 
+const maybeName = Optional.ofNullable(process.env.DEFAULT_NAME);
+const defaultName = maybeName.orElseUndefined();
+
 const app = await Dede.create({
   framework: { use: 'express', port: 3000 },
   registries: []
@@ -218,6 +221,7 @@ vira:
 ### Middlewares
 
 Middlewares devem implementar `execute(input: Input<any>)`. Podem ser classe, factory ou instancia.
+Podem ser aplicados no controller (valem para todas as rotas) e/ou no método.
 
 ```ts
 import { Middleware, UseMiddleware, UseMiddlewares, Input } from './src';
@@ -228,7 +232,14 @@ class AuthMiddleware implements Middleware {
   }
 }
 
+class LoggerMiddleware implements Middleware {
+  async execute(input: Input<any>) {
+    input.context.logged = true;
+  }
+}
+
 @Controller('/secure')
+@UseMiddleware(LoggerMiddleware)
 class SecureController {
   @Get()
   @UseMiddleware(AuthMiddleware)
@@ -332,53 +343,65 @@ class CreatePhotoUseCase extends UseCase<void, void> {
 
 ### Entity e Model
 
-Entities sao dominio puro. Use `Model` para mapear coluna/property e construir o objeto de persistencia.
+Entities sao dominio puro. `Model` vive na borda e faz o mapeamento banco <-> model, alem de converter `Entity` <-> `Model`. Repositorios trabalham com `Model`, nao com `Entity`.
 
 ```ts
 import { Entity, Model, model, column } from './src';
 
-class Order extends Entity {
-  private readonly id: string;
-  private readonly name: string;
-  private readonly amount: number;
-
-  constructor(id: string, name: string, amount: number) {
-    super();
-    this.id = id;
-    this.name = name;
-    this.amount = amount;
-    this.generateGetters();
-  }
-}
-
-type OrderTable = 'orders';
+type UserTable = 'users';
 
-@model<OrderTable>('orders')
-class OrderModel extends Model<OrderTable> {
+@model<UserTable>('users')
+class UserModel extends Model<UserTable, User> {
   @column('id')
   id!: string;
 
-  @column('name')
+  @column('email2')
+  email!: string;
+
   name!: string;
+  password?: string;
 
-  @column('amount')
-  amount!: number;
+  fromEntity(user: User): this {
+    this.id = user.getId();
+    this.email = user.getEmail();
+    this.name = user.getName();
+    return this;
+  }
+
+  toEntity(): User {
+    return new User(this);
+  }
+}
 
-  constructor(order?: Order) {
+class User extends Entity {
+  private readonly id: string;
+  private readonly email: string;
+  private readonly name: string;
+
+  constructor(model: UserModel) {
     super();
-    if (order) {
-      this.id = order.getId();
-      this.name = order.getName();
-      this.amount = order.getAmount();
-    }
+    this.id = model.id;
+    this.email = model.email;
+    this.name = model.name;
+    this.generateGetters();
   }
 }
 ```
 
+Carregando do banco:
+
+```ts
+const row = result[0] ?? null;
+const model = row ? new UserModel().fromModel(row) : null;
+return Optional.ofNullable(model);
+```
+
 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)
+- `fromModel` aplica o mapeamento coluna -> propriedade e ignora `null/undefined` (retorna o proprio model)
+- `fromEntity` / `toEntity` fazem a conversao entity <-> model
+- `Entity` recebe o `Model` no construtor (acoplamento forte na borda)
 - `generateGetters()` cria getters para campos (ex.: `getName`, `isActive`, `hasProfile`), mesmo quando o valor não foi definido.
 
 ### Storage Gateway
@@ -470,16 +493,40 @@ 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>`
+- `Optional<T>` (helper inspirado em micronaut/spring)
+- `RepositoryModel` (base para o acoplamento do repositorio com Model)
+- `RepositoryCreate<T extends RepositoryModel>`
+- `RepositoryUpdate<T extends RepositoryModel>`
 - `RepositoryRemove`
-- `RepositoryRestore<T extends Entity>`
+- `RepositoryRestore<T extends RepositoryModel>`
 - `RepositoryRemoveBy<T>`
 - `RepositoryRestoreBy<T>`
 - `RepositoryExistsBy<T>`
 - `RepositoryNotExistsBy<T>`
 - `RepositoryPagination<T>`
 
+`RepositoryRestore` e `RepositoryRestoreBy` retornam `Optional<T>` para desacoplar a mensagem de erro do repositório:
+
+```ts
+import { Optional } from './src';
+
+class UserRepository {
+  async restore(id: string): Promise<Optional<UserModel>> {
+    const result = await this.orm
+      .select()
+      .from(userTable)
+      .where(eq(userTable.id, id));
+
+    const row = result[0] ?? null;
+    const model = row ? new UserModel().fromModel(row) : null;
+    return Optional.ofNullable(model);
+  }
+}
+
+const user = await repo.restore('1').orElseThrow('Usuario nao encontrado');
+const userByEmail = await repo.restoreByEmail('a@b.com').orElseNull();
+```
+
 ## Exemplos
 
 ### Express

package/dist/application/controller.d.ts

@@ -31,8 +31,8 @@ export declare function Controller(basePath?: string): (target: any) => void;
 export declare function Tracing<R>(tracer: Tracer<R>): (target: any, propertyKey?: string) => void;
 export declare function Version(version: number): (target: any, propertyKey?: string) => void;
 export declare function PresetIgnore(ignorePrefix?: boolean, ignoreVersion?: boolean): (target: any, propertyKey?: string) => void;
-export declare function UseMiddleware(middlewareClass: MiddlewareDefinition): (target: any, propertyKey: string, descriptor: PropertyDescriptor) => void;
-export declare function UseMiddlewares(middlewareClasses: MiddlewareDefinition[]): (target: any, propertyKey: string, descriptor: PropertyDescriptor) => void;
+export declare function UseMiddleware(middlewareClass: MiddlewareDefinition): (target: any, propertyKey?: string, descriptor?: PropertyDescriptor) => void;
+export declare function UseMiddlewares(middlewareClasses: MiddlewareDefinition[]): (target: any, propertyKey?: string, descriptor?: PropertyDescriptor) => void;
 export declare function Post(config?: {
     path?: string;
     statusCode?: number;

package/dist/application/controller.js

@@ -52,15 +52,31 @@ export function UseMiddleware(middlewareClass) {
         if (typeof middlewareClass === 'function' && isClass(middlewareClass) && !middlewareClass.prototype?.execute) {
             throw new FrameworkError('Middleware must implement execute()');
         }
+        const metadataTarget = propertyKey ? target : target;
+        const metadataKey = propertyKey ?? undefined;
         if (typeof middlewareClass === 'function' && middlewareClass.prototype?.execute) {
-            const middlewares = Reflect.getMetadata('middlewares', target, propertyKey) || [];
+            const middlewares = metadataKey
+                ? Reflect.getMetadata('middlewares', metadataTarget, metadataKey) || []
+                : Reflect.getMetadata('middlewares', metadataTarget) || [];
             middlewares.push(middlewareClass);
-            Reflect.defineMetadata('middlewares', middlewares, target, propertyKey);
+            if (metadataKey) {
+                Reflect.defineMetadata('middlewares', middlewares, metadataTarget, metadataKey);
+            }
+            else {
+                Reflect.defineMetadata('middlewares', middlewares, metadataTarget);
+            }
             return;
         }
-        const middlewares = Reflect.getMetadata('middlewares', target, propertyKey) || [];
+        const middlewares = metadataKey
+            ? Reflect.getMetadata('middlewares', metadataTarget, metadataKey) || []
+            : Reflect.getMetadata('middlewares', metadataTarget) || [];
         middlewares.push(middlewareClass);
-        Reflect.defineMetadata('middlewares', middlewares, target, propertyKey);
+        if (metadataKey) {
+            Reflect.defineMetadata('middlewares', middlewares, metadataTarget, metadataKey);
+        }
+        else {
+            Reflect.defineMetadata('middlewares', middlewares, metadataTarget);
+        }
     };
 }
 export function UseMiddlewares(middlewareClasses) {
@@ -73,9 +89,18 @@ export function UseMiddlewares(middlewareClasses) {
                 throw new FrameworkError('Middleware must implement execute()');
             }
         }
-        const existingMiddlewares = Reflect.getMetadata('middlewares', target, propertyKey) || [];
+        const metadataTarget = propertyKey ? target : target;
+        const metadataKey = propertyKey ?? undefined;
+        const existingMiddlewares = metadataKey
+            ? Reflect.getMetadata('middlewares', metadataTarget, metadataKey) || []
+            : Reflect.getMetadata('middlewares', metadataTarget) || [];
         existingMiddlewares.push(...middlewareClasses);
-        Reflect.defineMetadata('middlewares', existingMiddlewares, target, propertyKey);
+        if (metadataKey) {
+            Reflect.defineMetadata('middlewares', existingMiddlewares, metadataTarget, metadataKey);
+        }
+        else {
+            Reflect.defineMetadata('middlewares', existingMiddlewares, metadataTarget);
+        }
     };
 }
 export function Post(config = {}) {

package/dist/domain/index.d.ts

@@ -1,2 +1,3 @@
 import { Entity } from './entity';
-export { Entity };
+import { Optional } from './optional';
+export { Entity, Optional };

package/dist/domain/index.js

@@ -1,2 +1,3 @@
 import { Entity } from './entity';
-export { Entity };
+import { Optional } from './optional';
+export { Entity, Optional };

package/dist/domain/optional.d.ts

@@ -0,0 +1,13 @@
+export type OptionalError = Error | string | (() => Error);
+export declare class Optional<T> {
+    private readonly value;
+    private constructor();
+    static of<T>(value: T): Optional<T>;
+    static ofNullable<T>(value: T | null | undefined): Optional<T>;
+    isPresent(): boolean;
+    isEmpty(): boolean;
+    get(): T;
+    orElseNull(): T | null;
+    orElseUndefined(): T | undefined;
+    orElseThrow(error?: OptionalError): T;
+}

package/dist/domain/optional.js

@@ -0,0 +1,47 @@
+export class Optional {
+    constructor(value) {
+        this.value = value;
+    }
+    static of(value) {
+        if (value === null || value === undefined) {
+            throw new Error('Optional.of() cannot be null or undefined');
+        }
+        return new Optional(value);
+    }
+    static ofNullable(value) {
+        return new Optional(value);
+    }
+    isPresent() {
+        return this.value !== null && this.value !== undefined;
+    }
+    isEmpty() {
+        return !this.isPresent();
+    }
+    get() {
+        if (!this.isPresent()) {
+            throw new Error('Optional is empty');
+        }
+        return this.value;
+    }
+    orElseNull() {
+        return this.isPresent() ? this.value : null;
+    }
+    orElseUndefined() {
+        return this.isPresent() ? this.value : undefined;
+    }
+    orElseThrow(error) {
+        if (this.isPresent()) {
+            return this.value;
+        }
+        if (typeof error === 'function') {
+            throw error();
+        }
+        if (typeof error === 'string') {
+            throw new Error(error);
+        }
+        if (error instanceof Error) {
+            throw error;
+        }
+        throw new Error('Optional is empty');
+    }
+}

package/dist/http/controller.handler.js

@@ -98,10 +98,12 @@ export default class ControllerHandler {
             let tracer = Reflect.getMetadata('tracer', controller) || null;
             const controllerVersion = Reflect.getMetadata('version', controller);
             const controllerPresetIgnore = Reflect.getMetadata('presetIgnore', controller);
+            const controllerMiddlewares = Reflect.getMetadata('middlewares', controller) || [];
             const instance = new controller();
             for (const methodName of methodNames) {
                 const routeConfig = Reflect.getMetadata('route', controller.prototype, methodName);
-                const middlewares = Reflect.getMetadata('middlewares', controller.prototype, methodName);
+                const methodMiddlewares = Reflect.getMetadata('middlewares', controller.prototype, methodName) || [];
+                const middlewares = [...controllerMiddlewares, ...methodMiddlewares];
                 const responseType = Reflect.getMetadata('responseType', controller.prototype, methodName) || 'json';
                 tracer = Reflect.getMetadata('tracer', controller.prototype, methodName) || tracer;
                 const methodVersion = Reflect.getMetadata('version', controller.prototype, methodName);
@@ -128,7 +130,7 @@ export default class ControllerHandler {
                         tracer
                     },
                     responseType,
-                    middlewares: middlewares ? middlewares.map(middleware => this.resolveMiddleware(middleware)) : [],
+                    middlewares: middlewares.length ? middlewares.map(middleware => this.resolveMiddleware(middleware)) : [],
                 });
             }
         }

package/dist/index.d.ts

@@ -3,8 +3,10 @@ import { Container, DefaultContainer, Inject, setDefaultContainer } from './infr
 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 { Optional } from './domain/optional';
 import type { ValidatorDefinition } from './interface/validation/validator';
 import type { StorageGateway, Event, EventPayload } from './application';
+import { RepositoryModel } from './protocols/model';
 import type { RepositoryCreate, RepositoryUpdate, RepositoryRemove, RepositoryRemoveBy, RepositoryExistsBy, RepositoryRestore, RepositoryRestoreBy, RepositoryNotExistsBy, RepositoryPagination } from './protocols/repository';
-export { Controller, Post, Get, Put, Delete, Patch, Input, Version, PresetIgnore, Middleware, UseMiddleware, UseMiddlewares, Tracer, Tracing, TracerData, Entity, Restrict, VirtualProperty, GetterPrefix, Transform, Model, model, column, UseCase, DecorateUseCase, Hook, BeforeHook, AfterHook, HookBefore, HookAfter, 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 { Controller, Post, Get, Put, Delete, Patch, Input, Version, PresetIgnore, Middleware, UseMiddleware, UseMiddlewares, Tracer, Tracing, TracerData, Entity, Restrict, VirtualProperty, GetterPrefix, Transform, Model, model, column, UseCase, DecorateUseCase, Hook, BeforeHook, AfterHook, HookBefore, HookAfter, Storage, CacheGateway, EventDispatcher, Inject, Container, DefaultContainer, setDefaultContainer, Dede, Options, Register, ServerError, NotFound, Forbidden, Conflict, Unauthorized, UnprocessableEntity, BadRequest, InternalServerError, CustomServerError, AppError, Optional, RepositoryModel, RepositoryCreate, RepositoryUpdate, RepositoryRemove, RepositoryRemoveBy, RepositoryRestore, RepositoryExistsBy, RepositoryRestoreBy, RepositoryNotExistsBy, RepositoryPagination };
 export type { ValidatorDefinition, StorageGateway, Event, EventPayload };

package/dist/index.js

@@ -16,4 +16,6 @@ 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, Version, PresetIgnore, UseMiddleware, UseMiddlewares, Tracing, Entity, Restrict, VirtualProperty, GetterPrefix, Transform, Model, model, column, UseCase, DecorateUseCase, Hook, BeforeHook, AfterHook, HookBefore, HookAfter, Storage, CacheGateway, EventDispatcher, Inject, Container, DefaultContainer, setDefaultContainer, Dede, ServerError, NotFound, Forbidden, Conflict, Unauthorized, UnprocessableEntity, BadRequest, InternalServerError, CustomServerError, AppError };
+import { Optional } from './domain/optional';
+import { RepositoryModel } from './protocols/model';
+export { Controller, Post, Get, Put, Delete, Patch, Version, PresetIgnore, UseMiddleware, UseMiddlewares, Tracing, Entity, Restrict, VirtualProperty, GetterPrefix, Transform, Model, model, column, UseCase, DecorateUseCase, Hook, BeforeHook, AfterHook, HookBefore, HookAfter, Storage, CacheGateway, EventDispatcher, Inject, Container, DefaultContainer, setDefaultContainer, Dede, ServerError, NotFound, Forbidden, Conflict, Unauthorized, UnprocessableEntity, BadRequest, InternalServerError, CustomServerError, AppError, Optional, RepositoryModel };

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

@@ -1,16 +1,16 @@
-import { Entity } from "../../application";
+import { RepositoryModel } from "../../protocols/model";
 export type ColumnDefinition = {
     column: string;
     property: string;
 };
-export declare abstract class Model<TTable = string> {
+export declare abstract class Model<TTable = string, TEntity = any> extends RepositoryModel<TEntity> {
     table: TTable;
     columns: ColumnDefinition[];
     [property: string]: any;
-    fromModel(input: Record<string, any>): Model;
-    abstract fromEntity(entity: Entity): Model;
+    fromModel(input: Record<string, any> | null | undefined): this;
+    abstract fromEntity(entity: TEntity): this;
     toModel(): Record<string, any>;
-    abstract toEntity(): Entity;
+    abstract toEntity(): TEntity;
 }
 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,5 +1,9 @@
-export class Model {
+import { RepositoryModel } from "../../protocols/model";
+export class Model extends RepositoryModel {
     fromModel(input) {
+        if (input === null || input === undefined) {
+            return this;
+        }
         const columns = this.columns ?? [];
         const columnByName = new Map(columns.map((column) => [column.column, column.property]));
         for (const [property, value] of Object.entries(input)) {

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

@@ -5,4 +5,4 @@ export type ValidationErrorOptions = {
     errorName?: string;
     validatorOptions?: ValidatorOptions;
 };
-export declare function validateWithClassValidator<T extends object>(dtoClass: new () => T, input: T, options?: ValidationErrorOptions): Promise<T>;
+export declare function validateWithClassValidator<T extends object>(dtoClass: new () => T, input: Record<string, any>, options?: ValidationErrorOptions): Promise<T & Record<string, any>>;

package/dist/protocols/model.d.ts

@@ -0,0 +1,6 @@
+export declare abstract class RepositoryModel<TEntity = any> {
+    abstract fromModel(input: Record<string, any> | null | undefined): this;
+    abstract toModel(): Record<string, any>;
+    abstract fromEntity(entity: TEntity): this;
+    abstract toEntity(): TEntity;
+}

package/dist/protocols/model.js

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

package/dist/protocols/repository.d.ts

@@ -1,21 +1,22 @@
-import { Entity } from "../domain";
-export interface RepositoryCreate<T extends Entity> {
+import { Optional } from "../domain";
+import { RepositoryModel } from "../protocols/model";
+export interface RepositoryCreate<T extends RepositoryModel> {
     create(input: T): Promise<void>;
 }
-export interface RepositoryUpdate<T extends Entity> {
+export interface RepositoryUpdate<T extends RepositoryModel> {
     update(input: T): 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<T extends RepositoryModel> {
+    restore(id: string | number): Promise<Optional<T>>;
 }
 export type RepositoryRemoveBy<T> = {
     [K in keyof T & string as `removeBy${Capitalize<K>}`]: (value: T[K]) => Promise<void>;
 };
 export type RepositoryRestoreBy<T> = {
-    [K in keyof T & string as `restoreBy${Capitalize<K>}`]: (value: T[K]) => Promise<any>;
+    [K in keyof T & string as `restoreBy${Capitalize<K>}`]: (value: T[K]) => Promise<Optional<T>>;
 };
 export type RepositoryExistsBy<T> = {
     [K in keyof T & string as `existsBy${Capitalize<K>}`]: (value: T[K]) => Promise<boolean>;

package/package.json

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