framework-do-dede 6.0.5 → 6.1.0

package/README.md

@@ -341,6 +341,26 @@ class CreatePhotoUseCase extends UseCase<void, void> {
 }
 ```
 
+Quando `@DecorateUseCase` está presente, `HookAfter` roda **depois de todo o fluxo** por padrão
+(use cases decoradores + use case principal), independentemente da ordem dos decorators.
+
+```ts
+@DecorateUseCase({ useCase: AuditUseCase })
+@HookAfter(SavePhoto)
+class CreateUserUseCase extends UseCase<void, void> {}
+// ordem: AuditUseCase -> CreateUserUseCase -> SavePhoto
+```
+
+Se precisar executar o HookAfter **logo após os use cases decoradores** (antes do principal),
+defina `after: 'decorator'`.
+
+```ts
+@HookAfter(SavePhoto, { after: 'decorator' })
+@DecorateUseCase({ useCase: AuditUseCase })
+class CreateUserUseCase extends UseCase<void, void> {}
+// ordem: AuditUseCase -> SavePhoto -> CreateUserUseCase
+```
+
 ### Entity e Model
 
 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`.

package/dist/application/usecase.d.ts

@@ -11,8 +11,10 @@ export declare abstract class UseCase<UseCaseInput, UseCaseOutput, UseCaseContex
 type UseCaseConstructor = new (...args: any[]) => UseCase<any, any>;
 type HookConstructor = new (...args: any[]) => Hook<any, any>;
 type HookPosition = 'before' | 'after';
+type HookAfterStage = 'decorator' | 'main';
 interface HookOptions {
     runOnError?: boolean;
+    after?: HookAfterStage;
 }
 interface DecorateUseCaseOptions {
     useCase: UseCaseConstructor | UseCaseConstructor[];
@@ -37,7 +39,7 @@ declare class HookManager {
     use(payload: unknown): void;
     useIfUnset(payload: unknown): void;
     notifyBefore(): Promise<void>;
-    notifyAfter(onError: boolean): Promise<void>;
+    notifyAfter(onError: boolean, stage?: HookAfterStage): Promise<void>;
     private buildEntry;
     private notifyEntry;
 }

package/dist/application/usecase.js

@@ -44,7 +44,7 @@ function ensureHookedExecution(target) {
             originalError = error;
         }
         afterHook.useIfUnset(this.data);
-        await afterHook.notifyAfter(!!originalError);
+        await afterHook.notifyAfter(!!originalError, 'main');
         if (originalError) {
             throw originalError;
         }
@@ -94,10 +94,14 @@ class HookManager {
             await this.notifyEntry(this.entry);
         }
     }
-    async notifyAfter(onError) {
+    async notifyAfter(onError, stage = 'main') {
         if (!this.entry || this.position !== 'after' || this.entry.metadata.position !== 'after') {
             return;
         }
+        const hookStage = this.entry.metadata.after ?? 'main';
+        if (hookStage !== stage) {
+            return;
+        }
         if (onError && !this.entry.metadata.runOnError) {
             return;
         }
@@ -151,7 +155,7 @@ function buildUseCaseInstances(owner, options) {
 export function DecorateUseCase(options) {
     return (target) => {
         const stateKey = Symbol('decoratorUseCases');
-        return class extends target {
+        const decorated = class extends target {
             constructor(...args) {
                 super(...args);
                 this[stateKey] = {
@@ -161,12 +165,29 @@ export function DecorateUseCase(options) {
             }
             async execute() {
                 const state = this[stateKey];
-                for (const useCase of state.useCases) {
-                    await useCase.execute();
+                let decoratorError;
+                try {
+                    for (const useCase of state.useCases) {
+                        await useCase.execute();
+                    }
+                }
+                catch (error) {
+                    decoratorError = error;
+                }
+                const afterHook = this.afterHook;
+                afterHook.useIfUnset(this.data);
+                await afterHook.notifyAfter(!!decoratorError, 'decorator');
+                if (decoratorError) {
+                    throw decoratorError;
                 }
                 return await state.original.call(this);
             }
         };
+        const hooks = getHookMetadata(target);
+        if (hooks.length) {
+            decorated[USE_CASE_HOOKS] = [...hooks];
+        }
+        return ensureHookedExecution(decorated);
     };
 }
 export function HookBefore(hookClass) {
@@ -177,7 +198,12 @@ export function HookBefore(hookClass) {
 }
 export function HookAfter(hookClass, options = {}) {
     return (target) => {
-        registerHook(target, { hookClass, position: 'after', runOnError: options.runOnError });
+        registerHook(target, {
+            hookClass,
+            position: 'after',
+            runOnError: options.runOnError,
+            after: options.after,
+        });
         return ensureHookedExecution(target);
     };
 }

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

@@ -9,7 +9,7 @@ export declare abstract class Model<TEntity extends Entity = Entity> extends Rep
     [property: string]: any;
     fromModel(input: Record<string, any> | null | undefined): this;
     abstract fromEntity(entity: TEntity): this;
-    toModel(): Record<string, any>;
+    toModel(ignoreId?: boolean, namedId?: string): Record<string, any>;
     abstract toEntity(): TEntity;
 }
 export declare function column(columnName: string): (target: any, propertyKey: string) => void;

package/dist/infra/model/model.js

@@ -12,10 +12,11 @@ export class Model extends RepositoryModel {
         }
         return this;
     }
-    toModel() {
+    toModel(ignoreId = false, namedId) {
         const record = {};
         const columns = this.columns ?? [];
         const mappedProperties = new Set();
+        const idColumn = columns.find((column) => column.property === "id")?.column ?? "id";
         for (const column of columns) {
             record[column.column] = this[column.property];
             mappedProperties.add(column.property);
@@ -29,6 +30,13 @@ export class Model extends RepositoryModel {
             }
             record[property] = this[property];
         }
+        const idValue = this.id ?? record[idColumn];
+        if (namedId && idValue !== undefined) {
+            record[namedId] = idValue;
+        }
+        if (ignoreId) {
+            delete record[idColumn];
+        }
         return record;
     }
 }

package/dist/protocols/model.d.ts

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

package/package.json

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