startx 0.0.1

package/packages/@repo/lib/src/bucket-module/s3-storage.ts

@@ -0,0 +1,114 @@
+/**
+ * TODO:  connect to bucket
+ */
+import {
+	DeleteObjectCommand,
+	PutObjectCommand,
+	type PutObjectCommandInput,
+	S3Client,
+} from "@aws-sdk/client-s3";
+
+const s3Endpoint = process.env.S3_ENDPOINT;
+
+const credentials = {
+	accessKeyId: process.env.AWS_ACCESS_KEY_ID,
+	secretAccessKey: process.env.AWS_SECRET_ACCESS_KEY,
+};
+
+// Create an S3 service client object.
+const s3Client = new S3Client({
+	credentials,
+	region: process.env.AWS_REGION,
+	endpoint: s3Endpoint,
+});
+
+const bucket = process.env.AWS_BUCKET;
+
+export type UploadFile = {
+	name: string;
+	mimetype: string;
+	data: Buffer;
+};
+
+export class S3Bucket {
+	static async uploadFile(file: UploadFile, path: string) {
+		let key = `${path}`;
+		if (!key.includes(".")) {
+			key += ".jpeg";
+		}
+		const params = {
+			Bucket: bucket,
+			Key: key,
+			Body: file.data,
+			ContentType: file.mimetype,
+		} as PutObjectCommandInput;
+		const command = new PutObjectCommand(params);
+		await s3Client.send(command);
+		const fileUrl = S3Bucket.getAwsUrl(key);
+		return fileUrl;
+	}
+
+	static getAwsUrl(path: string) {
+		return `https://${bucket}.s3.${process.env.AWS_REGION}.amazonaws.com/${path}`;
+	}
+
+	static getKeyFromUrl(url: string) {
+		const key = url.split(`https://${bucket}.s3.${process.env.AWS_REGION}.amazonaws.com/`)[1];
+		return key;
+	}
+
+	static async uploadFiles({ path, files }: { path: string; files: UploadFile[] }) {
+		try {
+			if (!path) throw new Error("Path must be provided.");
+			if (!files) throw new Error("File must be provided.");
+			// const buffers: UploadFile[] = [];
+			// for (const key in file) {
+			//   const item = file[key];
+			//   if (Array.isArray(item)) item.forEach((e) => buffers.push(e));
+			//   else buffers.push(item!);
+			// }
+
+			// let upload = [] as { url: string; type: string; name: string }[];
+			const upload = await Promise.all(
+				files.map(async (file) => {
+					const key = file.name;
+					const params: PutObjectCommandInput = {
+						Bucket: bucket,
+						Key: `${path}/${key}`,
+						Body: file.data,
+						ContentType: file.mimetype,
+					};
+					const command = new PutObjectCommand(params);
+					await s3Client.send(command);
+					return {
+						url: S3Bucket.getAwsUrl(`${path}/${key}`),
+						type: file.mimetype,
+						name: file.name,
+					};
+				}),
+			);
+			return upload;
+			// if (upload.length > 0) return upload;
+			// else throw new Error("Something went wrong.");
+		} catch (error) {
+			console.log(error);
+			throw error;
+		}
+	}
+
+	// ! don't use
+	static async deleteFile(path: string) {
+		try {
+			const params = {
+				Bucket: bucket,
+				Key: path,
+			};
+
+			const command = new DeleteObjectCommand(params);
+			await s3Client.send(command);
+		} catch (error) {
+			console.log(error);
+			throw error;
+		}
+	}
+}

package/packages/@repo/lib/src/bucket-module/utils.ts

@@ -0,0 +1,11 @@
+import { S3Bucket } from "./s3-storage.js";
+
+export const pathGenerator = {
+  asset: {
+    base: "image/assets",
+    supportImage: "image/assets/bemyguest_support.png",
+  },
+  profile: (userId: string) => `user/${userId}/profile`,
+};
+
+export const defaultAvatarUrl = `${S3Bucket.getAwsUrl("image/assets/avatar_image.png")}`;

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

@@ -0,0 +1,77 @@
+import { logger } from "./logger-module/logger.js";
+
+/**
+ * @description Custom command class that extends for creating custom commands
+ * @constructor
+ * @param name
+ * @param description
+ * @param fn
+ */
+export class Command {
+	name: string;
+	description?: string;
+	fn: (flags: string[]) => void;
+	constructor({
+		description = "",
+		fn,
+		name,
+	}: {
+		name: string;
+		description?: string;
+		fn: (flags: string[]) => void;
+	}) {
+		this.name = name;
+		this.description = description;
+		this.fn = fn;
+	}
+}
+
+/**
+ * @description Custom command executer class
+ */
+export class CommandExecuter {
+	/**
+	 * @description Available commands
+	 */
+	static commands = new Map<string, Command>();
+
+	/**
+	 * @description Register a new command
+	 * @param command
+	 */
+	static register(command: Command) {
+		this.commands.set(command.name, command);
+	}
+	static registerAll(commands: Command[]) {
+		for (const command of commands) {
+			this.register(command);
+		}
+	}
+
+	/**
+	 * @description execute the command from console
+	 * @param string
+	 */
+	static async start() {
+		const command = process.argv[2];
+		const flags = process.argv.slice(3);
+		if (command === undefined) {
+			CommandExecuter.listCommands();
+		} else if (this.commands.has(command)) {
+			this.commands.get(command)?.fn(flags);
+			await new Promise((resolve) => setTimeout(resolve, 1000));
+			logger.info(`Command executed: ${command}`);
+			process.exit();
+		} else {
+			console.log(`Unknown command: ${command}`);
+			CommandExecuter.listCommands();
+		}
+	}
+
+	static listCommands() {
+		console.log("Available commands:");
+		for (const command of this.commands.values()) {
+			console.log(`- ${command.name}: ${command.description}`);
+		}
+	}
+}

package/packages/@repo/lib/src/constants.ts

@@ -0,0 +1,3 @@
+export const constants = {
+	sessionDuration: 60 * 60 * 6
+};

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

@@ -0,0 +1,42 @@
+import type { CookieOptions } from "express";
+
+const constants = {
+	refreshToken: {
+		cookie: "",
+		cookieDomain: "",
+		secureCookie: false,
+		maxAge: 0,
+	},
+	initialize() {
+		const prodMaxAge = 1000 * 60 * 60 * 24 * 30;
+		const stagingMaxAge = 1000 * 60 * 60 * 24 * 365;
+		const prodEnv = process.env.NODE_ENV === "production";
+		const stagingEnv = process.env.NODE_ENV === "staging";
+
+		if (prodEnv) {
+			this.refreshToken.cookie = "refresh-token";
+			this.refreshToken.cookieDomain = process.env.COOKIE_DOMAIN;
+			this.refreshToken.secureCookie = true;
+			this.refreshToken.maxAge = prodMaxAge;
+		} else {
+			this.refreshToken.cookie = "refresh-token-staging";
+			this.refreshToken.cookieDomain = stagingEnv
+				? process.env.COOKIE_DOMAIN
+				: process.env.COOKIE_DOMAIN || "localhost";
+			this.refreshToken.secureCookie = stagingEnv ? true : false;
+			this.refreshToken.maxAge = stagingMaxAge;
+		}
+	},
+};
+constants.initialize();
+
+export function getCookieOptions(refreshToken: string): [string, string, CookieOptions] {
+	const cookieOptions: CookieOptions = {
+		domain: constants.refreshToken.cookieDomain,
+		maxAge: constants.refreshToken.maxAge,
+		sameSite: "lax",
+		httpOnly: true,
+		secure: constants.refreshToken.secureCookie,
+	};
+	return [constants.refreshToken.cookie, refreshToken, cookieOptions];
+}

package/packages/@repo/lib/src/custom-type.ts

@@ -0,0 +1,54 @@
+/* eslint-disable @typescript-eslint/no-namespace */
+import type { SessionUser } from "./user-session.js";
+
+declare global {
+	namespace NodeJS {
+		export interface ProcessEnv {
+			// from .env
+			COOKIE_DOMAIN: string;
+			NODE_ENV: "development" | "staging" | "production" | "test";
+			DATABASE_URL: string;
+			DATABASE_AUTH_TOKEN: string;
+			ACCESS_TOKEN_SECRET: string;
+			REFRESH_TOKEN_SECRET: string;
+			OAUTH_STATE_TOKEN_SECRET: string;
+			SUPPORT_MAIL: string;
+			AWS_ACCESS_KEY_ID: string;
+			AWS_SECRET_ACCESS_KEY: string;
+			AWS_REGION: string;
+			AWS_BUCKET: string;
+			GOOGLE_CLIENT_ID: string;
+			GOOGLE_CLIENT_SECRET: string;
+			GOOGLE_REDIRECT_URI: string;
+
+			CLIENT_URL: string;
+			SERVER_URL: string;
+			REDIS_URI: string;
+			REDIS_PORT: string;
+			REDIS_USERNAME: string;
+			REDIS_PASSWORD: string;
+			FIREBASE_PROJECT_ID: string;
+			STRIPE_WEBHOOK_SECRET: string;
+			STRIPE_SECRET_KEY: string;
+
+			SMTP_HOST: string;
+			SMTP_PORT: string;
+			SMTP_USER: string;
+			SMTP_PASSWORD: string;
+			SENDER_MAIL: string;
+		}
+	}
+
+	namespace Express {
+		export interface Request {
+			user: SessionUser;
+		}
+	}
+}
+
+declare module "http" {
+	interface IncomingMessage {
+		user: SessionUser;
+		body: any;
+	}
+}

package/packages/@repo/lib/src/env.ts

@@ -0,0 +1,13 @@
+import * as dotenv from "dotenv";
+import path from "path";
+
+import { __dirname } from "./utils.js";
+
+if (process.env.NODE_ENV === "test") {
+	console.log("loading test env", process.cwd(), __dirname());
+	dotenv.config({ path: path.join(__dirname(), ".env.test") });
+} else {
+	dotenv.config();
+	dotenv.config({ path: path.join(__dirname(), ".env") });
+}
+export  {dotenv};

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

@@ -0,0 +1,11 @@
+/**
+ * @description Custom error class that extends the built-in Error class for error responses
+ */
+export class ErrorResponse extends Error {
+  constructor(public message: string, public statusCode: number) {
+    super(message); // Call the parent constructor with the message
+
+    // Set the prototype chain explicitly for older environments (optional)
+    Object.setPrototypeOf(this, ErrorResponse.prototype);
+  }
+}

package/packages/@repo/lib/src/file-system/index.ts

@@ -0,0 +1,90 @@
+import fs from "fs/promises";
+import fsExists from "fs.promises.exists";
+import path from "path";
+
+import { __dirname } from "../utils.js";
+export class FStool {
+	root = __dirname();
+	async writeFile({ file, content }: { file: string; content: string }) {
+		await fs.writeFile(path.join(this.root, file), content);
+	}
+	async writeJSONFile({ file, content, dir }: { file: string; content: object; dir?: string }) {
+		file = `${file}.json`;
+		let destination = path.join(this.root, file);
+		if (dir) {
+			const dirPath = path.join(dir, file);
+			destination = path.join(this.root, dir, file);
+			await this.ensurePathExists({ dir: path.dirname(dirPath) });
+		}
+		await fs.writeFile(destination, JSON.stringify(content, null, 2));
+	}
+	async readFile({ file }: { file: string }) {
+		return await fs.readFile(path.join(this.root, file), "utf-8");
+	}
+	async readJSONFile({ file, dir }: { file: string; dir?: string }) {
+		try {
+			file = `${file}.json`;
+			return JSON.parse(await fs.readFile(path.join(this.root, dir || "", file), "utf-8")) as object;
+		} catch (err) {
+			console.error(err)
+			return null;
+		}
+	}
+	async ensurePathExists({ dir }: { dir: string }) {
+		dir = path.join(this.root, dir);
+		if (!(await fsExists(dir))) {
+			await fs.mkdir(dir, { recursive: true });
+		}
+	}
+	async avoidOverriding({ file }: { file: string }) {
+		file = path.join(this.root, file);
+		if (await fsExists(file)) {
+			throw new Error(`File ${file} already exists`);
+		}
+	}
+	async removeFile({ file }: { file: string }) {
+		file = path.join(this.root, file);
+		if (await fsExists(file)) {
+			await fs.unlink(file);
+		}
+	}
+	async removeDirectory({ dir, target }: { dir: string; target: string }) {
+		dir = path.join(this.root, dir, target);
+		if (await fsExists(dir)) {
+			await fs.rm(dir, { recursive: true });
+		}
+	}
+
+	async copyDirectory({ from, to, dir }: { from: string; to: string; dir: string }) {
+		from = path.join(this.root, dir, from);
+		to = path.join(this.root, dir, to);
+		if (await fsExists(from)) {
+			await fs.cp(from, to, { recursive: true });
+		}
+	}
+
+	async listDirectories({ dir }: { dir: string }) {
+		try {
+			return await fs
+				.readdir(path.join(this.root, dir), { withFileTypes: true })
+				.then((files) => files.filter((file) => file.isDirectory()))
+				.then((files) => files.map((file) => file.name));
+		} catch (error) {
+			console.warn(error);
+			return [];
+		}
+	}
+	async listFiles({ dir }: { dir: string }) {
+		try {
+			return await fs
+				.readdir(path.join(this.root, dir), { withFileTypes: true })
+				.then((files) => files.filter((file) => !file.isDirectory()))
+				.then((files) => files.map((file) => file.name));
+		} catch (error) {
+			console.warn(error);
+			return [];
+		}
+	}
+}
+
+export const fsTool = new FStool();

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

@@ -0,0 +1,9 @@
+import bcrypt from "bcryptjs";
+export class HashingModule {
+	static async hash(password: string) {
+		return await bcrypt.hash(password, 10);
+	}
+	static async compare(password: string, hash: string) {
+		return await bcrypt.compare(password, hash);
+	}
+}

package/packages/@repo/lib/src/index.ts

@@ -0,0 +1,27 @@
+// eslint-disable-next-line import-x/export
+export type * from "./custom-type.js";
+export * from "./utils.js";
+export * from "./logger-module/logger.js";
+export * from "./notification-module/push-notification.js";
+export * from "./token-module.js";
+export * from "./bucket-module/file-storage.js";
+export * from "./bucket-module/s3-storage.js";
+export * from "./bucket-module/utils.js";
+// export * from "./compression-module/compression-module.js";
+
+// export * from "./env.js";
+export * from "./file-system/index.js";
+export * from "./mail-module/mock.js";
+export * from "./mail-module/nodemailer.js";
+
+export * from "./cookie-module.js";
+export * from "./hashing-module.js";
+
+export * from "./oauth2-client.js";
+export * from "./otp-module.js";
+export * from "./pagination-module.js";
+export * from "./error-handlers-module/index.js";
+export * from "./validation-module.js";
+export * from "./command-module.js";
+export * from "./logger-module/memory-profiler.js";
+export * from "./user-session.js";

package/packages/@repo/lib/src/logger-module/log-config.ts

@@ -0,0 +1,16 @@
+export type LogConfig = {
+  routeInfo: boolean;
+  requestBody: boolean;
+  validationErrors: boolean;
+  queryParams: boolean;
+  responseBody: boolean;
+  steps: boolean;
+};
+export const logConfig: LogConfig = {
+  routeInfo: false,
+  responseBody: false,
+  validationErrors: false,
+  requestBody: false,
+  queryParams: false,
+  steps: false,
+};

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

@@ -0,0 +1,78 @@
+import { createLogger, format, transports } from "winston";
+
+import { type LogConfig, logConfig } from "./log-config.js";
+
+const { combine, timestamp, printf, errors, colorize } = format;
+
+// Custom format to include error stack traces
+const customFormat = printf(({ level, message, timestamp, stack }: any) => {
+	return `${timestamp} [${level}]: ${stack ?? message}`;
+});
+
+const logConfigFilter = format((info) => {
+	if (!info.logType || logConfig[info.logType as keyof LogConfig]) {
+		return info;
+	}
+	return false;
+});
+
+// Create level-specific filters
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+const levelFilter = (level: string) =>
+	format((info) => {
+		if (info.level === level) {
+			return info;
+		}
+		return false;
+	})();
+
+// Configure the logger
+export const logger = createLogger({
+	format: combine(
+		timestamp({ format: "YYYY-MM-DD HH:mm:ss" }),
+		errors({ stack: true }), // Capture stack traces
+		customFormat,
+	),
+	transports: [
+		// Console transport - shows all levels
+		new transports.Console({
+			format: combine(logConfigFilter(), colorize(), customFormat),
+		}),
+
+		// Standard log file for all levels
+		// new DailyRotateFile({
+		//   filename: path.join(__dirname(), "logs", "combined-%DATE%.log"),
+		//   datePattern: "DD-MM-YYYY",
+		//   maxFiles: "30d",
+		//   format: combine(logConfigFilter(), customFormat),
+		//   json: true,
+		// }),
+
+		// // File transport for 'info' logs only
+		// new DailyRotateFile({
+		//   filename: path.join(__dirname(), "logs", "info-%DATE%.log"),
+		//   datePattern: "DD-MM-YYYY",
+		//   maxFiles: "30d",
+		//   format: combine(logConfigFilter(), levelFilter("info"), customFormat),
+		//   json: true,
+		// }),
+
+		// // File transport for 'error' logs only
+		// new DailyRotateFile({
+		//   filename: path.join(__dirname(), "logs", "error-%DATE%.log"),
+		//   datePattern: "DD-MM-YYYY",
+		//   maxFiles: "30d",
+		//   format: combine(logConfigFilter(), levelFilter("error"), customFormat),
+		//   json: true,
+		// }),
+
+		// // File transport for 'warn' logs only
+		// new DailyRotateFile({
+		//   filename: path.join(__dirname(), "logs", "warn-%DATE%.log"),
+		//   datePattern: "DD-MM-YYYY",
+		//   maxFiles: "30d",
+		//   format: combine(logConfigFilter(), levelFilter("warn"), customFormat),
+		//   json: true,
+		// }),
+	],
+});

package/packages/@repo/lib/src/logger-module/memory-profiler.ts

@@ -0,0 +1,65 @@
+
+export class MemoryProfiler {
+	private startUsage: number | null = null;
+	private lastUsage: number | null = null;
+	private totalDelta = 0;
+	private state: "off" | "on" = "on";
+	private startTime: number | null = null;
+	private lastTime: number | null = null;
+
+	 setState(state: "on" | "off") {
+		this.state = state;
+	}
+
+	start(): void {
+		const usage = process.memoryUsage().heapUsed;
+		const now = Date.now();
+		this.startUsage = usage;
+		this.lastUsage = usage;
+		this.startTime = now;
+		this.lastTime = now;
+		this.totalDelta = 0;
+
+		if (this.state === "off") return;
+		console.log(`[Profiler] Started at ${this.formatMB(usage)}`);
+	}
+
+	 at(label: string = ""): void {
+		if (this.startUsage === null || this.startTime === null) {
+			throw new Error("Profiler not started. Call .start() first.");
+		}
+
+		const usage = process.memoryUsage().heapUsed;
+		const now = Date.now();
+
+		const deltaFromStart = usage - this.startUsage;
+		const deltaFromLast = usage - (this.lastUsage ?? usage);
+
+		const timeFromStart = now - this.startTime;
+		const timeFromLast = now - (this.lastTime ?? now);
+
+		this.totalDelta = deltaFromStart;
+
+		if (this.state === "on") {
+			console.log(
+				`[Profiler] ${label ? label + " - " : ""}` +
+					`since start: ${this.formatMB(deltaFromStart)} | ${this.formatMS(timeFromStart)}, ` +
+					`since last: ${this.formatMB(deltaFromLast)} | ${this.formatMS(timeFromLast)}, ` +
+					`current heap: ${this.formatMB(usage)}`
+			);
+		}
+
+		this.lastUsage = usage;
+		this.lastTime = now;
+	}
+
+	private formatMB(bytes: number): string {
+		return (bytes / 1024 / 1024).toFixed(2) + " MB";
+	}
+
+	private formatMS(ms: number): string {
+		if (ms < 1000) return `${ms} ms`;
+		const sec = (ms / 1000).toFixed(2);
+		return `${sec} s`;
+	}
+}

package/packages/@repo/lib/src/mail-module/mock.ts

@@ -0,0 +1,8 @@
+import { logger } from "../logger-module/logger";
+
+class MockMailService {
+	static sendMail({ text, to }: { to: string; text: string }) {
+		logger.info(`Email sent: ${to} ${text}`);
+	}
+}
+export { MockMailService };

package/packages/@repo/lib/src/mail-module/nodemailer.ts

@@ -0,0 +1,45 @@
+import type { Transporter } from "nodemailer";
+import * as nodemailer from "nodemailer";
+
+import { logger } from "../logger-module/logger";
+
+class SMTPMailService {
+	private static transporter: Transporter;
+
+	// Initialize the transporter only once
+	private static initializeTransporter() {
+		if (!this.transporter) {
+			this.transporter = nodemailer.createTransport({
+				host: process.env.SMTP_HOST,
+				port: Number.parseInt(process.env.SMTP_PORT) ?? 587,
+				secure: process.env.SMTP_MAIL_ENCRYPTION === "ssl",
+				auth: {
+					user: process.env.SMTP_USER,
+					pass: process.env.SMTP_PASSWORD,
+				},
+			});
+		}
+	}
+
+	static async sendMail(to: string, subject: string, text: string, html?: string): Promise<void> {
+		this.initializeTransporter();
+
+		const mailOptions = {
+			from: `Bemyguest <${process.env.SENDER_MAIL}>`,
+			to,
+			subject,
+			text,
+			html,
+		};
+
+		try {
+			const info = (await this.transporter.sendMail(mailOptions)) as { messageId: string };
+			logger.info(`Email sent: ${info.messageId}`);
+		} catch (error) {
+			logger.error("Error sending email:", error);
+			throw new Error("Failed to send email");
+		}
+	}
+}
+
+export { SMTPMailService };