bpjs-bridge 1.0.1 → 1.0.2

package/README.md

@@ -1,12 +1,19 @@
-# @newustechnology/bpjs-bridging
+<p align="center">
+  <img src="https://img.shields.io/badge/Newus%20BPJS%20Bridge-FKTP-blue?style=for-the-badge" />
+</p>
 
-Library resmi untuk bridging BPJS Kesehatan (PCare, VClaim, Antrean, iCare, Rekam Medis)
-yang sudah modular, type-safe, dan mudah diintegrasikan.
+<h1 align="center">BPJS Bridge FKTP Service</h1>
+
+<p align="center">
+  Integrasi BPJS PCare, Antrean FKTP, VClaim, dan iCare dengan dukungan Redis Cache, Logging, dan Modular Service Architecture. 
+  <br />
+  Repository resmi: <a href="https://github.com/NewusTech/bpjs-bridge">NewusTech/bpjs-bridge</a>
+</p>
 
 ## Installation
 
 ```bash
-npm install @newustechnology/bpjs-bridging
+npm i bpjs-bridge
 ```
 
 ## Usage
@@ -20,24 +27,267 @@ secretKey: "...",
 userKey: "...",
 username: "...",
 password: "..."
-});
+},redist);
 
-const dokter = await pcare.getDokter(0, 10);
+const dokter = await pcare.dokter.get(0, 10);
 console.log(dokter);
 ```
 
 ---
 
-Features
+## 📌 **Fitur Utama**
+
+- ⚡ **Redis Caching** untuk mempercepat response BPJS
+- 🔐 Request signing otomatis (X-Signature, Authorization, Timestamp)
+- 🧩 Arsitektur service modular (PcareService, FktpService, AntrolService)
+- 📚 Auto-retry request & error handling kuat
+- 🧵 Prefix Redis per fasilitas kesehatan
+- 🧼 Pattern deletion & flush cache
+- 📦 Endpoints BPJS terstruktur via config JSON
+- 🚀 Support transaksi BPJS GET/POST/PUT/DELETE
+
+---
+
+# Dokumentasi Fitur Redis Cache pada `FktpService`
+
+Dokumentasi ini menjelaskan cara kerja sistem caching Redis yang diimplementasikan pada class `FktpService`. Tujuannya adalah mempercepat respons API BPJS, mengurangi beban request berulang, serta meningkatkan performa aplikasi.
+
+---
+
+## 🚀 1. Overview Arsitektur
+
+Class **`FktpService`** berfungsi sebagai service utama untuk memanggil endpoint BPJS (PCare, Antrean, VClaim, iCare) dengan fitur tambahan berupa:
+
+- Redis caching
+- Prefix key dinamis per fasyankes/puskesmas
+- Otomatis menyimpan dan mengambil cache berdasarkan parameter API
+- TTL (kadaluarsa cache) otomatis
+- Penghapusan berdasarkan pola (pattern deletion)
+- Flush semua cache
+
+---
+
+## 🧩 2. Cara Kerja Redis Cache
+
+### **a. Inisialisasi Redis**
+
+```ts
+constructor(config, redisClient, chachePrefix) {
+  this.client = createBpjsClient(config);
+
+  if (redisClient) {
+    this.redisClient = redisClient;
+
+    this.redisClient.on("connect", () => console.info("Redis connected"));
+    this.redisClient.on("error", err => console.error("Redis error:", err));
+
+    if (chachePrefix) {
+      this.defaultRedisKeyPrefix =
+        this.defaultRedisKeyPrefix + "_" + chachePrefix + ":";
+    }
+  }
+}
+```
+
+Fitur ini memungkinkan:
+
+- Menggunakan Redis secara opsional
+- Menghasilkan prefix unik untuk setiap instansi faskes
+- Mempermudah isolasi cache antar puskesmas
+
+---
+
+## 📦 3. Menyimpan Data ke Redis (`set`)
+
+```ts
+private async set(key, value, expInSecond = 3600)
+```
+
+### Fungsi ini:
+
+- Menerima key dan value
+- Mengubah value menjadi JSON string
+- Menyimpan ke Redis dengan TTL default **3600 detik** (1 jam)
+
+Flow:
+
+1. Serialize → JSON.stringify
+2. Redis SET key with **EXPIRE**
+
+---
+
+## 🔍 4. Mengambil Data dari Redis (`get`)
+
+```ts
+private async get(key)
+```
+
+Fungsi:
+
+- Mencari key di Redis
+- Mengembalikan string JSON atau `null` jika tidak ada
+- Logging otomatis jika cache ditemukan
+
+Jika data ditemukan:
+
+- System **tidak memanggil API BPJS**
+- Mengembalikan data sebagai **fake AxiosResponse**
+
+---
+
+## 🗑️ 5. Menghapus Cache (`del`)
+
+```ts
+private async del(key)
+```
+
+Menghapus satu cache berdasarkan key lengkap.
+
+---
+
+## 🧹 6. Hapus Banyak Key Berdasarkan Pola (`deleteKeysByPattern`)
+
+```ts
+private async deleteKeysByPattern(pattern)
+```
+
+Contoh:
+
+- Menghapus semua cache endpoint PCare:  
+  `deleteKeysByPattern("pcare_*")`
+
+Fitur ini sangat berguna ketika:
+
+- Fasyankes update mapping
+- Data referensi berubah
+- Harus invalidasi cache massal
+
+---
+
+## 💣 7. Flush Semua Cache
+
+```ts
+private async flushAll()
+```
+
+Membersihkan seluruh isi Redis.
+
+---
+
+## 🔥 8. Mekanisme utama caching di `callEndpoint`
+
+### **Langkah-langkah lengkap:**
+
+#### 1️⃣ Generate cacheKey
+
+```ts
+const cacheKey = `${name}:${JSON.stringify(params)}`;
+```
+
+#### 2️⃣ Cek apakah data sudah ada di Redis
 
-🔐 Auto enkripsi/dekripsi AES BPJS
+```ts
+const cachedData = await this.get(cacheKey);
+```
+
+Jika ada → langsung return:
+
+```ts
+return {
+  data: parsed,
+  status: 200,
+  statusText: "OK",
+  headers: {},
+  config: client.defaults,
+};
+```
+
+Tanpa memanggil API BPJS!
+
+#### 3️⃣ Jika tidak ada cache → BPJS request dijalankan
+
+```ts
+const res = await this.client({ url: endpoint, method: "GET" });
+```
+
+#### 4️⃣ Data response yang bukan string disimpan ke Redis
 
-🔄 Auto generate header signature
+```ts
+await this.set(cacheKey, res.data);
+```
 
-📦 Modular service: PCare, VClaim, Antrean, iCare
+---
 
-🧪 Fully tested with Jest
+## 📘 9. Keuntungan Implementasi Cache
 
-⚡ Fast, clean, and simple
+| Fitur                | Manfaat                                           |
+| -------------------- | ------------------------------------------------- |
+| Redis TTL            | Otomatis invalidasi cache usang                   |
+| Prefix per puskesmas | Cache tidak saling tercampur                      |
+| Fake AxiosResponse   | Kompatibel dengan semua service yang expect Axios |
+| Pattern deletion     | Mudah invalidasi cache masal                      |
+| Response lebih cepat | Hemat request ke BPJS                             |
 
 ---
+
+## 📝 10. Contoh Struktur Key Redis
+
+```
+bpjs_bridge_fktp_puskesmasA:pcare_diagnosa:{"kode":"A00"}
+bpjs_bridge_fktp_puskesmasA:pcare_obat:{"kdObat":"40102"}
+bpjs_bridge_fktp_puskesmasB:vclaim_peserta:{"nokartu":"000123"}
+```
+
+Prefix → per instansi  
+Suffix → berdasarkan endpoint + parameter
+
+---
+
+## 🧪 11. Cara Menggunakan dalam Service PCare / Antrean
+
+```ts
+const res = await fktpService.callEndpoint("pcare_diagnosa", { kode: "A00" });
+```
+
+Jika sudah pernah dipanggil → langsung ambil dari Redis.
+
+---
+
+## 📄 12. Catatan Penting
+
+- Cache **hanya berjalan untuk request GET**, sesuai pola:
+  ```ts
+  if (method === "GET") save to Redis
+  ```
+- Untuk POST/PUT/DELETE → tidak disimpan agar tidak membuat konflik data.
+- TTL default bisa diganti sesuai kebutuhan.
+
+---
+
+#### ✅ Penutup
+
+Dokumentasi ini menjelaskan seluruh mekanisme internal caching Redis yang digunakan pada sistem BPJS Bridge.  
+Implementasi ini membuat aplikasi lebih cepat, efisien, dan hemat pemanggilan API.
+
+---
+
+🧑‍💻 Kontributor
+
+Terima kasih kepada semua kontributor yang telah membantu pengembangan project ini 🙏
+
+<br> <!-- Contrib rocks --> <p align="center"> <img src="https://contrib.rocks/image?repo=NewusTech/bpjs-bridge" /> </p>
+
+<!-- readme: contributors -start -->
+<!-- readme: contributors -end -->
+
+📄 Lisensi
+
+## MIT License © Newus Teknologi
+
+❤️ Dukungan
+
+Jika project ini bermanfaat, jangan lupa:
+
+⭐ Star repository
+🍴 Fork bila ingin modifikasi
+🐛 Open issue untuk bug/fitur baru

package/dist/__test__/pcare.service.test.js

@@ -4,14 +4,17 @@ const redis_1 = require("../lib/redis");
 const pcare_service_1 = require("../services/pcare/pcare.service");
 const config_1 = require("./config");
 // Setup PcareService
-const pcareService = new pcare_service_1.PcareService(config_1.PcareConfig, redis_1.redis);
+const pcareService = new pcare_service_1.PcareService(config_1.PcareConfig, redis_1.redis, "redis_prefix_test");
 describe("PcareService", () => {
+    afterAll(() => {
+        redis_1.redis.disconnect();
+    });
     it("should load environment variables", () => {
         console.log(config_1.PcareConfig);
         expect(config_1.PcareConfig).toBeDefined();
     });
     it("should fetch diagnosa data", async () => {
-        const response = await pcareService.getDiagnosa("r51", 0, 10);
+        const response = await pcareService.diagnosa.get("r51", 0, 10);
         expect(response).toEqual(expect.objectContaining({
             count: expect.any(Number), // count harus berupa number
             list: expect.arrayContaining([
@@ -25,7 +28,7 @@ describe("PcareService", () => {
         }));
     });
     it("should fetch getAlergiJenis 01", async () => {
-        const response = await pcareService.getAlergiJenis("01");
+        const response = await pcareService.alergi.get("01");
         expect(response).toEqual(expect.objectContaining({
             list: expect.arrayContaining([
                 // list harus berupa array
@@ -37,7 +40,7 @@ describe("PcareService", () => {
         }));
     });
     it("should fetch getDokter", async () => {
-        const response = await pcareService.getDokter(0, 1);
+        const response = await pcareService.dokter.get(0, 1);
         expect(response).toEqual(expect.objectContaining({
             count: expect.any(Number),
             list: expect.arrayContaining([
@@ -49,7 +52,7 @@ describe("PcareService", () => {
         }));
     });
     it("should fetch getKesadaran", async () => {
-        const response = await pcareService.getKesadaran();
+        const response = await pcareService.kesadaran.get();
         expect(response).toEqual(expect.objectContaining({
             count: expect.any(Number),
             list: expect.arrayContaining([
@@ -61,7 +64,7 @@ describe("PcareService", () => {
         }));
     });
     it("should fetch getDPHO", async () => {
-        const response = await pcareService.getDPHO("a", 0, 1);
+        const response = await pcareService.obat.getDPHO("a", 0, 1);
         expect(response).toEqual(expect.objectContaining({
             count: expect.any(Number),
             list: expect.arrayContaining([
@@ -74,7 +77,7 @@ describe("PcareService", () => {
         }));
     });
     it("should fetch Poli FKTP", async () => {
-        const response = await pcareService.getPiliFKTP(0, 1);
+        const response = await pcareService.poli.get(0, 1);
         expect(response).toEqual(expect.objectContaining({
             count: expect.any(Number),
             list: expect.arrayContaining([
@@ -87,7 +90,7 @@ describe("PcareService", () => {
         }));
     });
     it("should fetch Provider Rayonisasi", async () => {
-        const response = await pcareService.getProviderRayonisasi(0, 1);
+        const response = await pcareService.provider.get(0, 1);
         expect(response).toEqual(expect.objectContaining({
             count: expect.any(Number),
             list: expect.arrayContaining([
@@ -99,7 +102,7 @@ describe("PcareService", () => {
         }));
     });
     it("should fetch Status Pulang", async () => {
-        const response = await pcareService.getStatusPulang(false);
+        const response = await pcareService.statusPulang.get(false);
         expect(response).toEqual(expect.objectContaining({
             count: expect.any(Number),
             list: expect.arrayContaining([
@@ -111,7 +114,7 @@ describe("PcareService", () => {
         }));
     });
     it("should fetch Referensi Tindakan", async () => {
-        const response = await pcareService.getReferensiTindakan("10", 0, 1);
+        const response = await pcareService.tindakan.getReferensi("10", 0, 1);
         expect(response).toEqual(expect.objectContaining({
             count: expect.any(Number),
             list: expect.arrayContaining([
@@ -125,7 +128,7 @@ describe("PcareService", () => {
         }));
     });
     it("should fetch Prognosa", async () => {
-        const response = await pcareService.getPrognosa();
+        const response = await pcareService.prognosa.get();
         expect(response).toEqual(expect.objectContaining({
             list: expect.arrayContaining([
                 expect.objectContaining({

package/dist/config/enpoints.d.ts

@@ -274,13 +274,13 @@ export declare const BaseUrl: {
         url_pcare: string;
         url_icare: string;
         url_vclaim: string;
-        url_antrol: string;
+        url_antrean_fktp: string;
     };
     prod: {
         url_icare: string;
         url_pcare: string;
         url_vclaim: string;
-        url_antrol: string;
+        url_antrean_fktp: string;
     };
 };
 export type EndpointName = (typeof enpoints)[number]["name"];

package/dist/config/enpoints.js

@@ -332,12 +332,12 @@ exports.BaseUrl = {
         url_pcare: "https://apijkn-dev.bpjs-kesehatan.go.id/pcare-rest-dev",
         url_icare: "https://apijkn-dev.bpjs-kesehatan.go.id/ihs_dev",
         url_vclaim: "https://apijkn-dev.bpjs-kesehatan.go.id/vclaim-rest-dev",
-        url_antrol: "https://apijkn-dev.bpjs-kesehatan.go.id/antreanfktp_dev",
+        url_antrean_fktp: "https://apijkn-dev.bpjs-kesehatan.go.id/antreanfktp_dev",
     },
     prod: {
         url_icare: "https://apijkn.bpjs-kesehatan.go.id/ihs",
         url_pcare: "https://apijkn.bpjs-kesehatan.go.id/pcare-rest",
         url_vclaim: "https://apijkn.bpjs-kesehatan.go.id/vclaim-rest",
-        url_antrol: "https://apijkn.bpjs-kesehatan.go.id/antreanfktp",
+        url_antrean_fktp: "https://apijkn.bpjs-kesehatan.go.id/antreanfktp",
     },
 };

package/dist/core/configHelper.d.ts

@@ -6,6 +6,9 @@ export type configType = {
     userKey: string;
     mode: "dev" | "prod";
 };
+/**
+ * @deprecated
+ */
 export declare function resolveConfig(globalCfg: configType, serviceCfg: configType): {
     consId: string;
     secretKey: string;

package/dist/core/configHelper.js

@@ -2,6 +2,9 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.resolveConfig = resolveConfig;
 // src/core/configHelper.ts
+/**
+ * @deprecated
+ */
 function resolveConfig(globalCfg, serviceCfg) {
     return {
         consId: serviceCfg?.consId ?? globalCfg?.consId,

package/dist/core/httpClient.js

@@ -7,6 +7,7 @@ exports.createBpjsClient = void 0;
 const axios_1 = __importDefault(require("axios"));
 const decrypt_1 = require("./decrypt");
 const security_1 = require("./security");
+const globalErroModule_1 = require("../types/globalErroModule");
 const createBpjsClient = (config) => {
     const client = axios_1.default.create({
         baseURL: config.baseUrl,
@@ -25,27 +26,86 @@ const createBpjsClient = (config) => {
         return req;
     });
     client.interceptors.response.use(async (res) => {
+        const url = `${res.config.method?.toUpperCase()} ${res.config.baseURL}/${res.config.url}`;
         const { response: encryptedData } = res.data;
-        // Ensure encryptedData is a string before trying to decrypt
-        if (typeof encryptedData === "string") {
-            const timestamp = String(headers["X-timestamp"]);
-            const decrypted = (0, decrypt_1.decryptBpjsResponse)(encryptedData, config.consId, config.secretKey, timestamp);
-            return { ...res, data: decrypted };
+        if (encryptedData) {
+            if (typeof encryptedData !== "string") {
+                throw new globalErroModule_1.BpjsDecryptionError(`[DECRYPTION ERROR] ${url} Format encrypted data tidak valid, expected string`, { type: typeof encryptedData, data: encryptedData });
+            }
+            try {
+                const timestamp = String(headers["X-timestamp"]);
+                if (!timestamp) {
+                    throw new Error("Timestamp tidak tersedia untuk decryption");
+                }
+                const decrypted = (0, decrypt_1.decryptBpjsResponse)(encryptedData, config.consId, config.secretKey, timestamp);
+                return {
+                    ...res,
+                    data: decrypted,
+                    headers: {
+                        ...res.headers,
+                        "x-decrypted": "true",
+                    },
+                };
+            }
+            catch (decryptError) {
+                throw new globalErroModule_1.BpjsDecryptionError(`[DECRYPTION ERROR] ${url} : ${decryptError.message}`, {
+                    originalError: decryptError,
+                    encryptedLength: encryptedData.length,
+                    consId: config.consId,
+                });
+            }
         }
-        res.data = `[HTTP CLIENT ERROR => URL : ${res.config.baseURL}/${res.config.url} ] => ${res.data.metaData?.message || "unknown error"}`;
-        return res;
+        res.data = `[HTTP CLIENT ERROR => URL : ${res.config.baseURL}/${res.config.url} ] => ${"NO_CONTENT_IN_RESPONSE"}`;
+        res.status = 204;
+        res.statusText = "No Content";
+        const AxiosError = {
+            name: "BpjsResponseError",
+            code: "NO_CONTENT_IN_RESPONSE",
+            message: res.data,
+            status: res.status,
+            config: res.config,
+            isAxiosError: true,
+            response: {
+                data: res.data,
+                status: res.status,
+                statusText: res.statusText,
+                headers: res.headers,
+                config: res.config,
+            },
+            toJSON: () => ({}),
+        };
+        return Promise.reject(AxiosError);
     }, (err) => {
-        console.error("[HTTP CLIENT ERROR]", err.message + " || " + JSON.stringify(err.response?.data) || "");
-        const fallback = {
-            data: `[HTTP CLIENT ERROR => URL : ${err.config.baseURL}/${err.config.url} ] => ${err.response?.data?.metaData?.message ??
-                err.message ??
-                "unknown error"}`,
-            status: err.status || 500,
-            statusText: err.message || "Internal Server Error",
+        const url = `${err.config.method?.toUpperCase()} ${err.config.baseURL}/${err.config.url}`;
+        const fallBackResponse = {
+            data: {
+                message: `[HTTP CLIENT ERROR => URL : ${url} ] => ${err.response?.data?.metaData?.message ??
+                    err.message ??
+                    "unknown error"}`,
+                originalResponse: err.response?.data,
+            },
+            status: err.response?.data?.metaData?.code || err.status || 500,
+            statusText: err.response?.data?.metaData?.message ??
+                (err.message || "Internal Server Error"),
             headers: {},
             config: err.config || {},
         };
-        return fallback;
+        const AxiosError = {
+            name: "BpjsResponseError",
+            message: fallBackResponse.data.message,
+            status: fallBackResponse.status,
+            config: fallBackResponse.config,
+            isAxiosError: true,
+            response: {
+                data: fallBackResponse.data,
+                status: fallBackResponse.status,
+                statusText: fallBackResponse.statusText,
+                headers: err.headers,
+                config: fallBackResponse.config,
+            },
+            toJSON: () => ({}),
+        };
+        return Promise.reject(AxiosError);
     });
     return client;
 };

package/dist/index.d.ts

@@ -1,6 +1,15 @@
 export * from "./core/httpClient";
 export * from "./core/configHelper";
 export * from "./services/pcare/pcare.service";
+export * from "./services/antrean/fktpBPJS.service";
+export * from "./services/i-care/icare.service";
 export * from "./lib/redis";
 export * from "./types/global";
 export * from "./types/pcare";
+export * from "./types/kunjungan";
+export * from "./types/peserta";
+export * from "./types/kunjungan";
+export * from "./types/pendaftaran";
+export * from "./types/spesialis";
+export * from "./types/antreanFktp";
+export * from "./types/icare";

package/dist/index.js

@@ -17,6 +17,16 @@ Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./core/httpClient"), exports);
 __exportStar(require("./core/configHelper"), exports);
 __exportStar(require("./services/pcare/pcare.service"), exports);
+__exportStar(require("./services/antrean/fktpBPJS.service"), exports);
+__exportStar(require("./services/i-care/icare.service"), exports);
 __exportStar(require("./lib/redis"), exports);
+//
 __exportStar(require("./types/global"), exports);
 __exportStar(require("./types/pcare"), exports);
+__exportStar(require("./types/kunjungan"), exports);
+__exportStar(require("./types/peserta"), exports);
+__exportStar(require("./types/kunjungan"), exports);
+__exportStar(require("./types/pendaftaran"), exports);
+__exportStar(require("./types/spesialis"), exports);
+__exportStar(require("./types/antreanFktp"), exports);
+__exportStar(require("./types/icare"), exports);

package/dist/services/antrean/fktpBPJS.service.d.ts

@@ -0,0 +1,61 @@
+import Redis from "ioredis";
+import { configType } from "../../core/configHelper";
+import { DataArray } from "../../types/global";
+import { AntreanFktpBatalPayload, AntreanFktpPayload, AntreanFktpReferensiDokterType, AntreanFktpReferensiPoliType, AntreanFktpStatusPayload } from "../../types/antreanFktp";
+import { BaseService } from "../base.service";
+/**
+ * Service untuk mengakses endpoint Antrean BPJS FKTP
+ */
+export declare class AntreanFktpService extends BaseService {
+    /**
+     * Constructor AntreanFktpService
+     * @param config konfigurasi BPJS
+     * @param redisClient instance Redis (opsional)
+     * @param chachePrefix prefix untuk cache Redis (opsional)
+     */
+    constructor(config: configType, redisClient?: Redis, chachePrefix?: string);
+    /**
+     *
+     * @param tanggal
+     * @returns
+     * @description
+     * Melihat referensi poli pada layanan antrean (WS Antrol)
+     */
+    getReferensiPoli(tanggal: string): Promise<DataArray<AntreanFktpReferensiPoliType>>;
+    /**
+     *
+     * @param kodepoli
+     * @param tanggal
+     * @returns
+     * @description
+     * Melihat daftar dokter berdasarkan poli dan tanggal
+     */
+    getReferensiDokter(kodepoli: string, tanggal: string): Promise<DataArray<AntreanFktpReferensiDokterType>>;
+    /**
+     *
+     * @param body
+     * @returns
+     * @description
+     * Menambah data antrean pasien
+     */
+    add(body: AntreanFktpPayload): Promise<null>;
+    /**
+     *
+     * @param body
+     * ### notes :
+     * - Status 1 = Hadir; Status 2 = Tidak Hadir
+     * - Waktu dalam bentuk timestamp milisecond
+     * @returns
+     * @description
+     * Update status antrean hadir/tidak hadir
+     */
+    updateStatus(body: AntreanFktpStatusPayload): Promise<null>;
+    /**
+     *
+     * @param body
+     * @returns
+     * @description
+     * Membatalkan antrean pasien
+     */
+    batal(body: AntreanFktpBatalPayload): Promise<null>;
+}