create-zhx-monorepo 0.1.0

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

@@ -0,0 +1,165 @@
+import {
+  BadRequestException,
+  Injectable,
+  type OnModuleInit,
+} from "@nestjs/common";
+import passport from "passport";
+import {
+  Strategy as GoogleStrategy,
+  type Profile as GoogleProfile,
+} from "passport-google-oauth20";
+import {
+  Strategy as FacebookStrategy,
+  type Profile as FacebookProfile,
+} from "passport-facebook";
+import { EnvService } from "@modules/env/env.service";
+import { PrismaService } from "@modules/prisma/prisma.service";
+import { OtpService } from "./otp.service";
+import { NotificationService } from "@modules/notification/notification.service";
+
+interface NormalizedProfile {
+  provider: "google" | "facebook";
+  id: string;
+  email: string | null;
+  displayName: string;
+  firstName: string;
+  lastName: string;
+  photo?: string;
+}
+
+@Injectable()
+export class OAuthService implements OnModuleInit {
+  constructor(
+    private readonly prisma: PrismaService,
+    private readonly otpService: OtpService,
+    private readonly env: EnvService,
+    private readonly notifyService: NotificationService
+  ) {}
+
+  onModuleInit() {
+    this.initGoogleStrategy();
+    this.initFacebookStrategy();
+  }
+
+  private initGoogleStrategy() {
+    passport.use(
+      "google",
+      new GoogleStrategy(
+        {
+          clientID: this.env.get("GOOGLE_CLIENT_ID"),
+          clientSecret: this.env.get("GOOGLE_CLIENT_SECRET"),
+          callbackURL: this.env.get("GOOGLE_CALLBACK_URL"),
+          scope: ["profile", "email"],
+        },
+        async (_, __, profile: GoogleProfile, done) => {
+          try {
+            const user = await this.validateOAuthLogin(profile);
+            done(null, user);
+          } catch (err) {
+            done(err, false);
+          }
+        }
+      )
+    );
+  }
+
+  private initFacebookStrategy() {
+    passport.use(
+      "facebook",
+      new FacebookStrategy(
+        {
+          clientID: this.env.get("FACEBOOK_CLIENT_ID"),
+          clientSecret: this.env.get("FACEBOOK_CLIENT_SECRET"),
+          callbackURL: this.env.get("FACEBOOK_CALLBACK_URL"),
+          scope: "email",
+          profileFields: ["id", "emails", "name", "displayName"],
+        },
+        async (_, __, profile: FacebookProfile, done) => {
+          try {
+            const user = await this.validateOAuthLogin(profile);
+            done(null, user);
+          } catch (err) {
+            done(err, null);
+          }
+        }
+      )
+    );
+  }
+
+  private async validateOAuthLogin(profile: GoogleProfile | FacebookProfile) {
+    const normalized = this.normalizeProfile(profile);
+
+    if (!normalized.email) {
+      throw new BadRequestException("No email found");
+    }
+
+    let user = await this.prisma.user.findUnique({
+      where: { email: normalized.email },
+      include: { roles: true },
+    });
+
+    if (!user) {
+      user = await this.prisma.user.create({
+        data: {
+          email: normalized.email,
+          firstName: normalized.firstName,
+          lastName: normalized.lastName,
+          displayName: normalized.displayName,
+          imageUrl: normalized.photo,
+          isEmailVerified: true,
+          password: null,
+          roles: { create: [{ role: "customer" }] },
+        },
+        include: { roles: true },
+      });
+
+      await this.notifyService.sendNotification({
+        userId: user.id,
+        purpose: "signup",
+        to: user.email!,
+        metadata: { user },
+      });
+    }
+
+    if (!user.password) {
+      await this.otpService.sendOtp({
+        userId: user.id,
+        purpose: "setPassword",
+        identifier: normalized.email,
+        type: "token",
+        metadata: { user },
+      });
+    }
+
+    return {
+      id: user.id,
+      roles: user.roles.map((r) => r.role),
+    };
+  }
+
+  private normalizeProfile(
+    profile: GoogleProfile | FacebookProfile
+  ): NormalizedProfile {
+    const provider = profile.provider as "google" | "facebook";
+
+    const email = profile.emails?.[0]?.value || null;
+    const displayName =
+      profile.displayName ||
+      `${profile.name?.givenName || ""} ${profile.name?.familyName || ""}`.trim();
+
+    const firstName = profile.name?.givenName || "";
+    const lastName = profile.name?.familyName || "";
+
+    const photo = profile.photos?.[0]?.value;
+
+    return {
+      provider,
+      id: profile.id,
+      email,
+      displayName,
+      firstName,
+      lastName,
+      photo,
+    };
+  }
+}

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

@@ -0,0 +1,133 @@
+import { Injectable, UnauthorizedException } from "@nestjs/common";
+import { OtpPurpose, OtpType } from "@prisma/client";
+import { PrismaService } from "@modules/prisma/prisma.service";
+import { NotificationService } from "@modules/notification/notification.service";
+import { expiryDate } from "@utils/general.util";
+import { EnvService } from "@modules/env/env.service";
+import crypto from "crypto";
+import { LoggerService } from "@modules/logger/logger.service";
+import { InjectLogger } from "@decorators/logger.decorator";
+
+interface SendOtpPayload {
+  userId: string;
+  identifier: string;
+  purpose: OtpPurpose;
+  type?: OtpType;
+  notify?: boolean;
+  metadata?: Record<string, any>;
+}
+
+interface verifyOtpPayload {
+  userId: string;
+  secret: string;
+  purpose: OtpPurpose;
+  type?: OtpType;
+}
+
+@Injectable()
+export class OtpService {
+  @InjectLogger()
+  private readonly logger!: LoggerService;
+
+  constructor(
+    private readonly prisma: PrismaService,
+    private readonly notifyService: NotificationService,
+    private readonly env: EnvService
+  ) {}
+
+  async sendOtp({
+    userId,
+    identifier,
+    purpose,
+    type = "otp",
+    notify = true,
+    metadata,
+  }: SendOtpPayload) {
+    let otp = await this.prisma.otp.findFirst({
+      where: {
+        userId,
+        purpose,
+        type,
+        usedAt: null,
+        expiresAt: { gt: new Date() },
+      },
+    });
+
+    if (!otp) {
+      otp = await this.prisma.otp.create({
+        data: {
+          userId,
+          purpose,
+          type,
+          secret: this.generateSecret(type),
+          expiresAt: expiryDate(this.env.get("OTP_EXP"), true),
+        },
+      });
+    }
+
+    this.logger.log(`🔢 OTP generated`, {
+      userId,
+      purpose,
+      type,
+      expiresAt: otp.expiresAt,
+      context: OtpService.name,
+    });
+
+    if (!notify) return otp;
+
+    await this.notifyService.sendNotification({
+      userId: userId,
+      purpose,
+      to: identifier,
+      metadata: { otp, identifier, ...metadata },
+    });
+
+    return otp;
+  }
+
+  async verifyOtp({ userId, secret, purpose, type = "otp" }: verifyOtpPayload) {
+    const otp = await this.prisma.otp.findFirst({
+      where: {
+        userId,
+        secret,
+        purpose,
+        type,
+        usedAt: null,
+        expiresAt: { gt: new Date() },
+      },
+    });
+
+    if (!otp) {
+      this.logger.warn(`Invalid OTP`, {
+        userId,
+        purpose,
+        context: OtpService.name,
+      });
+      throw new UnauthorizedException("Invalid OTP");
+    }
+
+    await this.prisma.otp.update({
+      where: { id: otp.id },
+      data: { usedAt: new Date() },
+    });
+
+    this.logger.log(`✅ OTP verified`, {
+      userId,
+      purpose,
+      context: OtpService.name,
+    });
+
+    return otp;
+  }
+
+  private generateSecret(type: OtpType, prefix = "") {
+    switch (type) {
+      case "token":
+        return `${prefix}${crypto.randomBytes(32).toString("hex")}`;
+      case "otp":
+        return crypto.randomInt(100000, 999999).toString();
+      default:
+        throw new Error(`Unsupported type: ${type}`);
+    }
+  }
+}

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

@@ -0,0 +1,99 @@
+import { BadRequestException, Injectable } from "@nestjs/common";
+import { PrismaService } from "@modules/prisma/prisma.service";
+import { LoggerService } from "@modules/logger/logger.service";
+import { InjectLogger } from "@decorators/logger.decorator";
+import { UserRole } from "@generated/prisma";
+
+@Injectable()
+export class RoleService {
+  @InjectLogger()
+  private readonly logger!: LoggerService;
+
+  constructor(private readonly prisma: PrismaService) {}
+
+  /** Assign a role to a user */
+  async assignRole(userId: string, role: UserRole) {
+    const existing = await this.prisma.roleAssignment.findFirst({
+      where: { userId, role },
+    });
+
+    if (existing) {
+      throw new BadRequestException(`User already has role '${role}'.`);
+    }
+
+    const newRole = await this.prisma.roleAssignment.create({
+      data: { userId, role },
+    });
+
+    this.logger.log(`✅ Role '${role}' assigned to user ${userId}`, {
+      userId,
+      role,
+    });
+
+    return {
+      message: `Role '${role}' assigned successfully.`,
+      data: { newRole },
+    };
+  }
+
+  /** Revoke a role from a user */
+  async revokeRole(userId: string, role: UserRole) {
+    const roleRecord = await this.prisma.roleAssignment.findFirst({
+      where: { userId, role },
+    });
+
+    if (!roleRecord) {
+      throw new BadRequestException(`User does not have role '${role}'.`);
+    }
+
+    await this.prisma.roleAssignment.delete({
+      where: { id: roleRecord.id },
+    });
+
+    this.logger.log(`🚫 Role '${role}' revoked from user ${userId}`, {
+      userId,
+      role,
+    });
+
+    return { message: `Role '${role}' revoked successfully.` };
+  }
+
+  /** Get all roles for a user */
+  async getUserRoles(userId: string) {
+    const roles = await this.prisma.roleAssignment.findMany({
+      where: { userId },
+      select: { role: true },
+    });
+
+    const list = roles.map((r) => r.role);
+
+    return {
+      message: `Roles fetched successfully.`,
+      data: { userId, roles: list },
+    };
+  }
+
+  /** Check if user has specific role */
+  async hasRole(userId: string, role: UserRole) {
+    const existing = await this.prisma.roleAssignment.findFirst({
+      where: { userId, role },
+    });
+    return !!existing;
+  }
+
+  /** Update user's roles in bulk (sync) */
+  async syncRoles(userId: string, roles: UserRole[]) {
+    await this.prisma.roleAssignment.deleteMany({ where: { userId } });
+
+    await this.prisma.roleAssignment.createMany({
+      data: roles.map((r) => ({ userId, role: r })),
+    });
+
+    this.logger.log(`🔄 Roles synced for user ${userId}`, {
+      userId,
+      roles,
+    });
+
+    return { message: "User roles synced successfully.", data: { roles } };
+  }
+}

package/templates/monorepo-starter/server/src/modules/auth/security-setting.service.ts

@@ -0,0 +1,102 @@
+import {
+  BadRequestException,
+  Injectable,
+  NotFoundException,
+} from "@nestjs/common";
+import { PrismaService } from "@modules/prisma/prisma.service";
+import { LoggerService } from "@modules/logger/logger.service";
+import { InjectLogger } from "@decorators/logger.decorator";
+import crypto from "crypto";
+import { expiryDate } from "@utils/general.util";
+import type { Request } from "express";
+import type {
+  UpdateSecuritySettingDto,
+  VerifyBackupCodeDto,
+} from "@dto/security-setting.dto";
+
+@Injectable()
+export class SecuritySettingService {
+  @InjectLogger()
+  private readonly logger!: LoggerService;
+  constructor(private readonly prisma: PrismaService) {}
+
+  async generateBackupCodes(req: Request) {
+    const userId = req.user!.id;
+    const count = 8;
+
+    const codes = Array.from({ length: count }).map(() =>
+      crypto.randomBytes(6).toString("hex").toUpperCase()
+    );
+
+    await this.prisma.backupCode.deleteMany({ where: { userId } });
+
+    await this.prisma.backupCode.createMany({
+      data: codes.map((code) => ({
+        userId,
+        code,
+        isUsed: false,
+        expiresAt: expiryDate("7d", true),
+      })),
+    });
+
+    this.logger.log("🔢 Backup codes generated", {
+      userId,
+      count,
+    });
+
+    return { message: "Backup Codes Generated Successfully", data: { codes } };
+  }
+
+  async verifyBackupCode(dto: VerifyBackupCodeDto, req: Request) {
+    const userId = req.user!.id;
+
+    const backup = await this.prisma.backupCode.findFirst({
+      where: { userId, code: dto.code, usedAt: null },
+    });
+
+    if (!backup) {
+      throw new BadRequestException("Invalid or used backup code.");
+    }
+
+    await this.prisma.backupCode.update({
+      where: { id: backup.id },
+      data: { usedAt: new Date() },
+    });
+
+    this.logger.log("✅ Backup code used successfully", {
+      userId,
+      code: dto.code,
+    });
+
+    return { message: "Backup code verified successfully." };
+  }
+
+  async getBackupCodes(req: Request) {
+    const userId = req.user!.id;
+
+    const codes = await this.prisma.backupCode.findMany({
+      where: { userId, usedAt: null },
+      select: { code: true },
+    });
+
+    if (!codes.length) {
+      throw new NotFoundException("No active backup codes found.");
+    }
+
+    return {
+      message: "Backup codes fetched successfully.",
+      data: { codes: codes.map((c) => c.code) },
+    };
+  }
+
+  async updateSecuritySetting(dto: UpdateSecuritySettingDto, req: Request) {
+    const userId = req.user!.id;
+
+    await this.prisma.securitySetting.update({
+      where: { userId },
+      data: dto,
+    });
+
+    return { message: "Recovery information updated successfully." };
+  }
+}

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

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

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

@@ -0,0 +1,22 @@
+import { Injectable } from "@nestjs/common";
+import { ConfigService } from "@nestjs/config";
+import type { EnvSchema } from "@schemas/env.schema";
+import { LoggerService } from "@modules/logger/logger.service";
+import { InjectLogger } from "@decorators/logger.decorator";
+
+@Injectable()
+export class EnvService {
+  @InjectLogger()
+  private readonly logger!: LoggerService;
+
+  constructor(private readonly config: ConfigService<EnvSchema>) {}
+
+  get<K extends keyof EnvSchema>(key: K): EnvSchema[K] {
+    const value = this.config.get(key);
+    if (value === undefined) {
+      this.logger.warn(`Missing env key: ${String(key)}`);
+      throw new Error(`Missing env key: ${String(key)}`);
+    }
+    return value;
+  }
+}

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

@@ -0,0 +1,12 @@
+import { Global, Module } from "@nestjs/common";
+import { WinstonModule } from "nest-winston";
+import { winstonConfig } from "./winston.config";
+import { LoggerService } from "./logger.service";
+
+@Global()
+@Module({
+  imports: [WinstonModule.forRoot(winstonConfig)],
+  providers: [LoggerService],
+  exports: [LoggerService],
+})
+export class LoggerModule {}

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

@@ -0,0 +1,37 @@
+import { Inject, Injectable, Scope } from "@nestjs/common";
+import { WINSTON_MODULE_PROVIDER } from "nest-winston";
+import type { Logger } from "winston";
+
+@Injectable({ scope: Scope.TRANSIENT })
+export class LoggerService {
+  private context?: string;
+
+  constructor(
+    @Inject(WINSTON_MODULE_PROVIDER)
+    private readonly winston: Logger
+  ) {}
+
+  setContext(context: string) {
+    this.context = context;
+  }
+
+  private withContext(meta: Record<string, any> = {}) {
+    return this.context ? { context: this.context, ...meta } : meta;
+  }
+
+  log(message: string, meta: Record<string, any> = {}) {
+    this.winston.info(message, this.withContext(meta));
+  }
+
+  error(message: string, meta: Record<string, any> = {}) {
+    this.winston.error(message, this.withContext(meta));
+  }
+
+  warn(message: string, meta: Record<string, any> = {}) {
+    this.winston.warn(message, this.withContext(meta));
+  }
+
+  debug(message: string, meta: Record<string, any> = {}) {
+    this.winston.debug(message, this.withContext(meta));
+  }
+}

package/templates/monorepo-starter/server/src/modules/logger/winston.config.ts

@@ -0,0 +1,32 @@
+import * as winston from "winston";
+import "winston-daily-rotate-file";
+import { utilities } from "nest-winston";
+
+export const winstonConfig = {
+  transports: [
+    new winston.transports.Console({
+      format: winston.format.combine(
+        winston.format.timestamp(),
+        utilities.format.nestLike("EcomApp", { prettyPrint: true })
+      ),
+    }),
+    new winston.transports.DailyRotateFile({
+      dirname: "logs",
+      filename: "app-%DATE%.log",
+      datePattern: "DD-MM-YYYY",
+      zippedArchive: true,
+      maxSize: "20m",
+      maxFiles: "14d",
+      level: "info",
+    }),
+    new winston.transports.DailyRotateFile({
+      dirname: "logs",
+      filename: "error-%DATE%.log",
+      datePattern: "DD-MM-YYYY",
+      zippedArchive: true,
+      maxSize: "20m",
+      maxFiles: "30d",
+      level: "error",
+    }),
+  ],
+};

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

@@ -0,0 +1,11 @@
+import { Global, Module } from "@nestjs/common";
+import { NotificationService } from "./notification.service";
+import { TemplateModule } from "@modules/template/template.module";
+
+@Global()
+@Module({
+  imports: [TemplateModule],
+  providers: [NotificationService],
+  exports: [NotificationService],
+})
+export class NotificationModule {}