crypt-express-app 1.0.0 → 1.3.1

package/dist/scripts/generate-app.js

@@ -1,88 +1,104 @@
-// generate-utils.ts
 import * as fs from "fs";
 import * as path from "path";
-const basePath = path.join(__dirname, "..");
-if (!fs.existsSync(basePath)) {
-    fs.mkdirSync(basePath, { recursive: true });
-}
-/* ================= redis.ts ================= */
-const appContent = `
+export function generateApp(projectDir) {
+    const basePath = projectDir;
+    const srcPath = path.join(basePath, "src");
+    // ensure src directory exists
+    if (!fs.existsSync(srcPath)) {
+        fs.mkdirSync(srcPath, { recursive: true });
+    }
+    /* ================= app.ts ================= */
+    const routeContent = `
+import express, { Router } from 'express';
+import swaggerUi from "swagger-ui-express";
+import { swaggerSpec } from "./utils/swagger";
+
+const router: Router = express.Router();
+
+router.get("/", (req, res) => {
+  res.send(req.t("WELCOME"));
+});
+
+router.use(
+  "/api/docs",
+  swaggerUi.serve,
+  swaggerUi.setup(swaggerSpec, {
+    swaggerOptions: {
+      persistAuthorization: true,
+    },
+  })
+);
+
+export default router;
+`;
+    fs.writeFileSync(path.join(srcPath, "routes.ts"), routeContent.trim());
+    /* ================= app.ts ================= */
+    const appContent = `
 import express, { type Express } from "express";
 import cors from "cors";
 import morgan from "morgan";
 import { json, urlencoded } from "express";
-import i18next from 'i18next';
-import Backend from 'i18next-fs-backend';
-import middleware from 'i18next-http-middleware';
-import path from 'path';
+import i18next from "i18next";
+import Backend from "i18next-fs-backend";
+import middleware from "i18next-http-middleware";
+import path from "path";
 import { errorMiddleware } from "./middlewares/error.middleware";
 import { loggerMiddleware } from "./middlewares/logger.middleware";
 import swaggerUi from "swagger-ui-express";
 import { swaggerSpec } from "./utils/swagger";
+import routes from "./routes";
 
 export const app: Express = express();
 
-// i18n
 i18next
-    .use(Backend)
-    .use(middleware.LanguageDetector)
-    .init({
-        fallbackLng: 'en',
-        preload: ['en', 'bn'],
-        backend: {
-            loadPath: path.join(__dirname, 'locales/{{lng}}/translation.json')
-        },
-        detection: {
-            order: ['querystring', 'cookie', 'header'],
-            caches: ['cookie']
-        }
-    });
+  .use(Backend)
+  .use(middleware.LanguageDetector)
+  .init({
+    fallbackLng: "en",
+    preload: ["en", "bn"],
+    backend: {
+      loadPath: path.join(__dirname, "locales/{{lng}}/translation.json"),
+    },
+    detection: {
+      order: ["querystring", "cookie", "header"],
+      caches: ["cookie"],
+    },
+  });
 
-// Middlewares
 app.use(cors());
 app.use(json());
 app.use(urlencoded({ extended: true }));
 app.use(morgan("dev"));
 app.use(middleware.handle(i18next));
-
-// Logger middleware should come first
 app.use(loggerMiddleware);
-
-// Routes
-app.get('/', (req, res) => {
-    res.send(req.t('WELCOME')); // automatically returns text in detected language
-});
-app.use("/api/docs", swaggerUi.serve, swaggerUi.setup(swaggerSpec, {
-    swaggerOptions: {
-        persistAuthorization: true, // ✅ এটা রাখে token reload-এও
-    },
-}));
-
-// Error handler
+app.use(routes);
 app.use(errorMiddleware);
 
 export default app;
 `;
-fs.writeFileSync(path.join(basePath, "src", "app.ts"), appContent);
-/* ================= redis.ts ================= */
-const serverContent = `
+    fs.writeFileSync(path.join(srcPath, "app.ts"), appContent.trim());
+    /* ================= server.ts ================= */
+    const serverContent = `
 import app from "./src/app";
 import bootstrapSystem from "./src/utils/bootstrap";
 import { connectRedis } from "./src/utils/redis";
 
+const port = process.env.PORT ?? 3000
+
 async function startServer() {
-  try{
-  await bootstrapSystem();  // 🔥 important
-  await connectRedis();
+  try {
+    await bootstrapSystem();
+    await connectRedis();
 
-  app.listen(5010, () => {
-    console.log("🚀 Server running at http://localhost:3000");
-    console.log("📘 Swagger docs at http://localhost:3000/api/docs");
-  });
-}catch(error){
-  console.log("Error.........\\n\\n")
-}
+    app.listen(port, () => {
+      console.log(\`🚀 Server running at http://localhost:\${port}\`);
+      console.log(\`📘 Swagger docs at http://localhost:\${port}/api/docs\`);
+    });
+  } catch (error) {
+    console.error("Error.........", error);
+  }
 }
+
 process.on("uncaughtException", (err) => {
   console.error("🔥 Uncaught Exception:", err);
 });
@@ -90,7 +106,9 @@ process.on("uncaughtException", (err) => {
 process.on("unhandledRejection", (reason) => {
   console.error("🔥 Unhandled Rejection:", reason);
 });
+
 startServer();
 `;
-fs.writeFileSync(path.join(basePath, "server.ts"), serverContent);
-console.log("✅ App files generated successfully inside src");
+    fs.writeFileSync(path.join(basePath, "server.ts"), serverContent.trim());
+    console.log("✅ App files generated successfully inside src");
+}

package/dist/scripts/generate-locales.js

@@ -1,29 +1,25 @@
-// generate-locales.ts
 import * as fs from "fs";
 import * as path from "path";
-const basePath = path.join(__dirname, "..", "src", "locales");
-const bnPath = path.join(basePath, "bn");
-const enPath = path.join(basePath, "en");
-// ফোল্ডার তৈরি
-[basePath, bnPath, enPath].forEach((dir) => {
-    if (!fs.existsSync(dir)) {
-        fs.mkdirSync(dir, { recursive: true });
-    }
-});
-// বাংলা translation
-const bnContent = `
-{
-  "WELCOME": "আমাদের এপিতে স্বাগতম",
-  "USER_NOT_FOUND": "ব্যবহারকারী পাওয়া যায়নি"
+export function generateLocales(projectDir) {
+    const localesPath = path.join(projectDir, "src", "locales");
+    const bnPath = path.join(localesPath, "bn");
+    const enPath = path.join(localesPath, "en");
+    // create directories if not exist
+    [localesPath, bnPath, enPath].forEach((dir) => {
+        if (!fs.existsSync(dir)) {
+            fs.mkdirSync(dir, { recursive: true });
+        }
+    });
+    // translations
+    const bnContent = {
+        WELCOME: "আমাদের এপিতে স্বাগতম",
+        USER_NOT_FOUND: "ব্যবহারকারী পাওয়া যায়নি",
+    };
+    const enContent = {
+        WELCOME: "Welcome to our API",
+        USER_NOT_FOUND: "User not found",
+    };
+    fs.writeFileSync(path.join(bnPath, "translation.json"), JSON.stringify(bnContent, null, 2));
+    fs.writeFileSync(path.join(enPath, "translation.json"), JSON.stringify(enContent, null, 2));
+    console.log("Locales generated successfully inside src/locales");
 }
-`;
-// ইংরেজি translation
-const enContent = `
-{
-  "WELCOME": "Welcome to our API",
-  "USER_NOT_FOUND": "User not found"
-}
-`;
-fs.writeFileSync(path.join(bnPath, "translation.json"), bnContent.trim());
-fs.writeFileSync(path.join(enPath, "translation.json"), enContent.trim());
-console.log("Locales generated successfully inside src/locales");

package/dist/scripts/generate-middleware.js

@@ -1,24 +1,25 @@
 import * as fs from "fs";
 import * as path from "path";
-const projectRoot = process.cwd();
-const basePath = path.join(projectRoot, "src", "middlewares");
-if (!fs.existsSync(basePath)) {
-    fs.mkdirSync(basePath, { recursive: true });
-}
-/* ================= AUTHORIZATION ================= */
-const authorizationContent = `
+export function generateMiddlewares(projectDir) {
+    const basePath = path.join(projectDir, "src", "middlewares");
+    if (!fs.existsSync(basePath)) {
+        fs.mkdirSync(basePath, { recursive: true });
+    }
+    /* ================= AUTHORIZATION ================= */
+    const authorizationContent = `
 import { Request, Response, NextFunction } from "express";
-import { ResourceType, ActionsType, Resource } from "../utils/consts";
-import { cacheService } from "../utils/redis";
+import { TypeResource, TypeAction, Resource } from "../utils/consts";
+import cacheService from "../utils/redis";
 
 export function authorizationMiddleware(authorization: {
   resource: Resource;
-  resourceType: ResourceType;
-  actions: ActionsType[];
+  resourceType: TypeResource;
+  actions: TypeAction[];
 }) {
   return async (req: Request, res: Response, next: NextFunction) => {
     try {
       const userId = req?.user?.userId;
+      const isMasterRealmUser = req?.user?.isMasterRealmUser;
       if (!userId) {
         return res.status(401).json({ message: "Unauthorized" });
       }
@@ -28,15 +29,16 @@ export function authorizationMiddleware(authorization: {
         return res.status(403).json({ message: "Permissions not loaded" });
       }
 
-      const profile = JSON.parse(cached as string);
+      const profile = JSON.parse(cached);
       const permissions: string[] = profile.permissions || [];
 
+      // check permission
       const allowed = permissions.some((perm) => {
         const [resName, action, type] = perm.split(":");
         return (
           resName === authorization.resource &&
           type === authorization.resourceType &&
-          authorization.actions.includes(action as ActionsType)
+          authorization.actions.includes(action as TypeAction)
         );
       });
 
@@ -50,14 +52,13 @@ export function authorizationMiddleware(authorization: {
       return res.status(500).json({ message: "Authorization error" });
     }
   };
-};
+}
 `;
-fs.writeFileSync(path.join(basePath, "authorization.middleware.ts"), authorizationContent.trim());
-/* ================= AUTH ================= */
-const authContent = `
+    fs.writeFileSync(path.join(basePath, "authorization.middleware.ts"), authorizationContent.trim());
+    /* ================= AUTH ================= */
+    const authContent = `
 import { Request, Response, NextFunction } from "express";
 import jwt from "jsonwebtoken";
-import prisma from "../../prisma/client";
 import { cacheService } from "../utils/redis";
 
 interface JwtPayload {
@@ -77,60 +78,54 @@ declare global {
   }
 }
 
+/**
+ * @description Middleware to protect routes and verify JWT token
+ */
 export const authMiddleware = async (req: Request, res: Response, next: NextFunction) => {
-  const authHeader = req.headers.authorization;
+  const authHeader = req.headers["authorization"];
   if (!authHeader) return res.status(401).json({ message: "Authorization header missing" });
 
-  const [scheme, tokenRaw] = authHeader.split(" ");
-  if (scheme !== "Bearer" || !tokenRaw) {
-    return res.status(401).json({ message: "Invalid Authorization header format" });
-  }
-
-  const token = tokenRaw.replace(/^\"|\"$/g, "");
-
-  const decodedPayload = jwt.decode(token) as JwtPayload | null;
-  if (!decodedPayload || !decodedPayload.realmId) {
-    return res.status(401).json({ message: "Invalid token: realmId missing" });
-  }
-
-  const realmId = decodedPayload.realmId;
-
-  const secretKey = \`realm:\${realmId}:secret\`;
-  const secret = await cacheService.get(secretKey);
-  if (!secret) {
-    return res.status(500).json({ message: "JWT secret not configured in Redis" });
-  }
+  const token = authHeader.split(" ")[1]; // Bearer <token>
+  if (!token) return res.status(401).json({ message: "Token missing" });
 
   try {
-    const decoded = jwt.verify(token, secret as string, {
-      algorithms: ["HS256"],
-    }) as JwtPayload & { userId: string; sessionId: string };
-
-    const session = await prisma.userSession.findUnique({
-      where: { userSessionId: decoded.sessionId },
-    });
-
-    if (!session) {
-      return res.status(401).json({ message: "Session invalid or logged out" });
+    const decodedPayload = jwt.decode(token) as JwtPayload | null;
+    if (!decodedPayload || !decodedPayload.realmId) {
+      return res.status(401).json({ message: "Invalid token: realmId missing" });
     }
-
-    req.user = decoded;
-    next();
-  } catch (err: any) {
-    if (err.name === "TokenExpiredError") {
-      return res.status(401).json({ message: "Token expired" });
+    const realmId = decodedPayload.realmId as string;
+
+    // 2. Redis থেকে secret load করা
+    const secretKey = \`realm:\${realmId}:secret\`;
+    const secret = await cacheService.get(secretKey) as string;
+    if (!secret) return res.status(500).json({ message: "JWT secret not configured in Redis" });
+
+    // const secret = JWT_SECRET;
+    const decoded = jwt.verify(token, secret, { algorithms: ["HS256"] }) as JwtPayload;
+    
+    const isBlacklisted = await cacheService.get(\`blacklist:\${token}\`);
+    if (isBlacklisted) {
+      return res.status(401).json({ message: "Token revoked" });
     }
-
-    return res.status(401).json({ message: "Invalid token" });
+    req.user = decoded; // attach payload to request
+    next();
+  } catch (err) {
+    return res.status(401).json({ message: "Invalid or expired token" });
   }
 };
+ 
 `;
-fs.writeFileSync(path.join(basePath, "auth.middleware.ts"), authContent.trim());
-/* ================= ERROR ================= */
-const errorContent = `
+    fs.writeFileSync(path.join(basePath, "auth.middleware.ts"), authContent.trim());
+    /* ================= ERROR ================= */
+    const errorContent = `
 import { Request, Response, NextFunction } from "express";
 
-export const errorMiddleware = (err: any, req: Request, res: Response, next: NextFunction) => {
+export const errorMiddleware = (
+  err: any,
+  req: Request,
+  res: Response,
+  next: NextFunction
+) => {
   console.error(err);
 
   const status = err.status || 500;
@@ -144,22 +139,29 @@ export const errorMiddleware = (err: any, req: Request, res: Response, next: Nex
   });
 };
 `;
-fs.writeFileSync(path.join(basePath, "error.middleware.ts"), errorContent.trim());
-/* ================= LOGGER ================= */
-const loggerContent = `
+    fs.writeFileSync(path.join(basePath, "error.middleware.ts"), errorContent.trim());
+    /* ================= LOGGER ================= */
+    const loggerContent = `
 import { Request, Response, NextFunction } from "express";
 import logger from "../utils/logger";
 
-export const loggerMiddleware = (req: Request, res: Response, next: NextFunction) => {
+export const loggerMiddleware = (
+  req: Request,
+  res: Response,
+  next: NextFunction
+) => {
   const start = Date.now();
 
   res.on("finish", () => {
     const duration = Date.now() - start;
-    logger.info(\`[\${new Date().toISOString()}] \${req.method} \${req.originalUrl} \${res.statusCode} - \${duration}ms\`);
+    logger.info(
+      \`[\${new Date().toISOString()}] \${req.method} \${req.originalUrl} \${res.statusCode} - \${duration}ms\`
+    );
   });
 
   next();
 };
 `;
-fs.writeFileSync(path.join(basePath, "logger.middleware.ts"), loggerContent.trim());
-console.log(`✅ Middleware files generated successfully at ${basePath}`);
+    fs.writeFileSync(path.join(basePath, "logger.middleware.ts"), loggerContent.trim());
+    console.log(`✅ Middleware files generated successfully at ${basePath}`);
+}