create-zhx-monorepo 0.1.0

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

@@ -0,0 +1,118 @@
+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";
+
+interface SendNotificationProps {
+  userId: string;
+  purpose: NotificationPurpose;
+  to: string;
+  metadata: Record<string, any>;
+}
+
+@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"));
+  }
+
+  async sendNotification({
+    userId,
+    purpose,
+    to,
+    metadata,
+  }: SendNotificationProps) {
+    const { html, subject, text } = this.templateService.resolveTemplate(
+      purpose,
+      metadata
+    );
+    const type: Exclude<NotificationType, "inApp"> = to.includes("@")
+      ? "email"
+      : "sms";
+
+    try {
+      const notification = await this.createNotificationRecord({
+        userId,
+        type,
+        title: subject,
+        message: text,
+        purpose,
+        metadata,
+      });
+
+      this.logger.debug(`Notification record created`, {
+        notification: notification.id,
+      });
+
+      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);
+      }
+
+      await this.updateNotificationStatus(notification.id, "sent");
+    } catch (error) {
+      this.logger.error(`❌ Notification send Failed`, {
+        type,
+        to,
+        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 createNotificationRecord(
+    data: Prisma.NotificationUncheckedCreateInput
+  ) {
+    return this.prisma.notification.create({ data });
+  }
+
+  private async updateNotificationStatus(
+    id: string,
+    status: NotificationStatus
+  ) {
+    return this.prisma.notification.update({
+      where: { id },
+      data: { status },
+    });
+  }
+
+  async markAsRead(id: string) {
+    return this.prisma.notification.update({
+      where: { id },
+      data: { status: "read", readAt: new Date() },
+    });
+  }
+}

package/templates/monorepo-starter/server/src/modules/prisma/prisma.extension.ts

@@ -0,0 +1,72 @@
+import { Prisma } from "@generated/prisma";
+
+const hasDeletedAt = (model: string) => {
+  const dmmf = Prisma.dmmf.datamodel.models;
+  const m = dmmf.find((m) => m.name === model);
+  return !!m?.fields.find((f) => f.name === "deletedAt");
+};
+
+export const softDeleteExtension = Prisma.defineExtension({
+  name: "softDelete",
+
+  query: {
+    $allModels: {
+      async delete({ model, args, query }) {
+        const hasDel = hasDeletedAt(model);
+        const force = (args as any).force;
+
+        if (hasDel && !force) {
+          const prisma = Prisma.getExtensionContext(this);
+          console.log("prisma", prisma);
+          return (prisma as any)[model].update({
+            where: args.where,
+            data: { deletedAt: new Date() },
+          });
+        }
+
+        return query(args);
+      },
+
+      async deleteMany({ model, args, query }) {
+        const hasDel = hasDeletedAt(model);
+        const force = (args as any).force;
+
+        if (hasDel && !force) {
+          const prisma = Prisma.getExtensionContext(this);
+          console.log("prisma", prisma);
+          return (prisma as any)[model].updateMany({
+            where: args.where,
+            data: { deletedAt: new Date() },
+          });
+        }
+
+        return query(args);
+      },
+
+      async $allOperations({ model, operation, args, query }) {
+        const hasDel = hasDeletedAt(model);
+        const _args = args as Record<string, any>;
+        const targetOps = [
+          "findUnique",
+          "findFirst",
+          "findMany",
+          "count",
+          "aggregate",
+        ];
+
+        if (!targetOps.includes(operation) || !hasDel) return query(args);
+        if (_args.includeDeleted) {
+          delete _args.includeDeleted;
+          return query(_args);
+        }
+
+        _args.where = _args.where ?? {};
+        if (!("deletedAt" in _args.where)) {
+          _args.where = { ..._args.where, deletedAt: null };
+        }
+
+        return query(_args);
+      },
+    },
+  },
+});

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

@@ -0,0 +1,9 @@
+import { Global, Module } from "@nestjs/common";
+import { PrismaService } from "./prisma.service";
+
+@Global()
+@Module({
+  providers: [PrismaService],
+  exports: [PrismaService],
+})
+export class PrismaModule {}

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

@@ -0,0 +1,49 @@
+import type { OnModuleDestroy, OnModuleInit } from "@nestjs/common";
+import { Injectable } from "@nestjs/common";
+import { PrismaClient } from "@generated/prisma";
+import { PrismaPg } from "@prisma/adapter-pg";
+
+import { LoggerService } from "@modules/logger/logger.service";
+import { InjectLogger } from "@decorators/logger.decorator";
+import { softDeleteExtension } from "./prisma.extension";
+
+@Injectable()
+export class PrismaService
+  extends PrismaClient
+  implements OnModuleInit, OnModuleDestroy
+{
+  @InjectLogger()
+  private readonly logger!: LoggerService;
+
+constructor() {
+  const adapter = new PrismaPg({
+    connectionString: process.env.DB_URI!,
+  });
+
+  super({ adapter });
+
+  Object.assign(this, this.$extends(softDeleteExtension));
+}
+
+  async onModuleInit() {
+    this.logger.log("Connecting to the database...");
+    try {
+      await this.$connect();
+      this.logger.log("✅ Database connection established.");
+    } catch (error) {
+      this.logger.error("❌ Database connection failed", { error });
+      throw error;
+    }
+  }
+
+  async onModuleDestroy() {
+    this.logger.log("Disconnecting from the database...");
+    try {
+      await this.$disconnect();
+      this.logger.log("Database connection closed.");
+    } catch (error) {
+      this.logger.error("❌ Error disconnecting database", { error });
+      throw error;
+    }
+  }
+}

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

@@ -0,0 +1,21 @@
+import { Controller, Get, Req } from "@nestjs/common";
+import { PublicService } from "./public.service";
+import type { Request } from "express";
+import { Public } from "@decorators/public.decorator";
+
+@Controller()
+export class PublicController {
+  constructor(private readonly publicService: PublicService) {}
+
+  @Public()
+  @Get("/")
+  welcome(@Req() req: Request) {
+    return this.publicService.welcome(req);
+  }
+
+  @Public()
+  @Get("/health")
+  healthCheck() {
+    return this.publicService.getHealth();
+  }
+}

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

@@ -0,0 +1,9 @@
+import { Module } from '@nestjs/common';
+import { PublicService } from './public.service';
+import { PublicController } from './public.controller';
+
+@Module({
+  providers: [PublicService],
+  controllers: [PublicController]
+})
+export class PublicModule {}

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

@@ -0,0 +1,30 @@
+import { Injectable } from "@nestjs/common";
+import { LoggerService } from "@modules/logger/logger.service";
+import type { Request } from "express";
+import { InjectLogger } from "@decorators/logger.decorator";
+
+@Injectable()
+export class PublicService {
+  @InjectLogger()
+  private readonly logger!: LoggerService;
+
+  welcome(req: Request) {
+    this.logger.log(
+      `Welcome endpoint hit from IP: ${req.ip}, path: ${req.url}`
+    );
+    return { message: "Server is running 🚀" };
+  }
+
+  getHealth() {
+    const uptime = process.uptime();
+    const timestamp = new Date().toISOString();
+
+    this.logger.log(`Health check requested. Uptime: ${uptime}s`);
+    return {
+      message: "Server is healthy",
+      status: "ok",
+      uptime,
+      timestamp,
+    };
+  }
+}

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

@@ -0,0 +1,33 @@
+import { Injectable } from "@nestjs/common";
+import { Cron, CronExpression } from "@nestjs/schedule";
+import { PrismaService } from "@modules/prisma/prisma.service";
+import { LoggerService } from "@modules/logger/logger.service";
+import { InjectLogger } from "@decorators/logger.decorator";
+
+@Injectable()
+export class CleanupService {
+  @InjectLogger()
+  private readonly logger!: LoggerService;
+
+  constructor(private readonly prisma: PrismaService) {}
+
+  @Cron(CronExpression.EVERY_HOUR)
+  async handleOtpCleanup() {
+    this.logger.log("🧹 Running OTP cleanup job...");
+    const result = await this.prisma.otp.deleteMany({
+      where: { expiresAt: { lt: new Date() } },
+    });
+    this.logger.log(`✅ Deleted ${result.count} expired OTPs`);
+  }
+
+  @Cron(CronExpression.EVERY_DAY_AT_MIDNIGHT)
+  async handleRefreshTokenCleanup() {
+    this.logger.log("🧹 Running Refresh Token cleanup job...");
+    const result = await this.prisma.refreshToken.deleteMany({
+      where: {
+        expiresAt: { lt: new Date() },
+      },
+    });
+    this.logger.log(`✅ Deleted ${result.count} expired refresh tokens`);
+  }
+}

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

@@ -0,0 +1,7 @@
+import { Module } from "@nestjs/common";
+import { CleanupService } from "./cleanup.service";
+
+@Module({
+  providers: [CleanupService],
+})
+export class SchedulerModule {}

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

@@ -0,0 +1,8 @@
+import { Module } from "@nestjs/common";
+import { TemplateService } from "./template.service";
+
+@Module({
+  providers: [TemplateService],
+  exports: [TemplateService],
+})
+export class TemplateModule {}

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

@@ -0,0 +1,33 @@
+import { Injectable } from "@nestjs/common";
+import { EnvService } from "@modules//env/env.service";
+
+import * as templates from "@templates/notification.templates";
+
+@Injectable()
+export class TemplateService {
+  constructor(private readonly env: EnvService) {}
+
+  private readonly templateFactory: Record<
+    NotificationPurpose,
+    (data: any, env: EnvService) => TemplateReturn
+  > = {
+    signin: templates.signinTemplate,
+    signup: templates.signupTemplate,
+    verifyIdentifier: templates.verifyIdentifierTemplate,
+    setPassword: templates.setPasswordTemplate,
+    resetPassword: templates.resetPasswordTemplate,
+    changeIdentifier: templates.changeIdentifierTemplate,
+    verifyMfa: templates.verifyMfaTemplate,
+    enableMfa: templates.enableMfaTemplate,
+    disableMfa: templates.disableMfaTemplate,
+  };
+
+  resolveTemplate(purpose: NotificationPurpose, metadata: any): TemplateReturn {
+    const templateFn = this.templateFactory[purpose];
+    if (!templateFn) {
+      throw new Error(`Undefined template purpose: ${purpose}`);
+    }
+
+    return templateFn(metadata, this.env);
+  }
+}

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

@@ -0,0 +1,11 @@
+import { Module } from "@nestjs/common";
+import { TokenService } from "./token.service";
+import { JwtModule } from "@nestjs/jwt";
+import { CookieService } from "@utils/cookie.util";
+
+@Module({
+  imports: [JwtModule.register({})],
+  providers: [TokenService, CookieService],
+  exports: [TokenService],
+})
+export class TokenModule {}

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

@@ -0,0 +1,131 @@
+import { Injectable } from "@nestjs/common";
+import { JwtService } from "@nestjs/jwt";
+import { expiryDate } from "@utils/general.util";
+import { PrismaService } from "@modules/prisma/prisma.service";
+import { UserRole } from "@generated/prisma";
+import { EnvService } from "@modules/env/env.service";
+import type { Request, Response } from "express";
+import { CookieService } from "@utils/cookie.util";
+
+export interface TokenPayload {
+  sub: string;
+  roles: UserRole[];
+}
+
+interface TokensType {
+  accessToken: string;
+  refreshToken: string;
+  tokenId: string;
+}
+
+@Injectable()
+export class TokenService {
+  constructor(
+    private readonly jwtService: JwtService,
+    private readonly env: EnvService,
+    private readonly prisma: PrismaService,
+    private readonly cookieService: CookieService
+  ) {}
+
+  async generateTokens(req: Request, payload: TokenPayload) {
+    const [accessToken, refreshToken] = await Promise.all([
+      this.jwtService.signAsync(payload, {
+        secret: this.env.get("JWT_ACCESS_SECRET"),
+        expiresIn: this.env.get("ACCESS_TOKEN_EXP"),
+      }),
+      this.jwtService.signAsync(payload, {
+        secret: this.env.get("JWT_REFRESH_SECRET"),
+        expiresIn: this.env.get("REFRESH_TOKEN_EXP"),
+      }),
+    ]);
+
+    const tokenId = req.cookies["tokenId"] || "undefined";
+    const refreshExp = expiryDate(this.env.get("REFRESH_TOKEN_EXP"), true);
+
+    const tokenData = {
+      token: refreshToken,
+      userId: payload.sub,
+      ip: req.ip || "Unknown IP",
+      userAgent: req.headers["user-agent"] || "Unknown User Agent",
+      lastUsed: new Date(),
+      blacklisted: false,
+      isActive: true,
+      expiresAt: refreshExp,
+    };
+
+    const newToken = await this.prisma.refreshToken.upsert({
+      where: { id: tokenId },
+      update: tokenData,
+      create: tokenData,
+    });
+
+    return { accessToken, refreshToken, tokenId: newToken.id };
+  }
+
+  async verifyToken(
+    token: string,
+    type: "access" | "refresh"
+  ): Promise<TokenPayload | null> {
+    const secret =
+      type === "access"
+        ? this.env.get("JWT_ACCESS_SECRET")
+        : this.env.get("JWT_REFRESH_SECRET");
+    try {
+      return await this.jwtService.verifyAsync<TokenPayload>(token, { secret });
+    } catch (error) {
+      return null;
+    }
+  }
+
+  async refreshTokens(req: Request, res: Response, payload: TokenPayload) {
+    const refreshToken = req.cookies["refreshToken"];
+
+    const tokenRecord = await this.prisma.refreshToken.findUnique({
+      where: { token: refreshToken, blacklisted: false },
+    });
+
+    if (!tokenRecord) {
+      throw new Error("Invalid or expired refresh token.");
+    }
+
+    await this.createAuthSession(req, res, {
+      id: payload.sub,
+      roles: payload.roles,
+    });
+  }
+
+  async createAuthSession(req: Request, res: Response, user: Express.User) {
+    const tokens = await this.generateTokens(req, {
+      sub: user.id,
+      roles: user.roles,
+    });
+    this.setAuthCookies(res, tokens);
+    return tokens;
+  }
+
+  attachDecodedUser = (req: Request, decoded: TokenPayload) => {
+    if (decoded) req["user"] = { id: decoded.sub, roles: decoded.roles };
+  };
+
+  setAuthCookies(res: Response, tokens: TokensType): void {
+    const { accessToken, refreshToken, tokenId } = tokens;
+    const accessExp = expiryDate(this.env.get("ACCESS_TOKEN_EXP"), true);
+    const refreshExp = expiryDate(this.env.get("REFRESH_TOKEN_EXP"), true);
+
+    this.cookieService.setCookie(res, "accessToken", accessToken, {
+      expires: accessExp,
+    });
+    this.cookieService.setCookie(res, "refreshToken", refreshToken, {
+      expires: refreshExp,
+    });
+    this.cookieService.setCookie(res, "tokenId", tokenId, {
+      expires: refreshExp,
+    });
+  }
+
+  clearAuthCookies(res: Response): void {
+    res.clearCookie("accessToken");
+    res.clearCookie("refreshToken");
+    res.clearCookie("tokenId");
+  }
+}

package/templates/monorepo-starter/server/src/types/express.d.ts

@@ -0,0 +1,10 @@
+import { UserRole } from "@generated/prisma";
+
+declare global {
+  namespace Express {
+    interface User {
+      id: string;
+      roles: UserRole[];
+    }
+  }
+}

package/templates/monorepo-starter/server/src/types/index.d.ts

@@ -0,0 +1,13 @@
+import { OrderStatus, OtpPurpose } from "@generated/prisma";
+
+declare global {
+  type IdentifierKey = "email" | "phone";
+
+  type NotificationPurpose = "signin" | "signup" | OtpPurpose;
+
+  type TemplateReturn = {
+    subject: string;
+    html: string;
+    text: string;
+  };
+}