create-zhx-monorepo 0.2.2 → 2.0.0

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

@@ -1,58 +1,80 @@
-import { Controller, Get, Req, Res, UseGuards } from "@nestjs/common";
+import {
+  Get,
+  Req,
+  Res,
+  UseGuards,
+  Controller,
+  BadRequestException,
+} from "@nestjs/common";
 import { AuthGuard } from "@nestjs/passport";
-import { Public } from "@decorators/public.decorator";
 import type { Request, Response } from "express";
-import { TokenService } from "@modules/token/token.service";
-import { PrismaService } from "@modules/prisma/prisma.service";
+
+import { AuthService } from "./auth.service";
+import { UseOAuthGuard } from "@/decorators/oauth.decorator";
+import { TokenService } from "@/modules/token/token.service";
+import { PrismaService } from "@/modules/prisma/prisma.service";
 
 @Controller("oauth")
 export class OAuthController {
   constructor(
+    private readonly prisma: PrismaService,
     private readonly tokenService: TokenService,
-    private readonly prisma: PrismaService
+    private readonly authService: AuthService,
   ) {}
 
-  @Public()
+  // ===== GOOGLE =====
+
   @Get("google")
-  @UseGuards(AuthGuard("google"))
+  @UseOAuthGuard("google")
   googleLogin() {}
 
-  @Public()
   @Get("google/callback")
   @UseGuards(AuthGuard("google"))
-  async googleCallback(
-    @Req() req: Request,
-    @Res({ passthrough: true }) res: Response
-  ) {
-    const user = req.user!;
-    await this.tokenService.createAuthSession(req, res, user);
-    await this.prisma.user.update({
-      where: { id: user.id },
-      data: { lastLoginAt: new Date() },
-    });
-
-    return res.redirect("/");
+  googleCallback(@Req() req: Request, @Res() res: Response) {
+    return this.handleOAuthCallback(req, res);
   }
 
-  @Public()
+  // ===== FACEBOOK =====
+
   @Get("facebook")
-  @UseGuards(AuthGuard("facebook"))
+  @UseOAuthGuard("facebook")
   facebookLogin() {}
 
-  @Public()
   @Get("facebook/callback")
   @UseGuards(AuthGuard("facebook"))
-  async facebookCallback(
-    @Req() req: Request,
-    @Res({ passthrough: true }) res: Response
-  ) {
+  facebookCallback(@Req() req: Request, @Res() res: Response) {
+    return this.handleOAuthCallback(req, res);
+  }
+
+  // ===== SHARED =====
+
+  private async handleOAuthCallback(req: Request, res: Response) {
     const user = req.user!;
+    const redirectUrl = this.extractRedirectUrl(req);
+
+    this.authService.checkUserStatus(user.status);
+
     await this.tokenService.createAuthSession(req, res, user);
+
     await this.prisma.user.update({
       where: { id: user.id },
       data: { lastLoginAt: new Date() },
     });
 
-    return res.redirect("/");
+    return res.redirect(redirectUrl);
+  }
+
+  private extractRedirectUrl(req: Request): string {
+    const state = req.query.state;
+
+    if (typeof state !== "string") {
+      throw new BadRequestException("Invalid OAuth state");
+    }
+
+    try {
+      return Buffer.from(state, "base64").toString("utf-8");
+    } catch {
+      throw new BadRequestException("Invalid OAuth state encoding");
+    }
   }
 }

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

@@ -12,19 +12,21 @@ 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 { slugify } from "@workspace/shared/utils";
+
 import { OtpService } from "./otp.service";
-import { NotificationService } from "@modules/notification/notification.service";
+import { EnvService } from "@/modules/env/env.service";
+import { PrismaService } from "@/modules/prisma/prisma.service";
+import { NotificationService } from "@/modules/notification/notification.service";
 
-interface NormalizedProfile {
-  provider: "google" | "facebook";
+interface OAuthProfile {
+  provider: OAuthProvider;
   id: string;
   email: string | null;
-  displayName: string;
   firstName: string;
   lastName: string;
-  photo?: string;
+  displayName: string;
+  imageUrl?: string;
 }
 
 @Injectable()
@@ -33,7 +35,7 @@ export class OAuthService implements OnModuleInit {
     private readonly prisma: PrismaService,
     private readonly otpService: OtpService,
     private readonly env: EnvService,
-    private readonly notifyService: NotificationService
+    private readonly notifyService: NotificationService,
   ) {}
 
   onModuleInit() {
@@ -58,8 +60,8 @@ export class OAuthService implements OnModuleInit {
           } catch (err) {
             done(err, false);
           }
-        }
-      )
+        },
+      ),
     );
   }
 
@@ -72,7 +74,6 @@ export class OAuthService implements OnModuleInit {
           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 {
@@ -81,8 +82,8 @@ export class OAuthService implements OnModuleInit {
           } catch (err) {
             done(err, null);
           }
-        }
-      )
+        },
+      ),
     );
   }
 
@@ -95,7 +96,6 @@ export class OAuthService implements OnModuleInit {
 
     let user = await this.prisma.user.findUnique({
       where: { email: normalized.email },
-      include: { roles: true },
     });
 
     if (!user) {
@@ -105,44 +105,69 @@ export class OAuthService implements OnModuleInit {
           firstName: normalized.firstName,
           lastName: normalized.lastName,
           displayName: normalized.displayName,
-          imageUrl: normalized.photo,
           isEmailVerified: true,
           password: null,
-          roles: { create: [{ role: "customer" }] },
+          role: "customer",
         },
-        include: { roles: true },
       });
 
       await this.notifyService.sendNotification({
-        userId: user.id,
-        purpose: "signup",
+        purpose: "authSignUp",
         to: user.email!,
-        metadata: { user },
+        meta: { user },
+      });
+    }
+
+    if (normalized.imageUrl) {
+      await this.prisma.media.upsert({
+        where: {
+          url: normalized.imageUrl,
+        },
+        create: {
+          type: "photo",
+          url: normalized.imageUrl,
+          filename: `${slugify(normalized.displayName)}-avatar`,
+          title: `${slugify(normalized.displayName)}-avatar`,
+          mimeType: "image/jpeg",
+          size: 0,
+          hash: crypto.randomUUID(),
+          uploadedById: user.id,
+        },
+        update: {
+          url: normalized.imageUrl,
+          filename: `${slugify(normalized.displayName)}-avatar`,
+          mimeType: "image/jpeg",
+          size: 0,
+          hash: crypto.randomUUID(),
+          uploadedById: user.id,
+        },
       });
     }
 
-    if (!user.password) {
+    const { password, ...rest } = user;
+
+    if (!password) {
       await this.otpService.sendOtp({
-        userId: user.id,
-        purpose: "setPassword",
+        purpose: "authSetPassword",
         identifier: normalized.email,
-        type: "token",
-        metadata: { user },
+        type: "secureToken",
+        meta: { user: rest },
       });
     }
 
     return {
-      id: user.id,
-      roles: user.roles.map((r) => r.role),
+      id: rest.id,
+      role: user.role,
+      status: user.status,
     };
   }
 
   private normalizeProfile(
-    profile: GoogleProfile | FacebookProfile
-  ): NormalizedProfile {
-    const provider = profile.provider as "google" | "facebook";
-
+    profile: GoogleProfile | FacebookProfile,
+  ): OAuthProfile {
+    const provider = profile.provider as OAuthProvider;
     const email = profile.emails?.[0]?.value || null;
+
     const displayName =
       profile.displayName ||
       `${profile.name?.givenName || ""} ${profile.name?.familyName || ""}`.trim();
@@ -150,16 +175,16 @@ export class OAuthService implements OnModuleInit {
     const firstName = profile.name?.givenName || "";
     const lastName = profile.name?.familyName || "";
 
-    const photo = profile.photos?.[0]?.value;
+    const imageUrl = profile.photos?.[0]?.value;
 
     return {
-      provider,
       id: profile.id,
+      provider,
       email,
       displayName,
       firstName,
       lastName,
-      photo,
+      imageUrl,
     };
   }
 }

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

@@ -1,20 +1,20 @@
-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";
+import { Injectable, UnauthorizedException } from "@nestjs/common";
+import { futureDate } from "@workspace/shared/utils";
+
+import { InjectLogger } from "@/decorators/logger.decorator";
+import { PrismaService } from "@/modules/prisma/prisma.service";
+import { EnvService } from "@/modules/env/env.service";
+import { LoggerService } from "@/modules/logger/logger.service";
+import { CacheService } from "@/modules/cache/cache.service";
+import { NotificationService } from "@/modules/notification/notification.service";
 
 interface SendOtpPayload {
-  userId: string;
   identifier: string;
   purpose: OtpPurpose;
   type?: OtpType;
   notify?: boolean;
-  metadata?: Record<string, any>;
+  meta: EmailTemplateProps;
 }
 
 interface verifyOtpPayload {
@@ -32,20 +32,20 @@ export class OtpService {
   constructor(
     private readonly prisma: PrismaService,
     private readonly notifyService: NotificationService,
-    private readonly env: EnvService
+    private readonly env: EnvService,
+    private readonly cache: CacheService,
   ) {}
 
   async sendOtp({
-    userId,
     identifier,
     purpose,
-    type = "otp",
+    type = "numericCode",
     notify = true,
-    metadata,
+    meta,
   }: SendOtpPayload) {
     let otp = await this.prisma.otp.findFirst({
       where: {
-        userId,
+        userId: meta.user.id,
         purpose,
         type,
         usedAt: null,
@@ -56,36 +56,35 @@ export class OtpService {
     if (!otp) {
       otp = await this.prisma.otp.create({
         data: {
-          userId,
+          userId: meta.user.id,
           purpose,
           type,
           secret: this.generateSecret(type),
-          expiresAt: expiryDate(this.env.get("OTP_EXP"), true),
+          expiresAt: futureDate(this.env.get("OTP_EXP")),
+          meta: meta as any,
         },
       });
     }
 
-    this.logger.log(`🔢 OTP generated`, {
-      userId,
-      purpose,
-      type,
-      expiresAt: otp.expiresAt,
-      context: OtpService.name,
-    });
-
     if (!notify) return otp;
 
+    const clientUrl = (await this.cache.get("clientUrl")) as string;
+
     await this.notifyService.sendNotification({
-      userId: userId,
       purpose,
       to: identifier,
-      metadata: { otp, identifier, ...metadata },
+      meta: { otp, identifier, ...meta, clientUrl },
     });
 
     return otp;
   }
 
-  async verifyOtp({ userId, secret, purpose, type = "otp" }: verifyOtpPayload) {
+  async verifyOtp({
+    userId,
+    secret,
+    purpose,
+    type = "numericCode",
+  }: verifyOtpPayload) {
     const otp = await this.prisma.otp.findFirst({
       where: {
         userId,
@@ -111,20 +110,14 @@ export class OtpService {
       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":
+      case "secureToken":
         return `${prefix}${crypto.randomBytes(32).toString("hex")}`;
-      case "otp":
+      case "numericCode":
         return crypto.randomInt(100000, 999999).toString();
       default:
         throw new Error(`Unsupported type: ${type}`);

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

@@ -0,0 +1,28 @@
+import KeyvRedis from "@keyv/redis";
+import { CacheModule as NestCacheModule } from "@nestjs/cache-manager";
+import {
+  Global,
+  Module,
+  type MiddlewareConsumer,
+  type NestModule,
+} from "@nestjs/common";
+
+import { CacheService } from "./cache.service";
+import { CacheContextMiddleware } from "@/middleware/cache.middleware";
+
+@Global()
+@Module({
+  imports: [
+    NestCacheModule.register({
+      store: new KeyvRedis("redis://localhost:6379"),
+      ttl: 60 * 60,
+    }),
+  ],
+  providers: [CacheService],
+  exports: [CacheService],
+})
+export class CacheModule implements NestModule {
+  configure(consumer: MiddlewareConsumer) {
+    consumer.apply(CacheContextMiddleware).forRoutes("*");
+  }
+}

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

@@ -0,0 +1,33 @@
+import type { Cache } from "cache-manager";
+import { CACHE_MANAGER } from "@nestjs/cache-manager";
+import { Inject, Injectable } from "@nestjs/common";
+
+export const CACHE_KEYS = ["clientUrl"] as const;
+
+export type CacheKeys = (typeof CACHE_KEYS)[number] | (string & {});
+
+@Injectable()
+export class CacheService {
+  constructor(@Inject(CACHE_MANAGER) private readonly cache: Cache) {}
+
+  async get<T>(key: CacheKeys): Promise<T | null> {
+    return (await this.cache.get<T>(key)) ?? null;
+  }
+
+  async set<T>(key: CacheKeys, value: T, ttl?: number) {
+    await this.cache.set(key, value, ttl);
+  }
+
+  async del(key: CacheKeys) {
+    await this.cache.del(key);
+  }
+
+  async wrap<T>(key: CacheKeys, factory: () => Promise<T>, ttl = 60 * 60) {
+    const cached = await this.get<T>(key);
+    if (cached !== null) return cached;
+
+    const value = await factory();
+    await this.set(key, value, ttl);
+    return value;
+  }
+}

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

@@ -1,8 +1,9 @@
 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";
+
+import type { EnvSchema } from "@/schemas/env.schema";
+import { InjectLogger } from "@/decorators/logger.decorator";
+import { LoggerService } from "@/modules/logger/logger.service";
 
 @Injectable()
 export class EnvService {

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

@@ -1,5 +1,6 @@
 import { Global, Module } from "@nestjs/common";
 import { WinstonModule } from "nest-winston";
+
 import { winstonConfig } from "./winston.config";
 import { LoggerService } from "./logger.service";
 

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

@@ -8,7 +8,7 @@ export class LoggerService {
 
   constructor(
     @Inject(WINSTON_MODULE_PROVIDER)
-    private readonly winston: Logger
+    private readonly winston: Logger,
   ) {}
 
   setContext(context: string) {

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

@@ -1,15 +1,20 @@
 import * as winston from "winston";
 import "winston-daily-rotate-file";
 import { utilities } from "nest-winston";
+import { appName } from "@workspace/shared/constants";
+
+const isProduction = process.env.NODE_ENV === "production";
 
 export const winstonConfig = {
   transports: [
     new winston.transports.Console({
+      level: isProduction ? "info" : "debug",
       format: winston.format.combine(
         winston.format.timestamp(),
-        utilities.format.nestLike("EcomApp", { prettyPrint: true })
+        utilities.format.nestLike(appName.short, { prettyPrint: true }),
       ),
     }),
+
     new winston.transports.DailyRotateFile({
       dirname: "logs",
       filename: "app-%DATE%.log",
@@ -19,6 +24,7 @@ export const winstonConfig = {
       maxFiles: "14d",
       level: "info",
     }),
+
     new winston.transports.DailyRotateFile({
       dirname: "logs",
       filename: "error-%DATE%.log",
@@ -29,4 +35,12 @@ export const winstonConfig = {
       level: "error",
     }),
   ],
+
+  exceptionHandlers: [
+    new winston.transports.File({ filename: "logs/exceptions.log" }),
+  ],
+
+  rejectionHandlers: [
+    new winston.transports.File({ filename: "logs/rejections.log" }),
+  ],
 };

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

@@ -0,0 +1,14 @@
+import { v2 as cloudinary } from "cloudinary";
+
+export const cloudinaryProvider = {
+  provide: "CLOUDINARY",
+  useFactory: () => {
+    cloudinary.config({
+      cloud_name: process.env.CLOUDINARY_CLOUD_NAME,
+      api_key: process.env.CLOUDINARY_API_KEY,
+      api_secret: process.env.CLOUDINARY_API_SECRET,
+    });
+
+    return cloudinary;
+  },
+};

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

@@ -0,0 +1,62 @@
+import { createHash } from "crypto";
+import * as streamifier from "streamifier";
+import { Inject, Injectable, BadRequestException } from "@nestjs/common";
+import { type UploadApiResponse, v2 as Cloudinary } from "cloudinary";
+
+import { PrismaService } from "@/modules/prisma/prisma.service";
+
+@Injectable()
+export class CloudinaryService {
+  constructor(
+    @Inject("CLOUDINARY") private readonly cloudinary: typeof Cloudinary,
+    private readonly prisma: PrismaService,
+  ) {}
+
+  async uploadFile(
+    file: Express.Multer.File,
+    folder = "posts",
+  ): Promise<{ data: UploadApiResponse; hash: string }> {
+    if (!file) throw new BadRequestException("No file provided");
+
+    const hash = createHash("sha256").update(file.buffer).digest("hex");
+
+    const existing = await this.prisma.media.findUnique({
+      where: { hash },
+    });
+
+    if (existing) {
+      throw new BadRequestException("File already uploaded");
+    }
+
+    const result = await new Promise<UploadApiResponse>((resolve, reject) => {
+      const uploadStream = this.cloudinary.uploader.upload_stream(
+        {
+          folder,
+          resource_type: "auto",
+          public_id: hash,
+          overwrite: false,
+        },
+        (error, res) => {
+          if (error) reject(error);
+          else resolve(res!);
+        },
+      );
+
+      streamifier.createReadStream(file.buffer).pipe(uploadStream);
+    });
+
+    return { data: result, hash };
+  }
+
+  async deleteFile(publicId: string) {
+    const res = await this.cloudinary.uploader.destroy(publicId, {
+      resource_type: "auto",
+    });
+
+    if (res.result !== "ok" && res.result !== "not found") {
+      throw new BadRequestException("Failed to delete file from Cloudinary");
+    }
+
+    return res;
+  }
+}