@fluyappgocore/commons-backend 1.0.205 → 1.0.210

package/build/helpers/dialectHelper.d.ts

@@ -0,0 +1,34 @@
+export declare class DialectHelper {
+    private dialect;
+    constructor(dialectOrSequelize: string | {
+        getDialect(): string;
+    });
+    get isPostgres(): boolean;
+    get isMssql(): boolean;
+    get isMysql(): boolean;
+    get dialectName(): string;
+    now(): string;
+    bool(val: boolean): string;
+    qi(name: string): string;
+    jsonType(): string;
+    autoIncrement(): string;
+    textArrayType(): string;
+    ilike(): string;
+    booleanType(): string;
+    textType(): string;
+    jsonValue(column: string, path: string): string;
+    jsonQuery(column: string, path: string): string;
+    jsonSet(column: string, path: string, value: string): string;
+    upsertIgnore(table: string, columns: string[], values: string[][], conflictColumn: string): string;
+    upsertUpdate(table: string, columns: string[], values: string[], conflictColumn: string, updateColumns: string[]): string;
+    returning(columns?: string[]): string;
+    limit(n: number): string;
+    limitClause(n: number): string;
+    timestampDefault(): string;
+    createIndexIfNotExists(table: string, indexName: string, columns: string[], unique?: boolean): string;
+    concat(...parts: string[]): string;
+    toTimestamp(value: string): string;
+}
+export declare function createDialectHelper(dialectOrSequelize: string | {
+    getDialect(): string;
+}): DialectHelper;

package/build/helpers/dialectHelper.js

@@ -0,0 +1,206 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createDialectHelper = exports.DialectHelper = void 0;
+var DialectHelper = /** @class */ (function () {
+    function DialectHelper(dialectOrSequelize) {
+        this.dialect = typeof dialectOrSequelize === 'string'
+            ? dialectOrSequelize
+            : dialectOrSequelize.getDialect();
+    }
+    Object.defineProperty(DialectHelper.prototype, "isPostgres", {
+        get: function () { return this.dialect === 'postgres'; },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(DialectHelper.prototype, "isMssql", {
+        get: function () { return this.dialect === 'mssql'; },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(DialectHelper.prototype, "isMysql", {
+        get: function () { return this.dialect === 'mysql' || this.dialect === 'mariadb'; },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(DialectHelper.prototype, "dialectName", {
+        get: function () { return this.dialect; },
+        enumerable: false,
+        configurable: true
+    });
+    DialectHelper.prototype.now = function () {
+        if (this.isMssql)
+            return 'GETDATE()';
+        return 'NOW()'; // postgres + mysql
+    };
+    DialectHelper.prototype.bool = function (val) {
+        if (this.isMssql)
+            return val ? '1' : '0';
+        if (this.isMysql)
+            return val ? '1' : '0';
+        return val ? 'true' : 'false'; // postgres
+    };
+    DialectHelper.prototype.qi = function (name) {
+        if (this.isMssql)
+            return "[" + name + "]";
+        if (this.isMysql)
+            return "`" + name + "`";
+        return "\"" + name + "\""; // postgres
+    };
+    DialectHelper.prototype.jsonType = function () {
+        if (this.isMssql)
+            return 'NVARCHAR(MAX)';
+        if (this.isMysql)
+            return 'JSON';
+        return 'JSONB'; // postgres
+    };
+    DialectHelper.prototype.autoIncrement = function () {
+        if (this.isMssql)
+            return 'INT IDENTITY(1,1)';
+        if (this.isMysql)
+            return 'INT AUTO_INCREMENT';
+        return 'SERIAL'; // postgres
+    };
+    DialectHelper.prototype.textArrayType = function () {
+        if (this.isPostgres)
+            return 'TEXT[]';
+        return 'NVARCHAR(MAX)'; // mssql + mysql (store as JSON string)
+    };
+    DialectHelper.prototype.ilike = function () {
+        return this.isPostgres ? 'ILIKE' : 'LIKE'; // mssql + mysql use LIKE
+    };
+    DialectHelper.prototype.booleanType = function () {
+        if (this.isMssql)
+            return 'BIT';
+        if (this.isMysql)
+            return 'TINYINT(1)';
+        return 'BOOLEAN'; // postgres
+    };
+    DialectHelper.prototype.textType = function () {
+        if (this.isMssql)
+            return 'NVARCHAR(MAX)';
+        if (this.isMysql)
+            return 'LONGTEXT';
+        return 'TEXT'; // postgres
+    };
+    DialectHelper.prototype.jsonValue = function (column, path) {
+        if (this.isMssql)
+            return "JSON_VALUE(" + this.qi(column) + ", '$." + path + "')";
+        if (this.isMysql)
+            return "JSON_UNQUOTE(JSON_EXTRACT(" + this.qi(column) + ", '$." + path + "'))";
+        return this.qi(column) + "->>'" + path + "'"; // postgres
+    };
+    DialectHelper.prototype.jsonQuery = function (column, path) {
+        if (this.isMssql)
+            return "JSON_QUERY(" + this.qi(column) + ", '$." + path + "')";
+        if (this.isMysql)
+            return "JSON_EXTRACT(" + this.qi(column) + ", '$." + path + "')";
+        return this.qi(column) + "->'" + path + "'"; // postgres
+    };
+    DialectHelper.prototype.jsonSet = function (column, path, value) {
+        if (this.isMssql)
+            return "JSON_MODIFY(" + this.qi(column) + ", '$." + path + "', " + value + ")";
+        if (this.isMysql)
+            return "JSON_SET(" + this.qi(column) + ", '$." + path + "', " + value + ")";
+        return "jsonb_set(" + this.qi(column) + ", '{" + path.replace(/\./g, ',') + "}', " + value + ")"; // postgres
+    };
+    DialectHelper.prototype.upsertIgnore = function (table, columns, values, conflictColumn) {
+        var _this = this;
+        var colList = columns.map(function (c) { return _this.qi(c); }).join(', ');
+        if (this.isMssql) {
+            return values.map(function (row) {
+                var conflictIdx = columns.indexOf(conflictColumn);
+                var whereClause = _this.qi(conflictColumn) + " = " + row[conflictIdx];
+                var valList = row.join(', ');
+                return "IF NOT EXISTS (SELECT 1 FROM " + _this.qi(table) + " WHERE " + whereClause + ")\n  INSERT INTO " + _this.qi(table) + " (" + colList + ") VALUES (" + valList + ");";
+            }).join('\n');
+        }
+        if (this.isMysql) {
+            var valRows_1 = values.map(function (row) { return "(" + row.join(', ') + ")"; }).join(',\n      ');
+            return "INSERT IGNORE INTO " + this.qi(table) + " (" + colList + ") VALUES\n      " + valRows_1 + ";";
+        }
+        // postgres
+        var valRows = values.map(function (row) { return "(" + row.join(', ') + ")"; }).join(',\n      ');
+        return "INSERT INTO " + this.qi(table) + " (" + colList + ") VALUES\n      " + valRows + "\n    ON CONFLICT (" + this.qi(conflictColumn) + ") DO NOTHING;";
+    };
+    DialectHelper.prototype.upsertUpdate = function (table, columns, values, conflictColumn, updateColumns) {
+        var _this = this;
+        var colList = columns.map(function (c) { return _this.qi(c); }).join(', ');
+        var valList = values.join(', ');
+        if (this.isMssql) {
+            var updateSet_1 = updateColumns.map(function (c) {
+                var idx = columns.indexOf(c);
+                return _this.qi(c) + " = " + values[idx];
+            }).join(', ');
+            return "MERGE " + this.qi(table) + " AS target\nUSING (SELECT " + values.map(function (v, i) { return v + " AS " + _this.qi(columns[i]); }).join(', ') + ") AS source\nON target." + this.qi(conflictColumn) + " = source." + this.qi(conflictColumn) + "\nWHEN MATCHED THEN UPDATE SET " + updateSet_1 + "\nWHEN NOT MATCHED THEN INSERT (" + colList + ") VALUES (" + valList + ");";
+        }
+        if (this.isMysql) {
+            var updateSet_2 = updateColumns.map(function (c) { return _this.qi(c) + " = VALUES(" + _this.qi(c) + ")"; }).join(', ');
+            return "INSERT INTO " + this.qi(table) + " (" + colList + ") VALUES (" + valList + ")\nON DUPLICATE KEY UPDATE " + updateSet_2 + ";";
+        }
+        // postgres
+        var updateSet = updateColumns.map(function (c) { return _this.qi(c) + " = EXCLUDED." + _this.qi(c); }).join(', ');
+        return "INSERT INTO " + this.qi(table) + " (" + colList + ") VALUES (" + valList + ")\nON CONFLICT (" + this.qi(conflictColumn) + ") DO UPDATE SET " + updateSet + ";";
+    };
+    DialectHelper.prototype.returning = function (columns) {
+        var _this = this;
+        if (columns === void 0) { columns = ['*']; }
+        if (this.isMssql || this.isMysql)
+            return '';
+        return "RETURNING " + columns.map(function (c) { return _this.qi(c); }).join(', '); // postgres only
+    };
+    DialectHelper.prototype.limit = function (n) {
+        return this.isMssql ? "TOP " + n : ''; // postgres + mysql use LIMIT clause
+    };
+    DialectHelper.prototype.limitClause = function (n) {
+        if (this.isMssql)
+            return '';
+        return "LIMIT " + n; // postgres + mysql
+    };
+    DialectHelper.prototype.timestampDefault = function () {
+        if (this.isMssql)
+            return 'DEFAULT GETDATE()';
+        return 'DEFAULT NOW()'; // postgres + mysql
+    };
+    // Create index with IF NOT EXISTS support
+    DialectHelper.prototype.createIndexIfNotExists = function (table, indexName, columns, unique) {
+        var _this = this;
+        if (unique === void 0) { unique = false; }
+        var uniqueStr = unique ? 'UNIQUE ' : '';
+        var colList = columns.map(function (c) { return _this.qi(c); }).join(', ');
+        if (this.isMssql) {
+            return "IF NOT EXISTS (SELECT 1 FROM sys.indexes WHERE name = '" + indexName + "')\nCREATE " + uniqueStr + "INDEX " + this.qi(indexName) + " ON " + this.qi(table) + " (" + colList + ");";
+        }
+        if (this.isMysql) {
+            // MySQL doesn't support IF NOT EXISTS for CREATE INDEX, use procedure
+            return "CREATE " + uniqueStr + "INDEX " + this.qi(indexName) + " ON " + this.qi(table) + " (" + colList + ");";
+        }
+        // postgres
+        return "CREATE " + uniqueStr + "INDEX IF NOT EXISTS " + this.qi(indexName) + " ON " + this.qi(table) + " (" + colList + ");";
+    };
+    // Concatenation
+    DialectHelper.prototype.concat = function () {
+        var parts = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            parts[_i] = arguments[_i];
+        }
+        if (this.isMssql)
+            return parts.join(' + ');
+        if (this.isMysql)
+            return "CONCAT(" + parts.join(', ') + ")";
+        return parts.join(' || '); // postgres
+    };
+    // String to timestamp
+    DialectHelper.prototype.toTimestamp = function (value) {
+        if (this.isMssql)
+            return "CAST(" + value + " AS DATETIME2)";
+        if (this.isMysql)
+            return "CAST(" + value + " AS DATETIME)";
+        return value + "::TIMESTAMP"; // postgres
+    };
+    return DialectHelper;
+}());
+exports.DialectHelper = DialectHelper;
+function createDialectHelper(dialectOrSequelize) {
+    return new DialectHelper(dialectOrSequelize);
+}
+exports.createDialectHelper = createDialectHelper;

package/build/helpers/index.d.ts

@@ -0,0 +1,2 @@
+export { DialectHelper, createDialectHelper } from './dialectHelper';
+export { getMultiDialectGlobs } from './multiDialectMigrator';

package/build/helpers/index.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getMultiDialectGlobs = exports.createDialectHelper = exports.DialectHelper = void 0;
+var dialectHelper_1 = require("./dialectHelper");
+Object.defineProperty(exports, "DialectHelper", { enumerable: true, get: function () { return dialectHelper_1.DialectHelper; } });
+Object.defineProperty(exports, "createDialectHelper", { enumerable: true, get: function () { return dialectHelper_1.createDialectHelper; } });
+var multiDialectMigrator_1 = require("./multiDialectMigrator");
+Object.defineProperty(exports, "getMultiDialectGlobs", { enumerable: true, get: function () { return multiDialectMigrator_1.getMultiDialectGlobs; } });

package/build/helpers/multiDialectMigrator.d.ts

@@ -0,0 +1,15 @@
+interface MigratorConfig {
+    migrationsPath: string;
+    dialect: string;
+    serviceName: string;
+}
+/**
+ * Returns the glob patterns for multi-dialect migrations.
+ * If common/ or {dialect}/ folders exist, returns those paths.
+ * Otherwise falls back to flat migrations/*.{ts,js} (backward compatible).
+ */
+export declare function getMultiDialectGlobs(config: MigratorConfig): {
+    globs: string[];
+    isMultiDialect: boolean;
+};
+export {};

package/build/helpers/multiDialectMigrator.js

@@ -0,0 +1,32 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getMultiDialectGlobs = void 0;
+var path_1 = __importDefault(require("path"));
+var fs_1 = __importDefault(require("fs"));
+/**
+ * Returns the glob patterns for multi-dialect migrations.
+ * If common/ or {dialect}/ folders exist, returns those paths.
+ * Otherwise falls back to flat migrations/*.{ts,js} (backward compatible).
+ */
+function getMultiDialectGlobs(config) {
+    var migrationsPath = config.migrationsPath, dialect = config.dialect, serviceName = config.serviceName;
+    var commonDir = path_1.default.join(migrationsPath, 'common');
+    var dialectDir = path_1.default.join(migrationsPath, dialect);
+    var hasCommon = fs_1.default.existsSync(commonDir);
+    var hasDialect = fs_1.default.existsSync(dialectDir);
+    if (hasCommon || hasDialect) {
+        var globs = [];
+        if (hasCommon)
+            globs.push(path_1.default.join(commonDir, '*.{ts,js}'));
+        if (hasDialect)
+            globs.push(path_1.default.join(dialectDir, '*.{ts,js}'));
+        console.log("[" + serviceName + "] Multi-dialect migrations: common/" + (hasCommon ? '✓' : '✗') + " " + dialect + "/" + (hasDialect ? '✓' : '✗'));
+        return { globs: globs, isMultiDialect: true };
+    }
+    console.log("[" + serviceName + "] Legacy flat migrations");
+    return { globs: [path_1.default.join(migrationsPath, '*.{ts,js}')], isMultiDialect: false };
+}
+exports.getMultiDialectGlobs = getMultiDialectGlobs;

package/build/index.d.ts

@@ -5,6 +5,7 @@ export * from "./middlewares";
 export * from "./events";
 export * from "./dtos";
 export * from "./lib";
+export * from "./helpers";
 export { BacklogManager } from './classes/BacklogManager';
 export { BacklogMonitor } from './classes/BacklogMonitor';
 export { Listener } from './events/baseListener';

package/build/index.js

@@ -18,6 +18,7 @@ __exportStar(require("./middlewares"), exports);
 __exportStar(require("./events"), exports);
 __exportStar(require("./dtos"), exports);
 __exportStar(require("./lib"), exports);
+__exportStar(require("./helpers"), exports);
 // Classes
 var BacklogManager_1 = require("./classes/BacklogManager");
 Object.defineProperty(exports, "BacklogManager", { enumerable: true, get: function () { return BacklogManager_1.BacklogManager; } });

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.205",
+  "version": "1.0.210",
   "description": "",
   "main": "./build/index.js",
   "types": "./build/index.d.ts",