startx 0.0.1

package/packages/@repo/lib/src/notification-module/index.ts

@@ -0,0 +1,172 @@
+// import db from "@repo/db";
+// import {
+//   notificationsTable,
+//   notificationTypeEnum,
+//   userDetails,
+// } from "@repo/db/schema";
+// import { desc, eq, inArray, sql } from "drizzle-orm";
+// import { FcmPayload, PushNotificationManager } from "./push-notification.js";
+// import logger from "../logger-module/logger.js";
+
+// export type CreateNotificationPayload = {
+//   title: string;
+//   inAppTitle?: string;
+//   userId: string;
+//   description?: string;
+//   type: (typeof notificationTypeEnum.enumValues)[number][];
+//   url?: string;
+//   image?: string;
+//   data: any;
+// };
+
+// export class NotificationModule {
+//   /**
+//    * Updates the user's FCM token
+//    * @param userID the id of the user
+//    * @param fcmToken the FCM token to be updated
+//    * @throws if the update fails
+//    */
+//   static async uploadFcmToken(userID: string, fcmToken: string) {
+//     try {
+//       await db
+//         .update(userDetails)
+//         .set({ fcmToken })
+//         .where(eq(userDetails.userId, userID));
+//     } catch (error) {
+//       throw error;
+//     }
+//   }
+//   /**
+//    * Mark the given notification IDs as read
+//    * @param notificationIds the IDs of the notifications to mark as read
+//    * @throws if the update fails
+//    */
+//   static async markAsRead(notificationIds: string[]) {
+//     try {
+//       await db
+//         .update(notificationsTable)
+//         .set({ read: true })
+//         .where(inArray(notificationsTable.id, notificationIds));
+//     } catch (error) {
+//       throw error;
+//     }
+//   }
+//   /**
+//    * Send a notification to a user
+//    * @param payload the notification payload
+//    * @throws if either the in-app notification or the push notification fails
+//    */
+//   static async sendNotification(
+//     payload: CreateNotificationPayload,
+//     options: { push?: boolean; inApp?: boolean } = { push: true, inApp: true }
+//   ) {
+//     try {
+//       if (options.inApp)
+//         await NotificationModule.sendInAppNotification(payload);
+//       if (options.push) await NotificationModule.sendPushNotification(payload);
+//     } catch (error) {
+//       throw error;
+//     }
+//   }
+//   /**
+//    * Sends an in-app notification by inserting a new record into the notifications table.
+//    *
+//    * @param payload - The notification payload containing details such as title, userId, description, type, url, image, and data.
+//    * @throws if the database insert operation fails
+//    */
+
+//   static async sendInAppNotification(payload: CreateNotificationPayload) {
+//     await db.insert(notificationsTable).values({
+//       title: payload.inAppTitle || payload.title,
+//       userId: payload.userId,
+//       // description: payload.description,
+//       type: payload.type,
+//       url: payload.url,
+//       image: payload.image,
+//       data: { ...payload.data, url: payload.url, type: payload.type },
+//     });
+//   }
+
+//   /**
+//    * Sends a push notification using the FCM token associated with the given user ID.
+//    *
+//    * @param payload - The notification payload containing details such as title, userId, description, type, url, image, and data.
+//    * @throws if the database query for the FCM token fails or if the FCM token is not found
+//    */
+//   static async sendPushNotification(payload: CreateNotificationPayload) {
+//     const [user] = await db
+//       .select({
+//         fcmToken: userDetails.fcmToken,
+//         allowNotifications: userDetails.notifications,
+//       })
+//       .from(userDetails)
+//       .where(eq(userDetails.userId, payload.userId));
+//     if (!user?.fcmToken) {
+//       logger.error("No FCM token found");
+//       return;
+//     }
+//     if (!user.allowNotifications) {
+//       logger.info("User does not allow notifications");
+//       return;
+//     }
+//     PushNotificationManager.sendNotification([
+//       {
+//         notification: {
+//           body: payload.description,
+//           title: removeCurlyBraces(payload.title),
+//         },
+//         token: user.fcmToken,
+//         data: {
+//           ...payload.data,
+//           url: payload.url,
+//           type: JSON.stringify(payload.type),
+//         },
+//       },
+//     ]);
+//   }
+
+//   static async sendBulkNotification(
+//     userIds: string[],
+//     payload: Omit<CreateNotificationPayload, "userId">
+//   ) {
+//     await db.insert(notificationsTable).values(
+//       userIds.map((userId) => ({
+//         title: payload.title,
+//         userId: userId,
+//         description: payload.description,
+//         type: payload.type,
+//         url: payload.url,
+//         image: payload.image,
+//         data: { ...payload.data, url: payload.url, type: payload.type },
+//       }))
+//     );
+//     const users = await db
+//       .select({
+//         fcmToken: userDetails.fcmToken,
+//         allowNotifications: userDetails.notifications,
+//       })
+//       .from(userDetails)
+//       .where(inArray(userDetails.userId, userIds));
+//     await PushNotificationManager.sendNotification(
+//       users
+//         .filter((u) => u.fcmToken && u.allowNotifications)
+//         .map((u) => ({
+//           notification: {
+//             body: payload.description,
+//             title: removeCurlyBraces(payload.title),
+//           },
+//           token: u.fcmToken!,
+//           data: {
+//             ...payload.data,
+//             url: payload.url,
+//             type: JSON.stringify(payload.type),
+//           },
+//         }))
+//     );
+//   }
+// }
+
+// function removeCurlyBraces(text: string) {
+//   // The regular expression captures the text between '{{' and '}}'
+//   return text.replace(/\{\{(.*?)\}\}/g, "$1");
+// }

package/packages/@repo/lib/src/notification-module/push-notification.ts

@@ -0,0 +1,90 @@
+import firebaseAdmin from "firebase-admin";
+import path from "path";
+
+import { logger } from "../logger-module/logger.js";
+import { __dirname } from "../utils.js";
+
+export type FcmPayload = {
+	notification?: {
+		title: string;
+		body?: string;
+	};
+	data?: Record<string, any>;
+	token: string;
+};
+
+type InitOptions =
+	| {
+			type: "file";
+	  }
+	| {
+			type: "env";
+	  };
+
+export class PushNotificationManager {
+	private static initialized = false;
+
+	static initialize(options: InitOptions) {
+		if (this.initialized) return;
+
+		try {
+			let credential: firebaseAdmin.credential.Credential;
+
+			if (options.type === "file") {
+				credential = firebaseAdmin.credential.cert(
+					path.join(__dirname(), "/keys/firebase-messaging-secret.json"),
+				);
+			} else if (options.type === "env") {
+				credential = firebaseAdmin.credential.cert({
+					projectId: process.env.FIREBASE_PROJECT_ID,
+					clientEmail: process.env.FIREBASE_CLIENT_EMAIL!,
+					privateKey: process.env.FIREBASE_PRIVATE_KEY!.replace(/\\n/g, "\n"),
+				});
+			} else {
+				throw new Error("Invalid initialization options");
+			}
+
+			firebaseAdmin.initializeApp({ credential });
+			this.initialized = true;
+			logger.info("Firebase Admin initialized");
+		} catch (error) {
+			logger.error("Firebase initialization error:", error);
+		}
+	}
+
+	static async sendNotification(payload: FcmPayload[]) {
+		if (!this.initialized) {
+			logger.warn("PushNotificationManager not initialized. Skipping notification.");
+			return;
+		}
+
+		const formattedPayload = payload.map((item) => {
+			const data: Record<string, string> = {};
+
+			for (const key in item.data) {
+				const value = item.data[key] as string;
+				if (value !== null) {
+					data[key] = typeof value === "string" ? value : String(value);
+				}
+			}
+
+			return {
+				notification: item.notification
+					? {
+							title: item.notification.title,
+							body: item.notification.body,
+						}
+					: undefined,
+				data,
+				token: item.token,
+			};
+		});
+
+		try {
+			const response = await firebaseAdmin.messaging().sendEach(formattedPayload);
+			logger.info("Successfully sent message:", response.responses);
+		} catch (error) {
+			logger.error("Error sending message:", error);
+		}
+	}
+}

package/packages/@repo/lib/src/oauth2-client.ts

@@ -0,0 +1,109 @@
+import axios from "axios";
+
+import { logger } from "./logger-module/logger";
+
+type AuthorizationURLParams = {
+	authorizationURL: string;
+	clientID: string;
+	redirectURI: string;
+	scopes: string[];
+	state: string;
+	aud?: string;
+	code_challenge?: string;
+	code_challenge_method?: string;
+	offline_access?: boolean;
+};
+
+type AccessTokenParams = {
+	tokenURL: string;
+	clientID: string;
+	clientSecret: string;
+	redirectURI: string;
+	code: string;
+	code_verifier?: string;
+};
+
+type ProfileRouteParams = {
+	profileRoute: string;
+	accessToken: string;
+};
+
+export class OauthClient {
+	static getAuthorizationUrl(params: AuthorizationURLParams) {
+		// constructing authorization url
+		const url = new URL(params.authorizationURL);
+		// adding our client id
+		url.searchParams.append("client_id", params.clientID);
+		// adding the endpoint to redirect after user gives consent
+		url.searchParams.append("redirect_uri", params.redirectURI);
+		// choosing the response type (code here which we'll use to redeem an accessToken)
+		url.searchParams.append("response_type", "code");
+		// required for twitter, just a random string (will be needed when redeeming accessToken from code)
+		if (params.code_challenge) {
+			url.searchParams.append("code_challenge", params.code_challenge);
+		}
+		if (params.code_challenge_method) {
+			url.searchParams.append("code_challenge_method", params.code_challenge_method);
+		}
+		if (params.offline_access) {
+			url.searchParams.append("access_type", "offline");
+			url.searchParams.append("prompt", "consent");
+		}
+		// adding scopes which specify what are we asking from user
+		if (params.scopes) {
+			url.searchParams.append("scope", params.scopes.join(" "));
+		}
+		// just a random value on state
+		url.searchParams.append("state", params.state);
+
+		// not important, sometimes necessary, takes baseUrl
+		if (params.aud) {
+			url.searchParams.append("aud", params.aud);
+		}
+		return url.toString();
+	}
+
+	static async getAccessToken(
+		params: AccessTokenParams,
+		options?: { authInBody?: boolean },
+	) {
+		try {
+			const body = new URLSearchParams();
+			body.append("grant_type", "authorization_code");
+			body.append("code", params.code);
+			body.append("redirect_uri", params.redirectURI);
+			if (params.code_verifier) {
+				body.append("code_verifier", params.code_verifier);
+			}
+			if (options?.authInBody) {
+				body.append("client_id", params.clientID);
+				body.append("client_secret", params.clientSecret);
+			}
+
+			const { data } = await axios.post(params.tokenURL, body, {
+				headers: {
+					"Content-Type": "application/x-www-form-urlencoded",
+				},
+				auth: {
+					username: params.clientID,
+					password: params.clientSecret,
+				},
+			});
+			return data as Record<"access_token" | "refresh_token" | "scope" | "id_token", string>;
+		} catch (error: any) {
+			if (error.response?.data) {
+				logger.error(Error(JSON.stringify(error.response.data, null, 2)));
+			} else logger.error(error);
+			return;
+		}
+	}
+	//
+	static async getUserInfo(params: ProfileRouteParams) {
+		const { data } = await axios.get(params.profileRoute, {
+			headers: {
+				Authorization: `Bearer ${params.accessToken}`,
+			},
+		});
+		return data;
+	}
+}

package/packages/@repo/lib/src/otp-module.ts

@@ -0,0 +1,98 @@
+import  { db, otps } from "@repo/db";
+import { AdminEmailTemplate } from "@repo/email";
+import { eq } from "drizzle-orm";
+
+import { HashingModule } from "./hashing-module.js";
+import { SMTPMailService } from "./mail-module/nodemailer.js";
+import { Random } from "./utils.js";
+
+/**
+ * @description Handles operations related to One Time Passwords (OTPs).
+ */
+export class OTPModule {
+	/**
+	 * @description Generates a random OTP and sends it to the user's email via email service.
+	 * @param {{ email: string; name: string }} options
+	 * @returns {Promise<void>}
+	 */
+	static async sendMailOTP({ email }: { email: string }): Promise<void> {
+		const otp = Random.generateNumber(4);
+		const hash = await HashingModule.hash(otp.toString());
+		// const otpDoc = await db.query.otps.findFirst({
+		// 	where: (data, { eq }) => eq(data.email, email),
+		// });
+		const otpDoc = await db.select().from(otps).where(eq(otps.email, email));
+		if (otpDoc) {
+			await db.update(otps).set({ otp: hash }).where(eq(otps.email, email));
+		} else {
+			await db.insert(otps).values([{ email, otp: hash }]);
+		}
+		if (["test", ""].includes(process.env.NODE_ENV)) {
+			// await MockMailService.sendMail({
+			//   to: email,
+			//   text: `your otp is ${otp}`,
+			// });
+		} else {
+			const html = await AdminEmailTemplate.getOtpEmail({
+				otp: otp.toString(),
+			});
+			await SMTPMailService.sendMail(email, `OTP for ${email}`, `your otp is ${otp}`, html);
+		}
+	}
+
+	/**
+	 * @description Verifies the OTP sent to the user's email.
+	 * @param {string} email
+	 * @param {string} otp
+	 * @param {boolean} [deleteOtp=true] whether to delete the OTP doc after verification
+	 * @returns {Promise<boolean>}
+	 */
+	static async verifyMailOTP(email: string, otp: string, deleteOtp = false): Promise<boolean> {
+		// const EXPIRATION_CONSTANT = 5 * 60 * 1000;
+		// const expirationTime = new Date(Date.now() + EXPIRATION_CONSTANT).getTime();
+
+		if (["test", "development"].includes(process.env.NODE_ENV)) return true;
+
+		// const otpDoc = await db.query.otps.findFirst({
+		// 	where: (data, { eq }) => and(eq(data.email, email)),
+		// });
+		const otpDoc = await db.select().from(otps).where(eq(otps.email, email));
+		if (["test", "development"].includes(process.env.NODE_ENV)) return true;
+		if (!otpDoc.length) return false;
+
+		const firstOtp = otpDoc[0];
+
+		const verified = await HashingModule.compare(otp, firstOtp.otp);
+		if (!verified) return false;
+		if (deleteOtp) {
+			await db.delete(otps).where(eq(otps.email, email));
+		} else {
+			await db.update(otps).set({ status: "verified" }).where(eq(otps.email, email));
+		}
+		return true;
+	}
+
+	/**
+	 * @description Checks if the OTP has been verified.
+	 * @param {string} email
+	 * @returns {Promise<boolean>}
+	 */
+	static async checkOTPStatus(email: string): Promise<boolean> {
+		// const otpDoc = await db.query.otps.findFirst({
+		// 	where: (data, { eq }) => eq(data.email, email),
+		// });
+		const otpDoc = await db.select().from(otps).where(eq(otps.email, email));
+		if (!otpDoc) return false;
+		const firstOtp = otpDoc[0];
+		return firstOtp.status === "verified";
+	}
+	static async deleteOTP(email: string): Promise<boolean> {
+		const otpDoc = await db.select().from(otps).where(eq(otps.email, email));
+		// const otpDoc = await db.query.otps.findFirst({
+		// 	where: (data, { eq }) => eq(data.email, email),
+		// });
+		if (!otpDoc) return false;
+		await db.delete(otps).where(eq(otps.email, email));
+		return true;
+	}
+}

package/packages/@repo/lib/src/pagination-module.ts

@@ -0,0 +1,49 @@
+import type { PgSelect } from "drizzle-orm/pg-core";
+
+type PageQuery = { page?: string; limit?: string };
+
+export class Paginator {
+  static getPage(query: PageQuery = { page: "1", limit: "10" }) {
+    const page = parseInt(query.page ?? "1", 10);
+    const limit = parseInt(query.limit ?? "20", 10);
+    const offset = (page - 1) * limit;
+    return { page, limit, offset };
+  }
+
+  static async getTotalCount(
+    promise: Promise<
+     Array< {
+        count: number;
+      }>
+    >,
+  ) {
+    const result = await promise;
+    return result[0]?.count || 0;
+  }
+
+  static paginate<T>(
+    query: PageQuery = { page: "1", limit: "10" },
+    rows: T[],
+    total: number,
+  ) {
+    const { page, limit } = Paginator.getPage(query);
+    const totalPages = Math.ceil(total / limit);
+    return {
+      data: rows,
+      pagination: {
+        total,
+        totalPages,
+        currentPage: page,
+        pageSize: limit,
+      },
+    };
+  }
+  // Not worth using
+  static withPagination<T extends PgSelect>(
+    qb: T,
+    query: PageQuery = { page: "1", limit: "10" },
+  ) {
+    const { offset, limit } = Paginator.getPage(query);
+    return qb.limit(limit).offset(offset);
+  }
+}

package/packages/@repo/lib/src/token-module.ts

@@ -0,0 +1,35 @@
+import * as jwt from "jsonwebtoken";
+export type AuthTokenPayload = {
+	userID: string;
+	email: string;
+};
+const accessTokenSecret = process.env.ACCESS_TOKEN_SECRET;
+const refreshTokenSecret = process.env.REFRESH_TOKEN_SECRET;
+
+export class TokenModule {
+	static signRefreshToken(payload: AuthTokenPayload) {
+		return jwt.sign(payload, refreshTokenSecret, { expiresIn: "365d" });
+	}
+	static verifyRefreshToken(refreshToken: string) {
+		try {
+			const payload = jwt.verify(refreshToken, refreshTokenSecret) as AuthTokenPayload;
+			return payload;
+		} catch (error) {
+			console.error(error)
+			return null;
+		}
+	}
+	static signAccessToken(payload: AuthTokenPayload) {
+		const expiration = process.env.NODE_ENV === "development" ? "30d" : "1d";
+		return jwt.sign(payload, accessTokenSecret, { expiresIn: expiration });
+	}
+	static verifyAccessToken(accessToken: string) {
+		try {
+			const payload = jwt.verify(accessToken, accessTokenSecret) as AuthTokenPayload;
+			return payload;
+		} catch (error) {
+			console.error(error)
+			return null;
+		}
+	}
+}

package/packages/@repo/lib/src/user-session.ts

@@ -0,0 +1,117 @@
+import { redisClient } from "@repo/redis";
+
+import { constants } from "./constants.js";
+import { TokenModule } from "./token-module.js";
+
+const accessTokenKey = (key: string) => `access_token:${key}`;
+const refreshTokenKey = (key: string) => `refresh_token:${key}`;
+const userTokensKey = (userId: string) => `session:${userId}`;
+export type SessionUser = {
+	id: string;
+	email: string;
+	fullName: string;
+	countries: string[];
+	department: string;
+	currentScenario?: string;
+	accessToken: string;
+};
+
+function jsonParse<T>(value: string) {
+	try {
+		return JSON.parse(value) as T;
+	} catch (error) {
+		console.error(error)
+		throw error;
+	}
+}
+
+export class UserSession {
+	static async getSessionUser(token: string) {
+		const session = await redisClient.get(accessTokenKey(token));
+		if (session) {
+			try {
+				const user = JSON.parse(session) as SessionUser;
+				return user;
+			} catch (error) {
+				console.log(error);
+			}
+		}
+		return session ? jsonParse<SessionUser>(session) : null;
+	}
+	static async startSession(payload: Omit<SessionUser, "accessToken">) {
+		await UserSession.endSession(payload.id);
+		const accessToken = TokenModule.signAccessToken({
+			userID: payload.id,
+			email: payload.email,
+		});
+		const refreshToken = TokenModule.signRefreshToken({
+			userID: payload.id,
+			email: payload.email,
+		});
+
+		await redisClient.setex(
+			accessTokenKey(accessToken),
+			constants.sessionDuration,
+			JSON.stringify({ ...payload, accessToken })
+		);
+		await redisClient.setex(refreshTokenKey(refreshToken), constants.sessionDuration, payload.id);
+		await redisClient.setex(
+			userTokensKey(payload.id),
+			constants.sessionDuration,
+			JSON.stringify({
+				accessToken,
+				refreshToken,
+			})
+		);
+		return { accessToken, refreshToken };
+	}
+
+	static async checkRefreshToken(refreshToken: string) {
+		const userId = await redisClient.get(refreshTokenKey(refreshToken));
+		return userId;
+	}
+
+	static async updateAccessToken(payload: Omit<SessionUser, "accessToken">) {
+		let accessToken: string;
+		const tokens = await UserSession.getTokens(payload.id);
+		if (tokens) {
+			accessToken = tokens.accessToken;
+		} else {
+			return null;
+		}
+
+		await redisClient.setex(
+			accessTokenKey(accessToken),
+			constants.sessionDuration,
+			JSON.stringify({ ...payload, accessToken })
+		);
+		return accessToken;
+	}
+
+	static async getTokens(userId: string) {
+		const tokens = await redisClient.get(userTokensKey(userId));
+		return tokens ? jsonParse<{ refreshToken: string; accessToken: string }>(tokens) : null;
+	}
+
+	static async logout(accessToken: string) {
+		const payload = await redisClient.get(accessTokenKey(accessToken));
+		if (!payload) return null;
+		const user = jsonParse<SessionUser>(payload);
+		const tokens = await UserSession.getTokens(user.id);
+		if (tokens) {
+			await redisClient.del(refreshTokenKey(tokens.refreshToken));
+			await redisClient.del(accessTokenKey(accessToken));
+			await redisClient.del(userTokensKey(user.id));
+		}
+		return;
+	}
+
+	static async endSession(userId: string) {
+		const tokens = await UserSession.getTokens(userId);
+		if (tokens) {
+			await redisClient.del(refreshTokenKey(tokens.refreshToken));
+			await redisClient.del(accessTokenKey(tokens.accessToken));
+			await redisClient.del(userTokensKey(userId));
+		}
+	}
+}