startx 1.0.5 → 1.0.9

package/apps/web-client/Dockerfile

@@ -0,0 +1,40 @@
+# syntax=docker/dockerfile:1
+
+FROM node:24-alpine AS base
+RUN corepack enable && corepack prepare pnpm@11.5.1 --activate
+
+WORKDIR /app
+
+FROM base AS builder
+
+COPY package.json pnpm-lock.yaml pnpm-workspace.yaml ./
+
+COPY --parents apps/web-client/package.json ./
+COPY --parents packages/common/package.json ./
+COPY --parents packages/ui/package.json ./
+COPY --parents configs/*/package.json ./
+
+RUN --mount=type=cache,id=pnpm,target=/root/.local/share/pnpm/store \
+    pnpm install --frozen-lockfile
+
+COPY apps/web-client/ ./apps/web-client/
+COPY packages/common ./packages/common
+COPY packages/ui ./packages/ui
+COPY configs ./configs
+COPY turbo.json ./
+
+# Build the required packages with Turbo cache mounted
+RUN --mount=type=cache,id=turbo,target=/app/.turbo/cache \
+    pnpm build --filter=web-client
+
+# --- Final production image ---
+FROM nginx:stable-alpine
+
+
+# Copy built server dist
+COPY --from=builder /app/apps/web-client/build/client /usr/share/nginx/html
+COPY --from=builder /app/apps/web-client/nginx.conf /etc/nginx/conf.d/default.conf
+
+EXPOSE 80
+
+CMD ["nginx", "-g", "daemon off;"]

package/apps/web-client/nginx.conf

@@ -0,0 +1,20 @@
+server {
+    listen 80;
+    server_name _;
+
+    root /usr/share/nginx/html;
+    index index.html;
+
+    include /etc/nginx/mime.types;
+
+    location / {
+        try_files $uri $uri/ /index.html;
+    }
+
+    location /assets/ {
+        expires 1y;
+        add_header Cache-Control "public, immutable";
+    }
+
+    error_page 404 /index.html;
+}

package/apps/web-client/package.json

@@ -8,7 +8,7 @@
 		"dev": "react-router dev",
 		"format": "biome format --write .",
 		"format:check": "biome ci .",
-		"start": "react-router-serve ./build/server/index.js",
+		"start": "vite preview",
 		"typecheck": "react-router typegen && tsc",
 		"test": "vitest run",
 		"lint": "eslint .",

package/apps/web-client/src/app.css

@@ -1 +0,0 @@
-@import "tailwindcss";

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "startx",
   "description": "",
-  "version": "1.0.5",
+  "version": "1.0.9",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/avinashid/startx.git"
@@ -33,6 +33,12 @@
     "clean": "turbo clean",
     "test": "turbo test",
     "format": "turbo format",
-    "db:push": "turbo db:push"
+    "db:push": "turbo run db:push",
+    "db:studio": "turbo run db:studio",
+    "db:generate": "turbo run db:generate",
+    "db:migrate": "turbo run db:migrate",
+    "db:up": "turbo run db:up",
+    "db:check": "turbo run db:check",
+    "db:pull": "turbo run db:pull"
   }
 }

package/packages/@db/drizzle/drizzle.config.ts

@@ -6,7 +6,7 @@ const env = defineEnv({
 });
 export default defineConfig({
 	out: "./drizzle",
-	schema: "./src/schema/index.ts",
+	schema: "./src/schema/**/*.ts",
 	dialect: "postgresql",
 	dbCredentials: {
 		url: env.DATABASE_URL!,

package/packages/@db/drizzle/src/index.ts

@@ -1,26 +1,15 @@
 import { defineEnv } from "@repo/env";
-import type { ExtractTablesWithRelations } from "drizzle-orm";
 import { drizzle, type NodePgQueryResultHKT } from "drizzle-orm/node-postgres";
-import { type PgTransaction } from "drizzle-orm/pg-core";
-import Pg from "pg";
+import { PgAsyncTransaction } from "drizzle-orm/pg-core";
 import z from "zod";
 
-import * as schema from "./schema/index.js";
-
 const env = defineEnv({
 	DATABASE_URL: z.string(),
 });
-export const client = new Pg.Pool({
-	connectionString: env.DATABASE_URL,
-});
-const db = drizzle({ client, schema });
-export type DrizzleTransaction = PgTransaction<
-	NodePgQueryResultHKT,
-	typeof schema,
-	ExtractTablesWithRelations<typeof schema>
->;
+export type DrizzleTransaction = PgAsyncTransaction<NodePgQueryResultHKT>;
+const db = drizzle(env.DATABASE_URL);
+
 export type DrizzleDB = typeof db;
 export { db };
 export * from "drizzle-orm";
 export * from "./functions.js";
-export * from "./schema/index.js";

package/packages/@repo/env/src/default-env.ts

@@ -9,4 +9,5 @@ export const ENV = defineEnv({
 	CORS_URL: z.string().optional().default("http://localhost:3000"),
 	PORT: z.string().optional().default("3000"),
 	LOG_LEVEL: z.enum(["error", "warn", "info", "http", "debug"]).default("debug"),
+	FILE_STORAGE_PATH: z.string().optional().default("storage"),
 });

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

@@ -1,48 +1,104 @@
+import { Time } from "@repo/common/time";
 import { defineEnv, ENV } from "@repo/env";
 import type { CookieOptions } from "express";
 import z from "zod";
 
 const credentials = defineEnv({
-	COOKIE_DOMAIN: z.string().optional().default(".localhost"),
+	COOKIE_DOMAIN: z.string().optional(),
 });
 
-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 = ENV.NODE_ENV === "production";
-		const stagingEnv = ENV.NODE_ENV === "staging";
-
-		if (prodEnv) {
-			this.refreshToken.cookie = "refresh-token";
-			this.refreshToken.cookieDomain = credentials.COOKIE_DOMAIN;
-			this.refreshToken.secureCookie = true;
-			this.refreshToken.maxAge = prodMaxAge;
-		} else {
-			this.refreshToken.cookie = "refresh-token-staging";
-			this.refreshToken.cookieDomain = stagingEnv
-				? credentials.COOKIE_DOMAIN
-				: credentials.COOKIE_DOMAIN || "localhost";
-			this.refreshToken.secureCookie = stagingEnv ? true : false;
-			this.refreshToken.maxAge = stagingMaxAge;
-		}
-	},
+type RuntimeEnv = "development" | "staging" | "production";
+
+type CookieDescriptor = {
+	name: string;
+	options: CookieOptions;
 };
-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,
+
+const COOKIE_NAMES = {
+	production: "refresh-token",
+	nonProduction: "refresh-token-staging",
+} as const;
+
+const COOKIE_TTL = {
+	development: Time.days(90).milliseconds,
+	staging: Time.days(90).milliseconds,
+	production: Time.days(30).milliseconds,
+} as const;
+
+function getRuntimeEnv(): RuntimeEnv {
+	switch (ENV.NODE_ENV) {
+		case "production":
+			return "production";
+		case "staging":
+			return "staging";
+		default:
+			return "development";
+	}
+}
+
+function resolveCookieDomain(env: RuntimeEnv): string | undefined {
+	if (env === "development") {
+		return undefined;
+	}
+
+	if (!credentials.COOKIE_DOMAIN) {
+		throw new Error("COOKIE_DOMAIN must be configured in staging/production environments");
+	}
+
+	return credentials.COOKIE_DOMAIN;
+}
+
+function resolveSameSite(env: RuntimeEnv): CookieOptions["sameSite"] {
+	/**
+	 * If frontend and API are on different origins:
+	 * use "none" + secure=true
+	 *
+	 * Otherwise lax is safer.
+	 */
+	return env === "production" || env === "staging" ? "lax" : "lax";
+}
+
+function createRefreshTokenCookie(): CookieDescriptor {
+	const env = getRuntimeEnv();
+	const secure = env !== "development";
+
+	return {
+		name: env === "production" ? COOKIE_NAMES.production : COOKIE_NAMES.nonProduction,
+		options: {
+			httpOnly: true,
+			secure,
+			sameSite: resolveSameSite(env),
+			maxAge: COOKIE_TTL[env],
+			domain: resolveCookieDomain(env),
+			path: "/",
+		},
 	};
-	return [constants.refreshToken.cookie, refreshToken, cookieOptions];
 }
+
+const refreshTokenCookie = createRefreshTokenCookie();
+
+export const CookieModule = Object.freeze({
+	refreshTokenName(): string {
+		return refreshTokenCookie.name;
+	},
+
+	setRefreshToken(token: string): [string, string, CookieOptions] {
+		return [refreshTokenCookie.name, token, refreshTokenCookie.options];
+	},
+
+	clearRefreshToken(): [string, string, CookieOptions] {
+		return [
+			refreshTokenCookie.name,
+			"",
+			{
+				...refreshTokenCookie.options,
+				maxAge: 0,
+				expires: new Date(0),
+			},
+		];
+	},
+
+	getRefreshTokenOptions(): CookieOptions {
+		return refreshTokenCookie.options;
+	},
+});

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

@@ -1 +1,2 @@
 export * from "./pagination-module.js";
+export * from "./token-module.js"

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

@@ -1,41 +1,70 @@
-import { defineEnv, ENV } from "@repo/env";
-import * as jwt from "jsonwebtoken";
+import { Time } from "@repo/common/time";
+import { defineEnv } from "@repo/env";
+import { logger } from "@repo/logger";
+import jwt from "jsonwebtoken";
 import z from "zod";
-export type AuthTokenPayload = {
+
+export type AccessTokenPayload = {
+	userID: string;
+	email: string;
+	sessionID: string;
+};
+
+export type RefreshTokenPayload = {
 	userID: string;
 	email: string;
+	sessionID: string;
+	jti: string;
 };
 
-const credentials = defineEnv({
-	ACCESS_TOKEN_SECRET: z.string(),
-	REFRESH_TOKEN_SECRET: z.string(),
+const env = defineEnv({
+	ACCESS_TOKEN_SECRET: z.string().min(32),
+	REFRESH_TOKEN_SECRET: z.string().min(32),
+	ACCESS_TOKEN_EXPIRY: z.coerce.number().default(Time.hours(1).milliseconds),
+	REFRESH_TOKEN_EXPIRY: z.coerce.number().default(Time.days(30).milliseconds),
 });
-const accessTokenSecret = credentials.ACCESS_TOKEN_SECRET;
-const refreshTokenSecret = credentials.REFRESH_TOKEN_SECRET;
+
+const JWT_CONFIG = {
+	algorithm: "HS256" as const,
+};
 
 export class TokenModule {
-	static signRefreshToken(payload: AuthTokenPayload) {
-		return jwt.sign(payload, refreshTokenSecret, { expiresIn: "365d" });
+	static signAccessToken(payload: AccessTokenPayload): string {
+		return jwt.sign(payload, env.ACCESS_TOKEN_SECRET, {
+			...JWT_CONFIG,
+			expiresIn: env.ACCESS_TOKEN_EXPIRY,
+		});
 	}
-	static verifyRefreshToken(refreshToken: string) {
+
+	static verifyAccessToken(token: string): AccessTokenPayload | null {
 		try {
-			const payload = jwt.verify(refreshToken, refreshTokenSecret) as AuthTokenPayload;
-			return payload;
+			return jwt.verify(token, env.ACCESS_TOKEN_SECRET, {
+				algorithms: ["HS256"],
+			}) as AccessTokenPayload;
 		} catch (error) {
-			console.error(error);
+			logger.warn("Access token verification failed", {
+				error: error instanceof Error ? error.message : "unknown",
+			});
 			return null;
 		}
 	}
-	static signAccessToken(payload: AuthTokenPayload) {
-		const expiration = ENV.NODE_ENV === "development" ? "30d" : "1d";
-		return jwt.sign(payload, accessTokenSecret, { expiresIn: expiration });
+
+	static signRefreshToken(payload: RefreshTokenPayload): string {
+		return jwt.sign(payload, env.REFRESH_TOKEN_SECRET, {
+			...JWT_CONFIG,
+			expiresIn: env.REFRESH_TOKEN_EXPIRY,
+		});
 	}
-	static verifyAccessToken(accessToken: string) {
+
+	static verifyRefreshToken(token: string): RefreshTokenPayload | null {
 		try {
-			const payload = jwt.verify(accessToken, accessTokenSecret) as AuthTokenPayload;
-			return payload;
+			return jwt.verify(token, env.REFRESH_TOKEN_SECRET, {
+				algorithms: ["HS256"],
+			}) as RefreshTokenPayload;
 		} catch (error) {
-			console.error(error);
+			logger.warn("Refresh token verification failed", {
+				error: error instanceof Error ? error.message : "unknown",
+			});
 			return null;
 		}
 	}

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

@@ -4,50 +4,64 @@ import type { Transporter, SendMailOptions } from "nodemailer";
 import * as nodemailer from "nodemailer";
 import z from "zod";
 
-const credentials = defineEnv({
+const credentials = {
 	SMTP_HOST: z.string(),
-	SMTP_PORT: z.coerce.number().default(587),
+	SMTP_PORT: z.coerce.number().default(465),
 	SMTP_USER: z.string(),
 	SMTP_PASSWORD: z.string(),
-	SMTP_MAIL_ENCRYPTION: z.string().default("tls"),
+	SMTP_MAIL_ENCRYPTION: z.enum(["ssl", "tls", "starttls"]).default("ssl"),
 	SMTP_SENDER_MAIL: z.string().email(),
 	SMTP_SENDER_NAME: z.string().default("Startx"),
-});
+};
+const _SMTPConfigSchema = z.object(credentials);
+
+export type SMTPConfig = z.infer<typeof _SMTPConfigSchema>;
 
 class SMTPMailService {
-	private static transporter: Transporter | null = null;
+	private static transporters = new Map<string, Transporter>();
+
+	private static getTransporter(config: SMTPConfig): Transporter {
+		const cacheKey = `${config.SMTP_HOST}:${config.SMTP_USER}`;
 
-	private static initializeTransporter(): Transporter {
-		if (!this.transporter) {
-			this.transporter = nodemailer.createTransport({
-				host: credentials.SMTP_HOST,
-				port: credentials.SMTP_PORT,
-				secure: credentials.SMTP_MAIL_ENCRYPTION === "ssl",
+		if (!this.transporters.has(cacheKey)) {
+			const transporter = nodemailer.createTransport({
+				host: config.SMTP_HOST,
+				port: config.SMTP_PORT,
+				secure: config.SMTP_MAIL_ENCRYPTION === "ssl",
 				auth: {
-					user: credentials.SMTP_USER,
-					pass: credentials.SMTP_PASSWORD,
+					user: config.SMTP_USER,
+					pass: config.SMTP_PASSWORD,
 				},
 			});
+			this.transporters.set(cacheKey, transporter);
 		}
-		return this.transporter;
+
+		return this.transporters.get(cacheKey)!;
 	}
 
-	static async verifyConnection(): Promise<void> {
-		const transporter = this.initializeTransporter();
+	static async verifyConnection(customConfig?: SMTPConfig): Promise<boolean> {
+		const config = customConfig || defineEnv(credentials);
+		const transporter = this.getTransporter(config);
+
 		try {
 			await transporter.verify();
-			logger.info("SMTP Connection verified successfully.");
+			logger.info(`SMTP Connection verified successfully for ${config.SMTP_HOST}`);
+			return true;
 		} catch (error) {
-			logger.error("SMTP Connection verification failed:", error);
-			throw error;
+			logger.error(`SMTP Connection verification failed for ${config.SMTP_HOST}:`, error);
+			return false;
 		}
 	}
 
-	static async sendMail(props: { to: string; subject: string; text: string; html?: string }) {
-		const transporter = this.initializeTransporter();
+	static async sendMail(
+		props: { to: string; subject: string; text: string; html?: string },
+		customConfig?: SMTPConfig
+	) {
+		const config = customConfig || defineEnv(credentials);
+		const transporter = this.getTransporter(config);
 
 		const mailOptions: SendMailOptions = {
-			from: `"${credentials.SMTP_SENDER_NAME}" <${credentials.SMTP_SENDER_MAIL}>`,
+			from: `"${config.SMTP_SENDER_NAME}" <${config.SMTP_SENDER_MAIL}>`,
 			to: props.to,
 			subject: props.subject,
 			text: props.text,
@@ -60,7 +74,6 @@ class SMTPMailService {
 			return info;
 		} catch (error) {
 			logger.error("Error sending email:", error);
-			// Retain the original error context for debugging
 			throw new Error("Failed to send email", { cause: error });
 		}
 	}