wip

Author: brunozoric

packages/api-workflows/src/domain/notification/abstractions.ts

@@ -170,7 +170,8 @@ export const NotificationAdapter = createAbstraction<INotificationAdapter>(
 
 export namespace NotificationAdapter {
     export type Interface = INotificationAdapter;
-    export type SendParams = INotificationAdapterSendParams;
+    export type Params = INotificationAdapterSendParams;
+    export type User = INotificationAdapterUser;
 }
 
 export namespace Notification {

packages/api-workflows/src/features/notification/NotificationMailAdapter/NotificationMailAdapter.ts

@@ -1,8 +1,6 @@
 import { MailerService } from "@webiny/api-mailer";
-import {
-    NotificationAdapter,
-    NotificationMessageBodyConverter
-} from "~/domain/notification/abstractions.js";
+import type { NotificationMessageBodyConverter } from "~/domain/notification/abstractions.js";
+import { NotificationAdapter } from "~/domain/notification/abstractions.js";
 
 class NotificationMailAdapterImpl implements NotificationAdapter.Interface {
     public readonly id = "e-mail";
@@ -18,7 +16,7 @@ class NotificationMailAdapterImpl implements NotificationAdapter.Interface {
         return null;
     }
 
-    public async send(params: NotificationAdapter.SendParams): Promise<void> {
+    public async send(params: NotificationAdapter.Params): Promise<void> {
         const { users, message } = params;
 
         const bcc = users

packages/api-workflows/src/features/notification/NotifyUsers/GetWorkflow.ts

@@ -0,0 +1,32 @@
+import { IWorkflow } from "~/domain/workflow/abstractions.js";
+import { GetWorkflow as GetWorkflowAbstraction } from "./abstractions.js";
+import { GetWorkflowRepository } from "~/features/workflow/GetWorkflow/index.js";
+import { Logger } from "@webiny/api-core/features/logger/index.js";
+
+class GetWorkflowImpl implements GetWorkflowAbstraction.Interface {
+    public constructor(
+        private logger: Logger.Interface,
+        private getWorkflowRepository: GetWorkflowRepository.Interface
+    ) {}
+
+    public async execute(params: GetWorkflowAbstraction.Params): Promise<IWorkflow | null> {
+        const result = await this.getWorkflowRepository.execute({
+            id: params.id,
+            app: params.app
+        });
+        if (result.isFail()) {
+            this.logger.error(
+                `Could not load workflow "${params.id}"/${params.app}. More in a log below this line.`
+            );
+            this.logger.log(result.error);
+            return null;
+        }
+
+        return result.value;
+    }
+}
+
+export const GetWorkflow = GetWorkflowAbstraction.createImplementation({
+    implementation: GetWorkflowImpl,
+    dependencies: [Logger, GetWorkflowRepository]
+});

packages/api-workflows/src/features/notification/NotifyUsers/NotifyUsersOnStateApproveStep.ts

@@ -1,12 +1,25 @@
 import { WorkflowStateApproveStepHandler } from "~/features/workflowState/ApproveWorkflowStateStep/events.js";
+import { GetWorkflow } from "~/features/notification/NotifyUsers/abstractions.js";
 
 class NotifyUsersOnStateApproveStepImpl implements WorkflowStateApproveStepHandler.Interface {
+    public constructor(private getWorkflow: GetWorkflow.Interface) {}
+
     public async handle(event: WorkflowStateApproveStepHandler.Event): Promise<void> {
         const { state } = event.payload;
+
+        const workflow = await this.getWorkflow.execute({
+            id: state.workflowId,
+            app: state.app
+        });
+        if (!workflow) {
+            return;
+        }
+        
+        
     }
 }
 
 export const NotifyUsersOnStateApproveStep = WorkflowStateApproveStepHandler.createImplementation({
     implementation: NotifyUsersOnStateApproveStepImpl,
-    dependencies: []
+    dependencies: [GetWorkflow]
 });

packages/api-workflows/src/features/notification/NotifyUsers/NotifyUsersOnStateCreate.ts

@@ -1,12 +1,49 @@
 import { WorkflowStateAfterCreateHandler } from "~/features/workflowState/CreateWorkflowState/index.js";
+import { GetWorkflow, TriggerAdapters } from "~/features/notification/NotifyUsers/abstractions.js";
+import { NotificationAdapter } from "~/domain/notification/abstractions.js";
+import type { NonEmptyArray } from "@webiny/api/types.js";
 
+/**
+ * This handler is responsible for notifying users when a new workflow state is created - a user requests a review of the entry.
+ */
 class NotifyUsersOnStateCreateImpl implements WorkflowStateAfterCreateHandler.Interface {
+    public constructor(
+        private getWorkflow: GetWorkflow.Interface,
+        private triggerAdapters: TriggerAdapters.Interface
+    ) {}
+
     public async handle(event: WorkflowStateAfterCreateHandler.Event): Promise<void> {
+        /**
+         * No point triggering adapters if none are registered.
+         */
+        if (this.triggerAdapters.hasAny() === false) {
+            return;
+        }
         const { state } = event.payload;
+
+        const workflow = await this.getWorkflow.execute({
+            id: state.workflowId,
+            app: state.app
+        });
+        if (!workflow) {
+            return;
+        }
+        // need to find all users that need to be notified.
+        const users: NotificationAdapter.User[] = [];
+        if (users.length === 0) {
+            return;
+        }
+        // and then trigger all adapters
+        await this.triggerAdapters.execute({
+            state,
+            workflow,
+            users: users as NonEmptyArray<NotificationAdapter.User>,
+            message
+        });
     }
 }
 
 export const NotifyUsersOnStateCreate = WorkflowStateAfterCreateHandler.createImplementation({
     implementation: NotifyUsersOnStateCreateImpl,
-    dependencies: []
+    dependencies: [GetWorkflow, TriggerAdapters]
 });

packages/api-workflows/src/features/notification/NotifyUsers/TriggerAdapters.ts

@@ -0,0 +1,39 @@
+import { Result } from "@webiny/feature/api";
+import { NotificationAdapter } from "~/domain/notification/abstractions.js";
+import {
+    type ITriggerAdaptersParams,
+    TriggerAdapters as TriggerAdaptersAbstraction,
+    type TriggerAdaptersResult
+} from "./abstractions.js";
+
+class TriggerAdaptersImpl implements TriggerAdaptersAbstraction.Interface {
+    public constructor(private adapters: NotificationAdapter.Interface[]) {}
+
+    public hasAny(): boolean {
+        return this.adapters.length > 0;
+    }
+
+    public async execute(params: ITriggerAdaptersParams): Promise<TriggerAdaptersResult> {
+        const { users, message } = params;
+        // execute all adapters in parallel?
+        const promises = await Promise.all(
+            this.adapters.map(async adapter => {
+                try {
+                    return await adapter.send({
+                        message,
+                        users
+                    });
+                } catch (ex) {
+                    return;
+                }
+            })
+        );
+
+        return Result.ok();
+    }
+}
+
+export const TriggerAdapters = TriggerAdaptersAbstraction.createImplementation({
+    implementation: TriggerAdaptersImpl,
+    dependencies: [[NotificationAdapter, { multiple: true }]]
+});

packages/api-workflows/src/features/notification/NotifyUsers/abstractions.ts

@@ -0,0 +1,57 @@
+import { createAbstraction } from "@webiny/feature/createAbstraction.js";
+import type { IWorkflow } from "~/domain/workflow/abstractions.js";
+import type { IWorkflowState } from "~/domain/workflowState/abstractions.js";
+import type { Result } from "@webiny/feature/api/index.js";
+import type { NonEmptyArray } from "@webiny/api/types.js";
+import {
+    type INotificationAdapterMessage,
+    NotificationAdapter
+} from "~/domain/notification/abstractions.js";
+
+/**
+ * Get Workflow
+ */
+export interface IGetWorkflowExecuteParams {
+    id: string;
+    app: string;
+}
+
+export interface IGetWorkflow {
+    /**
+     * This method should log errors internally and return null if the workflow is not found.
+     */
+    execute(params: IGetWorkflowExecuteParams): Promise<IWorkflow | null>;
+}
+
+export const GetWorkflow = createAbstraction<IGetWorkflow>("NotifyUsersGetWorkflow");
+
+export namespace GetWorkflow {
+    export type Interface = IGetWorkflow;
+    export type Params = IGetWorkflowExecuteParams;
+}
+
+/**
+ * Trigger Adapters
+ */
+
+export interface ITriggerAdaptersParams {
+    workflow: IWorkflow;
+    state: IWorkflowState;
+    users: NonEmptyArray<NotificationAdapter.User>;
+    message: INotificationAdapterMessage;
+}
+
+export type TriggerAdaptersResult = Promise<Result<void, unknown>>;
+
+export interface ITriggerAdapters {
+    hasAny(): boolean;
+    execute(params: ITriggerAdaptersParams): Promise<TriggerAdaptersResult>;
+}
+
+export const TriggerAdapters = createAbstraction<ITriggerAdapters>("NotifyUsersTriggerAdapters");
+
+export namespace TriggerAdapters {
+    export type Interface = ITriggerAdapters;
+    export type Params = ITriggerAdaptersParams;
+    export type Result = TriggerAdaptersResult;
+}

packages/api-workflows/src/features/notification/NotifyUsers/feature.ts

@@ -6,10 +6,16 @@ import { NotifyUsersOnStateCreate } from "./NotifyUsersOnStateCreate.js";
 import { NotifyUsersOnStateDelete } from "./NotifyUsersOnStateDelete.js";
 import { NotifyUsersOnStateStartStep } from "./NotifyUsersOnStateStartStep.js";
 import { NotifyUsersOnStateTakeOverStep } from "./NotifyUsersOnStateTakeOverStep.js";
+import { TriggerAdapters } from "./TriggerAdapters.js";
+import { GetWorkflow } from "./GetWorkflow.js";
 
 export const NotifyUsersFeature = createFeature({
     name: "WorkflowNotifications/NotifyUsers",
     register(container) {
+        // helpers for event handlers
+        container.register(TriggerAdapters);
+        container.register(GetWorkflow);
+        // event handlerrs
         container.register(NotifyUsersOnStateCreate);
         container.register(NotifyUsersOnStateDelete);
         container.register(NotifyUsersOnStateStartStep);