plac-micro-common 1.1.13 → 1.2.1

package/dist/http/constants/index.d.ts

@@ -0,0 +1 @@
+export declare const REQUIRE_PERMISSIONS_KEY = "require_permissions";

package/dist/http/constants/index.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.REQUIRE_PERMISSIONS_KEY = void 0;
+exports.REQUIRE_PERMISSIONS_KEY = "require_permissions";

package/dist/http/decorators/index.d.ts

@@ -1,3 +1,4 @@
 export * from "./client_ctx.decorator";
 export * from "./current_app.decorator";
 export * from "./current_app_client.decorator";
+export * from "./require_permission.decorator";

package/dist/http/decorators/index.js

@@ -17,3 +17,4 @@ Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./client_ctx.decorator"), exports);
 __exportStar(require("./current_app.decorator"), exports);
 __exportStar(require("./current_app_client.decorator"), exports);
+__exportStar(require("./require_permission.decorator"), exports);

package/dist/http/decorators/require_permission.decorator.d.ts

@@ -0,0 +1 @@
+export declare const RequirePermissions: (...permissions: string[]) => import("@nestjs/common").CustomDecorator<string>;

package/dist/http/decorators/require_permission.decorator.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RequirePermissions = void 0;
+const common_1 = require("@nestjs/common");
+const constants_1 = require("../constants");
+const RequirePermissions = (...permissions) => (0, common_1.SetMetadata)(constants_1.REQUIRE_PERMISSIONS_KEY, permissions);
+exports.RequirePermissions = RequirePermissions;

package/dist/http/guards/index.d.ts

@@ -1 +1,2 @@
 export * from "./jwt_auth.guard";
+export * from "./permission.guard";

package/dist/http/guards/index.js

@@ -15,3 +15,4 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./jwt_auth.guard"), exports);
+__exportStar(require("./permission.guard"), exports);

package/dist/http/guards/permission.guard.d.ts

@@ -0,0 +1,7 @@
+import { CanActivate, ExecutionContext } from "@nestjs/common";
+import { Reflector } from "@nestjs/core";
+export declare class PermissionsGuard implements CanActivate {
+    private readonly reflector;
+    constructor(reflector: Reflector);
+    canActivate(context: ExecutionContext): boolean;
+}

package/dist/http/guards/permission.guard.js

@@ -0,0 +1,44 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PermissionsGuard = void 0;
+const common_1 = require("@nestjs/common");
+const core_1 = require("@nestjs/core");
+const constants_1 = require("../constants");
+let PermissionsGuard = class PermissionsGuard {
+    constructor(reflector) {
+        this.reflector = reflector;
+    }
+    canActivate(context) {
+        const required = this.reflector.getAllAndOverride(constants_1.REQUIRE_PERMISSIONS_KEY, [context.getHandler(), context.getClass()]);
+        // No permissions required => allow
+        if (!required || required.length === 0)
+            return true;
+        const req = context.switchToHttp().getRequest();
+        // Must have req.user set by JwtAuthGuard (passport-jwt or custom)
+        const user = req?.user;
+        if (!user)
+            throw new common_1.UnauthorizedException("Missing auth user");
+        const userPerms = Array.isArray(user.permissions)
+            ? user.permissions
+            : [];
+        // require ALL permissions by default
+        const hasAll = required.every((p) => userPerms.includes(p));
+        if (!hasAll)
+            throw new common_1.ForbiddenException("Insufficient permissions");
+        return true;
+    }
+};
+exports.PermissionsGuard = PermissionsGuard;
+exports.PermissionsGuard = PermissionsGuard = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [core_1.Reflector])
+], PermissionsGuard);

package/dist/libs/redis/redis.constant.d.ts

@@ -1,4 +1,16 @@
-export declare const REDIS_CLIENT = "REDIS_CLIENT";
+export declare const REDIS_CLIENTS = "REDIS_CLIENTS";
+/**
+ * Named client token helper (if you want to inject a specific client directly)
+ * Example: @Inject(getRedisClientToken('geo')) private geoRedis: Redis
+ */
+export declare const getRedisClientToken: (name: string) => string;
+/**
+ * Backward compatible tokens:
+ * - REDIS_CLIENT is the "main" redis client
+ * - REDIS_GEO_CLIENT is the "geo" redis client
+ */
+export declare const REDIS_CLIENT: string;
+export declare const REDIS_GEO_CLIENT: string;
 export type RedisModuleOptions = {
     url?: string;
     host?: string;

package/dist/libs/redis/redis.constant.js

@@ -1,4 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.REDIS_CLIENT = void 0;
-exports.REDIS_CLIENT = "REDIS_CLIENT";
+exports.REDIS_GEO_CLIENT = exports.REDIS_CLIENT = exports.getRedisClientToken = exports.REDIS_CLIENTS = void 0;
+exports.REDIS_CLIENTS = "REDIS_CLIENTS";
+/**
+ * Named client token helper (if you want to inject a specific client directly)
+ * Example: @Inject(getRedisClientToken('geo')) private geoRedis: Redis
+ */
+const getRedisClientToken = (name) => `REDIS_CLIENT:${name}`;
+exports.getRedisClientToken = getRedisClientToken;
+/**
+ * Backward compatible tokens:
+ * - REDIS_CLIENT is the "main" redis client
+ * - REDIS_GEO_CLIENT is the "geo" redis client
+ */
+exports.REDIS_CLIENT = (0, exports.getRedisClientToken)("main");
+exports.REDIS_GEO_CLIENT = (0, exports.getRedisClientToken)("geo");

package/dist/libs/redis/redis.module.js

@@ -16,40 +16,92 @@ const config_1 = require("@nestjs/config");
 const ioredis_1 = __importDefault(require("ioredis"));
 const redis_constant_1 = require("./redis.constant");
 const redis_service_1 = require("./redis.service");
+function parseNames(v) {
+    // default includes geo for backward compatibility with your existing code
+    const raw = (v ?? "main,geo")
+        .split(",")
+        .map((s) => s.trim())
+        .filter(Boolean);
+    // ensure unique
+    return Array.from(new Set(raw));
+}
+function upper(name) {
+    return name.replace(/[^a-zA-Z0-9]/g, "_").toUpperCase();
+}
 let RedisModule = RedisModule_1 = class RedisModule {
     static forRootAsync() {
         return {
             module: RedisModule_1,
             imports: [config_1.ConfigModule],
             providers: [
+                // 1) Build ALL clients from env and store as a map
                 {
-                    provide: redis_constant_1.REDIS_CLIENT,
+                    provide: redis_constant_1.REDIS_CLIENTS,
                     inject: [config_1.ConfigService],
                     useFactory: (config) => {
-                        const url = config.get("REDIS_URL");
-                        const keyPrefix = config.get("REDIS_KEY_PREFIX") || undefined;
-                        // Prefer REDIS_URL if present
-                        const client = url
-                            ? new ioredis_1.default(url, { keyPrefix })
-                            : new ioredis_1.default({
-                                host: config.get("REDIS_HOST"),
-                                port: config.get("REDIS_PORT"),
-                                password: config.get("REDIS_PASSWORD") || undefined,
-                                db: config.get("REDIS_DB") || 0,
-                                keyPrefix,
+                        const names = parseNames(config.get("REDIS_NAMES"));
+                        const baseUrl = config.get("REDIS_URL");
+                        const baseHost = config.get("REDIS_HOST");
+                        const basePort = config.get("REDIS_PORT");
+                        const basePassword = config.get("REDIS_PASSWORD") || undefined;
+                        const baseDb = config.get("REDIS_DB") ?? 0;
+                        const baseKeyPrefix = config.get("REDIS_KEY_PREFIX") || undefined;
+                        const map = {};
+                        for (const name of names) {
+                            const N = upper(name);
+                            const url = config.get(`REDIS_${N}_URL`) ?? baseUrl;
+                            const host = config.get(`REDIS_${N}_HOST`) ?? baseHost;
+                            const port = config.get(`REDIS_${N}_PORT`) ?? basePort;
+                            const password = config.get(`REDIS_${N}_PASSWORD`) ?? basePassword;
+                            const db = config.get(`REDIS_${N}_DB`) ?? baseDb;
+                            const keyPrefix = config.get(`REDIS_${N}_KEY_PREFIX`) ?? baseKeyPrefix;
+                            const client = url
+                                ? new ioredis_1.default(url, { keyPrefix })
+                                : new ioredis_1.default({
+                                    host,
+                                    port,
+                                    password,
+                                    db,
+                                    keyPrefix,
+                                });
+                            client.on("error", (err) => {
+                                // eslint-disable-next-line no-console
+                                console.error(`[redis:${name}] error:`, err?.message || err);
                             });
-                        // (Optional) basic visibility
-                        client.on("error", (err) => {
-                            // don’t throw here; just log
-                            // eslint-disable-next-line no-console
-                            console.error("[redis] error:", err?.message || err);
-                        });
-                        return client;
+                            map[name] = client;
+                        }
+                        return map;
                     },
                 },
+                // 2) Provide each named token for DI (optional but useful)
+                //    e.g. @Inject(getRedisClientToken('geo')) geoRedis: Redis
+                {
+                    provide: (0, redis_constant_1.getRedisClientToken)("main"),
+                    inject: [redis_constant_1.REDIS_CLIENTS],
+                    useFactory: (clients) => {
+                        if (!clients.main)
+                            throw new Error(`[redis] missing client "main" (check REDIS_NAMES)`);
+                        return clients.main;
+                    },
+                },
+                {
+                    provide: (0, redis_constant_1.getRedisClientToken)("geo"),
+                    inject: [redis_constant_1.REDIS_CLIENTS],
+                    useFactory: (clients) => {
+                        if (!clients.geo)
+                            throw new Error(`[redis] missing client "geo" (check REDIS_NAMES)`);
+                        return clients.geo;
+                    },
+                },
+                // 3) Service uses the map; you can use any client name dynamically
+                redis_service_1.RedisService,
+            ],
+            exports: [
+                redis_constant_1.REDIS_CLIENTS,
                 redis_service_1.RedisService,
+                (0, redis_constant_1.getRedisClientToken)("main"),
+                (0, redis_constant_1.getRedisClientToken)("geo"),
             ],
-            exports: [redis_constant_1.REDIS_CLIENT, redis_service_1.RedisService],
         };
     }
 };

package/dist/libs/redis/redis.service.d.ts

@@ -1,13 +1,18 @@
 import { OnModuleDestroy } from "@nestjs/common";
 import { Redis } from "ioredis";
+type RedisClientMap = Record<string, Redis>;
 export declare class RedisService implements OnModuleDestroy {
-    private readonly redis;
-    constructor(redis: Redis);
-    get(key: string): Promise<string | null>;
-    del(key: string): Promise<number>;
-    exists(key: string): Promise<number>;
-    getJson<T>(key: string): Promise<T | null>;
-    setJson(key: string, value: unknown, ttlSeconds?: number): Promise<"OK">;
-    client(): Redis;
+    private readonly clients;
+    constructor(clients: RedisClientMap);
+    private pick;
+    get(key: string, clientName?: string): Promise<string | null>;
+    del(key: string, clientName?: string): Promise<number>;
+    exists(key: string, clientName?: string): Promise<number>;
+    client(clientName?: string): Redis;
+    getJson<T>(key: string, clientName?: string): Promise<T | null>;
+    setJson(key: string, value: unknown, ttlSeconds?: number, clientName?: string): Promise<"OK">;
+    getGeoJson<T>(key: string): Promise<T | null>;
+    setGeoJson(key: string, value: unknown, ttlSeconds?: number): Promise<"OK">;
     onModuleDestroy(): Promise<void>;
 }
+export {};

package/dist/libs/redis/redis.service.js

@@ -14,25 +14,35 @@ var __param = (this && this.__param) || function (paramIndex, decorator) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RedisService = void 0;
 const common_1 = require("@nestjs/common");
-const ioredis_1 = require("ioredis");
 const redis_constant_1 = require("./redis.constant");
 let RedisService = class RedisService {
-    constructor(redis) {
-        this.redis = redis;
+    constructor(clients) {
+        this.clients = clients;
     }
-    // Raw helpers
-    get(key) {
-        return this.redis.get(key);
+    pick(name = "main") {
+        const client = this.clients[name];
+        if (!client) {
+            const available = Object.keys(this.clients).join(", ");
+            throw new Error(`[redis] client "${name}" not found. Available: ${available}`);
+        }
+        return client;
+    }
+    // -------------------- RAW --------------------
+    get(key, clientName = "main") {
+        return this.pick(clientName).get(key);
     }
-    del(key) {
-        return this.redis.del(key);
+    del(key, clientName = "main") {
+        return this.pick(clientName).del(key);
     }
-    exists(key) {
-        return this.redis.exists(key);
+    exists(key, clientName = "main") {
+        return this.pick(clientName).exists(key);
     }
-    // JSON helpers (most common use)
-    async getJson(key) {
-        const val = await this.redis.get(key);
+    client(clientName = "main") {
+        return this.pick(clientName);
+    }
+    // -------------------- JSON --------------------
+    async getJson(key, clientName = "main") {
+        const val = await this.pick(clientName).get(key);
         if (!val)
             return null;
         try {
@@ -42,31 +52,36 @@ let RedisService = class RedisService {
             return null;
         }
     }
-    async setJson(key, value, ttlSeconds) {
+    async setJson(key, value, ttlSeconds, clientName = "main") {
         const payload = JSON.stringify(value);
-        if (ttlSeconds && ttlSeconds > 0) {
-            return this.redis.set(key, payload, "EX", ttlSeconds);
-        }
-        return this.redis.set(key, payload);
+        const c = this.pick(clientName);
+        if (ttlSeconds && ttlSeconds > 0)
+            return c.set(key, payload, "EX", ttlSeconds);
+        return c.set(key, payload);
     }
-    // Optional: if you need access to ioredis commands directly
-    client() {
-        return this.redis;
+    // Backward-compat convenience (optional)
+    async getGeoJson(key) {
+        return this.getJson(key, "geo");
+    }
+    async setGeoJson(key, value, ttlSeconds) {
+        return this.setJson(key, value, ttlSeconds, "geo");
     }
     async onModuleDestroy() {
-        // Graceful shutdown
-        try {
-            await this.redis.quit();
-        }
-        catch {
-            // fallback
-            this.redis.disconnect();
+        // Graceful shutdown for ALL clients
+        const list = Object.values(this.clients);
+        for (const c of list) {
+            try {
+                await c.quit();
+            }
+            catch {
+                c.disconnect();
+            }
         }
     }
 };
 exports.RedisService = RedisService;
 exports.RedisService = RedisService = __decorate([
     (0, common_1.Injectable)(),
-    __param(0, (0, common_1.Inject)(redis_constant_1.REDIS_CLIENT)),
-    __metadata("design:paramtypes", [ioredis_1.Redis])
+    __param(0, (0, common_1.Inject)(redis_constant_1.REDIS_CLIENTS)),
+    __metadata("design:paramtypes", [Object])
 ], RedisService);

package/dist/types/permission.type.d.ts

@@ -1,11 +1,19 @@
 export declare enum PermissionAction {
+    Approve = "approve",
     Create = "create",
+    Delete = "delete",
+    Export = "export",
     Read = "read",
-    Update = "update",
-    Delete = "delete"
+    Update = "update"
 }
-export declare enum PermissionResource {
-    Permission = "permission",
-    Quotation = "quotation",
-    User = "user"
+export declare const PermissionResource: {
+    readonly Permission: "permission";
+    readonly Quotation: "quotation";
+    readonly User: "user";
+};
+export type PermissionResource = (typeof PermissionResource)[keyof typeof PermissionResource];
+export declare enum PermissionModule {
+    Admin = "admin",
+    Claim = "claim",
+    Policy = "policy"
 }

package/dist/types/permission.type.js

@@ -1,16 +1,23 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.PermissionResource = exports.PermissionAction = void 0;
+exports.PermissionModule = exports.PermissionResource = exports.PermissionAction = void 0;
 var PermissionAction;
 (function (PermissionAction) {
+    PermissionAction["Approve"] = "approve";
     PermissionAction["Create"] = "create";
+    PermissionAction["Delete"] = "delete";
+    PermissionAction["Export"] = "export";
     PermissionAction["Read"] = "read";
     PermissionAction["Update"] = "update";
-    PermissionAction["Delete"] = "delete";
 })(PermissionAction || (exports.PermissionAction = PermissionAction = {}));
-var PermissionResource;
-(function (PermissionResource) {
-    PermissionResource["Permission"] = "permission";
-    PermissionResource["Quotation"] = "quotation";
-    PermissionResource["User"] = "user";
-})(PermissionResource || (exports.PermissionResource = PermissionResource = {}));
+exports.PermissionResource = {
+    Permission: "permission",
+    Quotation: "quotation",
+    User: "user",
+};
+var PermissionModule;
+(function (PermissionModule) {
+    PermissionModule["Admin"] = "admin";
+    PermissionModule["Claim"] = "claim";
+    PermissionModule["Policy"] = "policy";
+})(PermissionModule || (exports.PermissionModule = PermissionModule = {}));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "plac-micro-common",
-  "version": "1.1.13",
+  "version": "1.2.1",
   "types": "dist/index.d.ts",
   "main": "dist/index.js",
   "scripts": {