@fluyappgocore/commons-backend 1.0.204 → 1.0.208

package/build/events/createClient.js

@@ -60,7 +60,13 @@ var KafkaConnection = function (brokers, clientId) {
         console.log("[events] Using RabbitMQ for " + clientId);
         return createRabbitMQAdapter(clientId);
     }
-    var kafka = new kafkajs_1.Kafka({ clientId: clientId, brokers: brokers });
+    // Filter out empty/undefined broker strings
+    var validBrokers = brokers.filter(function (b) { return !!b && b.trim() !== ""; });
+    if (validBrokers.length === 0) {
+        console.log("[events] No Kafka brokers or RabbitMQ configured for " + clientId + " \u2014 events disabled");
+        return createNoopAdapter();
+    }
+    var kafka = new kafkajs_1.Kafka({ clientId: clientId, brokers: validBrokers });
     return kafka;
 };
 exports.KafkaConnection = KafkaConnection;
@@ -79,11 +85,20 @@ function createRabbitMQAdapter(clientId) {
             if (connecting)
                 return [2 /*return*/, connecting];
             connecting = (function () { return __awaiter(_this, void 0, void 0, function () {
-                var conn;
+                var maxRetries, attempt, conn, err_1;
                 return __generator(this, function (_a) {
                     switch (_a.label) {
-                        case 0: return [4 /*yield*/, amqp.connect(config_1.rabbitmqUrl)];
+                        case 0:
+                            maxRetries = 10;
+                            attempt = 1;
+                            _a.label = 1;
                         case 1:
+                            if (!(attempt <= maxRetries)) return [3 /*break*/, 7];
+                            _a.label = 2;
+                        case 2:
+                            _a.trys.push([2, 4, , 6]);
+                            return [4 /*yield*/, amqp.connect(config_1.rabbitmqUrl)];
+                        case 3:
                             conn = _a.sent();
                             conn.on("error", function (err) {
                                 console.error("[RabbitMQ:" + clientId + "] Connection error:", err.message);
@@ -97,7 +112,23 @@ function createRabbitMQAdapter(clientId) {
                             });
                             connection = conn;
                             connecting = null;
+                            console.log("[RabbitMQ:" + clientId + "] Connected");
                             return [2 /*return*/, conn];
+                        case 4:
+                            err_1 = _a.sent();
+                            if (attempt === maxRetries) {
+                                connecting = null;
+                                throw err_1;
+                            }
+                            console.log("[RabbitMQ:" + clientId + "] Waiting for RabbitMQ... (attempt " + attempt + "/" + maxRetries + ")");
+                            return [4 /*yield*/, new Promise(function (r) { return setTimeout(r, 3000); })];
+                        case 5:
+                            _a.sent();
+                            return [3 /*break*/, 6];
+                        case 6:
+                            attempt++;
+                            return [3 /*break*/, 1];
+                        case 7: return [2 /*return*/];
                     }
                 });
             }); })();
@@ -402,6 +433,54 @@ function runBatchMode(channel, queueName, topic, eachBatch, autoResolve) {
         });
     });
 }
+// ─── Noop adapter (no broker configured) ────────────────────────────────────
+function createNoopAdapter() {
+    return {
+        producer: function () {
+            return {
+                connect: function () {
+                    return __awaiter(this, void 0, void 0, function () { return __generator(this, function (_a) {
+                        return [2 /*return*/];
+                    }); });
+                },
+                send: function (_payload) {
+                    return __awaiter(this, void 0, void 0, function () { return __generator(this, function (_a) {
+                        return [2 /*return*/];
+                    }); });
+                },
+                disconnect: function () {
+                    return __awaiter(this, void 0, void 0, function () { return __generator(this, function (_a) {
+                        return [2 /*return*/];
+                    }); });
+                },
+            };
+        },
+        consumer: function (_opts) {
+            return {
+                connect: function () {
+                    return __awaiter(this, void 0, void 0, function () { return __generator(this, function (_a) {
+                        return [2 /*return*/];
+                    }); });
+                },
+                subscribe: function (_payload) {
+                    return __awaiter(this, void 0, void 0, function () { return __generator(this, function (_a) {
+                        return [2 /*return*/];
+                    }); });
+                },
+                run: function (_opts) {
+                    return __awaiter(this, void 0, void 0, function () { return __generator(this, function (_a) {
+                        return [2 /*return*/];
+                    }); });
+                },
+                disconnect: function () {
+                    return __awaiter(this, void 0, void 0, function () { return __generator(this, function (_a) {
+                        return [2 /*return*/];
+                    }); });
+                },
+            };
+        },
+    };
+}
 // ─── Message conversion ──────────────────────────────────────────────────────
 function toKafkaMessage(amqpMsg) {
     var _a, _b, _c;

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

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

package/build/middlewares/error.middleware.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.errorMiddleware = void 0;
+// Typed as 'any' to avoid Express version conflicts across microservices
 var errorMiddleware = function (error, request, response, next) {
     var status = error.status || 500;
     var message = error.message || 'Something went wrong';

package/build/middlewares/index.d.ts

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

package/build/middlewares/index.js

@@ -13,3 +13,4 @@ Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./auth.middleware"), exports);
 __exportStar(require("./error.middleware"), exports);
 __exportStar(require("./validation.middleware"), exports);
+__exportStar(require("./licenseGuard.middleware"), exports);

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

@@ -0,0 +1,56 @@
+import { Request, Response, NextFunction } from "express";
+/**
+ * License feature guard middleware for microservices.
+ * Caches license data from the licensing server and checks feature flags.
+ *
+ * Usage in any MS route:
+ *   router.get("/analytics", authFBMiddleware, licenseGuard("analytics-summary"), controller)
+ *
+ * Requires LICENSE_URL and INSTALLATION_UUID env vars.
+ * Falls back to allowing access if license server is unreachable.
+ */
+interface LicenseCache {
+    valid: boolean;
+    readOnly: boolean;
+    blocked: boolean;
+    features: Record<string, boolean>;
+    limits: {
+        maxBranches: number;
+        maxAgents: number;
+        maxServices: number;
+    };
+    tier: string;
+    fetchedAt: number;
+}
+/**
+ * Check if a license feature is enabled.
+ * Can be used programmatically without middleware.
+ */
+export declare function isLicenseFeatureEnabled(featureKey: string): Promise<boolean>;
+/**
+ * Get cached license limits.
+ */
+export declare function getLicenseLimits(): Promise<LicenseCache["limits"] | null>;
+/**
+ * Express middleware that blocks access if a license feature is not enabled.
+ */
+export declare function licenseGuard(...requiredFeatures: string[]): (_req: Request, res: Response, next: NextFunction) => Promise<void | Response<any, Record<string, any>>>;
+/**
+ * Blocks write operations (POST/PUT/DELETE) when license is in READONLY mode.
+ * Use on all mutation routes. GET requests are always allowed in readonly.
+ */
+export declare function licenseWriteGuard(): (req: Request, res: Response, next: NextFunction) => Promise<void | Response<any, Record<string, any>>>;
+/**
+ * Blocks ALL access (including login) when license is BLOCKED.
+ * Use on auth/login routes.
+ */
+export declare function licenseLoginGuard(): (_req: Request, res: Response, next: NextFunction) => Promise<void | Response<any, Record<string, any>>>;
+/**
+ * Get current license status (for use in controllers).
+ */
+export declare function getLicenseStatus(): Promise<{
+    valid: boolean;
+    readOnly: boolean;
+    blocked: boolean;
+} | null>;
+export {};

package/build/middlewares/licenseGuard.middleware.js

@@ -0,0 +1,263 @@
+"use strict";
+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.getLicenseStatus = exports.licenseLoginGuard = exports.licenseWriteGuard = exports.licenseGuard = exports.getLicenseLimits = exports.isLicenseFeatureEnabled = void 0;
+var cache = null;
+var CACHE_TTL = 1000 * 60 * 60; // 1 hour
+function fetchLicense() {
+    return __awaiter(this, void 0, void 0, function () {
+        var licenseUrl, installationUuid, controller_1, timeout_1, res, data, _a;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    licenseUrl = process.env.LICENSE_URL || "";
+                    installationUuid = process.env.INSTALLATION_UUID || process.env.ENTITY_UUID || "";
+                    if (!licenseUrl || !installationUuid)
+                        return [2 /*return*/, null];
+                    _b.label = 1;
+                case 1:
+                    _b.trys.push([1, 4, , 5]);
+                    controller_1 = new AbortController();
+                    timeout_1 = setTimeout(function () { return controller_1.abort(); }, 5000);
+                    return [4 /*yield*/, fetch(licenseUrl + "/api/license/validate/" + installationUuid, { signal: controller_1.signal }).finally(function () { return clearTimeout(timeout_1); })];
+                case 2:
+                    res = _b.sent();
+                    if (!res.ok)
+                        return [2 /*return*/, null];
+                    return [4 /*yield*/, res.json()];
+                case 3:
+                    data = _b.sent();
+                    return [2 /*return*/, {
+                            valid: data.valid,
+                            readOnly: data.readOnly || false,
+                            blocked: data.blocked || false,
+                            features: data.features || {},
+                            limits: data.limits || {},
+                            tier: data.tier || "BASIC",
+                            fetchedAt: Date.now(),
+                        }];
+                case 4:
+                    _a = _b.sent();
+                    return [2 /*return*/, null];
+                case 5: return [2 /*return*/];
+            }
+        });
+    });
+}
+function getCachedLicense() {
+    return __awaiter(this, void 0, void 0, function () {
+        var fresh;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    if (cache && (Date.now() - cache.fetchedAt) < CACHE_TTL)
+                        return [2 /*return*/, cache];
+                    return [4 /*yield*/, fetchLicense()];
+                case 1:
+                    fresh = _a.sent();
+                    if (fresh)
+                        cache = fresh;
+                    return [2 /*return*/, cache];
+            }
+        });
+    });
+}
+/**
+ * Check if a license feature is enabled.
+ * Can be used programmatically without middleware.
+ */
+function isLicenseFeatureEnabled(featureKey) {
+    return __awaiter(this, void 0, void 0, function () {
+        var license;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, getCachedLicense()];
+                case 1:
+                    license = _a.sent();
+                    if (!license)
+                        return [2 /*return*/, true]; // Allow if can't check
+                    if (Object.keys(license.features).length === 0)
+                        return [2 /*return*/, true]; // No restrictions
+                    return [2 /*return*/, license.features[featureKey] === true];
+            }
+        });
+    });
+}
+exports.isLicenseFeatureEnabled = isLicenseFeatureEnabled;
+/**
+ * Get cached license limits.
+ */
+function getLicenseLimits() {
+    return __awaiter(this, void 0, void 0, function () {
+        var license;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, getCachedLicense()];
+                case 1:
+                    license = _a.sent();
+                    return [2 /*return*/, (license === null || license === void 0 ? void 0 : license.limits) || null];
+            }
+        });
+    });
+}
+exports.getLicenseLimits = getLicenseLimits;
+/**
+ * Express middleware that blocks access if a license feature is not enabled.
+ */
+function licenseGuard() {
+    var _this = this;
+    var requiredFeatures = [];
+    for (var _i = 0; _i < arguments.length; _i++) {
+        requiredFeatures[_i] = arguments[_i];
+    }
+    return function (_req, res, next) { return __awaiter(_this, void 0, void 0, function () {
+        var license, _i, requiredFeatures_1, feature;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, getCachedLicense()];
+                case 1:
+                    license = _a.sent();
+                    // If can't check license, allow (don't block users)
+                    if (!license)
+                        return [2 /*return*/, next()];
+                    // If license is not valid (expired/revoked), block
+                    if (!license.valid) {
+                        return [2 /*return*/, res.status(403).json({
+                                error: "Licencia no valida",
+                                code: "LICENSE_INVALID",
+                            })];
+                    }
+                    // If no features defined in license, allow everything
+                    if (Object.keys(license.features).length === 0)
+                        return [2 /*return*/, next()];
+                    // Check all required features
+                    for (_i = 0, requiredFeatures_1 = requiredFeatures; _i < requiredFeatures_1.length; _i++) {
+                        feature = requiredFeatures_1[_i];
+                        if (license.features[feature] !== true) {
+                            return [2 /*return*/, res.status(403).json({
+                                    error: "Modulo \"" + feature + "\" no habilitado en su licencia",
+                                    code: "FEATURE_DISABLED",
+                                    feature: feature,
+                                    tier: license.tier,
+                                })];
+                        }
+                    }
+                    next();
+                    return [2 /*return*/];
+            }
+        });
+    }); };
+}
+exports.licenseGuard = licenseGuard;
+/**
+ * Blocks write operations (POST/PUT/DELETE) when license is in READONLY mode.
+ * Use on all mutation routes. GET requests are always allowed in readonly.
+ */
+function licenseWriteGuard() {
+    var _this = this;
+    return function (req, res, next) { return __awaiter(_this, void 0, void 0, function () {
+        var license;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    // Only block write methods
+                    if (req.method === "GET" || req.method === "HEAD" || req.method === "OPTIONS")
+                        return [2 /*return*/, next()];
+                    return [4 /*yield*/, getCachedLicense()];
+                case 1:
+                    license = _a.sent();
+                    if (!license)
+                        return [2 /*return*/, next()]; // Can't check → allow
+                    if (license.blocked) {
+                        return [2 /*return*/, res.status(403).json({
+                                error: "Licencia expirada. Acceso bloqueado.",
+                                code: "LICENSE_BLOCKED",
+                            })];
+                    }
+                    if (license.readOnly) {
+                        return [2 /*return*/, res.status(403).json({
+                                error: "Licencia en modo solo lectura. No se permiten cambios.",
+                                code: "LICENSE_READONLY",
+                            })];
+                    }
+                    next();
+                    return [2 /*return*/];
+            }
+        });
+    }); };
+}
+exports.licenseWriteGuard = licenseWriteGuard;
+/**
+ * Blocks ALL access (including login) when license is BLOCKED.
+ * Use on auth/login routes.
+ */
+function licenseLoginGuard() {
+    var _this = this;
+    return function (_req, res, next) { return __awaiter(_this, void 0, void 0, function () {
+        var license;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, getCachedLicense()];
+                case 1:
+                    license = _a.sent();
+                    if (!license)
+                        return [2 /*return*/, next()]; // Can't check → allow
+                    if (license.blocked) {
+                        return [2 /*return*/, res.status(403).json({
+                                error: "Licencia expirada. El acceso ha sido suspendido. Contacte al administrador.",
+                                code: "LICENSE_BLOCKED",
+                            })];
+                    }
+                    next();
+                    return [2 /*return*/];
+            }
+        });
+    }); };
+}
+exports.licenseLoginGuard = licenseLoginGuard;
+/**
+ * Get current license status (for use in controllers).
+ */
+function getLicenseStatus() {
+    return __awaiter(this, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            return [2 /*return*/, getCachedLicense()];
+        });
+    });
+}
+exports.getLicenseStatus = getLicenseStatus;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fluyappgocore/commons-backend",
-  "version": "1.0.204",
+  "version": "1.0.208",
   "description": "",
   "main": "./build/index.js",
   "types": "./build/index.d.ts",