raahul-fastify-basic 1.0.0

package/templates/basic/package.json

@@ -0,0 +1,56 @@
+{
+  "name": "backend",
+  "version": "1.0.0",
+  "description": "",
+  "main": "index.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1",
+    "dev": "nodemon",
+    "start:tunnel": "node src/inx.ts",
+    "dev:tunnel": "node src/inx.ts",
+    "start": "node dist/index.js",
+    "build": "tsc && tsc-alias && npm run postbuild && npm run sentry:sourcemaps",
+    "postbuild": "node -e \"const fs = require('fs'); try { fs.cpSync('src/services/email/views', 'dist/services/email/views', { recursive: true }); } catch (e) {}\"",
+    "setup": "node scripts/setup-public.ts",
+    "postinstall": "node scripts/setup-public.ts"
+  },
+  "keywords": [
+    "fastify",
+    "backend"
+  ],
+  "author": "Rahul Mehta",
+  "license": "ISC",
+  "type": "module",
+  "dependencies": {
+    "@fastify/cookie": "^11.0.2",
+    "@fastify/cors": "^11.2.0",
+    "@fastify/multipart": "^10.0.0",
+    "@fastify/static": "^9.1.3",
+    "@socket.io/redis-adapter": "^8.3.0",
+    "axios": "^1.16.1",
+    "bcrypt": "^6.0.0",
+    "dotenv": "^17.4.2",
+    "fastify": "^5.8.5",
+    "googleapis": "^172.0.0",
+    "jose": "^6.2.3",
+    "jsonwebtoken": "^9.0.3",
+    "mongoose": "^9.6.2",
+    "nodemailer": "^8.0.8",
+    "nodemailer-express-handlebars": "^7.0.0",
+    "redis": "^5.12.1",
+    "sharp": "^0.34.5",
+    "socket.io": "^4.8.3"
+  },
+  "devDependencies": {
+    "@ngrok/ngrok": "^1.7.0",
+    "@types/bcrypt": "^6.0.0",
+    "@types/jsonwebtoken": "^9.0.10",
+    "@types/node": "^25.9.1",
+    "@types/nodemailer": "^8.0.0",
+    "@types/nodemailer-express-handlebars": "^4.0.6",
+    "nodemon": "^3.1.14",
+    "tsc-alias": "^1.8.17",
+    "tsx": "^4.22.3",
+    "typescript": "^6.0.3"
+  }
+}

package/templates/basic/scripts/setup-public.ts

@@ -0,0 +1,21 @@
+import { fileURLToPath } from "node:url";
+import path from "node:path";
+import * as fs from "fs";
+const _dirname = path.dirname(fileURLToPath(import.meta.url));
+const projectRoot = path.resolve(_dirname, "..");
+const requiredFolders = ["public/uploads"];
+function createFolders() {
+  requiredFolders.forEach((folderName) => {
+    const folderPath = path.join(projectRoot, folderName);
+    if (!fs.existsSync(folderPath)) {
+      fs.mkdirSync(folderPath, { recursive: true });
+      console.log(`[script/setup-public] Folder created ${folderName}`);
+    } else {
+      console.log(
+        `[script/setup-public] Folder already exists ${folderName}, skipping and trying next`,
+      );
+    }
+  });
+}
+createFolders();
+export { createFolders };

package/templates/basic/src/api/index.ts

@@ -0,0 +1,14 @@
+import type { FastifyInstance } from "fastify";
+import apiV1Router from "./v1/index.js";
+async function apiRouter(fastify: FastifyInstance, _options: object) {
+  fastify.get("/", (_req, reply) => {
+    return reply.status(200).send({
+      ok: true,
+      success: true,
+      message: "OK",
+      at: "backend/api",
+    });
+  });
+  fastify.register(apiV1Router, { prefix: "/v1" });
+}
+export default apiRouter;

package/templates/basic/src/api/v1/index.ts

@@ -0,0 +1,12 @@
+import { FastifyInstance } from "fastify";
+const apiV1Router = async (fastify: FastifyInstance, options: object) => {
+  fastify.get("/", (_request, reply) => {
+    return reply.status(200).send({
+      ok: true,
+      success: true,
+      message: "OK",
+      at: "backend/api/v1",
+    });
+  });
+};
+export default apiV1Router;

package/templates/basic/src/config/constants.ts

@@ -0,0 +1,15 @@
+import { FastifyCorsOptions } from "@fastify/cors";
+import { ENV } from "./env.js";
+export const CONSTANTS: Record<string, any> = {
+  CORS_OPTIONS: {
+    credentials: true,
+    origin: ENV.ALLOWED_ORIGINS.split(",").filter((origin) => origin),
+    allowedHeaders: [
+      "Content-Type",
+      "Authorization",
+      ...(ENV.MODE === "dev" ? ["ngrok-skip-browser-warning", ""] : []),
+    ],
+    methods: ["GET", "POST", "PUT", "DELETE", "PATCH", "OPTIONS"],
+  } satisfies FastifyCorsOptions,
+
+};

package/templates/basic/src/config/env.ts

@@ -0,0 +1,32 @@
+import { assertValue } from "@/utils/assert.js";
+import { fileURLToPath } from "node:url";
+import path from "node:path";
+import dotenv from "dotenv";
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+dotenv.config({ path: path.resolve(__dirname, "../../.env") });
+export const ENV = {
+  MODE: assertValue(process.env.MODE, "Missing environment variable : MODE"),
+  PORT: Number(
+    assertValue(process.env.PORT, "Missing environment Variable : PORT"),
+  ),
+  ALLOWED_ORIGINS: assertValue(
+    process.env.ALLOWED_ORIGINS,
+    "Missing environment variable: ALLOWED_ORIGINS",
+  ),
+  JWT_SECRET: assertValue(
+    process.env.JWT_SECRET,
+    "Missing environment variable: JWT_SECRET",
+  ),
+  REDIS_URL: assertValue(
+    process.env.REDIS_URL,
+    "Missing environment variable: REDIS_URL",
+  ),
+  MONGOS_CONNECTION_STR: assertValue(
+    process.env.MONGOS_CONNECTION_STR,
+    "Missing environment variable: MONGOS_CONNECTION_STR",
+  ),
+  NGROK_AUTH_TOKEN: assertValue(
+    process.env.NGROK_AUTH_TOKEN,
+    "Missing environment variable: NGROK_AUTH_TOKEN",
+  ),
+};

package/templates/basic/src/core/fastify.ts

@@ -0,0 +1,25 @@
+import Fastify, { FastifyInstance } from "fastify";
+import cors from "@fastify/cors";
+import cookie from "@fastify/cookie";
+import { Server as HttpServer } from "node:http";
+import { CONSTANTS } from "@/config/constants.js";
+class FastifyServer {
+  public readonly app: FastifyInstance;
+  public readonly server: HttpServer;
+  constructor() {
+    this.app = Fastify({
+      trustProxy: true,
+      logger: process.env.MODE === "dev",
+    });
+    this.server = this.app.server;
+    this.registerPlugins();
+  }
+  private async registerPlugins() {
+    await this.app.register(cors, CONSTANTS.CORS_OPTIONS);
+    await this.app.register(cookie);
+  }
+}
+const fastifyService = new FastifyServer();
+export default fastifyService;
+export const app = fastifyService.app;
+export const server = fastifyService.server;

package/templates/basic/src/core/server.ts

@@ -0,0 +1,55 @@
+import path from "node:path";
+export const startServer = async () => {
+  const [
+    { app },
+    { default: MongoDBService },
+    { default: fastifyStatic },
+    { ENV },
+    apiRouter,
+    _io,
+  ] = await Promise.all([
+    import("@/core/fastify.js"),
+    import("@/infra/db/mongodb/mongodb.service.js"),
+    import("@fastify/static"),
+    import("@/config/env.js"),
+    import("@/api/index.js"),
+    import("@/core/socket.js"),
+  ]);
+  await app.register(fastifyStatic, {
+    root: path.resolve(process.cwd(), "public"),
+    prefix: "/",
+    wildcard: true,
+  });
+  app.get("/", (_req, reply) => {
+    return reply.type("text/html").send("OK");
+  });
+  app.register(apiRouter.default, {
+    prefix: "/api",
+  });
+  app.get("/health", async (_req, reply) => {
+    const healthy = await MongoDBService.checkDbHealth();
+    if (!healthy) {
+      return reply.status(500).send({
+        success: false,
+        status: 500,
+        message: "DB or API SERVER UNHEALTHY",
+      });
+    }
+    return reply.status(200).send("OK");
+  });
+  app.setErrorHandler((error, _request, reply) => {
+    console.log("Global Error Caught", error);
+    return reply.status(500).send({
+      success: false,
+      status: 500,
+      message: "Internal Server Error",
+    });
+  });
+  try {
+    await app.listen({ port: Number(ENV.PORT), host: "0.0.0.0" });
+    console.log(`Server is running on port ${ENV.PORT}`);
+  } catch (err) {
+    console.error("❌ Server failed to start:", err);
+    process.exit(1);
+  }
+};

package/templates/basic/src/core/socket.ts

@@ -0,0 +1,62 @@
+import { CONSTANTS } from "@/config/constants.js";
+import { Server as HttpServer } from "node:http";
+import { Server } from "socket.io";
+import { createAdapter } from "@socket.io/redis-adapter";
+import jwt from "jsonwebtoken";
+import { server } from "./fastify.js";
+import { ENV } from "@/config/env.js";
+import redisService from "@/infra/redis/redis.service.js";
+class SocketService {
+  public readonly io: Server;
+  constructor(httpServer: HttpServer = server) {
+    this.io = new Server(httpServer, {
+      cors: CONSTANTS.CORS_OPTIONS as any,
+    });
+    this.io.use((socket, next) => {
+      const isHandshake = socket.handshake.query.sid === undefined;
+      if (!isHandshake) {
+        return next();
+      }
+      const header = socket.handshake.headers["authorization"];
+      if (!header) {
+        return next(new Error("no token"));
+      }
+      if (!header.startsWith("Bearer ")) {
+        return next(new Error("invalid authentication, Please login again"));
+      }
+      const token = header.substring(7);
+      jwt.verify(token, ENV.JWT_SECRET, (err: any, decoded: any) => {
+        if (err) {
+          return next(new Error("invalid authentication, Please login again"));
+        }
+        const user = {
+          ...decoded,
+          _id: decoded._id,
+          user_type: decoded.user_type || (decoded.name ? "admin" : "user"),
+        };
+        (socket.request as any).user = user;
+        return next();
+      });
+    });
+    this.initializeAdapter().catch((err) => {
+      console.error(
+        "❌ Failed to initialize Redis adapter for Socket.IO:",
+        err,
+      );
+    });
+  }
+  private async initializeAdapter(): Promise<void> {
+    try {
+      await redisService.connect();
+      const subClient = redisService.client.duplicate();
+      await subClient.connect();
+      this.io.adapter(createAdapter(redisService.client, subClient));
+      console.log("✅ Socket.IO Redis adapter connected");
+    } catch (error) {
+      console.error("❌ Redis adapter connection failed for Socket.IO:", error);
+    }
+  }
+}
+const socketService = new SocketService();
+const io = socketService.io;
+export { SocketService, socketService as default, io };

package/templates/basic/src/index.ts

@@ -0,0 +1,23 @@
+const [{ default: mongodb }, { startServer }, { default: redisLockService }] =
+  await Promise.all([
+    import("./infra/db/mongodb/mongodb.service.js"),
+    import("./core/server.js"),
+    import("./infra/redis/utils/lock.js"),
+  ]);
+mongodb.connectDb().then(async () => {
+  await startServer();
+  const key = "index-sync-service";
+  try {
+    const lock = await redisLockService.acquireLock(key);
+    if (!lock) {
+      console.log(
+        "[index] Indexes already being synced by another process, skipping for this PID",
+        process.pid,
+      );
+      return;
+    } else {
+      await mongodb.syncAllModelIndexes();
+      redisLockService.releaseLock(key, lock);
+    }
+  } catch (error) {}
+});

package/templates/basic/src/infra/db/mongodb/mongodb.service.ts

@@ -0,0 +1,73 @@
+import { ENV } from "@/config/env.js";
+import mongoose from "mongoose";
+let cached = global.__mongoose;
+if (!cached) {
+  cached = global.__mongoose = { conn: null, promise: null };
+}
+class MongoDBService {
+  async connectDb() {
+    if (cached.conn) {
+      return Promise.resolve(cached.conn);
+    }
+    if (cached.promise) {
+      return cached.promise;
+    }
+    console.log("Connecting to MongoDB...");
+    cached.promise = mongoose
+      .connect(ENV.MONGOS_CONNECTION_STR, {
+        bufferCommands: false,
+        maxPoolSize: 95,
+        minPoolSize: 15,
+        serverSelectionTimeoutMS: 45000,
+        socketTimeoutMS: 45000,
+        connectTimeoutMS: 45000,
+      })
+      .then((mongooseInstance) => {
+        console.log("✅ MongoDB connection established");
+        cached.conn = mongooseInstance;
+        return mongooseInstance;
+      })
+      .catch((err: any) => {
+        cached.promise = null;
+        console.log("❌ MongoDB connection error:", err);
+        throw err;
+      });
+    return cached.promise;
+  }
+  async syncAllModelIndexes() {
+    const modelNames = mongoose.modelNames();
+    const syncs = [];
+    for (const modelName of modelNames) {
+      try {
+        const model = mongoose.model(modelName);
+        await model.syncIndexes();
+        syncs.push(modelName);
+      } catch (err: any) {
+        console.log(
+          `❌ Failed to sync indexes for ${modelName}:`,
+          err?.message,
+        );
+      }
+    }
+    console.log(`✅ Indexes synced for models: ${syncs?.join("|")}`);
+  }
+  async checkDbHealth() {
+    try {
+      if (mongoose.connection.readyState !== 1) {
+        return false;
+      } else {
+        const pingResult: mongoose.mongo.BSON.Document | undefined =
+          await mongoose?.connection?.db?.admin?.()?.ping();
+        if (pingResult && pingResult.ok === 1) {
+          return true;
+        } else {
+          return false;
+        }
+      }
+    } catch (error) {
+      console.log(`Error while checking the health of data base.`, error);
+      return false;
+    }
+  }
+}
+export default new MongoDBService();

package/templates/basic/src/infra/redis/redis.service.ts

@@ -0,0 +1,42 @@
+import { ENV } from "@/config/env.js";
+import { createClient, RedisClientType } from "redis";
+class RedisService {
+  public readonly client: RedisClientType;
+  constructor() {
+    this.client = createClient({ url: ENV.REDIS_URL }) as RedisClientType;
+    this.client.on("error", (err) => {
+      console.error("❌ Redis Client Error:", err);
+    });
+    this.client.on("connect", () => {
+      console.log("Redis client connecting...");
+    });
+    this.client.on("ready", () => {
+      console.log("✅ Redis connection established and ready");
+    });
+  }
+  async connect(): Promise<void> {
+    if (!this.client.isOpen) {
+      console.log("Connecting to Redis...");
+      await this.client.connect();
+    }
+  }
+  async shutdown(): Promise<void> {
+    console.log("Shutting down Redis clients...");
+    try {
+      if (this.client.isOpen) {
+        await this.client.del("global_active_sockets");
+        await this.client.del("active_sessions");
+        await this.client.quit();
+        console.log("✅ Redis client shut down successfully");
+      }
+    } catch (err) {
+      console.error("❌ Error closing Redis clients:", err);
+    } finally {
+      process.exit(0);
+    }
+  }
+}
+const redisService = new RedisService();
+const client = redisService.client;
+const shutdown = () => redisService.shutdown();
+export { RedisService, redisService as default, client, shutdown };

package/templates/basic/src/infra/redis/utils/keys.ts

@@ -0,0 +1,11 @@
+function getTodayStr(): string {
+  const today = new Date();
+  const yyyy = today.getFullYear();
+  const mm = String(today.getMonth() + 1).padStart(2, "0");
+  const dd = String(today.getDate()).padStart(2, "0");
+  return `${yyyy}-${mm}-${dd}`;
+}
+const REDIS_KEYS: Record<string, string | Function> = {
+  todaySessions: () => `rc-users-sessions:today:${getTodayStr()}`,
+};
+export default REDIS_KEYS;

package/templates/basic/src/infra/redis/utils/lock.ts

@@ -0,0 +1,118 @@
+import { client } from "../redis.service.js";
+import type { RedisClientType } from "redis";
+class RedisLockService {
+  private readonly client: RedisClientType;
+  constructor(redisClient: RedisClientType = client) {
+    this.client = redisClient;
+  }
+  async acquireLock(key: string, ttl: number = 300000): Promise<string | null> {
+    if (!this.client.isOpen) return null;
+    const lockKey = `lock:${key}`;
+    const lockValue = `${process.pid}-${Date.now()}-${Math.random().toString(36).slice(2)}`;
+    try {
+      const result = await this.client.set(lockKey, lockValue, {
+        NX: true,
+        PX: ttl,
+      });
+      return result === "OK" ? lockValue : null;
+    } catch (error) {
+      console.error(`[RedisLock] acquireLock failed for key "${key}":`, error);
+      return null;
+    }
+  }
+  async releaseLock(key: string, lockValue: string | number): Promise<number> {
+    if (!this.client.isOpen) return 0;
+    const lockKey = `lock:${key}`;
+    try {
+      const current = await this.client.get(lockKey);
+      if (current === String(lockValue)) {
+        return await this.client.del(lockKey);
+      }
+      return 0;
+    } catch (error) {
+      console.error(`[RedisLock] releaseLock failed for key "${key}":`, error);
+      return 0;
+    }
+  }
+  async withLock<T>(
+    key: string,
+    fn: () => Promise<T>,
+    options: {
+      ttlMs?: number;
+      retries?: number;
+      retryDelayMs?: number;
+      fallback?: "skip" | "run" | "throw";
+    } = {},
+  ): Promise<T | undefined> {
+    const {
+      ttlMs = 30000,
+      retries = 3,
+      retryDelayMs = 150,
+      fallback = "run",
+    } = options;
+    let lockValue: string | null = null;
+    for (let attempt = 0; attempt <= retries; attempt++) {
+      lockValue = await this.acquireLock(key, ttlMs);
+      if (lockValue) break;
+      if (attempt < retries) {
+        await new Promise((r) => setTimeout(r, retryDelayMs * (attempt + 1)));
+      }
+    }
+    if (!lockValue) {
+      console.warn(
+        `[RedisLock] Could not acquire lock "${key}" after ${retries} retries.`,
+      );
+      if (fallback === "skip") return undefined;
+      if (fallback === "throw")
+        throw new Error(`Could not acquire lock: ${key}`);
+      return fn()
+    }
+    try {
+      return await fn();
+    } finally {
+      await this.releaseLock(key, lockValue);
+    }
+  }
+  async getWithLockAndCache<T>(
+    cacheKey: string,
+    fetchDb: () => Promise<T>,
+    ttlSeconds: number = 3600,
+  ): Promise<T> {
+    if (!this.client.isOpen) return fetchDb();
+    try {
+      const cached = await this.client.get(cacheKey);
+      if (cached) return JSON.parse(cached) as T;
+    } catch (err) {
+      console.warn(`[RedisLock] Cache read failed for "${cacheKey}":`, err);
+    }
+    const lockValue = await this.acquireLock(`cache_fill:${cacheKey}`, 10000);
+    if (lockValue) {
+      try {
+        const cached = await this.client.get(cacheKey);
+        if (cached) return JSON.parse(cached) as T;
+
+        const result = await fetchDb();
+        await this.client.set(cacheKey, JSON.stringify(result), {
+          EX: ttlSeconds,
+        });
+        return result;
+      } catch (err) {
+        console.warn(`[RedisLock] Cache fill failed for "${cacheKey}":`, err);
+        return fetchDb();
+      } finally {
+        await this.releaseLock(`cache_fill:${cacheKey}`, lockValue);
+      }
+    }
+    for (let i = 0; i < 5; i++) {
+      await new Promise((r) => setTimeout(r, 100 * (i + 1)));
+      try {
+        const cached = await this.client.get(cacheKey);
+        if (cached) return JSON.parse(cached) as T;
+      } catch {
+      }
+    }
+    return fetchDb();
+  }
+}
+const redisLockService = new RedisLockService();
+export { RedisLockService, redisLockService as default };

package/templates/basic/src/inx.ts

@@ -0,0 +1,10 @@
+import * as ngrok from "@ngrok/ngrok";
+import "@/index.js";
+import { ENV } from "./config/env.js";
+(async () => {
+  const listener = await ngrok.connect({
+    addr: ENV.PORT,
+    authtoken: ENV.NGROK_AUTH_TOKEN,
+  });
+  console.log("Backend Ingress (NGROK) URL:", listener.url());
+})();

package/templates/basic/src/types/global.d.ts

@@ -0,0 +1,16 @@
+import type { FastifyReply } from "fastify";
+declare global {
+  var jarvis: (...args: any[]) => void;
+  var errJarvis: (...args: any[]) => void;
+  var handleError: (
+    err: any,
+    res: FastifyReply,
+    status?: number,
+    message?: string,
+  ) => void;
+  var __mongoose: {
+    conn: typeof import("mongoose") | null;
+    promise: Promise<typeof import("mongoose")> | null;
+  };
+}
+export {};

package/templates/basic/src/utils/assert.ts

@@ -0,0 +1,7 @@
+function assertValue<T>(value: T | undefined | null, errorMessage: string): T {
+  if (!value || typeof value === undefined || typeof value === null) {
+    throw new Error(errorMessage);
+  }
+  return value;
+}
+export { assertValue };

package/templates/basic/tsconfig.json

@@ -0,0 +1,27 @@
+{
+    "compilerOptions": {
+        "target": "ES2022",
+        "module": "NodeNext",
+        "moduleResolution": "NodeNext",
+        "paths": {
+            "@/*": [
+                "./src/*"
+            ]
+        },
+        "outDir": "./dist",
+        "rootDir": "./src",
+        "strict": true,
+        "esModuleInterop": true,
+        "skipLibCheck": true,
+        "forceConsistentCasingInFileNames": true,
+        "sourceMap": true,
+        "inlineSources": true,
+        "sourceRoot": "/",
+        "types": [
+            "node"
+        ]
+    },
+    "include": [
+        "src/**/*",
+    ]
+}