framework-do-dede 5.2.3 → 5.4.1

package/README.md

@@ -235,7 +235,7 @@ class CreateUserUseCase extends UseCase<{ name: string }, { id: string }> {
 }
 ```
 
-Decorator `@DecorateUseCase` permite executar use cases antes do principal (chaining).
+Decorator `@DecorateUseCase` permite compor use cases ao redor do método.
 
 ```ts
 import { UseCase, DecorateUseCase } from './src';
@@ -250,6 +250,46 @@ class CreateUserUseCase extends UseCase<{ name: string }, { id: string }> {
 }
 ```
 
+Hooks oferecem uma alternativa simples para acoplar eventos sem depender de `data`/`context` da request. O use case dispara o hook e decide qual payload enviar. Cada use case registra **um HookBefore e/ou um HookAfter**.
+
+```ts
+import { UseCase, HookAfter, HookBefore, AfterHook, BeforeHook } from './src';
+
+class SavePhoto extends AfterHook<{ id: string }> {
+  async use(payload: { id: string }) {
+    // this.notify() é chamado automaticamente após o execute
+    console.log('photo saved:', payload.id);
+  }
+}
+
+class ValidatePhoto extends BeforeHook<{ name: string }> {
+  async use(payload: { name: string }) {
+    console.log('validating:', payload.name);
+  }
+}
+
+@HookBefore(ValidatePhoto)
+@HookAfter(SavePhoto)
+class CreatePhotoUseCase extends UseCase<{ name: string }, { id: string }> {
+  async execute() {
+    const photo = { id: 'photo-1', name: this.data?.name ?? 'no-name' };
+    this.afterHook.use({ id: photo.id });
+    return photo;
+  }
+}
+```
+
+`HookAfter` não executa quando o método lança erro. Para executar mesmo em erro:
+
+```ts
+@HookAfter(SavePhoto, { runOnError: true })
+class CreatePhotoUseCase extends UseCase<void, void> {
+  async execute() {
+    throw new Error('boom');
+  }
+}
+```
+
 ### Entity e Model
 
 Entities sao dominio puro. Use `Model` para mapear coluna/property e construir o objeto de persistencia.

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, 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, Transform, Model, model, column, };
+import { DecorateUseCase, UseCase, Hook, BeforeHook, AfterHook, HookBefore, HookAfter } from './usecase';
+export { Controller, UseMiddleware, UseMiddlewares, Post, Get, Put, Delete, Patch, Tracing, DecorateUseCase, UseCase, Hook, BeforeHook, AfterHook, HookBefore, HookAfter, 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, 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, Transform, Model, model, column, };
+import { DecorateUseCase, UseCase, Hook, BeforeHook, AfterHook, HookBefore, HookAfter, } from './usecase';
+export { Controller, UseMiddleware, UseMiddlewares, Post, Get, Put, Delete, Patch, Tracing, DecorateUseCase, UseCase, Hook, BeforeHook, AfterHook, HookBefore, HookAfter, Entity, Restrict, VirtualProperty, GetterPrefix, Transform, Model, model, column, };
 export { Storage, CacheGateway, EventDispatcher } from './services';

package/dist/application/usecase.d.ts

@@ -3,13 +3,43 @@ export declare const USE_CASE_DECORATORS: unique symbol;
 export declare abstract class UseCase<UseCaseInput, UseCaseOutput, UseCaseContext = any> {
     protected readonly data?: UseCaseInput;
     protected readonly context?: UseCaseContext;
+    protected readonly beforeHook: HookManager;
+    protected readonly afterHook: HookManager;
     constructor(input?: Input<UseCaseInput>);
     abstract execute(): Promise<UseCaseOutput>;
 }
 type UseCaseConstructor = new (...args: any[]) => UseCase<any, any>;
+type HookConstructor = new () => Hook<any, any>;
+type HookPosition = 'before' | 'after';
+interface HookOptions {
+    runOnError?: boolean;
+}
 interface DecorateUseCaseOptions {
     useCase: UseCaseConstructor | UseCaseConstructor[];
     params?: Record<string, any>;
 }
+export declare abstract class Hook<Payload = any, Context = any> {
+    protected payload?: Payload;
+    protected context?: Context;
+    setPayload(payload: Payload, context?: Context): void;
+    notify(): Promise<void>;
+    abstract use(payload: Payload, context?: Context): Promise<void> | void;
+}
+export declare abstract class AfterHook<Payload = any, Context = any> extends Hook<Payload, Context> {
+}
+export declare abstract class BeforeHook<Payload = any, Context = any> extends Hook<Payload, Context> {
+}
+declare class HookManager {
+    private readonly entry?;
+    private readonly owner;
+    private readonly position;
+    constructor(owner: UseCase<any, any>, position: HookPosition);
+    use(payload: unknown): void;
+    notifyBefore(): Promise<void>;
+    notifyAfter(onError: boolean): Promise<void>;
+    private buildEntry;
+}
 export declare function DecorateUseCase(options: DecorateUseCaseOptions): <T extends UseCaseConstructor>(target: T) => T;
+export declare function HookBefore(hookClass: HookConstructor): <T extends UseCaseConstructor>(target: T) => T;
+export declare function HookAfter(hookClass: HookConstructor, options?: HookOptions): <T extends UseCaseConstructor>(target: T) => T;
 export {};

package/dist/application/usecase.js

@@ -5,35 +5,154 @@ export class UseCase {
         if (input?.context) {
             this.context = input.context;
         }
+        this.beforeHook = new HookManager(this, 'before');
+        this.afterHook = new HookManager(this, 'after');
     }
 }
+const USE_CASE_HOOKS = Symbol('USE_CASE_HOOKS');
+const USE_CASE_HOOKS_WRAPPED = Symbol('USE_CASE_HOOKS_WRAPPED');
+function getHookMetadata(target) {
+    return target[USE_CASE_HOOKS] ?? [];
+}
+function registerHook(target, metadata) {
+    const existing = getHookMetadata(target);
+    if (existing.some((entry) => entry.position === metadata.position)) {
+        throw new Error(`Only one ${metadata.position} hook can be registered per use case`);
+    }
+    target[USE_CASE_HOOKS] = [...existing, metadata];
+}
+function ensureHookedExecution(target) {
+    const prototype = target.prototype;
+    const original = prototype.execute;
+    if (typeof original !== 'function') {
+        return target;
+    }
+    if (original[USE_CASE_HOOKS_WRAPPED]) {
+        return target;
+    }
+    const wrapped = async function executeWithHooks(...args) {
+        const beforeHook = this.beforeHook;
+        const afterHook = this.afterHook;
+        await beforeHook.notifyBefore();
+        let result;
+        let originalError;
+        try {
+            result = await original.apply(this, args);
+        }
+        catch (error) {
+            originalError = error;
+        }
+        await afterHook.notifyAfter(!!originalError);
+        if (originalError) {
+            throw originalError;
+        }
+        return result;
+    };
+    wrapped[USE_CASE_HOOKS_WRAPPED] = true;
+    prototype.execute = wrapped;
+    return target;
+}
+export class Hook {
+    setPayload(payload, context) {
+        this.payload = payload;
+        if (context !== undefined) {
+            this.context = context;
+        }
+    }
+    async notify() {
+        await this.use(this.payload, this.context);
+    }
+}
+export class AfterHook extends Hook {
+}
+export class BeforeHook extends Hook {
+}
+class HookManager {
+    constructor(owner, position) {
+        this.owner = owner;
+        this.position = position;
+        this.entry = this.buildEntry();
+    }
+    use(payload) {
+        this.entry?.setPayload(payload);
+    }
+    async notifyBefore() {
+        if (this.position === 'before' && this.entry?.metadata.position === 'before') {
+            await this.entry.instance.notify();
+        }
+    }
+    async notifyAfter(onError) {
+        if (!this.entry || this.position !== 'after' || this.entry.metadata.position !== 'after') {
+            return;
+        }
+        if (onError && !this.entry.metadata.runOnError) {
+            return;
+        }
+        await this.entry.instance.notify();
+    }
+    buildEntry() {
+        const metadata = getHookMetadata(this.owner.constructor);
+        const entry = metadata.find((item) => item.position === this.position);
+        if (!entry) {
+            return undefined;
+        }
+        const instance = new entry.hookClass();
+        return {
+            metadata: entry,
+            instance,
+            setPayload: (payload) => {
+                instance.setPayload(payload, this.owner.context);
+            },
+        };
+    }
+}
+function buildUseCaseInstances(owner, options) {
+    const useCases = Array.isArray(options.useCase)
+        ? options.useCase
+        : [options.useCase];
+    if (useCases.length === 0) {
+        return [];
+    }
+    return useCases.map((UseCaseClass) => {
+        return new UseCaseClass({
+            data: owner?.data,
+            context: {
+                ...(owner?.context ?? {}),
+                options: options.params || {},
+            },
+        });
+    });
+}
 export function DecorateUseCase(options) {
     return (target) => {
+        const stateKey = Symbol('decoratorUseCases');
         return class extends target {
             constructor(...args) {
                 super(...args);
-                const useCases = Array.isArray(options.useCase)
-                    ? options.useCase
-                    : [options.useCase];
-                const self = this;
-                self._decoratorUseCases = useCases.map((UseCaseClass) => {
-                    return new UseCaseClass({
-                        data: this.data,
-                        context: {
-                            ...this.context,
-                            options: options.params || {}
-                        },
-                    });
-                });
-                self._originalMethod = target.prototype.execute;
+                this[stateKey] = {
+                    useCases: buildUseCaseInstances(this, options),
+                    original: target.prototype.execute,
+                };
             }
             async execute() {
-                const self = this;
-                for (const useCase of self._decoratorUseCases) {
+                const state = this[stateKey];
+                for (const useCase of state.useCases) {
                     await useCase.execute();
                 }
-                return await self._originalMethod.call(this);
+                return await state.original.call(this);
             }
         };
     };
 }
+export function HookBefore(hookClass) {
+    return (target) => {
+        registerHook(target, { hookClass, position: 'before' });
+        return ensureHookedExecution(target);
+    };
+}
+export function HookAfter(hookClass, options = {}) {
+    return (target) => {
+        registerHook(target, { hookClass, position: 'after', runOnError: options.runOnError });
+        return ensureHookedExecution(target);
+    };
+}

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-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 { Post, Get, Put, Delete, Patch, Controller, Input, Middleware, UseMiddleware, UseMiddlewares, Tracer, Tracing, TracerData, Entity, Restrict, VirtualProperty, GetterPrefix, Model, model, column, UseCase, DecorateUseCase, Hook, BeforeHook, AfterHook, HookBefore, HookAfter, 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';
@@ -6,5 +6,5 @@ import { AppError } from './domain/errors/app-error';
 import type { ValidatorDefinition } from './interface/validation/validator';
 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, 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 { Controller, Post, Get, Put, Delete, Patch, Input, Middleware, UseMiddleware, UseMiddlewares, Tracer, Tracing, TracerData, Entity, Restrict, VirtualProperty, GetterPrefix, 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 type { ValidatorDefinition, StorageGateway, Event, EventPayload };

package/dist/index.js

@@ -6,7 +6,7 @@ Post, Get, Put, Delete, Patch, Controller, UseMiddleware, UseMiddlewares, Tracin
 Entity, Restrict, VirtualProperty, GetterPrefix, Model, model, column, 
 // entity
 // usecase
-UseCase, DecorateUseCase, 
+UseCase, DecorateUseCase, Hook, BeforeHook, AfterHook, HookBefore, HookAfter, 
 // usecase
 // storage
 Storage, CacheGateway, EventDispatcher
@@ -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, model, column, 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, Hook, BeforeHook, AfterHook, HookBefore, HookAfter, Storage, CacheGateway, EventDispatcher, Inject, Container, DefaultContainer, setDefaultContainer, Dede, ServerError, NotFound, Forbidden, Conflict, Unauthorized, UnprocessableEntity, BadRequest, InternalServerError, CustomServerError, AppError };

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

@@ -1,10 +1,10 @@
 import { Entity as DomainEntity } from "../../domain/entity";
 export declare abstract class Entity extends DomainEntity {
     [x: string]: any;
-    to(transform?: boolean): Record<string, any>;
+    data(transform?: 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 Transform(callback: (value: any) => any): PropertyDecorator;
+export declare function Transform(callback: (value: any) => any | Promise<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 {
-    to(transform = true) {
+    async data(transform = true) {
         // @ts-ignore
         const propertiesConfigs = this.constructor.propertiesConfigs;
         // @ts-ignore
@@ -14,7 +14,7 @@ export class Entity extends DomainEntity {
             // @ts-ignore
             let value = this[propName];
             if (transform && propertiesConfigs && propertiesConfigs[propName]?.transform && value) {
-                value = propertiesConfigs[propName].transform(value);
+                value = await propertiesConfigs[propName].transform(value);
             }
             result[propName] = value;
         }

package/package.json

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