plac-micro-common 1.3.66 → 1.3.68

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

@@ -1,16 +1,4 @@
-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 declare const REDIS_CLIENT = "REDIS_CLIENT";
 export type RedisModuleOptions = {
     url?: string;
     host?: string;

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

@@ -1,17 +1,4 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-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");
+exports.REDIS_CLIENT = void 0;
+exports.REDIS_CLIENT = "REDIS_CLIENT";

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

@@ -16,92 +16,35 @@ 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_CLIENTS,
+                    provide: redis_constant_1.REDIS_CLIENT,
                     inject: [config_1.ConfigService],
                     useFactory: (config) => {
-                        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);
-                            });
-                            map[name] = client;
-                        }
-                        return map;
+                        const url = config.get("REDIS_URL");
+                        const host = config.get("REDIS_HOST");
+                        const port = config.get("REDIS_PORT");
+                        const password = config.get("REDIS_PASSWORD") || undefined;
+                        const db = config.get("REDIS_DB") ?? 0;
+                        const keyPrefix = config.get("REDIS_KEY_PREFIX") || undefined;
+                        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] error:`, err?.message || err);
+                        });
+                        return client;
                     },
                 },
-                // 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,18 +1,14 @@
 import { OnModuleDestroy } from "@nestjs/common";
 import { Redis } from "ioredis";
-type RedisClientMap = Record<string, Redis>;
 export declare class RedisService implements OnModuleDestroy {
-    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">;
+    private readonly redis;
+    constructor(redis: Redis);
+    get(key: string): Promise<string | null>;
+    set(key: string, value: string, ttlSeconds?: number): Promise<"OK">;
+    del(key: string): Promise<number>;
+    exists(key: string): Promise<number>;
+    client(): Redis;
+    getJson<T>(key: string): Promise<T | null>;
+    setJson(key: string, value: unknown, ttlSeconds?: number): Promise<"OK">;
     onModuleDestroy(): Promise<void>;
 }
-export {};

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

@@ -14,35 +14,33 @@ 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(clients) {
-        this.clients = clients;
-    }
-    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;
+    constructor(redis) {
+        this.redis = redis;
     }
     // -------------------- RAW --------------------
-    get(key, clientName = "main") {
-        return this.pick(clientName).get(key);
+    get(key) {
+        return this.redis.get(key);
     }
-    del(key, clientName = "main") {
-        return this.pick(clientName).del(key);
+    set(key, value, ttlSeconds) {
+        if (ttlSeconds && ttlSeconds > 0)
+            return this.redis.set(key, value, "EX", ttlSeconds);
+        return this.redis.set(key, value);
     }
-    exists(key, clientName = "main") {
-        return this.pick(clientName).exists(key);
+    del(key) {
+        return this.redis.del(key);
     }
-    client(clientName = "main") {
-        return this.pick(clientName);
+    exists(key) {
+        return this.redis.exists(key);
+    }
+    client() {
+        return this.redis;
     }
     // -------------------- JSON --------------------
-    async getJson(key, clientName = "main") {
-        const val = await this.pick(clientName).get(key);
+    async getJson(key) {
+        const val = await this.redis.get(key);
         if (!val)
             return null;
         try {
@@ -52,36 +50,24 @@ let RedisService = class RedisService {
             return null;
         }
     }
-    async setJson(key, value, ttlSeconds, clientName = "main") {
+    async setJson(key, value, ttlSeconds) {
         const payload = JSON.stringify(value);
-        const c = this.pick(clientName);
         if (ttlSeconds && ttlSeconds > 0)
-            return c.set(key, payload, "EX", ttlSeconds);
-        return c.set(key, payload);
-    }
-    // Backward-compat convenience (optional)
-    async getGeoJson(key) {
-        return this.getJson(key, "geo");
-    }
-    async setGeoJson(key, value, ttlSeconds) {
-        return this.setJson(key, value, ttlSeconds, "geo");
+            return this.redis.set(key, payload, "EX", ttlSeconds);
+        return this.redis.set(key, payload);
     }
     async onModuleDestroy() {
-        // Graceful shutdown for ALL clients
-        const list = Object.values(this.clients);
-        for (const c of list) {
-            try {
-                await c.quit();
-            }
-            catch {
-                c.disconnect();
-            }
+        try {
+            await this.redis.quit();
+        }
+        catch {
+            this.redis.disconnect();
         }
     }
 };
 exports.RedisService = RedisService;
 exports.RedisService = RedisService = __decorate([
     (0, common_1.Injectable)(),
-    __param(0, (0, common_1.Inject)(redis_constant_1.REDIS_CLIENTS)),
-    __metadata("design:paramtypes", [Object])
+    __param(0, (0, common_1.Inject)(redis_constant_1.REDIS_CLIENT)),
+    __metadata("design:paramtypes", [ioredis_1.Redis])
 ], RedisService);

package/dist/models/customer/customer_employment.entity.d.ts

@@ -1,6 +1,7 @@
 import { _BaseEntity } from "../_base_entity";
 import { CustomerEntity } from "./customer.entity";
 import { GeoCommuneEntity, GeoDistrictEntity, GeoProvinceEntity, GeoVillageEntity, OccupationEntity } from "../core";
+import { CurrencyType } from "../../types";
 export declare class CustomerEmploymentEntity extends _BaseEntity {
     id: string;
     customer_id: string;
@@ -18,6 +19,8 @@ export declare class CustomerEmploymentEntity extends _BaseEntity {
     village_id?: string | null;
     joined_date?: string | null;
     left_date?: string | null;
+    currency?: CurrencyType | null;
+    annual_salary?: number;
     is_primary: boolean;
     customer: CustomerEntity;
     occupation?: OccupationEntity | null;

package/dist/models/customer/customer_employment.entity.js

@@ -14,6 +14,8 @@ const typeorm_1 = require("typeorm");
 const _base_entity_1 = require("../_base_entity");
 const customer_entity_1 = require("./customer.entity");
 const core_1 = require("../core");
+const types_1 = require("../../types");
+const utils_1 = require("../../utils");
 let CustomerEmploymentEntity = class CustomerEmploymentEntity extends _base_entity_1._BaseEntity {
 };
 exports.CustomerEmploymentEntity = CustomerEmploymentEntity;
@@ -82,6 +84,19 @@ __decorate([
     (0, typeorm_1.Column)({ type: "date", nullable: true }),
     __metadata("design:type", Object)
 ], CustomerEmploymentEntity.prototype, "left_date", void 0);
+__decorate([
+    (0, typeorm_1.Column)({
+        type: "varchar",
+        length: 5,
+        nullable: true,
+        comment: (0, utils_1.enumToCommentString)(types_1.CurrencyType),
+    }),
+    __metadata("design:type", Object)
+], CustomerEmploymentEntity.prototype, "currency", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ type: "decimal", precision: 15, scale: 2, nullable: true }),
+    __metadata("design:type", Number)
+], CustomerEmploymentEntity.prototype, "annual_salary", void 0);
 __decorate([
     (0, typeorm_1.Column)({ type: "bool", default: false }),
     __metadata("design:type", Boolean)

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

@@ -1,3 +1,7 @@
+export declare enum CurrencyType {
+    USD = "USD",
+    KHR = "KHR"
+}
 export declare enum ExchangeRateSourceType {
     Manual = "manual",
     Api = "api",

package/dist/types/finance.type.js

@@ -1,6 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ExchangeRateSyncStatus = exports.ExchangeRateSourceType = void 0;
+exports.ExchangeRateSyncStatus = exports.ExchangeRateSourceType = exports.CurrencyType = void 0;
+var CurrencyType;
+(function (CurrencyType) {
+    CurrencyType["USD"] = "USD";
+    CurrencyType["KHR"] = "KHR";
+})(CurrencyType || (exports.CurrencyType = CurrencyType = {}));
 var ExchangeRateSourceType;
 (function (ExchangeRateSourceType) {
     ExchangeRateSourceType["Manual"] = "manual";

package/package.json

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