create-zhx-monorepo 0.1.0

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

@@ -0,0 +1,104 @@
+import { Injectable, UnauthorizedException } from "@nestjs/common";
+import type { CanActivate, ExecutionContext } from "@nestjs/common";
+import { Reflector } from "@nestjs/core";
+import type { Request, Response } from "express";
+import { IS_PUBLIC_KEY } from "@decorators/public.decorator";
+import { ROLES_KEY } from "@decorators/roles.decorator";
+import type { UserRole } from "@generated/prisma";
+import { TokenService } from "@modules/token/token.service";
+import { LoggerService } from "@modules/logger/logger.service";
+import { InjectLogger } from "@decorators/logger.decorator";
+
+@Injectable()
+export class AuthGuard implements CanActivate {
+  @InjectLogger()
+  private readonly logger!: LoggerService;
+
+  constructor(
+    private readonly tokenService: TokenService,
+    private readonly reflector: Reflector
+  ) {}
+
+  async canActivate(context: ExecutionContext): Promise<boolean> {
+    const isPublic = this.reflector.getAllAndOverride<boolean>(IS_PUBLIC_KEY, [
+      context.getHandler(),
+      context.getClass(),
+    ]);
+
+    if (isPublic) return true;
+
+    const requiredRoles = this.reflector.getAllAndOverride<UserRole[]>(
+      ROLES_KEY,
+      [context.getHandler(), context.getClass()]
+    );
+
+    const ctx = context.switchToHttp();
+    const req = ctx.getRequest<Request>();
+    const res = ctx.getResponse<Response>();
+
+    const accessToken = req.cookies["accessToken"];
+    const refreshToken = req.cookies["refreshToken"];
+
+    try {
+      if (!accessToken) {
+        this.logger.warn(`Access token missing}`, {
+          route: req.url,
+        });
+        throw new Error("Access token is missing or expired");
+      }
+      const decoded = await this.tokenService.verifyToken(
+        accessToken,
+        "access"
+      );
+      if (!decoded) throw new UnauthorizedException("Invalid Access Token");
+      this.checkRoles(decoded.roles, requiredRoles);
+      this.tokenService.attachDecodedUser(req, decoded);
+      this.logger.debug(`✅ User Attached - Auth success`, {
+        userId: decoded.sub,
+      });
+      return true;
+    } catch (err) {
+      if (!refreshToken)
+        throw new UnauthorizedException("Refresh token is missing");
+
+      try {
+        const decoded = await this.tokenService.verifyToken(
+          refreshToken,
+          "refresh"
+        );
+        if (!decoded) throw new Error("Invalid or expire Refresh Token");
+        this.logger.debug(`Refresh token verified`, {
+          userId: decoded.sub,
+        });
+        this.checkRoles(decoded.roles, requiredRoles);
+        await this.tokenService.refreshTokens(req, res, decoded);
+
+        if (!req["user"]) throw new UnauthorizedException("User not found");
+
+        this.logger.log(`✅ Auth success`, {
+          userId: req.user?.id,
+          method: req.method,
+        });
+
+        return true;
+      } catch {
+        this.logger.warn(`Access denied: Missing or invalid token`);
+
+        throw new UnauthorizedException(
+          "Unauthorized: Invalid or expired token."
+        );
+      }
+    }
+  }
+
+  private checkRoles(userRoles: UserRole[], requiredRoles?: UserRole[]) {
+    if (requiredRoles?.length) {
+      const hasRole = userRoles.some((role) => requiredRoles.includes(role));
+      if (!hasRole) {
+        throw new UnauthorizedException(
+          `Forbidden: Requires ${requiredRoles.join(", ")} access.`
+        );
+      }
+    }
+  }
+}

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

@@ -0,0 +1,33 @@
+import {
+  Injectable,
+  type NestInterceptor,
+  type ExecutionContext,
+  type CallHandler,
+} from "@nestjs/common";
+import { Observable, map } from "rxjs";
+
+@Injectable()
+export class ResponseInterceptor implements NestInterceptor {
+  intercept(context: ExecutionContext, next: CallHandler): Observable<any> {
+    const response = context.switchToHttp().getResponse();
+
+    return next.handle().pipe(
+      map((res) => {
+        if (!res || typeof res !== "object" || res instanceof Response) {
+          return res;
+        }
+
+        const statusCode = response.statusCode;
+        const { data = null, message = "Success", ...meta } = res || {};
+
+        return {
+          status: statusCode,
+          success: statusCode >= 200 && statusCode < 300,
+          message,
+          data,
+          ...(Object.keys(meta).length ? { meta } : {}),
+        };
+      })
+    );
+  }
+}

package/templates/monorepo-starter/server/src/lib/pipes/validation.pipe.ts

@@ -0,0 +1,7 @@
+import { ValidationPipe } from "@nestjs/common";
+
+export const GlobalValidationPipe = new ValidationPipe({
+  whitelist: true,
+  forbidNonWhitelisted: true,
+  transform: true,
+});

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

@@ -0,0 +1,99 @@
+import { z } from "zod";
+import ms, { type StringValue } from "ms";
+
+const zMsString = z
+  .string()
+  .transform((val) => val as StringValue)
+  .refine((val) => {
+    try {
+      const parsed = ms(val);
+      return typeof parsed === "number" && parsed > 0;
+    } catch {
+      return false;
+    }
+  }, "Invalid ms() duration string");
+
+export const envSchema = z.object({
+  // ==============================
+  // App Config
+  // ==============================
+  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
+  // ==============================
+  DB_URI: z.string(),
+
+  // ==============================
+  // OTP Model
+  // ==============================
+  OTP_EXP: zMsString,
+
+  // ==============================
+  // Auth
+  // ==============================
+  JWT_ACCESS_SECRET: z.string(),
+  JWT_REFRESH_SECRET: z.string(),
+  ACCESS_TOKEN_EXP: zMsString,
+  REFRESH_TOKEN_EXP: zMsString,
+
+  // ==============================
+  // OAuth Providers
+  // ==============================
+  GOOGLE_CLIENT_ID: z.string(),
+  GOOGLE_CLIENT_SECRET: z.string(),
+  GOOGLE_CALLBACK_URL: z.string(),
+
+  FACEBOOK_CLIENT_ID: z.string(),
+  FACEBOOK_CLIENT_SECRET: z.string(),
+  FACEBOOK_CALLBACK_URL: z.string(),
+
+  // ==============================
+  // SMS (Twilio)
+  // ==============================
+  TWILIO_ACCOUNT_SID: z.string(),
+  TWILIO_AUTH_TOKEN: z.string(),
+  TWILIO_PHONE_NUMBER: z.string(),
+
+  // ==============================
+  // Email (Resend)
+  // ==============================
+  RESEND_API_KEY: z.string(),
+
+  // ==============================
+  // API Keys
+  // ==============================
+  IP_STACK_API_KEY: z.string(),
+
+  // ==============================
+  // Admin
+  // ==============================
+  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
+    );
+    throw new Error("Invalid environment variables");
+  }
+
+  return parsed.data;
+}
+
+export type EnvSchema = z.infer<typeof envSchema>;

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

@@ -0,0 +1,23 @@
+import { Injectable } from "@nestjs/common";
+import { EnvService } from "@modules/env/env.service";
+import type { Response, CookieOptions } from "express";
+
+@Injectable()
+export class CookieService {
+  constructor(private readonly env: EnvService) {}
+
+  setCookie = (
+    res: Response,
+    key: string,
+    value: any,
+    options?: CookieOptions
+  ) => {
+    res.cookie(key, value, {
+      httpOnly: true,
+      secure: this.env.get("NODE_ENV") === "production",
+      sameSite: "strict",
+      path: "/",
+      ...options,
+    });
+  };
+}

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

@@ -0,0 +1,24 @@
+import ms, { type StringValue } from "ms";
+
+export const slugify = (str: string, slug?: string) => {
+  const base = slug && slug.trim().length > 0 ? slug : str;
+
+  return base
+    .toLowerCase()
+    .replace(/\s+/g, "-") // replace spaces with dashes
+    .replace(/[^\w\-]+/g, "") // remove invalid chars
+    .replace(/\-\-+/g, "-") // collapse multiple dashes
+    .replace(/^-+/, "") // trim starting dash
+    .replace(/-+$/, ""); // trim ending dash
+};
+
+export const parseExpiry = (exp: string, future = false): number => {
+  const val = ms(exp as StringValue);
+  if (future) return Date.now() + val;
+  return val;
+};
+
+export const expiryDate = (exp: string, future = false): Date => {
+  const val = parseExpiry(exp, future);
+  return new Date(val);
+};

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

@@ -0,0 +1,41 @@
+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";
+
+async function bootstrap() {
+  const app = await NestFactory.create(AppModule, {
+    logger: WinstonModule.createLogger(winstonConfig),
+  });
+  const env = app.get(EnvService);
+  const logger = await app.resolve(LoggerService);
+
+  const start = Date.now();
+  const port = env.get("APP_PORT");
+  const endpoint = env.get("APP_ENDPOINT");
+  const nodeEnv = env.get("NODE_ENV");
+
+  app.use(cookieParser());
+  app.useGlobalInterceptors(app.get(ResponseInterceptor));
+  app.useGlobalFilters(app.get(AllExceptionsFilter));
+  app.useGlobalPipes(GlobalValidationPipe);
+  await app.listen(port);
+
+  logger.log("==========================================");
+  logger.log(`🚀 Server started successfully!`);
+  logger.log(`🌐 Endpoint: ${endpoint}`);
+  logger.log(`🔒 Environment: ${nodeEnv}`);
+  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.log("==========================================");
+}
+bootstrap();

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

@@ -0,0 +1,74 @@
+import { Body, Controller, Get, Post, Query, Req, Res } from "@nestjs/common";
+import { AuthService } from "./auth.service";
+import {
+  ChangeIdentifierDto,
+  RequestOtpDto,
+  ResetPasswordDto,
+  SignInDto,
+  SignUpDto,
+  ValidateOtpDto,
+} from "@dto/auth.dto";
+import type { Request, Response } from "express";
+import { Public } from "@decorators/public.decorator";
+
+@Controller("auth")
+export class AuthController {
+  constructor(private readonly authService: AuthService) {}
+
+  @Public()
+  @Post("signup")
+  async signUp(@Body() dto: SignUpDto) {
+    return this.authService.signUp(dto);
+  }
+
+  @Public()
+  @Post("signin")
+  async signIn(
+    @Body() dto: SignInDto,
+    @Res({ passthrough: true }) res: Response,
+    @Req() req: Request
+  ) {
+    return this.authService.signIn(dto, req, res);
+  }
+
+  @Post("signout")
+  async signOut(
+    @Res({ passthrough: true }) res: Response,
+    @Req() req: Request
+  ) {
+    return this.authService.signOut(req, res);
+  }
+
+  @Public()
+  @Post("request-otp")
+  async requestOtp(@Body() dto: RequestOtpDto) {
+    return this.authService.requestOtp(dto);
+  }
+
+  @Public()
+  @Get("validate-otp")
+  async validateOtp(
+    @Query() dto: ValidateOtpDto,
+    @Res({ passthrough: true }) res: Response,
+    @Req() req: Request
+  ) {
+    return this.authService.validateOtp(dto, req, res);
+  }
+
+  @Public()
+  @Post("reset-password")
+  async resetPassword(@Body() dto: ResetPasswordDto) {
+    return this.authService.resetPassword(dto);
+  }
+
+  @Post("change-identifier")
+  async changeIdentifier(@Body() dto: ChangeIdentifierDto) {
+    return this.authService.changeIdentifierReq(dto);
+  }
+
+  @Public()
+  @Get("change-identifier")
+  async verifyIdentifier(@Query() dto: ChangeIdentifierDto) {
+    return this.authService.changeIdentifier(dto);
+  }
+}

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

@@ -0,0 +1,16 @@
+import { Module } from "@nestjs/common";
+import { OtpService } from "./otp.service";
+import { AuthService } from "./auth.service";
+import { OAuthService } from "./oauth.service";
+import { AuthController } from "./auth.controller";
+import { OAuthController } from "./oauth.controller";
+import { PassportModule } from "@nestjs/passport";
+import { TokenModule } from "@modules/token/token.module";
+
+@Module({
+  imports: [TokenModule, PassportModule],
+  controllers: [AuthController, OAuthController],
+  providers: [AuthService, OtpService, OAuthService],
+  exports: [AuthService],
+})
+export class AuthModule {}