create-zhx-monorepo 0.2.2 → 2.0.0

package/templates/monorepo-starter/server/src/modules/media/media.controller.ts

@@ -0,0 +1,72 @@
+import {
+  Controller,
+  Post,
+  UploadedFile,
+  UseInterceptors,
+  Query,
+  Get,
+  Put,
+  Delete,
+  Param,
+  Body,
+} from "@nestjs/common";
+import { FileInterceptor } from "@nestjs/platform-express";
+import {
+  MediaCreateDto,
+  MediaUpdateDto,
+  MediaQueryDto,
+} from "@workspace/contracts/media";
+
+import { MediaService } from "./media.service";
+import { User } from "@/decorators/user.decorator";
+import { BooleanQuery } from "@/lib/decorators/boolean-query.decorator";
+
+@Controller("media")
+export class MediaController {
+  constructor(private readonly mediaService: MediaService) {}
+
+  @Post()
+  @UseInterceptors(
+    FileInterceptor("file", {
+      limits: { fileSize: 5 * 1024 * 1024 },
+    }),
+  )
+  createMedia(
+    @UploadedFile() file: Express.Multer.File,
+    @Body() dto: MediaCreateDto,
+    @User("id") userId: string,
+  ) {
+    return this.mediaService.createMedia(file, dto, userId);
+  }
+
+  @Get()
+  async findAllMedia(@Query() query: MediaQueryDto) {
+    return this.mediaService.findAllMedia(query);
+  }
+
+  @Get("/:mediaId")
+  async findMedia(@Param("mediaId") mediaId: string) {
+    return this.mediaService.findMedia(mediaId);
+  }
+
+  @Put("/:mediaId")
+  async updateMedia(
+    @Body() dto: MediaUpdateDto,
+    @Param("mediaId") mediaId: string,
+  ) {
+    return this.mediaService.updateMedia(dto, mediaId);
+  }
+
+  @Delete("/:mediaId")
+  async deleteMedia(
+    @Param("mediaId") mediaId: string,
+    @BooleanQuery("force") force: boolean,
+  ) {
+    return this.mediaService.deleteMedia(mediaId, force);
+  }
+
+  @Post("/:mediaId")
+  async restoreMedia(@Param("mediaId") mediaId: string) {
+    return this.mediaService.restoreMedia(mediaId);
+  }
+}

package/templates/monorepo-starter/server/src/modules/media/media.module.ts

@@ -0,0 +1,13 @@
+import { Global, Module } from "@nestjs/common";
+import { MediaController } from "./media.controller";
+import { MediaService } from "./media.service";
+import { CloudinaryService } from "./cloudinary.service";
+import { cloudinaryProvider } from "./cloudinary.provider";
+
+@Global()
+@Module({
+  controllers: [MediaController],
+  providers: [MediaService, CloudinaryService, cloudinaryProvider],
+  exports: [CloudinaryService],
+})
+export class MediaModule {}

package/templates/monorepo-starter/server/src/modules/media/media.service.ts

@@ -0,0 +1,146 @@
+import { Injectable } from "@nestjs/common";
+import type { MediaWhereInput } from "prisma/generated/models";
+import { MediaQueryDto, MediaUpdateDto } from "@workspace/contracts/media";
+
+import { PrismaService } from "@/modules/prisma/prisma.service";
+import { CloudinaryService } from "./cloudinary.service";
+
+@Injectable()
+export class MediaService {
+  constructor(
+    private readonly prisma: PrismaService,
+    private readonly cloudinary: CloudinaryService,
+  ) {}
+
+  async createMedia(
+    file: Express.Multer.File,
+    dto: MediaCreateDto,
+    userId: string,
+  ) {
+    const { data, hash } = await this.cloudinary.uploadFile(
+      file,
+      `media/${dto.type}`,
+    );
+
+    const media = await this.prisma.media.create({
+      data: {
+        ...dto,
+        title: dto.title ?? data.original_filename,
+        uploadedById: userId,
+        url: data.secure_url,
+        filename: data.original_filename,
+        mimeType: `${data.resource_type}/${data.format}`,
+        size: data.bytes,
+        hash,
+      },
+      include: this.mediaInclude,
+    });
+
+    return {
+      message: "Media uploaded successfully",
+      data: media,
+    };
+  }
+
+  async findAllMedia(query: MediaQueryDto) {
+    const { page, limit, sortBy, sortOrder, search, searchBy, mimeType, type } =
+      query;
+
+    const where: MediaWhereInput = {};
+
+    if (type) where.type = { equals: type };
+    if (mimeType) where.mimeType = { contains: mimeType, mode: "insensitive" };
+
+    if (search && searchBy) {
+      const searchWhereMap: Record<typeof searchBy, MediaWhereInput> = {
+        id: { id: search },
+        title: {
+          title: { contains: search, mode: "insensitive" },
+        },
+      };
+      Object.assign(where, searchWhereMap[searchBy]);
+    }
+
+    const skip = (page - 1) * limit;
+    const orderBy = { [sortBy]: sortOrder };
+
+    const [medias, total] = await Promise.all([
+      this.prisma.media.findMany({
+        where,
+        skip,
+        take: limit,
+        orderBy,
+        include: this.mediaInclude,
+      }),
+      this.prisma.media.count({ where }),
+    ]);
+
+    return {
+      message: "Media fetched successfully",
+      data: {
+        medias,
+        total,
+        page,
+        limit,
+        totalPages: Math.ceil(total / limit),
+      },
+    };
+  }
+
+  async findMedia(mediaId: string) {
+    const media = await this.prisma.media.findUniqueOrThrow({
+      where: { id: mediaId },
+      include: this.mediaInclude,
+    });
+
+    return {
+      message: "Media fetched successfully",
+      data: media,
+    };
+  }
+
+  async updateMedia(dto: MediaUpdateDto, mediaId: string) {
+    const updated = await this.prisma.media.update({
+      where: { id: mediaId },
+      data: dto,
+      include: this.mediaInclude,
+    });
+
+    return {
+      message: "Media updated successfully",
+      data: updated,
+    };
+  }
+
+  async deleteMedia(mediaId: string, force = false) {
+    const media = await this.prisma.media.findUniqueOrThrow({
+      where: { id: mediaId },
+    });
+
+    if (force) {
+      await this.cloudinary.deleteFile(media.hash);
+    }
+
+    await this.prisma.media.delete({
+      where: { id: mediaId },
+      ...({ force } as any),
+    });
+
+    return {
+      message: "Media deleted successfully",
+    };
+  }
+
+  async restoreMedia(mediaId: string) {
+    await this.prisma.media.update({
+      where: { id: mediaId },
+      data: { deletedAt: null },
+    });
+
+    return {
+      message: "Media restored successfully",
+    };
+  }
+
+  private mediaInclude = { uploadedBy: { omit: { password: true } } };
+}

package/templates/monorepo-starter/server/src/modules/notification/email.service.ts

@@ -0,0 +1,30 @@
+import { Injectable } from "@nestjs/common";
+import { createTransport, type Transporter } from "nodemailer";
+
+import { EnvService } from "@/modules/env/env.service";
+
+@Injectable()
+export class EmailService {
+  private transporter: Transporter;
+
+  constructor(private readonly env: EnvService) {
+    this.transporter = createTransport({
+      host: this.env.get("SMTP_HOST"),
+      port: this.env.get("SMTP_PORT"),
+      secure: this.env.get("SMTP_PORT") === 465,
+      auth: {
+        user: this.env.get("SMTP_USER"),
+        pass: this.env.get("SMTP_PASS"),
+      },
+    });
+  }
+
+  async sendMail(options: {
+    from: string;
+    to: string;
+    subject: string;
+    html: string;
+  }) {
+    return await this.transporter.sendMail(options);
+  }
+}

package/templates/monorepo-starter/server/src/modules/notification/messaging.service.ts

@@ -0,0 +1,50 @@
+import twilio from "twilio";
+import { Injectable } from "@nestjs/common";
+
+import { EnvService } from "@/modules/env/env.service";
+import { LoggerService } from "@/modules/logger/logger.service";
+
+@Injectable()
+export class MessagingService {
+  private twilioClient: twilio.Twilio;
+  private readonly twilioPhone: string;
+  private readonly twilioWhatsapp: string;
+
+  constructor(
+    private readonly env: EnvService,
+    private readonly logger: LoggerService,
+  ) {
+    const accountSid = this.env.get("TWILIO_ACCOUNT_SID");
+    const authToken = this.env.get("TWILIO_AUTH_TOKEN");
+    this.twilioPhone = this.env.get("TWILIO_PHONE_NUMBER");
+    this.twilioWhatsapp = this.env.get("TWILIO_WHATSAPP_NUMBER");
+
+    this.twilioClient = twilio(accountSid, authToken);
+  }
+
+  async sendSms(to: string, body: string): Promise<void> {
+    try {
+      await this.twilioClient.messages.create({
+        body,
+        from: this.twilioPhone,
+        to,
+      });
+    } catch (error) {
+      this.logger.error("Error sending SMS", { error });
+      throw new Error("Failed to send SMS");
+    }
+  }
+
+  async sendWhatsapp(to: string, body: string): Promise<void> {
+    try {
+      await this.twilioClient.messages.create({
+        body,
+        from: this.twilioWhatsapp,
+        to: `whatsapp:${to}`,
+      });
+    } catch (error) {
+      this.logger.error("Error sending WhatsApp message", { error });
+      throw new Error("Failed to send WhatsApp message");
+    }
+  }
+}

package/templates/monorepo-starter/server/src/modules/notification/notification.controller.ts

@@ -0,0 +1,44 @@
+import { Controller, Put, Param, Post, Body, Get } from "@nestjs/common";
+import { RegisterPushTokenDto } from "@workspace/contracts/notification";
+
+import { User } from "@/decorators/user.decorator";
+import { PrismaService } from "@/modules/prisma/prisma.service";
+
+@Controller("notifications")
+export class NotificationController {
+  constructor(private readonly prisma: PrismaService) {}
+
+  @Get()
+  async getAllNotification(@User("id") userId: string) {
+    const notifications = this.prisma.notification.findMany({
+      where: { userId },
+    });
+
+    return {
+      message: "Notifications Fetched Successfully.",
+      data: notifications,
+    };
+  }
+
+  @Put("/:id")
+  async markAsRead(@Param("id") id: string) {
+    await this.prisma.notification.update({
+      where: { id },
+      data: { readAt: new Date() },
+    });
+
+    return { message: "Notification read successfully." };
+  }
+
+  @Post("push/register")
+  async registerPushToken(
+    @Body() dto: RegisterPushTokenDto,
+    @User("sessionId") sessionId: string,
+  ) {
+    await this.prisma.session.update({
+      where: { id: sessionId },
+      data: { pushToken: dto.token, pushProvider: dto.provider },
+    });
+    return { message: "Push Token registered to session" };
+  }
+}

package/templates/monorepo-starter/server/src/modules/notification/notification.module.ts

@@ -1,11 +1,15 @@
 import { Global, Module } from "@nestjs/common";
+
+import { PushService } from "./push.service";
+import { EmailService } from "./email.service";
+import { MessagingService } from "./messaging.service";
 import { NotificationService } from "./notification.service";
-import { TemplateModule } from "@modules/template/template.module";
+import { NotificationController } from "./notification.controller";
 
 @Global()
 @Module({
-  imports: [TemplateModule],
-  providers: [NotificationService],
+  controllers: [NotificationController],
+  providers: [EmailService, PushService, MessagingService, NotificationService],
   exports: [NotificationService],
 })
 export class NotificationModule {}

package/templates/monorepo-starter/server/src/modules/notification/notification.service.ts

@@ -1,118 +1,161 @@
 import { Injectable } from "@nestjs/common";
-import { Resend } from "resend";
-import { EnvService } from "@modules/env/env.service";
-import { NotificationStatus, NotificationType, Prisma } from "@generated/prisma";
-import { PrismaService } from "@modules/prisma/prisma.service";
-import { TemplateService } from "@modules/template/template.service";
-import { LoggerService } from "@modules/logger/logger.service";
-import { InjectLogger } from "@decorators/logger.decorator";
+import { resolveEmailTemplate } from "@workspace/templates";
+import { appName } from "@workspace/shared/constants";
+import { NOTIFICATION_POLICY_MAP } from "@/constants/index";
+
+import { PushService } from "./push.service";
+import { EmailService } from "./email.service";
+import { MessagingService } from "./messaging.service";
+
+import { InjectLogger } from "@/decorators/logger.decorator";
+import { EnvService } from "@/modules/env/env.service";
+import { PrismaService } from "@/modules/prisma/prisma.service";
+import { LoggerService } from "@/modules/logger/logger.service";
 
 interface SendNotificationProps {
-  userId: string;
-  purpose: NotificationPurpose;
   to: string;
-  metadata: Record<string, any>;
+  purpose: NotificationPurpose;
+  meta: EmailTemplateProps;
 }
 
 @Injectable()
 export class NotificationService {
   @InjectLogger()
   private readonly logger!: LoggerService;
-  private readonly resend: Resend;
 
   constructor(
-    private readonly env: EnvService,
     private readonly prisma: PrismaService,
-    private readonly templateService: TemplateService
-  ) {
-    this.resend = new Resend(this.env.get("RESEND_API_KEY"));
-  }
+    private readonly env: EnvService,
+    private readonly emailService: EmailService,
+    private readonly messagingService: MessagingService,
+    private readonly pushService: PushService,
+  ) {}
 
-  async sendNotification({
-    userId,
-    purpose,
-    to,
-    metadata,
-  }: SendNotificationProps) {
-    const { html, subject, text } = this.templateService.resolveTemplate(
+  async sendNotification({ purpose, to, meta }: SendNotificationProps) {
+    const { html, subject, message } = await resolveEmailTemplate(
       purpose,
-      metadata
+      meta,
+    );
+
+    const { priority, push } = NOTIFICATION_POLICY_MAP[purpose];
+    const channels = this.determineChannels(
+      to,
+      meta.user,
+      priority,
+      push,
+      !!meta.otp,
     );
-    const type: Exclude<NotificationType, "inApp"> = to.includes("@")
-      ? "email"
-      : "sms";
 
     try {
-      const notification = await this.createNotificationRecord({
-        userId,
-        type,
-        title: subject,
-        message: text,
-        purpose,
-        metadata,
+      const notification = await this.prisma.notification.create({
+        data: {
+          userId: meta.user.id,
+          recipient: to,
+          purpose,
+          channels,
+          priority,
+          subject,
+          message,
+          meta: meta as any,
+        },
       });
 
-      this.logger.debug(`Notification record created`, {
-        notification: notification.id,
-      });
+      let allSuccess = true;
+      let anySuccess = false;
 
-      if (type === "email") {
-        const from = "Your App <onboarding@resend.dev>";
-        await this.resend.emails.send({ from, to, subject, html });
-      } else if (type === "sms") {
-        // TODO integrate Twilio/Nexmo here
-        console.log(`Sending SMS to ${to}: ${purpose} with data`, metadata);
+      for (const channel of channels) {
+        try {
+          switch (channel) {
+            case "email":
+              await this.sendEmail(to, subject, html);
+              break;
+            case "sms":
+              await this.sendMessage("sms", to, message);
+              break;
+            case "whatsapp":
+              await this.sendMessage("whatsapp", to, message);
+              break;
+            case "push":
+              await this.sendPush(meta.user, subject, message);
+              break;
+          }
+          anySuccess = true;
+        } catch (error) {
+          allSuccess = false;
+          this.logger.error("Notification send Failed", {
+            to,
+            channel,
+            error,
+          });
+        }
       }
 
-      await this.updateNotificationStatus(notification.id, "sent");
+      const status: NotificationStatus = allSuccess
+        ? "sent"
+        : anySuccess
+          ? "partial"
+          : "failed";
+
+      await this.prisma.notification.update({
+        where: { id: notification.id },
+        data: { status },
+      });
     } catch (error) {
       this.logger.error(`❌ Notification send Failed`, {
-        type,
         to,
+        channels,
         error,
       });
       throw error;
     }
   }
 
-  async notifyInApp(
-    userId: string,
-    purpose: NotificationPurpose,
-    title: string,
-    message: string,
-    metadata?: Record<string, any>
-  ) {
-    return this.createNotificationRecord({
-      userId,
-      type: "inApp",
-      title,
-      message,
-      purpose,
-      metadata,
-      status: "sent",
-    });
+  private async sendEmail(to: string, subject: string, html: string) {
+    const from = `${appName.default} <${this.env.get("SMTP_USER")}>`;
+    await this.emailService.sendMail({ from, to, subject, html });
   }
 
-  private async createNotificationRecord(
-    data: Prisma.NotificationUncheckedCreateInput
-  ) {
-    return this.prisma.notification.create({ data });
+  private async sendMessage(type: MessagingChannel, to: string, text: string) {
+    if (type === "sms") {
+      await this.messagingService.sendSms(to, text);
+    } else {
+      await this.messagingService.sendWhatsapp(to, text);
+    }
   }
 
-  private async updateNotificationStatus(
-    id: string,
-    status: NotificationStatus
-  ) {
-    return this.prisma.notification.update({
-      where: { id },
-      data: { status },
-    });
+  private async sendPush(user: SafeUser, subject: string, message: string) {
+    await this.pushService.sendPush(user, subject, message);
   }
 
-  async markAsRead(id: string) {
-    return this.prisma.notification.update({
-      where: { id },
-      data: { status: "read", readAt: new Date() },
-    });
+  private determineChannels(
+    identifier: string,
+    user: SafeUser,
+    priority: NotificationPriority,
+    allowPush: boolean,
+    isOtp: boolean,
+  ): NotificationChannel[] {
+    const channels: NotificationChannel[] = [];
+
+    if (isOtp) {
+      const isEmail = identifier.includes("@");
+      return [isEmail ? "email" : user.fallbackChannel];
+    }
+
+    if (allowPush && user.pushNotifications) {
+      channels.push("push");
+    }
+
+    const hasEmail = user.email && user.isEmailVerified;
+    const hasPhone = user.phone && user.isPhoneVerified;
+
+    if (hasEmail) {
+      channels.push("email");
+    }
+
+    if (priority === "important" && hasPhone) {
+      channels.push(user.fallbackChannel);
+    }
+
+    return channels;
   }
 }