startx 1.0.4 → 1.0.8

package/packages/@repo/lib/src/session-module/redis-session.ts

@@ -1,44 +1,74 @@
-import type { SessionUser } from "@repo/common/types/users";
 import { RedisStore } from "@repo/redis";
-import { IUserSession, type TokenPair } from "./i-session.js";
+import type { SessionRecord, SessionType } from "./i-session.js";
+import { constants, IUserSession } from "./i-session.js";
+
+type SessionIndex = string[];
 
 export class RedisUserSession extends IUserSession {
-	private userStore: RedisStore<SessionUser>;
-	private tokenStore: RedisStore<TokenPair>;
+	private sessionStore: RedisStore<SessionRecord>;
+	private sessionIndexStore: RedisStore<SessionIndex>;
 
-	constructor() {
+	constructor(type: SessionType) {
 		super();
-		this.userStore = new RedisStore<SessionUser>({
-			namespace: "user-session",
+
+		this.type = type;
+
+		this.sessionStore = new RedisStore<SessionRecord>({
+			namespace: "auth-session",
 		});
-		this.tokenStore = new RedisStore<TokenPair>({
-			namespace: "user-tokens",
+
+		this.sessionIndexStore = new RedisStore<SessionIndex>({
+			namespace: "auth-session-index",
 		});
 	}
 
-	protected async setSessionData(key: string, data: SessionUser, ttl: number): Promise<void> {
-		await this.userStore.set(key, data, ttl);
+	protected type: SessionType;
+	protected async setSession(sessionId: string, data: SessionRecord, ttl: number): Promise<void> {
+		await this.sessionStore.set(sessionId, data, ttl);
 	}
 
-	protected async getSessionData(key: string): Promise<SessionUser | null> {
-		const data = await this.userStore.get(key);
-		return data ?? null;
+	protected async getSession(sessionId: string): Promise<SessionRecord | null> {
+		const session = await this.sessionStore.get(sessionId);
+		return session ?? null;
 	}
 
-	protected async deleteSessionData(key: string): Promise<void> {
-		await this.userStore.del(key);
+	protected async deleteSession(sessionId: string): Promise<void> {
+		await this.sessionStore.del(sessionId);
 	}
 
-	protected async setTokenData(key: string, data: TokenPair, ttl: number): Promise<void> {
-		await this.tokenStore.set(key, data, ttl);
+	protected async addUserSession(userId: string, sessionId: string): Promise<void> {
+		const key = this.userSessionsKey(userId);
+
+		const sessions = (await this.sessionIndexStore.get(key)) ?? [];
+
+		if (!sessions.includes(sessionId)) {
+			sessions.push(sessionId);
+		}
+
+		await this.sessionIndexStore.set(key, sessions, constants.sessionDuration);
+	}
+
+	protected async removeUserSession(userId: string, sessionId: string): Promise<void> {
+		const key = this.userSessionsKey(userId);
+
+		const sessions = (await this.sessionIndexStore.get(key)) ?? [];
+
+		const filtered = sessions.filter(id => id !== sessionId);
+
+		if (filtered.length === 0) {
+			await this.sessionIndexStore.del(key);
+			return;
+		}
+
+		await this.sessionIndexStore.set(key, filtered, constants.sessionDuration);
 	}
 
-	protected async getTokenData(key: string): Promise<TokenPair | null> {
-		const data = await this.tokenStore.get(key);
-		return data ?? null;
+	protected async getUserSessions(userId: string): Promise<string[]> {
+		const key = this.userSessionsKey(userId);
+		return (await this.sessionIndexStore.get(key)) ?? [];
 	}
 
-	protected async deleteTokenData(key: string): Promise<void> {
-		await this.tokenStore.del(key);
+	protected async clearUserSessions(userId: string): Promise<void> {
+		await this.sessionIndexStore.del(this.userSessionsKey(userId));
 	}
 }

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

@@ -1,15 +1,11 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { logger } from "@repo/logger";
 import vine from "@vinejs/vine";
 import type { Infer, SchemaTypes } from "@vinejs/vine/types";
 import type { NextFunction, Request, Response } from "express";
 
 import { ErrorResponse } from "../error-handlers-module/index.js";
-import { logger } from "@repo/logger";
 
-type ExpressHandler<P = unknown, ResBody = unknown, ReqBody = unknown, Query = unknown> = (
-	req: Request<P, ResBody, ReqBody, Query>,
-	res: Response,
-	next: NextFunction
-) => unknown;
 export async function validateBody<T extends SchemaTypes>(
 	schema: T,
 	payload: unknown
@@ -30,17 +26,20 @@ export async function validateBody<T extends SchemaTypes>(
 		return { error: ["Validation failed"] };
 	}
 }
+
 export function bodyValidator<T extends SchemaTypes>(schema: T) {
-	return function <F extends ExpressHandler<unknown, unknown, Infer<T>, unknown>>(
-		_target: unknown,
-		_propertyKey: string,
-		descriptor: TypedPropertyDescriptor<F>
-	) {
+	return function <
+		F extends (
+			req: Request<any, any, Infer<T>, any, Record<string, any>>,
+			res: Response<any, Record<string, any>>,
+			next: NextFunction
+		) => Promise<any> | void,
+	>(_target: unknown, _propertyKey: string, descriptor: TypedPropertyDescriptor<F>) {
 		const originalMethod = descriptor.value!;
 
 		descriptor.value = async function (
 			this: unknown,
-			req: Request<unknown, unknown, Infer<T>>,
+			req: Request<any, any, Infer<T>, any, Record<string, any>>,
 			res: Response,
 			next: NextFunction
 		) {
@@ -57,23 +56,26 @@ export function bodyValidator<T extends SchemaTypes>(schema: T) {
 
 			req.body = data;
 
-			return originalMethod.call(this, req, res, next);
-		} as F;
+			return await originalMethod.call(this, req, res, next);
+		} as unknown as F;
 
 		return descriptor;
 	};
 }
+
 export function paramsValidator<T extends SchemaTypes>(schema: T) {
-	return function <F extends ExpressHandler<Infer<T>, unknown, unknown, unknown>>(
-		_target: unknown,
-		_propertyKey: string,
-		descriptor: TypedPropertyDescriptor<F>
-	) {
+	return function <
+		F extends (
+			req: Request<any, any, Infer<T>, any, Record<string, any>>,
+			res: Response<any, Record<string, any>>,
+			next: NextFunction
+		) => Promise<any> | void,
+	>(_target: unknown, _propertyKey: string, descriptor: TypedPropertyDescriptor<F>) {
 		const originalMethod = descriptor.value!;
 
 		descriptor.value = async function (
 			this: unknown,
-			req: Request<Infer<T>>,
+			req: Request<Infer<T>, any, any, any, Record<string, any>>,
 			res: Response,
 			next: NextFunction
 		) {
@@ -84,26 +86,28 @@ export function paramsValidator<T extends SchemaTypes>(schema: T) {
 				return res.status(422).json({ message: error.join("\n") });
 			}
 
-			req.params = data;
+			Object.assign(req.query, data);
 
-			return originalMethod.call(this, req, res, next);
-		} as F;
+			return await originalMethod.call(this, req, res, next);
+		} as unknown as F;
 
 		return descriptor;
 	};
 }
 
 export function queryValidator<T extends SchemaTypes>(schema: T) {
-	return function <F extends ExpressHandler<unknown, unknown, unknown, Infer<T>>>(
-		_target: unknown,
-		_propertyKey: string,
-		descriptor: TypedPropertyDescriptor<F>
-	) {
+	return function <
+		F extends (
+			req: Request<any, any, Infer<T>, any, Record<string, any>>,
+			res: Response<any, Record<string, any>>,
+			next: NextFunction
+		) => Promise<any> | void,
+	>(_target: unknown, _propertyKey: string, descriptor: TypedPropertyDescriptor<F>) {
 		const originalMethod = descriptor.value!;
 
 		descriptor.value = async function (
 			this: unknown,
-			req: Request<unknown, unknown, unknown, Infer<T>>,
+			req: Request<any, any, any, Infer<T>, Record<string, any>>,
 			res: Response,
 			next: NextFunction
 		) {
@@ -114,56 +118,27 @@ export function queryValidator<T extends SchemaTypes>(schema: T) {
 				return res.status(422).json({ message: error.join("\n") });
 			}
 
-			req.query = data;
-
-			return originalMethod.call(this, req, res, next);
-		} as F;
+			Object.assign(req.query, data);
+			return await originalMethod.call(this, req, res, next);
+		} as unknown as F;
 
 		return descriptor;
 	};
 }
-// export function authValidator({ optional = false }: { optional?: boolean } | undefined = {}) {
-// 	return function (target: any, propertyKey: string, descriptor: PropertyDescriptor) {
-// 		const originalMethod = descriptor.value;
-// 		descriptor.value = async function (req: Request, res: Response, next: NextFunction) {
-// 			try {
-// 				const accessToken = req.headers["authorization"]?.split(" ")[1];
-// 				if (optional && (!accessToken || !TokenModule.verifyAccessToken(accessToken))) {
-// 					return originalMethod.apply(this, [req, res, next]);
-// 				}
-// 				if (!accessToken) {
-// 					res.status(401).json({ message: "access token missing" });
-// 					return;
-// 				}
-// 				const payload = TokenModule.verifyAccessToken(accessToken);
-
-// 				if (!payload) {
-// 					res.status(401).json({ message: "invalid access token" });
-// 					return;
-// 				}
-// 				req.user = {
-// 					id: payload.userID,
-// 					email: payload.email
-// 				};
-// 				return originalMethod.apply(this, [req, res, next]);
-// 			} catch (error) {
-// 				next(error);
-// 			}
-// 		};
-// 	};
-// }
 
 export function mediaBodyValidator<T extends SchemaTypes>(schema: T, optional = false) {
-	return function <F extends ExpressHandler<unknown, unknown, Infer<T>, unknown>>(
-		_target: unknown,
-		_propertyKey: string,
-		descriptor: TypedPropertyDescriptor<F>
-	) {
+	return function <
+		F extends (
+			req: Request<any, any, Infer<T>, any, Record<string, any>> & { files?: any },
+			res: Response<any, Record<string, any>>,
+			next: NextFunction
+		) => Promise<any> | void,
+	>(_target: unknown, _propertyKey: string, descriptor: TypedPropertyDescriptor<F>) {
 		const originalMethod = descriptor.value!;
 
 		descriptor.value = async function (
 			this: unknown,
-			req: Request<unknown, unknown, Infer<T>>,
+			req: Request<any, any, Infer<T>, any, Record<string, any>> & { files?: any },
 			res: Response,
 			next: NextFunction
 		) {
@@ -184,9 +159,7 @@ export function mediaBodyValidator<T extends SchemaTypes>(schema: T, optional =
 				}
 			};
 
-			const parsedData = Object.fromEntries(
-				Object.entries(req.body).map(([k, v]) => [k, isJSON(v)])
-			);
+			const parsedData = Object.fromEntries(Object.entries(req.body).map(([k, v]) => [k, isJSON(v)]));
 
 			const { error, data } = await validateBody(schema, parsedData);
 
@@ -198,12 +171,13 @@ export function mediaBodyValidator<T extends SchemaTypes>(schema: T, optional =
 			req.body = data;
 			req.files = files;
 
-			return originalMethod.call(this, req, res, next);
-		} as F;
+			return await originalMethod.call(this, req, res, next);
+		} as unknown as F;
 
 		return descriptor;
 	};
 }
+
 export const validateId = vine.object({
 	id: vine.string().uuid(),
 });
@@ -224,10 +198,8 @@ export const paginationValidator = vine.object({
 		.parse(e => (!e ? "" : e))
 		.optional(),
 });
-export async function validate<T extends SchemaTypes>(
-	schema: T,
-	payload: Infer<T>
-): Promise<Infer<T>> {
+
+export async function validate<T extends SchemaTypes>(schema: T, payload: Infer<T>): Promise<Infer<T>> {
 	const result = await validateBody(schema, payload);
 
 	if (result.error.length) {

package/packages/@repo/model/eslint.config.ts

@@ -0,0 +1,4 @@
+import { baseConfig } from "eslint-config/base";
+import { extend } from "eslint-config/extend";
+
+export default extend(baseConfig);

package/packages/@repo/model/package.json

@@ -0,0 +1,41 @@
+{
+	"name": "@repo/model",
+	"type": "module",
+	"scripts": {
+		"lint": "eslint .",
+		"lint:fix": "eslint . src/**/*.ts --fix",
+		"clean": "rimraf dist build .turbo",
+		"deep:clean": "rimraf node_modules dist build .turbo",
+		"typecheck": "tsc --noEmit",
+		"format": "prettier --write .",
+		"format:check": "prettier --check .",
+		"test": "vitest run"
+	},
+	"exports": {
+		".": "./src/index.ts",
+		"./*": "./src/*/index.ts"
+	},
+	"dependencies": {
+		"@repo/lib": "workspace:^",
+		"@repo/logger": "workspace:^"
+	},
+	"devDependencies": {
+		"typescript-config": "workspace:^",
+		"eslint-config": "workspace:^",
+		"vitest-config": "workspace:^"
+	},
+	"startx": {
+		"iTags": [
+			"node"
+		],
+		"gTags": [],
+		"tags": [],
+		"requiredDeps": [
+			"@repo/env",
+			"@repo/lib"
+		],
+		"requiredDevDeps": [
+			"typescript-config"
+		]
+	}
+}

package/packages/@repo/model/tsconfig.json

@@ -0,0 +1,7 @@
+{
+	"extends": "typescript-config/tsconfig.node.json",
+	"compilerOptions": {
+		// "baseUrl": "./src"
+	},
+	"include": ["src/**/*.ts"]
+}

package/packages/@repo/model/vitest.config.ts

@@ -0,0 +1,3 @@
+import vitestConfig from "vitest-config/node";
+
+export default vitestConfig;

package/packages/common/src/time.ts

@@ -1,23 +1,96 @@
-/**
- * Convert time from any time unit to any other unit
- */
-export const Time = {
-	milliseconds: {
-		toMinutes: 1 / (60 * 1000),
-		toSeconds: 1 / 1000,
-	},
-	seconds: {
-		toMilliseconds: 1000,
-	},
-	minutes: {
-		toMilliseconds: 60 * 1000,
-	},
-	hours: {
-		toMilliseconds: 60 * 60 * 1000,
-		toSeconds: 60 * 60,
-	},
-	days: {
-		toSeconds: 24 * 60 * 60,
-		toMilliseconds: 24 * 60 * 60 * 1000,
-	},
+type TimeUnit = "milliseconds" | "seconds" | "minutes" | "hours" | "days" | "weeks";
+
+const UNIT_IN_MS: Record<TimeUnit, number> = {
+	milliseconds: 1,
+	seconds: 1000,
+	minutes: 60 * 1000,
+	hours: 60 * 60 * 1000,
+	days: 24 * 60 * 60 * 1000,
+	weeks: 7 * 24 * 60 * 60 * 1000,
 };
+
+export class Time {
+	private ms: number;
+
+	constructor(value: number, unit: TimeUnit = "milliseconds") {
+		this.ms = value * UNIT_IN_MS[unit];
+	}
+
+	// factory methods
+	static ms(value: number) {
+		return new Time(value, "milliseconds");
+	}
+
+	static seconds(value: number) {
+		return new Time(value, "seconds");
+	}
+
+	static minutes(value: number) {
+		return new Time(value, "minutes");
+	}
+
+	static hours(value: number) {
+		return new Time(value, "hours");
+	}
+
+	static days(value: number) {
+		return new Time(value, "days");
+	}
+
+	static weeks(value: number) {
+		return new Time(value, "weeks");
+	}
+
+	// generic converter
+	to(unit: TimeUnit): number {
+		return this.ms / UNIT_IN_MS[unit];
+	}
+
+	// convenience getters
+	get milliseconds() {
+		return this.to("milliseconds");
+	}
+
+	get seconds() {
+		return this.to("seconds");
+	}
+
+	get minutes() {
+		return this.to("minutes");
+	}
+
+	get hours() {
+		return this.to("hours");
+	}
+
+	get days() {
+		return this.to("days");
+	}
+
+	get weeks() {
+		return this.to("weeks");
+	}
+
+	// arithmetic
+	add(value: number, unit: TimeUnit) {
+		this.ms += value * UNIT_IN_MS[unit];
+		return this;
+	}
+
+	subtract(value: number, unit: TimeUnit) {
+		this.ms -= value * UNIT_IN_MS[unit];
+		return this;
+	}
+
+	format() {
+		if (this.ms < UNIT_IN_MS.seconds) return `${this.ms}ms`;
+		if (this.ms < UNIT_IN_MS.minutes) return `${this.seconds}s`;
+		if (this.ms < UNIT_IN_MS.hours) return `${this.minutes}m`;
+		if (this.ms < UNIT_IN_MS.days) return `${this.hours}h`;
+		return `${this.days}d`;
+	}
+
+	valueOf() {
+		return this.ms;
+	}
+}