crypt-express-app 1.3.20

package/dist/index.js

@@ -0,0 +1,121 @@
+#!/usr/bin/env node
+import { execSync } from "child_process";
+import * as fs from "fs";
+import * as path from "path";
+import * as readline from "readline";
+import { generateApp } from "./scripts/generate-app.js";
+import { generateLocales } from "./scripts/generate-locales.js";
+import { generateMiddlewares } from "./scripts/generate-middleware.js";
+import { generateRootFiles } from "./scripts/generate-root-files.js";
+import { generateModule } from "./scripts/generate-module.js";
+import { generateUtils } from "./scripts/generate-utils.js";
+import { generatePrismaClient } from "./scripts/setup-prisma.js";
+/* ===================== CLI SETUP ===================== */
+const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+});
+function ask(question) {
+    return new Promise((resolve) => rl.question(question, resolve));
+}
+/* ===================== MAIN ===================== */
+(async function main() {
+    let inputName = process.argv[2];
+    if (process.argv.length > 3) {
+        console.error("❌ Only one project name allowed");
+        process.exit(1);
+    }
+    if (!inputName) {
+        inputName = await ask("Enter project name: ");
+    }
+    inputName = inputName.trim();
+    if (!inputName) {
+        console.error("❌ Project name required");
+        process.exit(1);
+    }
+    const useCurrentDir = inputName === ".";
+    // normalize only if not "."
+    const normalizedName = useCurrentDir
+        ? path.basename(process.cwd())
+        : inputName
+            .toLowerCase()
+            .trim()
+            .replace(/\s+/g, "-") // spaces → dash
+            .replace(/[^a-z0-9-]/g, ""); // remove invalid chars
+    if (!normalizedName) {
+        console.error("❌ Invalid project name");
+        process.exit(1);
+    }
+    const projectDir = useCurrentDir
+        ? process.cwd()
+        : path.join(process.cwd(), normalizedName);
+    if (!useCurrentDir) {
+        if (fs.existsSync(projectDir)) {
+            console.error("❌ Directory already exists");
+            process.exit(1);
+        }
+        fs.mkdirSync(projectDir, { recursive: true });
+    }
+    else {
+        const files = fs.readdirSync(projectDir).filter((f) => !f.startsWith("."));
+        if (files.length > 0) {
+            console.error("❌ Current directory must be empty");
+            process.exit(1);
+        }
+    }
+    rl.close();
+    process.env.PROJECT_NAME = normalizedName;
+    console.log(`📦 Creating project: ${normalizedName}`);
+    generateRootFiles(projectDir, normalizedName);
+    generateApp(projectDir);
+    generateMiddlewares(projectDir);
+    generateLocales(projectDir);
+    generateModule(projectDir, "common");
+    generateUtils(projectDir);
+    generatePrismaClient(projectDir);
+    console.log("📦 Installing dependencies...");
+    try {
+        execSync("pnpm install", {
+            cwd: projectDir,
+            stdio: "inherit",
+        });
+        console.log("✅ Dependencies installed");
+    }
+    catch (err) {
+        console.error("❌ pnpm install failed");
+        console.error(err);
+    }
+    try {
+        execSync("npx prisma generate", {
+            cwd: projectDir,
+            stdio: "inherit",
+        });
+        console.log("✅ Prisma client generated");
+    }
+    catch (err) {
+        console.error("❌ Prisma client generation failed");
+        console.error(err);
+    }
+    // try {
+    //   execSync("docker compose up -d redis postgres", {
+    //     cwd: projectDir,
+    //     stdio: "inherit",
+    //   });
+    //   console.log("✅ Redis and Postgres started");
+    // } catch (err) {
+    //   console.error("❌ Failed to start Redis and Postgres");
+    //   console.error(err);
+    // }
+    // try {
+    //   execSync("npx prisma db push", {
+    //     cwd: projectDir,
+    //     stdio: "inherit",
+    //   });
+    //   console.log("✅ Prisma client generated");
+    // } catch (err) {
+    //   console.error("❌ Prisma client generation failed");
+    //   console.error(err);
+    // }
+    console.log("✅ Project generated");
+})();
+/* ===================== CONFIG GENERATION ===================== */

package/dist/scripts/generate-app.js

@@ -0,0 +1,198 @@
+import * as fs from "fs";
+import * as path from "path";
+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";
+import redis from './utils/redis';
+import prisma from './prisma/client';
+import commonRoutes from "./modules/common/common.routes";
+
+const routers: Router = express.Router();
+
+/**
+ * @openapi
+ * tags:
+ *   - name: Root
+ *     description: Root route and labeling operations
+ */
+
+routers.get("/", (req, res) => {
+  res.send(req.t("WELCOME"));
+});
+
+/**
+ * @openapi
+ * /health/check:
+ *   get:
+ *     tags: [Root]
+ *     summary: Health check endpoint
+ *     description: Returns the status of the app, Redis, and Supabase function.
+ *     responses:
+ *       200:
+ *         description: App health status
+ *         content:
+ *           application/json:
+ *             schema:
+ *               type: object
+ *               properties:
+ *                 success:
+ *                   type: boolean
+ *                   example: true
+ *                 status:
+ *                   type: number
+ *                   example: 200
+ *                 message:
+ *                   type: string
+ *                   example: App health check
+ *                 services:
+ *                   type: object
+ *                   properties:
+ *                     app:
+ *                       type: string
+ *                       example: ok
+ *                     redis:
+ *                       type: string
+ *                       example: ok
+ *                     dbStatus:
+ *                       type: string
+ *                       example: ok
+ *                 time:
+ *                   type: string
+ *                   format: date-time
+ *                   example: 2026-03-11T10:21:00.000Z
+ */
+routers.get("/health/check", async (_req, res) => {
+  let redisStatus = "ok";
+  let dbStatus = "ok";
+
+  try {
+    await redis.ping();
+  } catch {
+    redisStatus = "failed";
+  }
+
+  try {
+    await prisma.$queryRaw\`SELECT 1\`;
+  } catch {
+    dbStatus = "failed";
+  }
+
+  res.json({
+    success: true,
+    status: 200,
+    message: "App health check",
+    services: {
+      app: "ok",
+      redis: redisStatus,
+      db: dbStatus,
+    },
+    time: new Date().toISOString(),
+  });
+});
+
+routers.use(
+  "/api/docs",
+  swaggerUi.serve,
+  swaggerUi.setup(swaggerSpec, {
+    swaggerOptions: {
+      persistAuthorization: true,
+    },
+  })
+);
+routers.use("/api/common", commonRoutes);
+
+export default routers;
+`;
+    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 { 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();
+
+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"],
+    },
+  });
+
+app.use(cors());
+app.use(json());
+app.use(urlencoded({ extended: true }));
+app.use(morgan("dev"));
+app.use(middleware.handle(i18next));
+app.use(loggerMiddleware);
+app.use(routes);
+app.use(errorMiddleware);
+
+export default app;
+`;
+    fs.writeFileSync(path.join(srcPath, "app.ts"), appContent.trim());
+    /* ================= server.ts ================= */
+    const serverContent = `
+import 'dotenv/config'
+import app from "./src/app";
+import bootstrapSystem from "./src/utils/bootstrap";
+import { ConnectIamRedis } from "./src/utils/iam.redis";
+
+const port = process.env.PORT ?? 3000
+
+async function startServer() {
+  try {
+    await bootstrapSystem();
+    await ConnectIamRedis();
+
+    app.listen(port, () => {
+      console.log(\`🚀 Auth running at http://localhost:5000\`);
+      console.log(\`📘 Auth swagger docs  at http://localhost:5000/api/docs\`);
+      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);
+});
+
+process.on("unhandledRejection", (reason) => {
+  console.error("🔥 Unhandled Rejection:", reason);
+});
+
+startServer();
+`;
+    fs.writeFileSync(path.join(basePath, "server.ts"), serverContent.trim());
+    console.log("✅ App files generated successfully inside src");
+}

package/dist/scripts/generate-locales.js

@@ -0,0 +1,25 @@
+import * as fs from "fs";
+import * as path from "path";
+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");
+}

package/dist/scripts/generate-middleware.js

@@ -0,0 +1,167 @@
+import * as fs from "fs";
+import * as path from "path";
+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 { TypeResource, TypeAction, Resource } from "../utils/consts";
+import iamCacheService from "../utils/iam.redis";
+
+export function authorizationMiddleware(authorization: {
+  resource: Resource;
+  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" });
+      }
+
+      const cached = await iamCacheService.get(\`user:\${userId}:permissions\`);
+      if (!cached) {
+        return res.status(403).json({ message: "Permissions not loaded" });
+      }
+
+      const profile = JSON.parse(cached);
+      const permissions: string[] = profile.permissions || [];
+
+      // check permission
+      const allowed = permissions.some((perm) => {
+        const [clientId, resName, action, type] = perm.split(":");
+        return (
+          resName === authorization.resource &&
+          type === authorization.resourceType &&
+          authorization.actions.includes(action as TypeAction)
+        );
+      });
+
+      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 { iamCacheService } from "../utils/iam.redis";
+
+interface JwtPayload {
+  realmId: string;
+  sessionId: string;
+  userId: string;
+  email: string;
+  clientIdInternal: string;
+  isMasterRealmUser: boolean;
+}
+
+declare global {
+  namespace Express {
+    interface Request {
+      user?: JwtPayload;
+    }
+  }
+}
+
+/**
+ * @description Middleware to protect routes and verify JWT token
+ */
+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 token = authHeader.split(" ")[1]; // Bearer <token>
+  if (!token) return res.status(401).json({ message: "Token missing" });
+
+  try {
+    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 as string;
+
+    // 2. Redis থেকে secret load করা
+    const secretKey = \`realm:\${realmId}:secret\`;
+    const secret = await iamCacheService.get(secretKey) as string;
+    if (!secret) return res.status(401).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 iamCacheService.get(\`blacklist:\${token}\`);
+    if (isBlacklisted) {
+      return res.status(401).json({ message: "Token revoked" });
+    }
+    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 = `
+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}`);
+}