framework-do-dede 5.4.4 → 5.4.6

package/README.md

@@ -279,6 +279,8 @@ class CreatePhotoUseCase extends UseCase<{ name: string }, { id: string }> {
 }
 ```
 
+Por padrão, `HookBefore` e `HookAfter` recebem `this.data` se nenhum payload for definido manualmente. Apenas `HookAfter` pode ser sobrescrito via `this.afterHook.use(...)`. O `HookBefore` não recebe o retorno do `execute()` por ser um evento before.
+
 `HookAfter` não executa quando o método lança erro. Para executar mesmo em erro:
 
 ```ts

package/dist/application/usecase.d.ts

@@ -35,9 +35,11 @@ declare class HookManager {
     private readonly position;
     constructor(owner: UseCase<any, any>, position: HookPosition);
     use(payload: unknown): void;
+    useIfUnset(payload: unknown): void;
     notifyBefore(): Promise<void>;
     notifyAfter(onError: boolean): Promise<void>;
     private buildEntry;
+    private notifyEntry;
 }
 export declare function DecorateUseCase(options: DecorateUseCaseOptions): <T extends UseCaseConstructor>(target: T) => T;
 export declare function HookBefore(hookClass: HookConstructor): <T extends UseCaseConstructor>(target: T) => T;

package/dist/application/usecase.js

@@ -33,6 +33,7 @@ function ensureHookedExecution(target) {
     const wrapped = async function executeWithHooks(...args) {
         const beforeHook = this.beforeHook;
         const afterHook = this.afterHook;
+        beforeHook.useIfUnset(this.data);
         await beforeHook.notifyBefore();
         let result;
         let originalError;
@@ -42,6 +43,7 @@ function ensureHookedExecution(target) {
         catch (error) {
             originalError = error;
         }
+        afterHook.useIfUnset(this.data);
         await afterHook.notifyAfter(!!originalError);
         if (originalError) {
             throw originalError;
@@ -74,11 +76,22 @@ class HookManager {
         this.entry = this.buildEntry();
     }
     use(payload) {
-        this.entry?.setPayload(payload);
+        if (!this.entry) {
+            return;
+        }
+        this.entry.setPayload(payload);
+        this.entry.payloadSet = true;
+    }
+    useIfUnset(payload) {
+        if (!this.entry || this.entry.payloadSet) {
+            return;
+        }
+        this.entry.setPayload(payload);
+        this.entry.payloadSet = true;
     }
     async notifyBefore() {
         if (this.position === 'before' && this.entry?.metadata.position === 'before') {
-            await this.entry.instance.notify();
+            await this.notifyEntry(this.entry);
         }
     }
     async notifyAfter(onError) {
@@ -88,7 +101,7 @@ class HookManager {
         if (onError && !this.entry.metadata.runOnError) {
             return;
         }
-        await this.entry.instance.notify();
+        await this.notifyEntry(this.entry);
     }
     buildEntry() {
         const metadata = getHookMetadata(this.owner.constructor);
@@ -97,13 +110,25 @@ class HookManager {
             return undefined;
         }
         const instance = new entry.hookClass();
-        return {
+        const hookEntry = {
             metadata: entry,
             instance,
+            payload: undefined,
+            payloadSet: false,
             setPayload: (payload) => {
+                hookEntry.payload = payload;
                 instance.setPayload(payload, this.owner.context);
             },
         };
+        return hookEntry;
+    }
+    async notifyEntry(entry) {
+        const proto = Object.getPrototypeOf(entry.instance);
+        const usesBaseNotify = proto.notify === Hook.prototype.notify;
+        if (!usesBaseNotify) {
+            await entry.instance.use(entry.payload, entry.instance.context);
+        }
+        await entry.instance.notify();
     }
 }
 function buildUseCaseInstances(owner, options) {

package/package.json

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