crypt-express-app 1.0.0

package/scripts/generate-middleware.ts

@@ -0,0 +1,176 @@
+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}`);