create-zhx-monorepo 0.2.2 → 2.0.0

package/templates/monorepo-starter/server/src/lib/guards/oauth.guard.ts

@@ -0,0 +1,28 @@
+import {
+  BadRequestException,
+  mixin,
+  type Type,
+  type ExecutionContext,
+} from "@nestjs/common";
+import { AuthGuard } from "@nestjs/passport";
+
+export type OAuthProvider = "google" | "facebook";
+
+export function OAuthGuard(provider: OAuthProvider): Type<any> {
+  class OAuthGuardMixin extends AuthGuard(provider) {
+    getAuthenticateOptions(context: ExecutionContext) {
+      const req = context.switchToHttp().getRequest();
+      const clientUrl = req.query.clientUrl;
+
+      if (typeof clientUrl !== "string") {
+        throw new BadRequestException("clientUrl is required");
+      }
+
+      return {
+        state: Buffer.from(clientUrl).toString("base64"),
+      };
+    }
+  }
+
+  return mixin(OAuthGuardMixin);
+}

package/templates/monorepo-starter/server/src/lib/interceptors/response.interceptor.ts

@@ -3,8 +3,11 @@ import {
   type NestInterceptor,
   type ExecutionContext,
   type CallHandler,
+  StreamableFile,
 } from "@nestjs/common";
 import { Observable, map } from "rxjs";
+import isPlainObject from "lodash/isPlainObject.js";
+import { Decimal } from "@prisma/client/runtime/client";
 
 @Injectable()
 export class ResponseInterceptor implements NestInterceptor {
@@ -13,21 +16,55 @@ export class ResponseInterceptor implements NestInterceptor {
 
     return next.handle().pipe(
       map((res) => {
-        if (!res || typeof res !== "object" || res instanceof Response) {
+        if (
+          !res ||
+          typeof res !== "object" ||
+          res instanceof StreamableFile ||
+          Buffer.isBuffer(res)
+        ) {
           return res;
         }
 
+        const action = res.action;
         const statusCode = response.statusCode;
-        const { data = null, message = "Success", ...meta } = res || {};
+        const { data = null, message = "Success", meta = null } = res || {};
 
         return {
           status: statusCode,
           success: statusCode >= 200 && statusCode < 300,
           message,
-          data,
-          ...(Object.keys(meta).length ? { meta } : {}),
+          data: this.sanitizeResponse(data),
+          action,
+          meta,
         };
-      })
+      }),
     );
   }
+
+  private sanitizeResponse<T>(value: T): T {
+    if (value === null || value === undefined) {
+      return undefined as T;
+    }
+
+    if (Array.isArray(value)) {
+      return value.map((item) => this.sanitizeResponse(item)) as T;
+    }
+
+    if (isPlainObject(value)) {
+      const result: Record<string, unknown> = {};
+      for (const [key, val] of Object.entries(value)) {
+        const sanitized = this.sanitizeResponse(val);
+        if (sanitized !== undefined) {
+          result[key] = sanitized;
+        }
+      }
+      return result as T;
+    }
+
+    if (value instanceof Decimal) {
+      return (value as Decimal).toNumber() as unknown as T;
+    }
+
+    return value;
+  }
 }

package/templates/monorepo-starter/server/src/lib/middleware/cache.middleware.ts

@@ -0,0 +1,24 @@
+import type { Request, Response, NextFunction } from "express";
+import { Injectable, type NestMiddleware } from "@nestjs/common";
+
+import { EnvService } from "@/modules/env/env.service";
+import { CacheService } from "@/modules/cache/cache.service";
+
+@Injectable()
+export class CacheContextMiddleware implements NestMiddleware {
+  constructor(
+    private readonly cache: CacheService,
+    private readonly env: EnvService,
+  ) {}
+
+  async use(req: Request, _: Response, next: NextFunction) {
+    const allowedOrigins = this.env.get("CORS_ORIGIN");
+    const incomingUrl =
+      (req.headers["x-client-url"] as string) ||
+      (req.query.clientUrl as string);
+    if (incomingUrl && allowedOrigins.includes(incomingUrl)) {
+      await this.cache.set("clientUrl", incomingUrl);
+    }
+    next();
+  }
+}

package/templates/monorepo-starter/server/src/lib/schemas/env.schema.ts

@@ -20,19 +20,26 @@ export const envSchema = z.object({
   NODE_ENV: z
     .enum(["development", "production", "test"])
     .default("development"),
+
   APP_PORT: z.coerce.number(),
   APP_ENDPOINT: z.string(),
   CLIENT_ENDPOINT: z.string(),
   ADMIN_ENDPOINT: z.string(),
+
   CORS_ORIGIN: z
     .string()
     .transform((val) => val.split(",").map((origin) => origin.trim())),
 
   // ==============================
-  // Database
+  // Database / Cloud
   // ==============================
   DB_URI: z.string(),
 
+  CLOUDINARY_CLOUD_NAME: z.string(),
+  CLOUDINARY_API_KEY: z.string(),
+  CLOUDINARY_API_SECRET: z.string(),
+  CLOUDINARY_URL: z.string(),
+
   // ==============================
   // OTP Model
   // ==============================
@@ -63,11 +70,24 @@ export const envSchema = z.object({
   TWILIO_ACCOUNT_SID: z.string(),
   TWILIO_AUTH_TOKEN: z.string(),
   TWILIO_PHONE_NUMBER: z.string(),
+  TWILIO_WHATSAPP_NUMBER: z.string(),
 
   // ==============================
   // Email (Resend)
   // ==============================
-  RESEND_API_KEY: z.string(),
+  SMTP_HOST: z.string(),
+  SMTP_PORT: z.coerce.number(),
+  SMTP_USER: z.string(),
+  SMTP_PASS: z.string(),
+
+  // ==============================
+  // Firebase
+  // ==============================
+  FIREBASE_PROJECT_ID: z.string(),
+  FIREBASE_CLIENT_EMAIL: z.string(),
+  FIREBASE_PRIVATE_KEY: z
+    .string()
+    .transform((key) => key.replace(/\\n/g, "\n")),
 
   // ==============================
   // API Keys
@@ -77,18 +97,18 @@ export const envSchema = z.object({
   // ==============================
   // Admin
   // ==============================
+  ADMIN_NAME: z.string(),
   ADMIN_EMAIL: z.string(),
   ADMIN_PASSWORD: z.string(),
-  ADMIN_NAME: z.string(),
-  ADMIN_PHONE: z.string(),
 });
 
 export function validateEnv(config: Record<string, any>) {
   const parsed = envSchema.safeParse(config);
+
   if (!parsed.success) {
     console.error(
       "❌ Invalid environment variables:",
-      parsed.error.flatten().fieldErrors
+      z.flattenError(parsed.error).fieldErrors,
     );
     throw new Error("Invalid environment variables");
   }

package/templates/monorepo-starter/server/src/lib/utils/client.utils.ts

@@ -0,0 +1,95 @@
+import axios from "axios";
+import type { Request } from "express";
+import { UAParser } from "ua-parser-js";
+import { Injectable } from "@nestjs/common";
+
+import { EnvService } from "@/modules/env/env.service";
+
+export interface ClientInfo {
+  ip: string;
+  location: string;
+  isp: string;
+  timezone: string;
+
+  deviceType: string;
+  deviceInfo: string;
+}
+
+@Injectable()
+export class ClientService {
+  private ipStackKey: string;
+
+  constructor(private readonly env: EnvService) {
+    this.ipStackKey = this.env.get("IP_STACK_API_KEY");
+  }
+
+  private normalizeIp(ip: string): string {
+    if (ip.startsWith("::ffff:")) return ip.replace("::ffff:", "");
+    if (ip === "::1") return "127.0.0.1";
+    return ip;
+  }
+
+  private async getIpData(ip: string) {
+    if (!this.ipStackKey) return null;
+
+    try {
+      const url = `https://api.ipstack.com/${ip}?access_key=${this.ipStackKey}&fields=city,region_name,country_name,timezone,connection`;
+      const res = (await axios.get(url)).data;
+
+      return {
+        location: [res.city, res.region_name, res.country_name]
+          .filter(Boolean)
+          .join(", "),
+        timezone: res.timezone?.id ?? "",
+        isp: res.connection?.isp ?? "",
+      };
+    } catch {
+      return null;
+    }
+  }
+
+  async resolve(req: Request): Promise<ClientInfo> {
+    const rawIp =
+      req.headers["x-forwarded-for"]?.toString().split(",")[0] ||
+      req.headers["x-real-ip"]?.toString() ||
+      req.socket.remoteAddress ||
+      "Unknown";
+
+    const ip = this.normalizeIp(rawIp);
+
+    const ua = UAParser(req.headers["user-agent"] ?? "");
+
+    const deviceType =
+      ua.device.type ??
+      (ua.os.name === "Android" || ua.os.name === "iOS" ? "mobile" : "desktop");
+
+    const deviceInfo =
+      [ua.os.name, ua.os.version].filter(Boolean).join(" ") +
+      " · " +
+      [ua.browser.name, ua.browser.major].filter(Boolean).join(" ");
+
+    const isProd = this.env.get("NODE_ENV") === "production";
+
+    if (!isProd || ip.startsWith("127.") || ip.startsWith("192.168")) {
+      return {
+        ip,
+        location: "Local Network",
+        isp: "",
+        timezone: "UTC",
+        deviceType,
+        deviceInfo,
+      };
+    }
+
+    const geo = await this.getIpData(ip);
+
+    return {
+      ip,
+      location: geo?.location || "Unknown location",
+      isp: geo?.isp || "",
+      timezone: geo?.timezone || "UTC",
+      deviceType,
+      deviceInfo,
+    };
+  }
+}

package/templates/monorepo-starter/server/src/lib/utils/cookie.util.ts

@@ -1,6 +1,7 @@
-import { Injectable } from "@nestjs/common";
-import { EnvService } from "@modules/env/env.service";
 import type { Response, CookieOptions } from "express";
+import { Injectable } from "@nestjs/common";
+
+import { EnvService } from "@/modules/env/env.service";
 
 @Injectable()
 export class CookieService {
@@ -10,7 +11,7 @@ export class CookieService {
     res: Response,
     key: string,
     value: any,
-    options?: CookieOptions
+    options?: CookieOptions,
   ) => {
     res.cookie(key, value, {
       httpOnly: true,

package/templates/monorepo-starter/server/src/main.ts

@@ -1,13 +1,12 @@
 import { NestFactory } from "@nestjs/core";
-import { AppModule } from "@/app.module";
 import cookieParser from "cookie-parser";
-import { GlobalValidationPipe } from "@pipes/validation.pipe";
-import { AllExceptionsFilter } from "@filters/exceptions.filter";
-import { ResponseInterceptor } from "@/lib/interceptors/response.interceptor";
-import { EnvService } from "@modules/env/env.service";
-import { LoggerService } from "@modules/logger/logger.service";
 import { WinstonModule } from "nest-winston";
-import { winstonConfig } from "@modules/logger/winston.config";
+import { AppModule } from "@/app.module";
+import { EnvService } from "@/modules/env/env.service";
+import { LoggerService } from "@/modules/logger/logger.service";
+import { winstonConfig } from "@/modules/logger/winston.config";
+import { AllExceptionsFilter } from "@/filters/exceptions.filter";
+import { ResponseInterceptor } from "@/interceptors/response.interceptor";
 
 async function bootstrap() {
   const app = await NestFactory.create(AppModule, {
@@ -20,11 +19,22 @@ async function bootstrap() {
   const port = env.get("APP_PORT");
   const endpoint = env.get("APP_ENDPOINT");
   const nodeEnv = env.get("NODE_ENV");
+  const allowedOrigins = env.get("CORS_ORIGIN");
 
+  app.enableCors({
+    origin: allowedOrigins,
+    credentials: true,
+    methods: ["GET", "POST", "PUT", "PATCH", "DELETE"],
+    allowedHeaders: [
+      "Content-Type",
+      "Authorization",
+      "x-client-url",
+      "x-trusted-device",
+    ],
+  });
   app.use(cookieParser());
   app.useGlobalInterceptors(app.get(ResponseInterceptor));
   app.useGlobalFilters(app.get(AllExceptionsFilter));
-  app.useGlobalPipes(GlobalValidationPipe);
   await app.listen(port);
 
   logger.log("==========================================");
@@ -34,8 +44,8 @@ async function bootstrap() {
   logger.log(`📦 Listening on port: ${port}`);
   logger.log(`⏱️ Startup time: ${Date.now() - start}ms`);
   logger.log(
-    `🪵 Logger initialized with Winston (see logs directory if enabled)`
+    `🪵 Logger initialized with Winston (see logs directory if enabled)`,
   );
   logger.log("==========================================");
 }
-bootstrap();
+await bootstrap();

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

@@ -0,0 +1,54 @@
+import {
+  Body,
+  Controller,
+  Delete,
+  Get,
+  Param,
+  Post,
+  Put,
+  Query,
+} from "@nestjs/common";
+import { CUUserDto, UserQueryDto } from "@workspace/contracts/admin";
+
+import { AdminService } from "./admin.service";
+import { Roles } from "@/decorators/roles.decorator";
+import { BooleanQuery } from "@/decorators/boolean-query.decorator";
+
+@Roles("admin")
+@Controller("admin")
+export class AdminController {
+  constructor(private readonly adminService: AdminService) {}
+
+  @Post("users")
+  createUser(@Body() dto: CUUserDto) {
+    return this.adminService.createUser(dto);
+  }
+
+  @Get("users")
+  findAllUsers(@Query() query: UserQueryDto) {
+    return this.adminService.findAllUsers(query);
+  }
+
+  @Get("users/:userId")
+  async findUser(@Param("userId") userId: string) {
+    return this.adminService.findUser(userId);
+  }
+
+  @Put("users/:userId")
+  async updateUser(@Body() dto: CUUserDto, @Param("userId") userId: string) {
+    return this.adminService.updateUser(dto, userId);
+  }
+
+  @Delete("users/:userId")
+  async deleteUser(
+    @Param("userId") userId: string,
+    @BooleanQuery("force") force: boolean,
+  ) {
+    return this.adminService.deleteUser(userId, force);
+  }
+
+  @Post("users/:userId/restore")
+  async restoreUser(@Param("userId") userId: string) {
+    return this.adminService.restoreUser(userId);
+  }
+}

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

@@ -0,0 +1,13 @@
+import { Module } from "@nestjs/common";
+
+import { AdminService } from "./admin.service";
+import { AdminController } from "./admin.controller";
+import { AuthModule } from "@/modules/auth/auth.module";
+
+@Module({
+  imports: [AuthModule],
+  providers: [AdminService],
+  controllers: [AdminController],
+  exports: [AdminService],
+})
+export class AdminModule {}

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

@@ -0,0 +1,134 @@
+import { Injectable } from "@nestjs/common";
+import type { Prisma } from "@generated/prisma";
+
+import { AuthService } from "@/modules/auth/auth.service";
+import { PrismaService } from "@/modules/prisma/prisma.service";
+
+@Injectable()
+export class AdminService {
+  constructor(
+    private readonly prisma: PrismaService,
+    private readonly authService: AuthService,
+  ) {}
+
+  async createUser(dto: CUUserDto) {
+    const { role, ...rest } = dto;
+    const { user } = await this.authService.createUser(rest, role);
+
+    return {
+      message: "Customer created successfully",
+      data: user,
+    };
+  }
+
+  async findAllUsers(query: UserQueryDto) {
+    const {
+      page,
+      limit,
+      sortBy,
+      sortOrder,
+      search,
+      searchBy,
+      role,
+      isEmailVerified,
+      isPhoneVerified,
+    } = query;
+
+    const where: Prisma.UserWhereInput = {};
+
+    if (role) where.role = role;
+    else where.role = { not: "admin" };
+
+    if (isEmailVerified !== undefined) where.isEmailVerified = isEmailVerified;
+    if (isPhoneVerified !== undefined) where.isPhoneVerified = isPhoneVerified;
+
+    if (search && searchBy) {
+      const searchWhereMap: Record<typeof searchBy, any> = {
+        id: { id: search },
+        email: {
+          email: { contains: search, mode: "insensitive" },
+        },
+        phone: {
+          phone: { contains: search, mode: "insensitive" },
+        },
+        displayName: {
+          displayName: { contains: search, mode: "insensitive" },
+        },
+      };
+      Object.assign(where, searchWhereMap[searchBy]);
+    }
+
+    const skip = (page - 1) * limit;
+    const orderBy = { [sortBy]: sortOrder };
+
+    const [users, total] = await Promise.all([
+      this.prisma.user.findMany({
+        where,
+        skip,
+        take: limit,
+        orderBy,
+        ...this.authService.userView,
+      }),
+      this.prisma.user.count({ where }),
+    ]);
+
+    return {
+      message: "Users fetched successfully.",
+      data: {
+        users,
+        total,
+        page,
+        limit,
+        totalPages: Math.ceil(total / limit),
+      },
+    };
+  }
+
+  async findUser(userId: string) {
+    const user = await this.prisma.user.findUniqueOrThrow({
+      where: { id: userId },
+      ...this.authService.userView,
+    });
+
+    return { message: "User Fetched Successfully.", data: user };
+  }
+
+  async updateUser({ identifier, ...dto }: CUUserDto, userId: string) {
+    const { key, value } = this.authService.parseIdentifier(identifier);
+
+    let hashedPassword: string | null = null;
+
+    if (dto.password) {
+      hashedPassword = await this.authService.hashPassword(dto.password);
+    }
+
+    await this.prisma.user.update({
+      where: { id: userId },
+      data: {
+        ...dto,
+        [key]: value,
+        ...(hashedPassword && { password: hashedPassword }),
+      },
+    });
+
+    return { message: "User Updated Successfully" };
+  }
+
+  async deleteUser(userId: string, force = false) {
+    await this.prisma.user.delete({
+      where: { id: userId },
+      ...({ force } as any),
+    });
+
+    return { message: "User Deleted Successfully." };
+  }
+
+  async restoreUser(userId: string) {
+    await this.prisma.user.update({
+      where: { id: userId },
+      data: { deletedAt: null },
+    });
+
+    return { message: "User Restored Successfully." };
+  }
+}

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

@@ -1,19 +1,36 @@
-import { Body, Controller, Get, Post, Query, Req, Res } from "@nestjs/common";
-import { AuthService } from "./auth.service";
+import type { Request, Response } from "express";
+import {
+  Body,
+  Controller,
+  Delete,
+  Get,
+  Param,
+  Post,
+  Query,
+  Req,
+  Res,
+} from "@nestjs/common";
 import {
-  ChangeIdentifierDto,
+  UpdateIdentifierDto,
   RequestOtpDto,
   ResetPasswordDto,
   SignInDto,
   SignUpDto,
   ValidateOtpDto,
-} from "@dto/auth.dto";
-import type { Request, Response } from "express";
-import { Public } from "@decorators/public.decorator";
+  UpdateMfaDto,
+} from "@workspace/contracts/auth";
+
+import { AuthService } from "./auth.service";
+import { Public } from "@/decorators/public.decorator";
+import { User } from "@/decorators/user.decorator";
+import { TokenService } from "@/modules/token/token.service";
 
 @Controller("auth")
 export class AuthController {
-  constructor(private readonly authService: AuthService) {}
+  constructor(
+    private readonly authService: AuthService,
+    private readonly tokenService: TokenService,
+  ) {}
 
   @Public()
   @Post("signup")
@@ -26,17 +43,17 @@ export class AuthController {
   async signIn(
     @Body() dto: SignInDto,
     @Res({ passthrough: true }) res: Response,
-    @Req() req: Request
+    @Req() req: Request,
   ) {
     return this.authService.signIn(dto, req, res);
   }
 
   @Post("signout")
   async signOut(
+    @User("sessionId") sessionId: string,
     @Res({ passthrough: true }) res: Response,
-    @Req() req: Request
   ) {
-    return this.authService.signOut(req, res);
+    return this.authService.signOut(sessionId, res);
   }
 
   @Public()
@@ -50,7 +67,7 @@ export class AuthController {
   async validateOtp(
     @Query() dto: ValidateOtpDto,
     @Res({ passthrough: true }) res: Response,
-    @Req() req: Request
+    @Req() req: Request,
   ) {
     return this.authService.validateOtp(dto, req, res);
   }
@@ -61,14 +78,39 @@ export class AuthController {
     return this.authService.resetPassword(dto);
   }
 
-  @Post("change-identifier")
-  async changeIdentifier(@Body() dto: ChangeIdentifierDto) {
-    return this.authService.changeIdentifierReq(dto);
+  @Public()
+  @Get("verify-update-identifier")
+  async verifyUpdateIdentifier(@Query() dto: UpdateIdentifierDto) {
+    return this.authService.verifyUpdateIdentifier(dto);
   }
 
-  @Public()
-  @Get("change-identifier")
-  async verifyIdentifier(@Query() dto: ChangeIdentifierDto) {
-    return this.authService.changeIdentifier(dto);
+  @Post("request-update-identifier")
+  async requestUpdateIdentifier(@Body() dto: UpdateIdentifierDto) {
+    return this.authService.requestUpdateIdentifier(dto);
+  }
+
+  @Post("update-mfa")
+  async updateMfa(@Body() dto: UpdateMfaDto) {
+    return this.authService.updateMfa(dto);
+  }
+
+  @Get("sessions")
+  listSessions(@User() user: Express.User) {
+    return this.tokenService.getUserSessions(user);
+  }
+
+  @Delete("sessions")
+  revokeAllSessions(@User() user: Express.User) {
+    return this.tokenService.revokeAllSessions(user);
+  }
+
+  @Delete("sessions/:sessionId")
+  revokeSession(@Param("sessionId") sessionId: string) {
+    return this.tokenService.revokeSession(sessionId);
+  }
+
+  @Get("session/validate")
+  validateSession() {
+    return { message: "Session is valid." };
   }
 }