crypt-express-app 1.0.0

package/README.md

@@ -0,0 +1 @@
+# crypt-express-app

package/dist/index.js

@@ -0,0 +1,20 @@
+#!/usr/bin/env node
+import { execSync } from "child_process";
+const projectName = process.argv[2];
+if (!projectName) {
+    console.error("❌ project-name required");
+    console.log("Usage: npx crypt-express-app <project-name>");
+    process.exit(1);
+}
+process.env.PROJECT_NAME = projectName;
+function run(cmd) {
+    execSync(cmd, { stdio: "inherit" });
+}
+// run generators
+// run("tsx scripts/generate-root-files.ts");
+// run("tsx scripts/generate-utils.ts");
+// run("tsx scripts/generate-locales.ts");
+// run("tsx scripts/setup-prisma.ts");
+// run("tsx scripts/generate-middleware.ts");
+// run("tsx scripts/generate-module.ts common");
+console.log("✅ project generated");

package/dist/scripts/generate-app.js

@@ -0,0 +1,96 @@
+// 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 = `
+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 { errorMiddleware } from "./middlewares/error.middleware";
+import { loggerMiddleware } from "./middlewares/logger.middleware";
+import swaggerUi from "swagger-ui-express";
+import { swaggerSpec } from "./utils/swagger";
+
+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']
+        }
+    });
+
+// 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(errorMiddleware);
+
+export default app;
+`;
+fs.writeFileSync(path.join(basePath, "src", "app.ts"), appContent);
+/* ================= redis.ts ================= */
+const serverContent = `
+import app from "./src/app";
+import bootstrapSystem from "./src/utils/bootstrap";
+import { connectRedis } from "./src/utils/redis";
+
+async function startServer() {
+  try{
+  await bootstrapSystem();  // 🔥 important
+  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")
+}
+}
+process.on("uncaughtException", (err) => {
+  console.error("🔥 Uncaught Exception:", 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");

package/dist/scripts/generate-locales.js

@@ -0,0 +1,29 @@
+// 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": "ব্যবহারকারী পাওয়া যায়নি"
+}
+`;
+// ইংরেজি 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

@@ -0,0 +1,165 @@
+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 = `
+import { Request, Response, NextFunction } from "express";
+import { ResourceType, ActionsType, Resource } from "../utils/consts";
+import { cacheService } from "../utils/redis";
+
+export function authorizationMiddleware(authorization: {
+  resource: Resource;
+  resourceType: ResourceType;
+  actions: ActionsType[];
+}) {
+  return async (req: Request, res: Response, next: NextFunction) => {
+    try {
+      const userId = req?.user?.userId;
+      if (!userId) {
+        return res.status(401).json({ message: "Unauthorized" });
+      }
+
+      const cached = await cacheService.get(\`user:\${userId}:permissions\`);
+      if (!cached) {
+        return res.status(403).json({ message: "Permissions not loaded" });
+      }
+
+      const profile = JSON.parse(cached as string);
+      const permissions: string[] = profile.permissions || [];
+
+      const allowed = permissions.some((perm) => {
+        const [resName, action, type] = perm.split(":");
+        return (
+          resName === authorization.resource &&
+          type === authorization.resourceType &&
+          authorization.actions.includes(action as ActionsType)
+        );
+      });
+
+      if (!allowed) {
+        return res.status(403).json({ message: "Access denied" });
+      }
+
+      next();
+    } catch (error) {
+      console.error(error);
+      return res.status(500).json({ message: "Authorization error" });
+    }
+  };
+};
+`;
+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 {
+  realmId: string;
+  sessionId: string;
+  userId: string;
+  email: string;
+  clientIdInternal: string;
+  isMasterRealmUser: boolean;
+}
+
+declare global {
+  namespace Express {
+    interface Request {
+      user?: JwtPayload;
+    }
+  }
+}
+
+export const authMiddleware = async (req: Request, res: Response, next: NextFunction) => {
+  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" });
+  }
+
+  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" });
+    }
+
+    req.user = decoded;
+    next();
+  } catch (err: any) {
+    if (err.name === "TokenExpiredError") {
+      return res.status(401).json({ message: "Token expired" });
+    }
+
+    return res.status(401).json({ message: "Invalid token" });
+  }
+};
+`;
+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) => {
+  console.error(err);
+
+  const status = err.status || 500;
+  const message = err.message || "Internal Server Error";
+
+  res.status(status).json({
+    success: false,
+    status,
+    message,
+    ...(process.env.NODE_ENV === "development" && { stack: err.stack }),
+  });
+};
+`;
+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) => {
+  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\`);
+  });
+
+  next();
+};
+`;
+fs.writeFileSync(path.join(basePath, "logger.middleware.ts"), loggerContent.trim());
+console.log(`✅ Middleware files generated successfully at ${basePath}`);