@fluyappgocore/commons-backend 1.0.202

package/build/middlewares/auth.middleware.js

@@ -0,0 +1,287 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.authTokenMiddleware = exports.midAuthMiddleware = exports.authMiddleware = exports.authFBMiddleware = void 0;
+var jwt = __importStar(require("jsonwebtoken"));
+var exceptions_1 = require("../exceptions/");
+var wrongAuth_exception_1 = require("../exceptions/wrongAuth.exception");
+var redis = __importStar(require("redis"));
+var promisify = require("util").promisify;
+var RedisClient = redis.createClient({ host: process.env.REDIS_HOST, port: 6379 });
+var hGetAsync = promisify(RedisClient.hget).bind(RedisClient);
+var hDelAsync = promisify(RedisClient.hdel).bind(RedisClient);
+function authFBMiddleware(request, response, next) {
+    var _a, _b;
+    return __awaiter(this, void 0, void 0, function () {
+        var authorization, secret, verificationResponse, userJwt, userRaw, user, jwtPayload, error_1;
+        return __generator(this, function (_c) {
+            switch (_c.label) {
+                case 0:
+                    authorization = ((_a = request.headers) === null || _a === void 0 ? void 0 : _a.authorization) || ((_b = request === null || request === void 0 ? void 0 : request.session) === null || _b === void 0 ? void 0 : _b.jwt);
+                    if (!authorization) return [3 /*break*/, 9];
+                    secret = process.env.JWT_KEY || " ";
+                    _c.label = 1;
+                case 1:
+                    _c.trys.push([1, 7, , 8]);
+                    verificationResponse = jwt.verify(authorization, secret);
+                    userJwt = verificationResponse;
+                    return [4 /*yield*/, hGetAsync("user", userJwt.uuid)];
+                case 2:
+                    userRaw = _c.sent();
+                    if (!userRaw) {
+                        console.error("🚨 SECURITY ALERT - User not found in Redis:", {
+                            uuid: userJwt.uuid,
+                            timestamp: new Date().toISOString(),
+                            ip: request.ip,
+                            userAgent: request.get("User-Agent"),
+                        });
+                        return [2 /*return*/, next(new wrongAuth_exception_1.WrongAuthException())];
+                    }
+                    user = JSON.parse(userRaw);
+                    if (!(user.id !== userJwt.id || user.uuid !== userJwt.uuid || user.entityUuid !== userJwt.entityUuid)) return [3 /*break*/, 4];
+                    console.error("🚨 CRITICAL SECURITY ALERT - Data mismatch detected:", {
+                        error: "Token and Redis data mismatch",
+                        jwtData: {
+                            id: userJwt.id,
+                            uuid: userJwt.uuid,
+                            entityUuid: userJwt.entityUuid,
+                        },
+                        redisData: {
+                            id: user.id,
+                            uuid: user.uuid,
+                            entityUuid: user.entityUuid,
+                            email: user.email,
+                        },
+                        timestamp: new Date().toISOString(),
+                        ip: request.ip,
+                        userAgent: request.get("User-Agent"),
+                        url: request.originalUrl,
+                        method: request.method,
+                    });
+                    return [4 /*yield*/, hDelAsync("user", userJwt.uuid)];
+                case 3:
+                    _c.sent();
+                    return [2 /*return*/, next(new wrongAuth_exception_1.WrongAuthException())];
+                case 4:
+                    jwtPayload = userJwt;
+                    if (!(jwtPayload.exp && jwtPayload.exp < Math.floor(Date.now() / 1000))) return [3 /*break*/, 6];
+                    console.error("🚨 SECURITY ALERT - Expired token used:", {
+                        uuid: userJwt.uuid,
+                        exp: jwtPayload.exp,
+                        now: Math.floor(Date.now() / 1000),
+                        timestamp: new Date().toISOString(),
+                    });
+                    return [4 /*yield*/, hDelAsync("user", userJwt.uuid)];
+                case 5:
+                    _c.sent();
+                    return [2 /*return*/, next(new wrongAuth_exception_1.WrongAuthException())];
+                case 6:
+                    request.user = user;
+                    next();
+                    return [3 /*break*/, 8];
+                case 7:
+                    error_1 = _c.sent();
+                    console.error("🚨 JWT VERIFICATION ERROR:", {
+                        error: error_1 instanceof Error ? error_1.message : String(error_1),
+                        timestamp: new Date().toISOString(),
+                    });
+                    next(new exceptions_1.MissingTokenException("Error: " + error_1));
+                    return [3 /*break*/, 8];
+                case 8: return [3 /*break*/, 10];
+                case 9:
+                    next(new exceptions_1.MissingTokenException("Error: no auth"));
+                    _c.label = 10;
+                case 10: return [2 /*return*/];
+            }
+        });
+    });
+}
+exports.authFBMiddleware = authFBMiddleware;
+function authMiddleware(request, response, next) {
+    var _a, _b;
+    return __awaiter(this, void 0, void 0, function () {
+        var authorization, secret, verificationResponse, user, userPayload;
+        return __generator(this, function (_c) {
+            authorization = ((_a = request.headers) === null || _a === void 0 ? void 0 : _a.authorization) || ((_b = request === null || request === void 0 ? void 0 : request.session) === null || _b === void 0 ? void 0 : _b.jwt);
+            if (authorization) {
+                secret = process.env.JWT_KEY || "";
+                try {
+                    verificationResponse = jwt.verify(authorization, secret);
+                    user = verificationResponse;
+                    if (user) {
+                        userPayload = user;
+                        if (userPayload.exp && userPayload.exp < Math.floor(Date.now() / 1000)) {
+                            console.error("🚨 SECURITY ALERT - Expired token in basic auth:", {
+                                exp: userPayload.exp,
+                                now: Math.floor(Date.now() / 1000),
+                                timestamp: new Date().toISOString(),
+                            });
+                            return [2 /*return*/, next(new wrongAuth_exception_1.WrongAuthException())];
+                        }
+                        request.user = user;
+                        next();
+                    }
+                    else {
+                        next(new wrongAuth_exception_1.WrongAuthException());
+                    }
+                }
+                catch (error) {
+                    console.error("🚨 AUTH MIDDLEWARE ERROR:", {
+                        error: error instanceof Error ? error.message : String(error),
+                        timestamp: new Date().toISOString(),
+                    });
+                    next(new exceptions_1.MissingTokenException("JWT verification failed"));
+                }
+            }
+            else {
+                next(new exceptions_1.MissingTokenException("No authorization token provided"));
+            }
+            return [2 /*return*/];
+        });
+    });
+}
+exports.authMiddleware = authMiddleware;
+function midAuthMiddleware(request, response, next) {
+    var _a, _b;
+    return __awaiter(this, void 0, void 0, function () {
+        var authorization, secret, verificationResponse, user;
+        return __generator(this, function (_c) {
+            authorization = ((_a = request.headers) === null || _a === void 0 ? void 0 : _a.authorization) || ((_b = request === null || request === void 0 ? void 0 : request.session) === null || _b === void 0 ? void 0 : _b.jwt);
+            if (authorization) {
+                secret = process.env.JWT_KEY || "";
+                try {
+                    verificationResponse = jwt.verify(authorization, secret);
+                    user = verificationResponse;
+                    if (user) {
+                        request.user = user;
+                        next();
+                    }
+                    else {
+                        request.user = {
+                            _id: "",
+                            email: "",
+                            password: "",
+                            lastName: "",
+                        };
+                        next();
+                    }
+                }
+                catch (error) {
+                    request.user = {
+                        _id: "",
+                        email: "",
+                        password: "",
+                        lastName: "",
+                    };
+                    next();
+                }
+            }
+            else {
+                request.user = {
+                    _id: "",
+                    email: "",
+                    password: "",
+                    lastName: "",
+                };
+                next();
+            }
+            return [2 /*return*/];
+        });
+    });
+}
+exports.midAuthMiddleware = midAuthMiddleware;
+function authTokenMiddleware(request, response, next) {
+    var _a, _b;
+    return __awaiter(this, void 0, void 0, function () {
+        var authorization, secret, verificationResponse;
+        return __generator(this, function (_c) {
+            authorization = ((_a = request.headers) === null || _a === void 0 ? void 0 : _a.authorization) || ((_b = request === null || request === void 0 ? void 0 : request.session) === null || _b === void 0 ? void 0 : _b.jwt);
+            if (authorization) {
+                secret = process.env.JWT_KEY || "";
+                try {
+                    verificationResponse = jwt.verify(authorization, secret);
+                    if (typeof verificationResponse !== "object" ||
+                        (verificationResponse.type !== "onboarding" && verificationResponse.type !== "recoverPassword")) {
+                        console.error("🚨 AUTH TOKEN MIDDLEWARE ERROR:", {
+                            error: "Invalid token type",
+                            tokenType: verificationResponse.type,
+                            timestamp: new Date().toISOString(),
+                        });
+                        return [2 /*return*/, next(new exceptions_1.InvalidTokenException("Error: invalid token type"))];
+                    }
+                    next();
+                }
+                catch (error) {
+                    console.error("🚨 AUTH TOKEN MIDDLEWARE ERROR:", {
+                        error: error instanceof Error ? error.message : String(error),
+                        timestamp: new Date().toISOString(),
+                    });
+                    next(new exceptions_1.HttpException(401, "Error veryfying token."));
+                }
+            }
+            else {
+                console.error("🚨 AUTH TOKEN MIDDLEWARE ERROR:", {
+                    error: "No token provided",
+                    timestamp: new Date().toISOString(),
+                });
+                next(new exceptions_1.MissingTokenException("Error: no token provided."));
+            }
+            return [2 /*return*/];
+        });
+    });
+}
+exports.authTokenMiddleware = authTokenMiddleware;

package/build/middlewares/error.middleware.d.ts

@@ -0,0 +1,3 @@
+import { NextFunction, Request, Response } from 'express';
+import { HttpException } from '../exceptions';
+export declare const errorMiddleware: (error: HttpException, request: Request, response: Response, next: NextFunction) => void;

package/build/middlewares/error.middleware.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.errorMiddleware = void 0;
+var errorMiddleware = function (error, request, response, next) {
+    var status = error.status || 500;
+    var message = error.message || 'Something went wrong';
+    response
+        .status(status)
+        .send({
+        status: status,
+        message: message,
+    });
+};
+exports.errorMiddleware = errorMiddleware;

package/build/middlewares/index.d.ts

@@ -0,0 +1,3 @@
+export * from './auth.middleware';
+export * from './error.middleware';
+export * from './validation.middleware';

package/build/middlewares/index.js

@@ -0,0 +1,15 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./auth.middleware"), exports);
+__exportStar(require("./error.middleware"), exports);
+__exportStar(require("./validation.middleware"), exports);

package/build/middlewares/validation.middleware.d.ts

@@ -0,0 +1,2 @@
+import * as express from 'express';
+export declare const validationMiddleware: <T>(type: any, skipMissingProperties?: boolean) => express.RequestHandler;

package/build/middlewares/validation.middleware.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validationMiddleware = void 0;
+var class_transformer_1 = require("class-transformer");
+var class_validator_1 = require("class-validator");
+var exceptions_1 = require("../exceptions");
+var validationMiddleware = function (type, skipMissingProperties) {
+    if (skipMissingProperties === void 0) { skipMissingProperties = false; }
+    return function (req, res, next) {
+        class_validator_1.validate(class_transformer_1.plainToClass(type, req.body), { skipMissingProperties: skipMissingProperties })
+            .then(function (errors) {
+            if (errors.length > 0) {
+                var message = errors.map(function (error) { return Object.values(error.constraints); }).join(', ');
+                next(new exceptions_1.HttpException(400, message));
+            }
+            else {
+                next();
+            }
+        });
+    };
+};
+exports.validationMiddleware = validationMiddleware;

package/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "@fluyappgocore/commons-backend",
+  "version": "1.0.202",
+  "description": "",
+  "main": "./build/index.js",
+  "types": "./build/index.d.ts",
+  "files": [
+    "/build/**/*"
+  ],
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1",
+    "clean": "del ./build/*",
+    "build": "npm run clean && tsc",
+    "pub": "npm version patch && npm run build && npm publish"
+  },
+  "author": "",
+  "license": "ISC",
+  "devDependencies": {
+    "@types/amqplib": "^0.10.8",
+    "@types/express": "^4.17.13",
+    "@types/express-session": "^1.17.0",
+    "@types/jsonwebtoken": "^8.5.6",
+    "@types/redis": "^2.8.28",
+    "@types/validator": "^13.7.1",
+    "del-cli": "^3.0.1",
+    "typescript": "^4.1.3"
+  },
+  "dependencies": {
+    "@fluyappgo/commons": "^2.1.148",
+    "amqplib": "^0.10.9",
+    "class-transformer": "^0.5.1",
+    "class-validator": "^0.14.2",
+    "cookie-parser": "^1.4.6",
+    "cookie-session": "^2.0.0",
+    "express": "^4.17.2",
+    "express-rate-limit": "^7.5.0",
+    "express-session": "^1.17.2",
+    "jsonwebtoken": "^9.0.2",
+    "kafkajs": "^1.15.0",
+    "moment-timezone": "^0.5.33",
+    "pino": "^9.6.0",
+    "pino-pretty": "^13.0.0",
+    "redis": "^3.1.2"
+  }
+}