@ecashlib/shared-message 1.0.0 → 1.0.1

package/README.md

@@ -4,15 +4,16 @@ Shared utilities for Ecash microservices - Message handling, i18n, error helpers
 
 ## Features
 
-- **i18n Message System**: Get localized messages from database with caching
+- **i18n Message System**: Get localized messages from database with **Redis caching**
 - **Parameter Replacement**: Dynamic message templates with `{placeholder}` support
 - **Language Detection**: Auto-detect language from request headers or query params
 - **Error Helpers**: Throw errors with dynamic, localized messages
+- **Framework Agnostic**: Works with any Redis implementation via `IRedisCache` interface
 
 ## Installation
 
 ```bash
-npm install @ecash/shared
+npm install @ecashlib/shared-message
 ```
 
 ## Setup
@@ -33,149 +34,298 @@ Create messages in your `messages` collection:
 }
 ```
 
-### 2. Implement MessageServicePort
-
-Each microservice implements the message service:
+### 2. Implement Database Service (WITHOUT cache)
 
 ```typescript
-// ecash-marketplace/src/application/services/message/get-message-content.service.ts
-import { MessageServicePort } from "@ecash/shared";
+// ecash-marketplace/src/infrastructure/adapters/outbound/message/message.repository.ts
+import { MessageServicePort } from "@ecashlib/shared-message";
 
-export class GetMessageContentService implements MessageServicePort {
+export class MessageRepository implements MessageServicePort {
   async getMessageContentByCode(code: string, language: string) {
-    // Your implementation - query DB/Redis
-    const cached = await redis.get(`message:${code}:${language}`);
-    if (cached) return JSON.parse(cached);
-
+    // ONLY query DB - NO cache logic here
     const message = await db.collection("messages").findOne({ code });
+    if (!message) return null;
+
     return {
       code: message.code,
       classificationCode: message.classificationCode,
-      message: message.content[language],
+      message: message.content[language] || null
     };
   }
 }
 ```
 
-## Usage
-
-### 1. Get Language from Request
+### 3. Implement IRedisCache Adapter (WITH your Redis wrapper)
 
 ```typescript
-import { getLanguageFromRequest } from "@ecash/shared";
+// src/infrastructure/adapters/outbound/cache/redis-cache.adapter.ts
+import { IRedisCache } from "@ecashlib/shared-message";
+
+export class RedisCacheAdapter implements IRedisCache {
+  constructor(private redis: FastifyInstance["redis"]) {}
+
+  async get(key: string): Promise<string | null> {
+    return await this.redis.get(key);
+  }
+
+  async set(key: string, value: string, ttl?: number): Promise<void> {
+    if (ttl) {
+      await this.redis.setex(key, ttl, value);
+    } else {
+      await this.redis.set(key, value);
+    }
+  }
+
+  async mset(keyValues: Record<string, string>): Promise<void> {
+    const pipeline = this.redis.pipeline();
+    for (const [key, value] of Object.entries(keyValues)) {
+      pipeline.set(key, value);
+    }
+    await pipeline.exec();
+  }
+
+  async exists(key: string): Promise<boolean> {
+    const result = await this.redis.exists(key);
+    return result === 1;
+  }
+
+  async del(key: string): Promise<number> {
+    return await this.redis.del(key);
+  }
+
+  async delPattern(pattern: string): Promise<string[]> {
+    const keys = await this.redis.keys(pattern);
+    if (keys.length > 0) {
+      await this.redis.del(...keys);
+    }
+    return keys;
+  }
 
-const language = getLanguageFromRequest(request); // "vi", "en", "ko"
+  async hgetall(key: string): Promise<Record<string, string>> {
+    return await this.redis.hgetall(key);
+  }
+
+  async hset(key: string, field: string, value: string): Promise<void> {
+    await this.redis.hset(key, field, value);
+  }
+
+  async hdel(key: string, field?: string): Promise<void> {
+    if (field) {
+      await this.redis.hdel(key, field);
+    } else {
+      await this.redis.hdel(key);
+    }
+  }
+}
 ```
 
-### 2. Get Localized Message
+### 4. Use CachedMessageService (WITH cache)
 
 ```typescript
-import { getMessage } from "@ecash/shared";
+import { CachedMessageService } from "@ecashlib/shared-message";
+import { RedisCacheAdapter } from "./infrastructure/adapters/outbound/cache/redis-cache.adapter";
+import { MessageRepository } from "./infrastructure/adapters/outbound/message/message.repository";
+
+// Setup Redis adapter
+const redisAdapter = new RedisCacheAdapter(fastify.redis);
+
+// Create cached service
+const dbService = new MessageRepository(); // Your DB service
+const cachedMessageService = new CachedMessageService(
+  redisAdapter,
+  dbService,
+  3600 // Cache TTL: 1 hour
+);
+```
+
+## Cache Flow
 
-const message = await getMessage(messageService, "ECASH_00001", "vi", {
-  projectTypeCode: "APARTMENT",
-  errors: "field required",
-});
-// Returns: "Metadata không hợp lệ theo schema của project type 'APARTMENT': field required"
 ```
+┌─────────────────────────────────────────────────────────────┐
+│                    getMessageContentByCode()                 │
+└─────────────────────────────────────────────────────────────┘
+                              │
+              ┌─────────────┴──────────────┐
+              ▼                              ▼
+    ┌─────────────────┐          ┌─────────────────┐
+    │  Check Redis    │   MISS    │   Query MongoDB │
+    │                 │ ────────> │                 │
+    │ message:ECASH_  │          │  messages       │
+    │ 00001:vi        │          │  {code, ...}    │
+    └─────────────────┘          └─────────────────┘
+              │                              │
+              │ HIT                         │
+              ▼                             │
+      ┌───────────────┐                  │
+      │ Return data   │                  │
+      └───────────────┘                  │
+                                     │
+                                     ▼
+                            ┌─────────────────┐
+                            │ Save to Redis   │
+                            │ message:ECASH_  │
+                            │ 00001:vi        │
+                            │ TTL: 3600s      │
+                            └─────────────────┘
+                                     │
+                                     ▼
+                            ┌─────────────────┐
+                            │ Return data     │
+                            └─────────────────┘
+```
+
+## Usage
 
-### 3. Get Message from Request (Shorthand)
+### 1. Get Message with Cache
 
 ```typescript
-import { getMessageFromRequest } from "@ecash/shared";
+import { CachedMessageService } from "@ecashlib/shared-message";
 
-const message = await getMessageFromRequest(
-  request,
-  messageService,
+const message = await cachedMessageService.getMessageContentByCode(
   "ECASH_00001",
-  { projectTypeCode: "APARTMENT" },
+  "vi"
 );
+// First call: Query DB → Save to Redis → Return
+// Next call: Return from Redis (FAST!)
 ```
 
-### 4. Throw Message Error
+### 2. Get Message with Parameters
 
 ```typescript
-import { throwMessageError } from "@ecash/shared";
+import { getMessage } from "@ecashlib/shared-message";
 
-await throwMessageError(
-  messageService,
+const message = await getMessage(
+  cachedMessageService,
+  "ECASH_00001",
   "vi",
+  { projectTypeCode: "APARTMENT", errors: "field required" }
+);
+// Returns: "Metadata không hợp lệ theo schema của project type 'APARTMENT': field required"
+```
+
+### 3. Get Message from Request
+
+```typescript
+import { getMessageFromRequest } from "@ecashlib/shared-message";
+
+const message = await getMessageFromRequest(
+  request,
+  cachedMessageService,
   "ECASH_00001",
-  { projectTypeCode: "APARTMENT", errors: "field required" },
-  "COMM0400",
+  { projectTypeCode: "APARTMENT" }
 );
 ```
 
-### 5. Create Message Error (without throwing)
+### 4. Invalidate Cache (after update)
 
 ```typescript
-import { createMessageError } from "@ecash/shared";
+// Invalidate all languages for a message
+await cachedMessageService.invalidate("ECASH_00001");
 
-const error = await createMessageError(messageService, "vi", {
-  messageCode: "ECASH_00001",
-  responseCode: "COMM0400",
-  params: { projectTypeCode: "APARTMENT" },
-});
+// Invalidate specific language
+await cachedMessageService.invalidateLanguage("ECASH_00001", "vi");
 
-throw error;
+// Set to cache manually (after create)
+await cachedMessageService.setToCache("ECASH_00001", {
+  vi: "Nội dung tiếng Việt",
+  en: "English content"
+});
 ```
 
-## API Reference
+### 5. Throw Message Error
 
-### `getLanguageFromRequest(request, defaultLang?)`
+```typescript
+import { throwMessageError } from "@ecashlib/shared-message";
 
-Extract language from request headers or query params.
+await throwMessageError(
+  cachedMessageService,
+  "vi",
+  "ECASH_00001",
+  { projectTypeCode: "APARTMENT", errors: "field required" },
+  "COMM0400"
+);
+```
 
-- **Priority**: `Accept-Language` header > `?lang=` query > `defaultLang`
-- **Returns**: Language code (`"vi"`, `"en"`, `"ko"`)
+## API Reference
 
-### `getMessage(messageService, code, language, params?)`
+### `CachedMessageService`
 
-Get localized message with parameter replacement.
+| Method | Description |
+|--------|-------------|
+| `getMessageContentByCode(code, language)` | Get message with cache logic |
+| `getAllLanguages(code)` | Get all languages from cache |
+| `invalidate(code)` | Delete all languages from cache |
+| `invalidateLanguage(code, language)` | Delete specific language from cache |
+| `setToCache(code, content)` | Manually set message to cache |
 
-- **messageService**: Service implementing `MessageServicePort`
-- **code**: Message code from database
-- **language**: Target language
-- **params**: Object with key-value pairs to replace `{key}` in template
+### `MessageCache` (Low-level)
 
-### `getMessageFromRequest(request, messageService, code, params?)`
+| Method | Description |
+|--------|-------------|
+| `get(code, language)` | Get from Redis |
+| `getAll(code)` | Get all languages from Redis |
+| `set(code, language, content, ttl?)` | Set to Redis with TTL |
+| `setAll(code, content, ttl?)` | Set multiple languages to Redis |
+| `delete(code)` | Delete all languages from Redis |
+| `deleteLanguage(code, language)` | Delete specific language |
+| `exists(code, language)` | Check if exists in cache |
+| `flush()` | Delete ALL message cache (use with caution!) |
 
-Shorthand that extracts language from request and gets message.
+### `IRedisCache` Interface
 
-### `throwMessageError(messageService, language, messageCode, params?, responseCode?, statusCode?)`
+Your microservice needs to implement this interface to work with the cache system:
 
-Throw error with localized message from database.
+```typescript
+export interface IRedisCache {
+  get(key: string): Promise<string | null>;
+  set(key: string, value: string, ttl?: number): Promise<void>;
+  mset(keyValues: Record<string, string>): Promise<void>;
+  exists(key: string): Promise<boolean>;
+  del(key: string): Promise<number>;
+  delPattern(pattern: string): Promise<string[]>;
+  hgetall(key: string): Promise<Record<string, string>>;
+  hset(key: string, field: string, value: string): Promise<void>;
+  hdel(key: string, field?: string): Promise<void>;
+}
+```
 
-### `createMessageError(messageService, language, options)`
+## Example: Full Setup in Microservice
 
-Create `MessageError` object without throwing.
+```typescript
+// 1. Setup
+import { CachedMessageService, getMessage, throwMessageError } from "@ecashlib/shared-message";
+import { RedisCacheAdapter } from "./infrastructure/adapters/outbound/cache/redis-cache.adapter";
+import { MessageRepository } from "./infrastructure/adapters/outbound/message/message.repository";
 
-## Language Detection
+const redisAdapter = new RedisCacheAdapter(fastify.redis);
+const dbService = new MessageRepository(); // Your DB service
+const messageService = new CachedMessageService(redisAdapter, dbService);
 
-The library detects language in this order:
+// 2. Use in controller/service
+async function getErrorMessage(request: Request) {
+  const language = request.headers["accept-language"] || "vi";
 
-1. **Header**: `Accept-Language: vi-VN, vi;q=0.9` → `"vi"`
-2. **Query**: `?lang=en` → `"en"`
-3. **Default**: `"vi"`
+  const message = await messageService.getMessageContentByCode(
+    "ECASH_00001",
+    language
+  );
 
-## Message Template Syntax
+  return message.message;
+}
 
-Use `{key}` placeholders in your message templates:
+// 3. Use with parameters
+async function throwValidationError(request: Request, projectTypeCode: string, errors: string) {
+  const language = request.headers["accept-language"] || "vi";
 
-```json
-{
-  "content": {
-    "vi": "Xin chào {name}, bạn có {count} tin nhắn mới",
-    "en": "Hello {name}, you have {count} new messages"
-  }
+  await throwMessageError(
+    messageService,
+    language,
+    "ECASH_00001",
+    { projectTypeCode, errors }
+  );
 }
 ```
 
-```typescript
-getMessage(messageService, "MSG_00001", "vi", { name: "John", count: 5 });
-// "Xin chào John, bạn có 5 tin nhắn mới"
-```
-
 ## Publishing
 
 ```bash

package/dist/cache/cache-interfaces.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Redis Cache Interface
+ * Implement this in your microservice to use with fastify.redis
+ *
+ */
+export interface IRedisCache {
+    /**
+     * Get string value from Redis
+     */
+    get(key: string): Promise<string | null>;
+    /**
+     * Set string value to Redis with optional TTL
+     */
+    set(key: string, value: string, ttl?: number): Promise<void>;
+    /**
+     * Set multiple key-value pairs
+     */
+    mset(keyValues: Record<string, string>): Promise<void>;
+    /**
+     * Check if key exists
+     */
+    exists(key: string): Promise<boolean>;
+    /**
+     * Delete key
+     */
+    del(key: string): Promise<number>;
+    /**
+     * Delete all keys matching pattern
+     */
+    delPattern(pattern: string): Promise<string[]>;
+    /**
+     * Get all hash fields for a key (HGETALL)
+     */
+    hgetall(key: string): Promise<Record<string, string>>;
+    /**
+     * Set hash field (HSET)
+     */
+    hset(key: string, field: string, value: string): Promise<void>;
+    /**
+     * Delete hash field (HDEL)
+     */
+    hdel(key: string, field: string): Promise<void>;
+    /**
+     * Delete all hash fields (HDEL)
+     */
+    hdel(key: string): Promise<void>;
+}
+//# sourceMappingURL=cache-interfaces.d.ts.map

package/dist/cache/cache-interfaces.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cache-interfaces.d.ts","sourceRoot":"","sources":["../../src/cache/cache-interfaces.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,MAAM,WAAW,WAAW;IAC1B;;OAEG;IACH,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAAC;IAEzC;;OAEG;IACH,GAAG,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAE7D;;OAEG;IACH,IAAI,CAAC,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAEvD;;OAEG;IACH,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;IAEtC;;OAEG;IACH,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;IAElC;;OAEG;IACH,UAAU,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,CAAC;IAE/C;;OAEG;IACH,OAAO,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;IAEtD;;OAEG;IACH,IAAI,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAE/D;;OAEG;IACH,IAAI,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAEhD;;OAEG;IACH,IAAI,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CAClC"}

package/dist/cache/cache-interfaces.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cache/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./message-cache";
+export * from "./cache-interfaces";
+//# sourceMappingURL=index.d.ts.map

package/dist/cache/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/cache/index.ts"],"names":[],"mappings":"AAAA,cAAc,iBAAiB,CAAC;AAChC,cAAc,oBAAoB,CAAC"}

package/dist/cache/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./message-cache"), exports);
+__exportStar(require("./cache-interfaces"), exports);

package/dist/cache/message-cache.d.ts

@@ -0,0 +1,76 @@
+import { IRedisCache } from "./cache-interfaces";
+/**
+ * Redis Cache Adapter for Message System
+ * Handles caching of messages with TTL support
+ *
+ * @example
+ * import { MessageCache, IRedisCache } from "@ecashlib/shared-message";
+ *
+ * class YourRedisAdapter implements IRedisCache {
+ *   // implement methods using your redis wrapper
+ * }
+ *
+ * const adapter = new YourRedisAdapter();
+ * const cache = new MessageCache(adapter, 3600);
+ */
+export declare class MessageCache {
+    private readonly redis;
+    private readonly defaultTTL;
+    constructor(redis: IRedisCache, defaultTTL?: number);
+    /**
+     * Get message content from cache
+     * @param code - Message code (e.g., "ECASH_00001")
+     * @param language - Language code (e.g., "vi", "en")
+     * @returns Message content or null if not found
+     */
+    get(code: string, language: string): Promise<string | null>;
+    /**
+     * Get all languages for a message code from cache
+     * @param code - Message code
+     * @returns Object with all language translations
+     */
+    getAll(code: string): Promise<Record<string, string> | null>;
+    /**
+     * Set message content to cache with TTL
+     * @param code - Message code
+     * @param language - Language code
+     * @param content - Message content
+     * @param ttl - Time to live in seconds (optional, uses default)
+     */
+    set(code: string, language: string, content: string, ttl?: number): Promise<void>;
+    /**
+     * Set all languages for a message code
+     * @param code - Message code
+     * @param content - Object with all language translations
+     * @param ttl - Time to live in seconds (optional)
+     */
+    setAll(code: string, content: Record<string, string>, ttl?: number): Promise<void>;
+    /**
+     * Delete message from cache (all languages)
+     * @param code - Message code
+     */
+    delete(code: string): Promise<void>;
+    /**
+     * Delete specific language from cache
+     * @param code - Message code
+     * @param language - Language code
+     */
+    deleteLanguage(code: string, language: string): Promise<void>;
+    /**
+     * Clear all message cache (use with caution!)
+     */
+    flush(): Promise<void>;
+    /**
+     * Check if message exists in cache
+     */
+    exists(code: string, language: string): Promise<boolean>;
+    /**
+     * Helper to delete keys by pattern
+     */
+    private delPattern;
+    /**
+     * Generate cache key
+     */
+    private getKey;
+}
+//# sourceMappingURL=message-cache.d.ts.map

package/dist/cache/message-cache.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"message-cache.d.ts","sourceRoot":"","sources":["../../src/cache/message-cache.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AAEjD;;;;;;;;;;;;;GAaG;AACH,qBAAa,YAAY;IACvB,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAc;IACpC,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAS;gBAExB,KAAK,EAAE,WAAW,EAAE,UAAU,GAAE,MAAa;IAKzD;;;;;OAKG;IACG,GAAG,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC;IAMjE;;;;OAIG;IACG,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,IAAI,CAAC;IAuBlE;;;;;;OAMG;IACG,GAAG,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAKvF;;;;;OAKG;IACG,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,GAAG,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAiBxF;;;OAGG;IACG,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAKzC;;;;OAIG;IACG,cAAc,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAKnE;;OAEG;IACG,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAK5B;;OAEG;IACG,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAK9D;;OAEG;YACW,UAAU;IAUxB;;OAEG;IACH,OAAO,CAAC,MAAM;CAGf"}

package/dist/cache/message-cache.js

@@ -0,0 +1,137 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MessageCache = void 0;
+/**
+ * Redis Cache Adapter for Message System
+ * Handles caching of messages with TTL support
+ *
+ * @example
+ * import { MessageCache, IRedisCache } from "@ecashlib/shared-message";
+ *
+ * class YourRedisAdapter implements IRedisCache {
+ *   // implement methods using your redis wrapper
+ * }
+ *
+ * const adapter = new YourRedisAdapter();
+ * const cache = new MessageCache(adapter, 3600);
+ */
+class MessageCache {
+    constructor(redis, defaultTTL = 3600) {
+        this.redis = redis;
+        this.defaultTTL = defaultTTL;
+    }
+    /**
+     * Get message content from cache
+     * @param code - Message code (e.g., "ECASH_00001")
+     * @param language - Language code (e.g., "vi", "en")
+     * @returns Message content or null if not found
+     */
+    async get(code, language) {
+        const key = this.getKey(code, language);
+        const cached = await this.redis.get(key);
+        return cached;
+    }
+    /**
+     * Get all languages for a message code from cache
+     * @param code - Message code
+     * @returns Object with all language translations
+     */
+    async getAll(code) {
+        const pattern = `message:${code}:*`;
+        const keys = await this.delPattern(pattern);
+        if (keys.length === 0) {
+            return null;
+        }
+        const result = {};
+        for (const key of keys) {
+            const value = await this.redis.get(key);
+            if (value) {
+                // Extract language from key: "message:ECASH_00001:vi" -> "vi"
+                const language = key.split(":").pop();
+                if (language) {
+                    result[language] = value;
+                }
+            }
+        }
+        return Object.keys(result).length > 0 ? result : null;
+    }
+    /**
+     * Set message content to cache with TTL
+     * @param code - Message code
+     * @param language - Language code
+     * @param content - Message content
+     * @param ttl - Time to live in seconds (optional, uses default)
+     */
+    async set(code, language, content, ttl) {
+        const key = this.getKey(code, language);
+        await this.redis.set(key, content, ttl ?? this.defaultTTL);
+    }
+    /**
+     * Set all languages for a message code
+     * @param code - Message code
+     * @param content - Object with all language translations
+     * @param ttl - Time to live in seconds (optional)
+     */
+    async setAll(code, content, ttl) {
+        const expireTtl = ttl ?? this.defaultTTL;
+        const keyValues = {};
+        for (const [language, message] of Object.entries(content)) {
+            const key = this.getKey(code, language);
+            keyValues[key] = message;
+        }
+        await this.redis.mset(keyValues);
+        // Set TTL for each key individually since mset doesn't support TTL
+        for (const key of Object.keys(keyValues)) {
+            await this.redis.set(key, keyValues[key], expireTtl);
+        }
+    }
+    /**
+     * Delete message from cache (all languages)
+     * @param code - Message code
+     */
+    async delete(code) {
+        const pattern = `message:${code}:*`;
+        await this.delPattern(pattern);
+    }
+    /**
+     * Delete specific language from cache
+     * @param code - Message code
+     * @param language - Language code
+     */
+    async deleteLanguage(code, language) {
+        const key = this.getKey(code, language);
+        await this.redis.del(key);
+    }
+    /**
+     * Clear all message cache (use with caution!)
+     */
+    async flush() {
+        const pattern = "message:*";
+        await this.delPattern(pattern);
+    }
+    /**
+     * Check if message exists in cache
+     */
+    async exists(code, language) {
+        const key = this.getKey(code, language);
+        return await this.redis.exists(key);
+    }
+    /**
+     * Helper to delete keys by pattern
+     */
+    async delPattern(pattern) {
+        // This requires the adapter to implement delPattern properly
+        // For fastify.redis, keys() returns array, then we call del()
+        const keys = [];
+        // We need to scan for keys matching pattern
+        // Since IRedisCache.delPattern returns the deleted keys, we use it
+        return await this.redis.delPattern(pattern);
+    }
+    /**
+     * Generate cache key
+     */
+    getKey(code, language) {
+        return `message:${code}:${language}`;
+    }
+}
+exports.MessageCache = MessageCache;

package/dist/index.d.ts

@@ -1,2 +1,3 @@
 export * from "./message";
+export * from "./cache";
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,WAAW,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,WAAW,CAAC;AAC1B,cAAc,SAAS,CAAC"}

package/dist/index.js

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

package/dist/message/cached-message-service.d.ts

@@ -0,0 +1,67 @@
+import { IRedisCache } from "../cache/cache-interfaces";
+import { MessageServicePort, MessageContent } from "./types";
+/**
+ * Cached Message Service
+ *
+ * Logic:
+ * 1. Check Redis cache FIRST
+ * 2. If miss → Query DB via MessageServicePort
+ * 3. Save result to Redis cache
+ * 4. Return cached data
+ *
+ * @example
+ * ```ts
+ * import { CachedMessageService, IRedisCache } from "@ecashlib/shared-message";
+ *
+ * // Your Redis adapter implementing IRedisCache
+ * class RedisAdapter implements IRedisCache {
+ *   constructor(private redis: FastifyInstance["redis"]) {}
+ *   // implement methods...
+ * }
+ *
+ * const adapter = new RedisAdapter(fastify.redis);
+ * const cachedService = new CachedMessageService(adapter, dbService, 3600);
+ *
+ * const message = await cachedService.getMessageContentByCode("ECASH_00001", "vi");
+ * ```
+ */
+export declare class CachedMessageService implements MessageServicePort {
+    private readonly cache;
+    private readonly dbService;
+    /**
+     * @param redis - IRedisCache implementation (your Redis wrapper)
+     * @param dbService - Database service implementing MessageServicePort
+     * @param cacheTTL - Cache TTL in seconds (default: 3600)
+     */
+    constructor(redis: IRedisCache, dbService: MessageServicePort, cacheTTL?: number);
+    /**
+     * Get message content with cache logic:
+     * 1. Check Redis cache
+     * 2. If miss → Query DB
+     * 3. Save to cache
+     * 4. Return result
+     */
+    getMessageContentByCode(code: string, language: string): Promise<MessageContent | null>;
+    /**
+     * Get all languages for a message code (with cache)
+     */
+    getAllLanguages(code: string): Promise<Record<string, string> | null>;
+    /**
+     * Invalidate cache for a message (call after update)
+     */
+    invalidate(code: string): Promise<void>;
+    /**
+     * Invalidate cache for a specific language (call after update)
+     */
+    invalidateLanguage(code: string, language: string): Promise<void>;
+    /**
+     * Set message to cache directly (use after create)
+     */
+    setToCache(code: string, content: Record<string, string>): Promise<void>;
+    /**
+     * Extract classification code from message code
+     * e.g., "ECASH_00001" -> "ECASH"
+     */
+    private extractClassificationCode;
+}
+//# sourceMappingURL=cached-message-service.d.ts.map

package/dist/message/cached-message-service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cached-message-service.d.ts","sourceRoot":"","sources":["../../src/message/cached-message-service.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,2BAA2B,CAAC;AAExD,OAAO,EAAE,kBAAkB,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AAE7D;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,qBAAa,oBAAqB,YAAW,kBAAkB;IAC7D,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAe;IACrC,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAqB;IAE/C;;;;OAIG;gBACS,KAAK,EAAE,WAAW,EAAE,SAAS,EAAE,kBAAkB,EAAE,QAAQ,CAAC,EAAE,MAAM;IAKhF;;;;;;OAMG;IACG,uBAAuB,CAC3B,IAAI,EAAE,MAAM,EACZ,QAAQ,EAAE,MAAM,GACf,OAAO,CAAC,cAAc,GAAG,IAAI,CAAC;IAuBjC;;OAEG;IACG,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,IAAI,CAAC;IAW3E;;OAEG;IACG,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAI7C;;OAEG;IACG,kBAAkB,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAIvE;;OAEG;IACG,UAAU,CACd,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAC9B,OAAO,CAAC,IAAI,CAAC;IAIhB;;;OAGG;IACH,OAAO,CAAC,yBAAyB;CAIlC"}

package/dist/message/cached-message-service.js

@@ -0,0 +1,105 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CachedMessageService = void 0;
+const message_cache_1 = require("../cache/message-cache");
+/**
+ * Cached Message Service
+ *
+ * Logic:
+ * 1. Check Redis cache FIRST
+ * 2. If miss → Query DB via MessageServicePort
+ * 3. Save result to Redis cache
+ * 4. Return cached data
+ *
+ * @example
+ * ```ts
+ * import { CachedMessageService, IRedisCache } from "@ecashlib/shared-message";
+ *
+ * // Your Redis adapter implementing IRedisCache
+ * class RedisAdapter implements IRedisCache {
+ *   constructor(private redis: FastifyInstance["redis"]) {}
+ *   // implement methods...
+ * }
+ *
+ * const adapter = new RedisAdapter(fastify.redis);
+ * const cachedService = new CachedMessageService(adapter, dbService, 3600);
+ *
+ * const message = await cachedService.getMessageContentByCode("ECASH_00001", "vi");
+ * ```
+ */
+class CachedMessageService {
+    /**
+     * @param redis - IRedisCache implementation (your Redis wrapper)
+     * @param dbService - Database service implementing MessageServicePort
+     * @param cacheTTL - Cache TTL in seconds (default: 3600)
+     */
+    constructor(redis, dbService, cacheTTL) {
+        this.cache = new message_cache_1.MessageCache(redis, cacheTTL);
+        this.dbService = dbService;
+    }
+    /**
+     * Get message content with cache logic:
+     * 1. Check Redis cache
+     * 2. If miss → Query DB
+     * 3. Save to cache
+     * 4. Return result
+     */
+    async getMessageContentByCode(code, language) {
+        // 1. Check Redis cache FIRST
+        const cached = await this.cache.get(code, language);
+        if (cached) {
+            return {
+                code,
+                classificationCode: this.extractClassificationCode(code),
+                message: cached
+            };
+        }
+        // 2. Cache miss → Query DB
+        const dbResult = await this.dbService.getMessageContentByCode(code, language);
+        if (!dbResult) {
+            return null;
+        }
+        // 3. Save to cache
+        await this.cache.set(code, language, dbResult.message);
+        return dbResult;
+    }
+    /**
+     * Get all languages for a message code (with cache)
+     */
+    async getAllLanguages(code) {
+        const cached = await this.cache.getAll(code);
+        if (cached) {
+            return cached;
+        }
+        // Cache miss - would need to query DB
+        // This is optional, can be implemented if needed
+        return null;
+    }
+    /**
+     * Invalidate cache for a message (call after update)
+     */
+    async invalidate(code) {
+        await this.cache.delete(code);
+    }
+    /**
+     * Invalidate cache for a specific language (call after update)
+     */
+    async invalidateLanguage(code, language) {
+        await this.cache.deleteLanguage(code, language);
+    }
+    /**
+     * Set message to cache directly (use after create)
+     */
+    async setToCache(code, content) {
+        await this.cache.setAll(code, content);
+    }
+    /**
+     * Extract classification code from message code
+     * e.g., "ECASH_00001" -> "ECASH"
+     */
+    extractClassificationCode(code) {
+        const parts = code.split("_");
+        return parts.slice(0, -1).join("_");
+    }
+}
+exports.CachedMessageService = CachedMessageService;

package/dist/message/index.d.ts

@@ -1,4 +1,5 @@
 export * from "./types";
 export * from "./message-helper";
 export * from "./message-error";
+export * from "./cached-message-service";
 //# sourceMappingURL=index.d.ts.map

package/dist/message/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/message/index.ts"],"names":[],"mappings":"AAAA,cAAc,SAAS,CAAC;AACxB,cAAc,kBAAkB,CAAC;AACjC,cAAc,iBAAiB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/message/index.ts"],"names":[],"mappings":"AAAA,cAAc,SAAS,CAAC;AACxB,cAAc,kBAAkB,CAAC;AACjC,cAAc,iBAAiB,CAAC;AAChC,cAAc,0BAA0B,CAAC"}

package/dist/message/index.js

@@ -17,3 +17,4 @@ Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./types"), exports);
 __exportStar(require("./message-helper"), exports);
 __exportStar(require("./message-error"), exports);
+__exportStar(require("./cached-message-service"), exports);

package/dist/message/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/message/types.ts"],"names":[],"mappings":"AAEA;;;GAGG;AACH,MAAM,WAAW,aAAa;IAC5B,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,GAAG,SAAS,CAAC;CAC5C;AAED;;GAEG;AACH,MAAM,WAAW,cAAc;IAC7B,IAAI,EAAE,MAAM,CAAC;IACb,kBAAkB,EAAE,MAAM,CAAC;IAC3B,OAAO,EAAE,MAAM,CAAC;CACjB;AAED;;GAEG;AACH,MAAM,WAAW,iBAAiB;IAChC,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,MAAM,CAAC,EAAE,aAAa,CAAC;CACxB;AAED;;;GAGG;AACH,MAAM,WAAW,kBAAkB;IACjC,uBAAuB,CACrB,IAAI,EAAE,MAAM,EACZ,QAAQ,EAAE,MAAM,GACf,OAAO,CAAC,cAAc,GAAG,IAAI,CAAC,CAAC;CACnC;AAED;;GAEG;AACH,MAAM,WAAW,mBAAmB;IAClC,WAAW,EAAE,MAAM,CAAC;IACpB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,MAAM,CAAC,EAAE,aAAa,CAAC;CACxB"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/message/types.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,MAAM,WAAW,aAAa;IAC5B,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,GAAG,SAAS,CAAC;CAC5C;AAED;;GAEG;AACH,MAAM,WAAW,cAAc;IAC7B,IAAI,EAAE,MAAM,CAAC;IACb,kBAAkB,EAAE,MAAM,CAAC;IAC3B,OAAO,EAAE,MAAM,CAAC;CACjB;AAED;;GAEG;AACH,MAAM,WAAW,iBAAiB;IAChC,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,MAAM,CAAC,EAAE,aAAa,CAAC;CACxB;AAED;;;GAGG;AACH,MAAM,WAAW,kBAAkB;IACjC,uBAAuB,CACrB,IAAI,EAAE,MAAM,EACZ,QAAQ,EAAE,MAAM,GACf,OAAO,CAAC,cAAc,GAAG,IAAI,CAAC,CAAC;CACnC;AAED;;GAEG;AACH,MAAM,WAAW,mBAAmB;IAClC,WAAW,EAAE,MAAM,CAAC;IACpB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,MAAM,CAAC,EAAE,aAAa,CAAC;CACxB"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ecashlib/shared-message",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "description": "Shared utilities for Ecash microservices - Message handling, i18n, error helpers",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",