startx 0.0.1

package/configs/typescript-config/tsconfig.node.json

@@ -0,0 +1,9 @@
+{
+	"extends": "./tsconfig.common.json",
+	"compilerOptions": {
+		"module": "nodenext",
+		"moduleResolution": "nodenext",
+		"experimentalDecorators": true,
+		"types": ["node"]
+	}
+}

package/configs/vitest-config/package.json

@@ -0,0 +1,25 @@
+{
+	"name": "vitest-config",
+	"version": "1.5.0",
+	"type": "module",
+	"peerDependencies": {
+		"vite": "catalog:",
+		"vitest": "catalog:"
+	},
+	"devDependencies": {
+		"typescript-config": "workspace:*",
+		"vite": "catalog:"
+	},
+	"exports": {
+		"./frontend": "./src/frontend.ts",
+		"./node": "./src/node.ts",
+		"./base": "./src/base.ts"
+	},
+	"scripts": {
+		"clean": "rimraf dist .turbo",
+		"deep:clean": "rimraf node_modules dist .turbo",
+		"typecheck": "tsc --noEmit",
+		"format": "biome format --write .",
+		"format:check": "biome ci ."
+	}
+}

package/configs/vitest-config/src/base.ts

@@ -0,0 +1,34 @@
+import { defineConfig } from "vitest/config";
+import type { InlineConfig } from "vitest/node";
+
+// Detect if we are running in "dev" mode (npm run test:dev)
+const isDev = process.env.npm_lifecycle_event === "test:dev";
+export const baseVitestConfig = (options: InlineConfig = {}) =>
+  defineConfig({
+    test: {
+      silent: true,
+      globals: true,
+
+      // Smart Include/Exclude Logic (Shared)
+      // Dev: Run TS source | Prod: Run compiled JS in dist
+      include: isDev
+        ? ["src/**/*.{test,spec}.{ts,tsx}"]
+        : ["dist/**/*.{test,spec}.{js,mjs,cjs}"],
+      exclude: isDev
+        ? ["**/node_modules/**", "**/dist/**"]
+        : ["**/node_modules/**", "**/src/**"],
+
+      // Standardized Coverage Logic
+      coverage:
+        process.env.COVERAGE_ENABLED === "true"
+          ? {
+              enabled: true,
+              provider: "v8",
+              ...options.coverage,
+            }
+          : { enabled: false },
+
+      // Merge whatever specific options are passed
+      ...options,
+    },
+  });

package/configs/vitest-config/src/frontend.ts

@@ -0,0 +1,15 @@
+import { baseVitestConfig } from "./base.js";
+
+export default baseVitestConfig({
+  environment: "jsdom",
+  setupFiles: ["./src/__tests__/setup.ts"],
+  css: {
+    modules: {
+      classNameStrategy: "non-scoped",
+    },
+  },
+
+  coverage: {
+    reporter: ["text-summary", "lcov", "html"],
+  }
+});

package/configs/vitest-config/src/node.ts

@@ -0,0 +1,5 @@
+import { baseVitestConfig } from "./base.js";
+
+export default baseVitestConfig({
+  environment: "node",
+});

package/configs/vitest-config/tsconfig.json

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

package/package.json

@@ -0,0 +1,47 @@
+{
+	"name": "startx",
+	"version": "0.0.1",
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/avinashid/startx.git"
+	},
+	"scripts": {
+		"config:build": "turbo run config:build",
+		"build": "turbo run build",
+		"dev": "turbo run dev",
+		"lint": "turbo run lint",
+		"typecheck": "turbo run typecheck",
+		"clean": "turbo run clean",
+		"test": "turbo run test",
+		"test:dev": "turbo run test:dev",
+		"format": "turbo run format"
+	},
+	"devDependencies": {
+		"@biomejs/biome": "catalog:",
+		"@vitest/coverage-v8": "catalog:",
+		"prettier": "catalog:",
+		"rimraf": "catalog:",
+		"turbo": "catalog:",
+		"typescript": "catalog:",
+		"eslint": "catalog:",
+		"tsdown": "catalog:",
+		"unrun": "catalog:",
+		"vitest": "catalog:",
+		"@types/node": "catalog:"
+	},
+	"dependencies": {
+		"zod": "catalog:"
+	},
+	"engines": {
+		"node": ">=22"
+	},
+	"keywords": [
+		"startx",
+		"turborepo",
+		"scaffold",
+		"express"
+	],
+	"author": "avinashid",
+	"license": "MIT",
+	"packageManager": "pnpm@10.28.2"
+}

package/packages/@repo/constants/eslint.config.mjs

@@ -0,0 +1,21 @@
+import { baseConfig } from "eslint-config/base";
+
+/** @type {import('eslint').Linter.Config[]} */
+export default [
+	// Spread the base config array
+	...baseConfig,
+	{
+		rules: {
+			"unicorn/filename-case": ["error", { case: "kebabCase" }],
+		},
+		// Note: basePath belongs inside languageOptions or simply isn't standard in flat config
+		// unless defined by a specific plugin, so I omitted it here to avoid future errors.
+	},
+	// Add this block to disable the rule for config files
+	{
+		files: ["./src/**/*.ts"],
+		rules: {
+			"import-x/no-default-export": "off",
+		},
+	},
+];

package/packages/@repo/constants/package.json

@@ -0,0 +1,19 @@
+{
+	"name": "@repo/constants",
+	"version": "0.12.0",
+	"scripts": {
+		"clean": "rimraf dist .turbo",
+		"watch:dev": "pnpm watch",
+		"typecheck": "tsc --noEmit",
+		"format": "biome format --write .",
+		"format:check": "biome ci .",
+		"lint": "eslint .",
+		"lint:fix": "eslint . --fix",
+		"watch": "tsc -p tsconfig.build.json --watch"
+	},
+	"exports": "./src/index.ts",
+	"devDependencies": {
+		"typescript-config": "workspace:*",
+		"eslint-config": "workspace:*"
+	}
+}

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

@@ -0,0 +1 @@
+export const BASE_API_URL = '';

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

@@ -0,0 +1,8 @@
+export * from "./api";
+
+export { Time } from "./time";
+
+export const MIN_PASSWORD_CHAR_LENGTH = 8;
+
+export const MAX_PASSWORD_CHAR_LENGTH = 64;
+export const ping = "pong";

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

@@ -0,0 +1,23 @@
+/**
+ * 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,
+	},
+};

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

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

package/packages/@repo/db/eslint.config.mjs

@@ -0,0 +1,21 @@
+import { defineConfig } from "eslint/config";
+import { baseConfig } from "eslint-config/base";
+
+export default defineConfig(
+	baseConfig,
+	{
+		rules: {
+			"unicorn/filename-case": ["error", { case: "kebabCase" }],
+			"local-rules/no-unneeded-backticks": "off",
+		},
+	},
+	{
+		files: ["**/*.test.ts"],
+		rules: {
+			"@typescript-eslint/no-unused-expressions": "warn",
+			"@typescript-eslint/no-unsafe-assignment": "warn",
+			"@typescript-eslint/unbound-method": "warn",
+			"import-x/no-duplicates": "warn",
+		},
+	},
+);

package/packages/@repo/db/package.json

@@ -0,0 +1,30 @@
+{
+	"name": "@repo/db",
+	"version": "0.0.0",
+	"private": true,
+	"scripts": {
+		"clean": "rimraf dist .turbo",
+		"watch:dev": "pnpm watch",
+		"typecheck": "tsc --noEmit",
+		"format": "biome format --write .",
+		"format:check": "biome ci .",
+		"lint": "eslint .",
+		"lint:fix": "eslint . --fix",
+		"watch": "tsc -p tsconfig.build.json --watch"
+	},
+	"exports": "./src/index.ts",
+	"devDependencies": {
+		"@types/eslint": "^8.56.5",
+		"@types/node": "^20.16.5",
+		"@types/pg": "^8.16.0",
+		"eslint": "catalog:",
+		"eslint-config": "workspace:*",
+		"tsc-alias": "^1.8.10",
+		"typescript": "5.5.4",
+		"typescript-config": "workspace:*"
+	},
+	"dependencies": {
+		"drizzle-orm": "^0.36.0",
+		"pg": "^8.16.3"
+	}
+}

package/packages/@repo/db/src/functions.ts

@@ -0,0 +1,122 @@
+import { type AnyColumn, sql, type SQL } from "drizzle-orm";
+import type { PgColumn } from "drizzle-orm/pg-core";
+
+export const increment = (column: AnyColumn, value = 1) => {
+  return sql`${column} + ${value}`;
+};
+
+export const decrement = (column: AnyColumn, value = 1) => {
+  return sql`${column} - ${value}`;
+};
+
+export const push = (column: AnyColumn, value: unknown) => {
+  return sql`array_append(${column}, ${value})`;
+};
+
+export const concatArray = (column: AnyColumn, values: unknown[]) => {
+  const columnType = column.getSQLType().replace("[]", "");
+
+  return sql`
+    array_cat(
+      ${column},
+      ${sql`ARRAY[${sql.join(
+        values.map((value) => sql`CAST(${value} AS ${sql.raw(columnType)})`),
+        sql`', '`
+      )}]`}
+    )
+  `;
+};
+
+export const sqlConcat = (
+  columns: Array<AnyColumn | null | undefined>,
+  separator = " "
+) => {
+  const filteredColumns = columns
+    .filter((col): col is AnyColumn => col !== null)
+    .map((col) => sql`TRIM(COALESCE(${col}, ''))`);
+
+  if (filteredColumns.length === 0) {
+    const separator = sql<string>`' '`;
+		return separator
+  }
+
+  return sql<string>`
+    TRIM(
+      CONCAT_WS(
+        ${separator},
+        ${sql.join(filteredColumns, sql`', '`)}
+      )
+    )
+  `;
+};
+
+export const removeFromArray = (column: AnyColumn, values: unknown[]) => {
+  const columnType = column.getSQLType().replace("[]", "");
+
+  return values.reduce<AnyColumn | SQL>(
+    (acc, value) =>
+      sql`array_remove(${acc}, ${sql`CAST(${value} AS ${sql.raw(columnType)})`})`,
+    column
+  );
+};
+
+export function castToText(column: AnyColumn) {
+  return sql`CAST(${column} AS TEXT)`;
+}
+
+export function objectBuilder<T extends Record<string, PgColumn | SQL>>(
+  shape: T,
+  aggregate: true
+): SQL<Array<UnwrapColumns<T>>>;
+
+export function objectBuilder<T extends Record<string, PgColumn | SQL>>(
+  shape: T,
+  aggregate?: false
+): SQL<UnwrapColumns<T>>;
+
+export function objectBuilder<T extends Record<string, PgColumn | SQL>>(
+  shape: T,
+  aggregate = false
+): SQL<UnwrapColumns<T> | Array<UnwrapColumns<T>>> {
+  const chunks: SQL[] = [];
+  const filter: SQL[] = [];
+
+  for (const [key, value] of Object.entries(shape)) {
+    if (chunks.length > 0) {
+      chunks.push(sql.raw(","));
+    }
+
+    chunks.push(sql.raw(`'${key}',`));
+    chunks.push(sql`${value}`);
+    filter.push(sql`${value} IS NOT NULL`);
+  }
+
+	// const or = sql<string>`" OR "`;
+
+  const query = aggregate
+    ? sql`
+        COALESCE(
+          json_agg(
+            DISTINCT jsonb_build_object(${sql.join(chunks)})
+          ) FILTER (WHERE ${sql.join(filter, sql`' OR '`)}),
+          '[]'
+        )
+      `
+    : sql`jsonb_build_object(${sql.join(chunks)})`;
+
+  return query as SQL<UnwrapColumns<T>>;
+}
+
+type UnwrapColumns<T> = T extends Record<string, unknown>
+  ? {
+      [K in keyof T]: T[K] extends PgColumn<infer C>
+        ? C["notNull"] extends true
+          ? C["data"]
+          : C["data"] | null
+        : T[K] extends SQL<infer S>
+        ? S
+        : never;
+    }
+  : never;
+
+export type Condition = boolean | SQL<unknown>;

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

@@ -0,0 +1,20 @@
+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 * as schema from "./schema/index.js";
+
+export const client = new Pg.Pool({
+	connectionString: process.env.DATABASE_URL,
+});
+const db = drizzle({ client, schema });
+export type DrizzleTransaction = PgTransaction<
+	NodePgQueryResultHKT,
+	typeof schema,
+	ExtractTablesWithRelations<typeof schema>
+>;
+export type DrizzleDB = typeof db;
+export  {db};
+export * from "./functions.js";
+export * from "./schema/index.js";

package/packages/@repo/db/src/schema/common.ts

@@ -0,0 +1,49 @@
+import { pgTable, uuid, varchar, timestamp, pgEnum, text } from "drizzle-orm/pg-core";
+
+// Helper function to generate current timestamp
+
+export const userRoleEnum = pgEnum("user_role", ["user", "admin", "superuser"]);
+
+export const usersTable = pgTable("users", {
+	id: uuid("id").primaryKey().defaultRandom(),
+	email: varchar("email", { length: 255 }).notNull().unique(),
+	fullName: varchar("full_name", { length: 255 }).default("Guest").notNull(),
+	password: varchar("password", { length: 255 }).default("foresight").notNull(),
+	countries: varchar("countries", { length: 255 }).array().notNull().default([]),
+	verifiedAt: timestamp("verified_at"),
+	pwdUpdatedAt: timestamp("pwd_updated_at"),
+	deletedAt: timestamp("deleted_at"),
+	createdAt: timestamp("created_at").defaultNow(),
+	lastLoginAt: timestamp("last_login_at").defaultNow(),
+	updatedAt: timestamp("updated_at")
+		.defaultNow()
+		.$onUpdate(() => new Date()),
+});
+
+export const filesTable = pgTable("files", {
+	id: uuid("id").primaryKey().defaultRandom(),
+	fileName: varchar("file_name", { length: 255 }).notNull(),
+	url: text("url").notNull(),
+	mimetype: text("mimetype").notNull(),
+	preview: text("preview"),
+	createdAt: timestamp("created_at").defaultNow(),
+	updatedAt: timestamp("updated_at")
+		.defaultNow()
+		.$onUpdate(() => new Date()),
+});
+
+export const otps = pgTable("otp", {
+	id: uuid("id").primaryKey().defaultRandom(),
+	email: varchar("email", { length: 255 }).notNull().unique(),
+	phone: varchar("phone", { length: 50 }),
+	status: varchar("status", { enum: ["pending", "verified"] })
+		.notNull()
+		.default("pending"),
+	otp: varchar("otp", { length: 255 }).notNull(),
+	createdAt: timestamp("created_at").defaultNow(),
+	updatedAt: timestamp("updated_at")
+		.defaultNow()
+		.$onUpdate(() => new Date()),
+});
+
+// ----------------------------------------------------------------------------

package/packages/@repo/db/src/schema/index.ts

@@ -0,0 +1 @@
+export * from "./common.js";

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

@@ -0,0 +1,13 @@
+{
+	"extends": "typescript-config/tsconfig.common.json",
+	"compilerOptions": {
+		"rootDir": ".",
+		"types": ["node"],
+		"baseUrl": "src",
+		"tsBuildInfoFile": "dist/typecheck.tsbuildinfo",
+		"experimentalDecorators": true,
+		"emitDecoratorMetadata": true,
+		"allowSyntheticDefaultImports": true
+	},
+	"include": ["src/**/*.ts"]
+}

package/packages/@repo/lib/eslint.config.mjs

@@ -0,0 +1,49 @@
+import { defineConfig } from "eslint/config";
+import { baseConfig } from "eslint-config/base";
+
+export default defineConfig(
+	baseConfig,
+	{
+		rules: {
+			"unicorn/filename-case": ["error", { case: "kebabCase" }],
+			complexity: ["error", 23],
+
+			// TODO: remove these
+			"no-empty": "warn",
+			"id-denylist": "warn",
+			"no-fallthrough": "warn",
+			"no-useless-escape": "warn",
+			"import-x/order": "warn",
+			"no-extra-boolean-cast": "warn",
+			"no-case-declarations": "warn",
+			"no-prototype-builtins": "warn",
+			"@typescript-eslint/naming-convention": "warn",
+			"@typescript-eslint/no-base-to-string": "warn",
+			"@typescript-eslint/no-redundant-type-constituents": "warn",
+			"@typescript-eslint/prefer-nullish-coalescing": "warn",
+			"@typescript-eslint/prefer-optional-chain": "warn",
+			"@typescript-eslint/return-await": ["error", "always"],
+			"@typescript-eslint/no-empty-object-type": "warn",
+			"@typescript-eslint/no-unsafe-function-type": "warn",
+			"@typescript-eslint/no-duplicate-type-constituents": "warn",
+			"@typescript-eslint/no-unsafe-return": "warn",
+			"@typescript-eslint/no-unsafe-call": "warn",
+			"@typescript-eslint/no-unsafe-member-access": "warn",
+			"@typescript-eslint/no-unsafe-assignment": "warn",
+			"@typescript-eslint/no-explicit-any": "warn",
+		},
+	},
+	{
+		files: ["**/*.test.ts"],
+		rules: {
+			// TODO: remove these
+			"prefer-const": "warn",
+			"@typescript-eslint/no-unused-expressions": "warn",
+			"@typescript-eslint/no-explicit-any": "warn",
+			"@typescript-eslint/no-unsafe-member-access": "warn",
+			"@typescript-eslint/no-unsafe-assignment": "warn",
+			"@typescript-eslint/no-unsafe-return": "warn",
+			"@typescript-eslint/ban-ts-comment": ["warn", { "ts-ignore": true }],
+		},
+	},
+);

package/packages/@repo/lib/package.json

@@ -0,0 +1,57 @@
+{
+	"name": "@repo/lib",
+	"version": "0.0.0",
+	"private": true,
+	"scripts": {
+		"clean": "rimraf dist .turbo",
+		"watch:dev": "pnpm watch",
+		"typecheck": "tsc --noEmit",
+		"format": "biome format --write .",
+		"format:check": "biome ci .",
+		"lint": "eslint .",
+		"lint:fix": "eslint . --fix",
+		"watch": "tsc -p tsconfig.build.json --watch"
+	},
+	"files": [
+		"dist/**/*"
+	],
+	"exports": "./src/index.ts",
+	"devDependencies": {
+		"@repo/email": "workspace:*",
+		"@repo/redis": "workspace:*",
+		"@types/eslint": "^8.56.5",
+		"@types/express": "^5.0.0",
+		"@types/node": "^20.16.5",
+		"@types/jsonwebtoken": "^9.0.7",
+		"@types/nodemailer": "^6.4.16",
+		"eslint-config": "workspace:*",
+		"tsc-alias": "^1.8.10",
+		"typescript-config": "workspace:*",
+		"vitest": "catalog:",
+		"vitest-config": "workspace:*",
+		"vitest-mock-extended": "^3.1.0",
+		"vine": "link:@types/vinejs/vine"
+	},
+	"dependencies": {
+		"@aws-sdk/client-s3": "^3.693.0",
+		"@repo/db": "workspace:^",
+		"@types/express-fileupload": "^1.5.1",
+		"@vinejs/vine": "^4.3.0",
+		"@repo/email": "workspace:*",
+		"axios": "^1.7.7",
+		"bcryptjs": "^3.0.2",
+		"country-state-city": "^3.2.1",
+		"dayjs": "^1.11.13",
+		"dayjs-plugin-utc": "^0.1.2",
+		"dotenv": "^16.6.1",
+		"drizzle-orm": "^0.36.0",
+		"express": "^4.21.1",
+		"express-fileupload": "^1.5.1",
+		"firebase-admin": "^13.0.2",
+		"fs.promises.exists": "^1.1.4",
+		"jsonwebtoken": "^9.0.2",
+		"nodemailer": "^6.9.16",
+		"winston": "^3.16.0",
+		"winston-daily-rotate-file": "^5.0.0"
+	}
+}

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

@@ -0,0 +1,49 @@
+import type { UploadedFile } from "express-fileupload";
+import fs from "fs";
+import path from "path";
+
+import { logger } from "../logger-module/logger";
+import { Random } from "../utils";
+
+export class FileBasedBucket {
+	static async upload(file: UploadedFile, subpath?: string) {
+		const fileName = Random.generateString(4, "hex") + path.extname(file.name);
+		const filePath = path.join(process.cwd(), "storage", subpath ?? "", fileName);
+		await FileBasedBucket.createDirectoryIfNotExists(`storage/${subpath ?? ""}`);
+		await file.mv(filePath);
+		const publicUrl = FileBasedBucket.getPublicUrl(`${subpath ?? ""}/${fileName}`);
+		return publicUrl;
+	}
+	static deleteFile(url: string) {
+		const filePath = FileBasedBucket.getPath(url);
+		try {
+			fs.unlinkSync(filePath);
+		} catch (error) {
+			logger.error("Error deleting file:", error);
+		}
+	}
+
+	static getPath(url: string) {
+		const path = url.replace(`${process.env.SERVER_URL}/files/`, `${process.cwd()}/storage/`);
+		return path;
+	}
+
+	static getPublicUrl(key: string) {
+		return path.join(process.env.SERVER_URL, "/files", key);
+	}
+
+	static async createDirectoryIfNotExists(path: string) {
+		return await new Promise<boolean>((resolve, reject) => {
+			if (fs.existsSync(path)) {
+				resolve(true);
+			} else {
+				fs.mkdir(path, { recursive: true }, (err) => {
+					if (err) {
+						reject(err);
+					}
+					resolve(true);
+				});
+			}
+		});
+	}
+}