@fluyappgocore/commons-backend 1.0.213 → 1.0.214

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

@@ -1,14 +1,4 @@
 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;
@@ -21,6 +11,9 @@ interface LicenseCache {
     };
     tier: string;
     fetchedAt: number;
+    unreachable?: boolean;
+    unreachableSince?: number | null;
+    unreachableGraceDaysLeft?: number | null;
 }
 /**
  * Check if a license feature is enabled.
@@ -47,10 +40,16 @@ export declare function licenseWriteGuard(): (req: Request, res: Response, next:
 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).
+ * Includes the unreachable-grace fields so the frontend can render a
+ * "licensing server unreachable, X days left" banner.
  */
 export declare function getLicenseStatus(): Promise<{
     valid: boolean;
     readOnly: boolean;
     blocked: boolean;
+    tier: string;
+    unreachable: boolean;
+    unreachableSince: number | null;
+    unreachableGraceDaysLeft: number | null;
 } | null>;
 export {};

package/build/middlewares/licenseGuard.middleware.js

@@ -1,4 +1,15 @@
 "use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
 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) {
@@ -37,8 +48,74 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getLicenseStatus = exports.licenseLoginGuard = exports.licenseWriteGuard = exports.licenseGuard = exports.getLicenseLimits = exports.isLicenseFeatureEnabled = void 0;
+var fs_1 = require("fs");
+/**
+ * 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.
+ *
+ * Unreachable behaviour (PaaS policy):
+ *   - If the licensing server can't be reached, the tenant keeps
+ *     working for UNREACHABLE_GRACE_DAYS days using the last cached
+ *     features (or open if there was none). After that, /license-status
+ *     reports `blocked: true` and the standard guards reject traffic.
+ *   - The client app is expected to read `unreachable` +
+ *     `unreachableGraceDaysLeft` from `getLicenseStatus()` and show a
+ *     warning banner.
+ */
+var UNREACHABLE_GRACE_DAYS = 7;
+var UNREACHABLE_GRACE_MS = UNREACHABLE_GRACE_DAYS * 24 * 60 * 60 * 1000;
+var GRACE_STATE_FILE = "/tmp/fluyapp-license-grace.json";
 var cache = null;
 var CACHE_TTL = 1000 * 60 * 60; // 1 hour
+function readGraceState() {
+    return __awaiter(this, void 0, void 0, function () {
+        var raw, _a;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    _b.trys.push([0, 2, , 3]);
+                    return [4 /*yield*/, fs_1.promises.readFile(GRACE_STATE_FILE, "utf8")];
+                case 1:
+                    raw = _b.sent();
+                    return [2 /*return*/, JSON.parse(raw)];
+                case 2:
+                    _a = _b.sent();
+                    return [2 /*return*/, null];
+                case 3: return [2 /*return*/];
+            }
+        });
+    });
+}
+function writeGraceState(state) {
+    return __awaiter(this, void 0, void 0, function () {
+        var _a;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    _b.trys.push([0, 5, , 6]);
+                    if (!state) return [3 /*break*/, 2];
+                    return [4 /*yield*/, fs_1.promises.writeFile(GRACE_STATE_FILE, JSON.stringify(state))];
+                case 1:
+                    _b.sent();
+                    return [3 /*break*/, 4];
+                case 2: return [4 /*yield*/, fs_1.promises.unlink(GRACE_STATE_FILE).catch(function () { })];
+                case 3:
+                    _b.sent();
+                    _b.label = 4;
+                case 4: return [3 /*break*/, 6];
+                case 5:
+                    _a = _b.sent();
+                    return [3 /*break*/, 6];
+                case 6: return [2 /*return*/];
+            }
+        });
+    });
+}
 /**
  * Where to fetch license data from. Two modes:
  *
@@ -125,18 +202,72 @@ function fetchLicense() {
     });
 }
 function getCachedLicense() {
+    var _a;
     return __awaiter(this, void 0, void 0, function () {
-        var fresh;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
+        var fresh, now, stored, since, elapsed, expired, daysLeft;
+        return __generator(this, function (_b) {
+            switch (_b.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;
+                    fresh = _b.sent();
+                    if (!fresh) return [3 /*break*/, 3];
+                    // Successful refresh: clear any pending grace state.
+                    return [4 /*yield*/, writeGraceState(null)];
+                case 2:
+                    // Successful refresh: clear any pending grace state.
+                    _b.sent();
+                    cache = __assign(__assign({}, fresh), { unreachable: false, unreachableSince: null, unreachableGraceDaysLeft: null });
+                    return [2 /*return*/, cache];
+                case 3:
+                    now = Date.now();
+                    return [4 /*yield*/, readGraceState()];
+                case 4:
+                    stored = _b.sent();
+                    since = (_a = stored === null || stored === void 0 ? void 0 : stored.unreachableSince) !== null && _a !== void 0 ? _a : now;
+                    if (!!stored) return [3 /*break*/, 6];
+                    return [4 /*yield*/, writeGraceState({ unreachableSince: now })];
+                case 5:
+                    _b.sent();
+                    _b.label = 6;
+                case 6:
+                    elapsed = now - since;
+                    expired = elapsed >= UNREACHABLE_GRACE_MS;
+                    daysLeft = expired ? 0 : Math.ceil((UNREACHABLE_GRACE_MS - elapsed) / (24 * 60 * 60 * 1000));
+                    if (expired) {
+                        // Past 7 days without a successful fetch — treat as blocked.
+                        cache = {
+                            valid: false,
+                            readOnly: false,
+                            blocked: true,
+                            features: {},
+                            limits: { maxBranches: 0, maxAgents: 0, maxServices: 0 },
+                            tier: "BASIC",
+                            fetchedAt: now,
+                            unreachable: true,
+                            unreachableSince: since,
+                            unreachableGraceDaysLeft: 0,
+                        };
+                        return [2 /*return*/, cache];
+                    }
+                    // Inside grace: keep last known features if we had any, otherwise open.
+                    if (cache && cache.valid !== false) {
+                        return [2 /*return*/, __assign(__assign({}, cache), { unreachable: true, unreachableSince: since, unreachableGraceDaysLeft: daysLeft, fetchedAt: now })];
+                    }
+                    cache = {
+                        valid: true,
+                        readOnly: false,
+                        blocked: false,
+                        features: {},
+                        limits: { maxBranches: 0, maxAgents: 0, maxServices: 0 },
+                        tier: "GRACE",
+                        fetchedAt: now,
+                        unreachable: true,
+                        unreachableSince: since,
+                        unreachableGraceDaysLeft: daysLeft,
+                    };
                     return [2 /*return*/, cache];
             }
         });
@@ -297,11 +428,30 @@ function licenseLoginGuard() {
 exports.licenseLoginGuard = licenseLoginGuard;
 /**
  * Get current license status (for use in controllers).
+ * Includes the unreachable-grace fields so the frontend can render a
+ * "licensing server unreachable, X days left" banner.
  */
 function getLicenseStatus() {
+    var _a, _b;
     return __awaiter(this, void 0, void 0, function () {
-        return __generator(this, function (_a) {
-            return [2 /*return*/, getCachedLicense()];
+        var lic;
+        return __generator(this, function (_c) {
+            switch (_c.label) {
+                case 0: return [4 /*yield*/, getCachedLicense()];
+                case 1:
+                    lic = _c.sent();
+                    if (!lic)
+                        return [2 /*return*/, null];
+                    return [2 /*return*/, {
+                            valid: lic.valid,
+                            readOnly: lic.readOnly,
+                            blocked: lic.blocked,
+                            tier: lic.tier,
+                            unreachable: lic.unreachable === true,
+                            unreachableSince: (_a = lic.unreachableSince) !== null && _a !== void 0 ? _a : null,
+                            unreachableGraceDaysLeft: (_b = lic.unreachableGraceDaysLeft) !== null && _b !== void 0 ? _b : null,
+                        }];
+            }
         });
     });
 }

package/package.json

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