crypt-express-app 1.0.0

package/dist/scripts/generate-root-files.js

@@ -0,0 +1,123 @@
+// scripts/generate-root-files.ts
+import * as fs from "fs";
+import * as path from "path";
+import * as readline from "readline";
+const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+});
+rl.question("Enter project name: ", (projectName) => {
+    /* ================= tsconfig.json ================= */
+    const tsconfig = {
+        compilerOptions: {
+            module: "nodenext",
+            moduleResolution: "nodenext",
+            resolvePackageJsonExports: true,
+            esModuleInterop: true,
+            isolatedModules: true,
+            declaration: true,
+            removeComments: true,
+            emitDecoratorMetadata: true,
+            experimentalDecorators: true,
+            allowSyntheticDefaultImports: true,
+            target: "ES2023",
+            sourceMap: true,
+            rootDir: ".",
+            outDir: "./dist",
+            types: ["node"],
+            incremental: true,
+            skipLibCheck: true,
+            strictNullChecks: true,
+            forceConsistentCasingInFileNames: true,
+            noImplicitAny: false,
+            strictBindCallApply: false,
+            noFallthroughCasesInSwitch: false,
+        },
+        include: ["src", "server.ts", "prisma.config.ts"],
+        exclude: ["node_modules"],
+        assets: ["src/locales"],
+    };
+    fs.writeFileSync(path.join(process.cwd(), "tsconfig.json"), JSON.stringify(tsconfig, null, 2));
+    /* ================= package.json ================= */
+    const packageJson = {
+        name: projectName.toLowerCase().replace(/\s+/g, "-"),
+        version: "1.0.0",
+        description: `${projectName} backend.`,
+        license: "ISC",
+        author: "abir-hosen",
+        main: "server.ts",
+        scripts: {
+            "copy-locales": 'cpx "src/locales/**/*" dist/src/locales',
+            dev: "nodemon",
+            build: "tsc && npm run copy-locales",
+            start: "node dist/server.js",
+            "generate-module": "ts-node scripts/generate-module.ts",
+            "generate-middlewares": "ts-node scripts/middleware.ts",
+            "generate-locales": "ts-node scripts/generate-locales.ts",
+            "generate-utils": "ts-node scripts/generate-utils.ts"
+        },
+    };
+    fs.writeFileSync(path.join(process.cwd(), "package.json"), JSON.stringify(packageJson, null, 2));
+    /* ================= nodemon.json ================= */
+    const nodemon = {
+        watch: ["src"],
+        ext: "ts",
+        ignore: ["dist"],
+        exec: "ts-node src/server.ts",
+    };
+    fs.writeFileSync(path.join(process.cwd(), "nodemon.json"), JSON.stringify(nodemon, null, 2));
+    /* ================= .gitignore ================= */
+    const gitignore = `
+node_modules
+/src/generated/prisma
+.env
+package-lock.json
+dist
+pnpm-lock.yaml
+/generated/prisma
+`;
+    fs.writeFileSync(path.join(process.cwd(), ".gitignore"), gitignore.trim());
+    /* ================= .prisma ================= */
+    const prisma = `
+// This is your Prisma schema file,
+// learn more about it in the docs: https://pris.ly/d/prisma-schema
+
+// Looking for ways to speed up your queries, or scale easily with your serverless or edge functions?
+// Try Prisma Accelerate: https://pris.ly/cli/accelerate-init
+
+  generator client {
+    provider = "prisma-client-js"
+  }
+  
+  datasource db {
+    provider = "postgresql"
+  }
+  
+  model Common {
+    commonId      String        @id @default(uuid())
+    name         String        @unique
+  }
+`;
+    fs.writeFileSync(path.join(process.cwd(), "prisma", "schema.prisma"), prisma.trim());
+    /* ================= .prisma ================= */
+    const prismaConfig = `
+// This file was generated by Prisma, and assumes you have installed the following:
+// npm install --save-dev prisma dotenv
+import "dotenv/config";
+import { defineConfig } from "prisma/config";
+
+export default defineConfig({
+  schema: "prisma/schema.prisma",
+  migrations: {
+    path: "prisma/migrations",
+  },
+  datasource: {
+    url: process.env["DATABASE_URL"],
+  },
+});
+
+`;
+    fs.writeFileSync(path.join(process.cwd(), "prisma.config.ts"), prismaConfig.trim());
+    console.log(`✅ Root config files generated for project: ${projectName}`);
+    rl.close();
+});

package/dist/scripts/generate-utils.js

@@ -0,0 +1,191 @@
+import * as fs from "fs";
+import * as path from "path";
+const projectRoot = process.cwd();
+const basePath = path.join(projectRoot, "src", "utils");
+if (!fs.existsSync(basePath)) {
+    fs.mkdirSync(basePath, { recursive: true });
+}
+/* ================= redis.ts ================= */
+const redisContent = `
+import { createClient, RedisClientType } from "redis";
+import { CONSTS } from "./consts";
+
+let redis: RedisClientType = createClient({
+  url: CONSTS.REDIS_URL,
+});
+
+redis.on("connect", () => {
+  console.log("✅ Redis Connected");
+});
+
+redis.on("error", (err) => {
+  console.error("❌ Redis Error", err);
+});
+
+export const connectRedis = async () => {
+  if (!redis.isOpen) {
+    await redis.connect();
+  }
+};
+
+export class CacheService {
+  async set(key: string, value: any, ttl?: number) {
+    const stringValue = JSON.stringify(value);
+    ttl ? await redis.set(key, stringValue, { EX: ttl }) : await redis.set(key, stringValue);
+  }
+
+  async get<T>(key: string): Promise<T | null> {
+    const data = await redis.get(key);
+    return data ? JSON.parse(data) : null;
+  }
+
+  async del(key: string) {
+    await redis.del(key);
+  }
+}
+
+export const cacheService = new CacheService();
+export default redis;
+`;
+fs.writeFileSync(path.join(basePath, "redis.ts"), redisContent.trim());
+/* ================= cache.ts ================= */
+const cacheContent = `
+interface CachedSecret {
+  value: string;
+  expiresAt: number;
+}
+
+const realmSecretCache = new Map<string, CachedSecret>();
+const DEFAULT_TTL_MS = 5 * 60 * 1000;
+
+export const getCachedSecret = (realmId: string) => {
+  const cached = realmSecretCache.get(realmId);
+  if (!cached || cached.expiresAt < Date.now()) {
+    realmSecretCache.delete(realmId);
+    return null;
+  }
+  return cached.value;
+};
+
+export const setCachedSecret = (realmId: string, secret: string, ttlMs = DEFAULT_TTL_MS) => {
+  realmSecretCache.set(realmId, {
+    value: secret,
+    expiresAt: Date.now() + ttlMs,
+  });
+};
+
+export const invalidateSecret = (realmId: string) => {
+  realmSecretCache.delete(realmId);
+};
+`;
+fs.writeFileSync(path.join(basePath, "cache.ts"), cacheContent.trim());
+/* ================= redis.dto.ts ================= */
+const redisDtoContent = `
+export interface CachedUserProfilePermissionDto {
+  userId: string;
+  username: string;
+  email: string;
+  realm: {
+    realmId: string;
+    name: string;
+  };
+  roles: string[];
+  permissions: string[];
+}
+`;
+fs.writeFileSync(path.join(basePath, "redis.dto.ts"), redisDtoContent.trim());
+/* ================= logger.ts ================= */
+const loggerContent = `
+import winston from "winston";
+
+const logger = winston.createLogger({
+  level: "info",
+  format: winston.format.combine(
+    winston.format.colorize(),
+    winston.format.timestamp(),
+    winston.format.printf(({ timestamp, level, message }) => \`[\${timestamp}] \${level}: \${message}\`)
+  ),
+  transports: [new winston.transports.Console()],
+});
+
+export default logger;
+`;
+fs.writeFileSync(path.join(basePath, "logger.ts"), loggerContent.trim());
+/* ================= bootstrap.ts ================= */
+const bootstrapContent = `
+import prisma from "../prisma/client";
+import logger from "./logger";
+
+async function bootstrapSystem() {
+  // optional: seed data or migrations
+  console.log("🚀 System bootstrap complete");
+}
+
+export async function wipeAllTables() {
+  try {
+    await prisma.$executeRawUnsafe(\`TRUNCATE TABLE "User" CASCADE;\`);
+    logger.info("✅ All tables wiped successfully");
+  } catch (error) {
+    logger.error(error);
+  }
+}
+
+export default bootstrapSystem;
+`;
+fs.writeFileSync(path.join(basePath, "bootstrap.ts"), bootstrapContent.trim());
+/* ================= consts.ts ================= */
+const constsContent = `
+export const CONSTS = {
+  REDIS_URL: process.env.REDIS_URL || "redis://localhost:6379",
+};
+
+export enum ActionsType {
+  CREATE = "CREATE",
+  READ = "READ",
+  READ_ALL = "READ_ALL",
+  UPDATE = "UPDATE",
+  DELETE = "DELETE",
+}
+
+export enum Resource {
+  COMMON = "COMMON",
+}
+
+export enum ResourceType {
+  API_ENDPOINT = "API_ENDPOINT",
+  UI_PAGE = "UI_PAGE",
+  FILE = "FILE",
+  SERVICE = "SERVICE",
+  DATASET = "DATASET",
+}
+`;
+fs.writeFileSync(path.join(basePath, "consts.ts"), constsContent.trim());
+/* ================= swagger.ts ================= */
+const swaggerContent = `
+import swaggerJsdoc from "swagger-jsdoc";
+
+export const swaggerSpec = swaggerJsdoc({
+  definition: {
+    openapi: "3.0.0",
+    info: {
+      title: "Express REST API",
+      version: "1.0.0",
+      description: "RESTful API with Express + TypeScript + Swagger",
+    },
+    components: {
+      securitySchemes: {
+        bearerAuth: {
+          type: "http",
+          scheme: "bearer",
+          bearerFormat: "JWT",
+        },
+      },
+    },
+    security: [{ bearerAuth: [] }],
+    servers: [{ url: "http://localhost:3000" }],
+  },
+  apis: ["./src/**/*.routes.ts", "./src/**/*.dto.ts"],
+});
+`;
+fs.writeFileSync(path.join(basePath, "swagger.ts"), swaggerContent.trim());
+console.log("✅ Utils files generated successfully inside src/utils");

package/dist/scripts/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}`);

package/dist/scripts/setup-prisma.js

@@ -0,0 +1,21 @@
+import * as fs from "fs";
+import * as path from "path";
+const projectRoot = process.cwd();
+const basePath = path.join(projectRoot, "src", "prisma");
+if (!fs.existsSync(basePath)) {
+    fs.mkdirSync(basePath, { recursive: true });
+}
+const clientContent = `
+import { PrismaClient } from "@prisma/client";
+import { PrismaPg } from "@prisma/adapter-pg";
+import "dotenv/config";
+
+const connectionString = process.env.DATABASE_URL;
+
+const adapter = new PrismaPg({ connectionString });
+const prisma = new PrismaClient({ adapter });
+
+export default prisma;
+`;
+fs.writeFileSync(path.join(basePath, "client.ts"), clientContent.trim());
+console.log(`✅ Prisma client generated successfully at ${basePath}`);

package/index.ts

@@ -0,0 +1,29 @@
+#!/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;
+
+console.log(projectName)
+
+function run(cmd: string) {
+  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/package.json

@@ -0,0 +1,23 @@
+{
+  "name": "crypt-express-app",
+  "version": "1.0.0",
+  "description": "",
+  "type": "module",
+  "main": "index.js",
+  "scripts": {
+    "dev": "tsx index.ts",
+    "build": "tsc"
+  },
+  "bin": {
+    "crypt-express-app": "index.ts"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "packageManager": "pnpm@10.29.3",
+  "devDependencies": {
+    "@types/node": "^25.3.2",
+    "tsx": "^4.21.0",
+    "typescript": "^5.9.3"
+  }
+}

package/scripts/generate-app.ts

@@ -0,0 +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 = `
+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/scripts/generate-locales.ts

@@ -0,0 +1,36 @@
+// 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");