multiple notification strategies

apps/edr-freight-api/src/modules/notifications/notifications.module.ts

@@ -1,9 +1,14 @@
 import { Module } from "@nestjs/common";
 
 import { NotificationsService } from "./notifications.service";
+import { EmailNotificationStrategy } from "./strategies/notification.email.strategy";
+import { SmsNotificationStrategy } from "./strategies/notification.sms.strategy";
+import { HttpModule } from "@nestjs/axios";
 
 @Module({
-  providers: [NotificationsService],
+  imports: [HttpModule],
+  controllers: [],
+  providers: [EmailNotificationStrategy, SmsNotificationStrategy, NotificationsService],
   exports: [NotificationsService],
 })
-export class NotificationsModule {}
+export class NotificationsModule { }

apps/edr-freight-api/src/modules/notifications/notifications.service.ts

@@ -1,14 +1,35 @@
-import { Injectable, Logger } from "@nestjs/common";
+import { Injectable, Logger, NotFoundException } from "@nestjs/common";
+import { EmailNotificationStrategy } from "./strategies/notification.email.strategy";
+import { NotificationStrategy } from "./strategies/notification.strategy";
+import { SmsNotificationStrategy } from "./strategies/notification.sms.strategy";
 
+
+
+type StrategyMethod = "sms" | "email"
 @Injectable()
 export class NotificationsService {
   private readonly logger = new Logger(NotificationsService.name);
+  private readonly strategies: Map<StrategyMethod, NotificationStrategy>
+  constructor(private readonly email: EmailNotificationStrategy, private readonly sms: SmsNotificationStrategy) {
+    this.strategies = new Map([
+      ["sms", this.sms as NotificationStrategy],
+      ["email", this.email as NotificationStrategy]
+    ])
+  }
 
   /**
    * Dispatch a notification to an operator or customer.
    * TODO: wire to email/SMS provider (SendGrid, SMS API, etc.) via a mailer service.
    */
-  async send(recipient: string, subject: string, body: string): Promise<void> {
-    this.logger.log(`[notify] ${recipient} :: ${subject} :: ${body}`);
+
+  async directSend(method: StrategyMethod, recipient: string, message: string) {
+    const strategy = this.strategies.get(method);
+    if (!strategy) {
+      throw new NotFoundException();
+    }
+    const sent = await strategy.send(recipient, message)
+    this.logger.log(`is sent - ${sent}`)
   }
+
+
 }

apps/edr-freight-api/src/modules/notifications/strategies/notification.email.strategy.ts

@@ -0,0 +1,12 @@
+import { Injectable, Logger } from "@nestjs/common";
+import { NotificationStrategy } from "./notification.strategy";
+
+@Injectable()
+export class EmailNotificationStrategy implements NotificationStrategy {
+    private readonly logger = new Logger(EmailNotificationStrategy.name);
+    constructor() { }
+    async send(recipient: string, message: string): Promise<boolean> {
+        this.logger.log(`${recipient}, ${message}`)
+        return false;
+    }
+}

apps/edr-freight-api/src/modules/notifications/strategies/notification.sms.strategy.ts

@@ -0,0 +1,25 @@
+import { Injectable} from "@nestjs/common";
+import { NotificationStrategy } from "./notification.strategy";
+import { HttpService } from '@nestjs/axios';
+import { ConfigService } from "@nestjs/config";
+import {  firstValueFrom } from 'rxjs';
+
+@Injectable()
+export class SmsNotificationStrategy implements NotificationStrategy {
+    constructor(private readonly httpService: HttpService, private readonly configService: ConfigService) { }
+    async send(recipient: string, message: string) {
+        const url = this.configService.get("OZIKING_SMS_URL")
+        const body = {
+            to: recipient,
+            text: message
+        }
+        const response = await firstValueFrom(
+            this.httpService.post(
+                url,
+                body,
+            ),
+        );
+
+        return response.status === 201;
+    }
+}

apps/edr-freight-api/src/modules/notifications/strategies/notification.strategy.ts

@@ -0,0 +1,6 @@
+import { Injectable } from "@nestjs/common";
+
+@Injectable()
+export abstract class NotificationStrategy {
+    abstract send(recipient: string, message: string): Promise<boolean>
+}