@cap-js-community/common 0.3.0 → 0.3.2

package/CHANGELOG.md

@@ -5,6 +5,18 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](http://keepachangelog.com/en/1.0.0/)
 and this project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.html).
 
+## Version 0.3.2 - 2025-11-05
+
+### Fixed
+
+- Rework redis client
+
+## Version 0.3.1 - 2025-11-05
+
+### Fixed
+
+- Rework redis client
+
 ## Version 0.3.0 - 2025-11-03
 
 ### Fixed

package/README.md

@@ -328,14 +328,14 @@ A Redis Client broker is provided to connect to Redis service.
 
 ```js
 const { RedisClient } = require("@cap-js-community/common");
-const mainClient = await RedisClient.default().createMainClientAndConnect(options);
+const mainClient = await RedisClient.create().createMainClientAndConnect(options);
 ```
 
 #### Main named singleton
 
 ```js
 const { RedisClient } = require("@cap-js-community/common");
-const mainClient = await RedisClient.default("name").createMainClientAndConnect(options);
+const mainClient = await RedisClient.create("name").createMainClientAndConnect(options);
 ```
 
 #### Custom named
@@ -384,14 +384,14 @@ Specific Redis options for a custom name can be established as follows:
 
 ```js
 const { RedisClient } = require("@cap-js-community/common");
-const mainClient = await RedisClient.default("customName").createMainClientAndConnect(options);
+const mainClient = await RedisClient.create("customName").createMainClientAndConnect(options);
 ```
 
 In addition, options can be passed to Redis client during creation via `options` parameter:
 
 ```js
 const { RedisClient } = require("@cap-js-community/common");
-const mainClient = await RedisClient.default().createMainClientAndConnect(options);
+const mainClient = await RedisClient.create().createMainClientAndConnect(options);
 ```
 
 For details on Redis `createClient` configuration options see [Redis Client Configuration](https://github.com/redis/node-redis/blob/master/docs/client-configuration.md).

package/cds-plugin.js

@@ -3,9 +3,7 @@
 const cds = require("@sap/cds");
 require("./src/common/promise");
 
-const { ReplicationCache, RateLimiting, RedisClient } = require("./src");
-
-const TIMEOUT_SHUTDOWN = 2500;
+const { ReplicationCache, RateLimiting } = require("./src");
 
 if (cds.env.rateLimiting.plugin) {
   cds.on("serving", async (service) => {
@@ -24,25 +22,3 @@ if (cds.env.rateLimiting.plugin) {
 if (cds.env.replicationCache.plugin) {
   cds.replicationCache = new ReplicationCache();
 }
-
-cds.on("shutdown", async () => {
-  await shutdownWebSocketServer();
-});
-
-async function shutdownWebSocketServer() {
-  return await new Promise((resolve, reject) => {
-    const timeoutRef = setTimeout(() => {
-      clearTimeout(timeoutRef);
-      resolve();
-    }, TIMEOUT_SHUTDOWN);
-    RedisClient.closeAllClients()
-      .then((result) => {
-        clearTimeout(timeoutRef);
-        resolve(result);
-      })
-      .catch((err) => {
-        clearTimeout(timeoutRef);
-        reject(err);
-      });
-  });
-}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cap-js-community/common",
-  "version": "0.3.0",
+  "version": "0.3.2",
   "description": "CAP Node.js Community Common",
   "homepage": "https://cap.cloud.sap/",
   "engines": {
@@ -56,7 +56,7 @@
     "@sap/cds": "^9.4.3",
     "@sap/cds-common-content": "^3.0.1",
     "@sap/cds-dk": "^9.4.1",
-    "eslint": "^9.36.0",
+    "eslint": "^9.39.1",
     "eslint-config-prettier": "^10.1.8",
     "eslint-plugin-jest": "^29.0.1",
     "eslint-plugin-n": "^17.23.1",

package/src/migration-check/MigrationCheck.js

@@ -5,7 +5,7 @@ const path = require("path");
 const fs = require("fs");
 const crypto = require("crypto");
 
-const COMPONENT_NAME = "migrationCheck";
+const COMPONENT_NAME = "/cap-js-community-common/migrationCheck";
 const STRING_DEFAULT_LENGTH = 5000;
 
 const Checks = [releasedEntityCheck, newEntityCheck, uniqueIndexCheck, journalModeCheck];

package/src/rate-limiting/RateLimiting.js

@@ -7,7 +7,7 @@ const redisResetTime = require("./redis/resetTime");
 
 const { connectionCheck } = require("./redis/common");
 
-const COMPONENT_NAME = "rateLimiting";
+const COMPONENT_NAME = "/cap-js-community-common/rateLimiting";
 
 class RateLimiting {
   constructor(service, { maxConcurrent, maxInWindow, window } = {}) {

package/src/rate-limiting/redis/common.js

@@ -4,14 +4,14 @@ const cds = require("@sap/cds");
 
 const { RedisClient } = require("../../redis-client");
 
-const COMPONENT_NAME = "rateLimiting";
+const COMPONENT_NAME = "/cap-js-community-common/rateLimiting";
 
 async function connectionCheck() {
-  return await RedisClient.default(COMPONENT_NAME).connectionCheck();
+  return await RedisClient.create(COMPONENT_NAME).connectionCheck();
 }
 
 async function perform(key, cb, cbFallback, retry = cds.env.rateLimiting.retry) {
-  const client = cds.env.rateLimiting.redis && (await RedisClient.default(COMPONENT_NAME).createMainClientAndConnect());
+  const client = cds.env.rateLimiting.redis && (await RedisClient.create(COMPONENT_NAME).createMainClientAndConnect());
   if (client) {
     const value = await cb(client, key);
     if (value === undefined) {

package/src/redis-client/RedisClient.js

@@ -1,19 +1,30 @@
 "use strict";
 
 const redis = require("redis");
+const cds = require("@sap/cds");
 
-const COMPONENT_NAME = "redisClient";
+const COMPONENT_NAME = "/cap-js-community-common/redisClient";
 const LOG_AFTER_SEC = 5;
+const TIMEOUT_SHUTDOWN = 2500;
 
 class RedisClient {
-  constructor(name) {
+  #clusterClient = false;
+  #beforeCloseHandler;
+  constructor(name, env) {
     this.name = name;
+    this.env = env || this.name;
     this.log = cds.log(COMPONENT_NAME);
     this.mainClientPromise = null;
-    this.additionalClientPromise = null;
     this.subscriberClientPromise = null;
     this.subscribedChannels = {};
     this.lastErrorLog = Date.now();
+
+    if (!RedisClient._shutdownRegistered) {
+      RedisClient._shutdownRegistered = true;
+      cds.on("shutdown", async () => {
+        await this.closeRedisClients();
+      });
+    }
   }
 
   createMainClientAndConnect(options) {
@@ -33,19 +44,8 @@ class RedisClient {
   }
 
   createAdditionalClientAndConnect(options) {
-    if (this.additionalClientPromise) {
-      return this.additionalClientPromise;
-    }
-
-    const errorHandlerCreateClient = (err) => {
-      this.additionalClientPromise?.then?.(this.resilientClientClose);
-      this.log.error("Error from additional redis client", err);
-      this.additionalClientPromise = null;
-      setTimeout(() => this.createAdditionalClientAndConnect(options), LOG_AFTER_SEC * 1000).unref();
-    };
-
-    this.additionalClientPromise = this.createClientAndConnect(options, errorHandlerCreateClient);
-    return this.additionalClientPromise;
+    const redisClient = RedisClient.create(this.name + "-2", this.env);
+    return redisClient.createMainClientAndConnect(options);
   }
 
   async createClientAndConnect(options, errorHandlerCreateClient, isConnectionCheck) {
@@ -92,7 +92,8 @@ class RedisClient {
         throw error;
       }
       if (client) {
-        await this.resilientClientClose(client);
+        // NOTE: ignore promise: client should not wait + fn can't throw
+        this.resilientClientClose(client);
         return true;
       }
     } catch (err) {
@@ -103,7 +104,7 @@ class RedisClient {
 
   createClientBase(redisOptions = {}) {
     const { credentials, options } =
-      (this.name ? cds.env.requires[`redis-${this.name}`] : undefined) || cds.env.requires["redis"] || {};
+      (this.env ? cds.env.requires[`redis-${this.env}`] : undefined) || cds.env.requires["redis"] || {};
     const socket = {
       host: credentials?.hostname ?? "127.0.0.1",
       tls: !!credentials?.tls,
@@ -119,6 +120,7 @@ class RedisClient {
     };
     try {
       if (credentials?.cluster_mode) {
+        this.#clusterClient = true;
         return redis.createCluster({
           rootNodes: [socketOptions],
           defaults: socketOptions,
@@ -141,14 +143,14 @@ class RedisClient {
         LOG_AFTER_SEC * 1000,
       ).unref();
     };
-    this.subscribeChannels(options, { [channel]: subscribeHandler }, errorHandlerCreateClient);
+    this.subscribeChannels(options, errorHandlerCreateClient);
   }
 
-  subscribeChannels(options, subscribedChannels, errorHandlerCreateClient) {
+  subscribeChannels(options, errorHandlerCreateClient) {
     this.subscriberClientPromise = this.createClientAndConnect(options, errorHandlerCreateClient)
       .then((client) => {
         for (const channel in this.subscribedChannels) {
-          const fn = subscribedChannels[channel];
+          const fn = this.subscribedChannels[channel];
           client._subscribedChannels ??= {};
           if (client._subscribedChannels[channel]) {
             continue;
@@ -193,16 +195,6 @@ class RedisClient {
     this.log.info("Main redis client closed!");
   }
 
-  async closeAdditionalClient() {
-    if (!this.additionalClientPromise) {
-      return;
-    }
-    const client = this.additionalClientPromise;
-    this.additionalClientPromise = null;
-    await this.resilientClientClose(await client);
-    this.log.info("Additional redis client closed!");
-  }
-
   async closeSubscribeClient() {
     if (!this.subscriberClientPromise) {
       return;
@@ -214,9 +206,10 @@ class RedisClient {
   }
 
   async closeClients() {
-    await this.closeMainClient();
-    await this.closeAdditionalClient();
-    await this.closeSubscribeClient();
+    if (this.#beforeCloseHandler) {
+      await this.#beforeCloseHandler();
+    }
+    await Promise.allSettled([this.closeMainClient(), this.closeSubscribeClient()]);
   }
 
   async resilientClientClose(client) {
@@ -229,16 +222,47 @@ class RedisClient {
     }
   }
 
-  static default(name = "default") {
-    RedisClient._default ??= {};
-    if (!RedisClient._default[name]) {
-      RedisClient._default[name] = new RedisClient(name);
+  async closeRedisClients() {
+    return await new Promise((resolve, reject) => {
+      const timeoutRef = setTimeout(() => {
+        clearTimeout(timeoutRef);
+        resolve();
+      }, TIMEOUT_SHUTDOWN);
+      RedisClient.closeAllClients()
+        .then((result) => {
+          clearTimeout(timeoutRef);
+          resolve(result);
+        })
+        .catch((err) => {
+          clearTimeout(timeoutRef);
+          reject(err);
+        });
+    });
+  }
+
+  set beforeCloseHandler(cb) {
+    this.#beforeCloseHandler = cb;
+  }
+
+  get isCluster() {
+    return this.#clusterClient;
+  }
+
+  static create(name = "default", env) {
+    env ??= name;
+    RedisClient._create ??= {};
+    if (!RedisClient._create[name]) {
+      RedisClient._create[name] = new RedisClient(name, env);
     }
-    return RedisClient._default[name];
+    return RedisClient._create[name];
+  }
+
+  static default(name) {
+    return RedisClient.create(name);
   }
 
   static async closeAllClients() {
-    for (const entry of Object.values(RedisClient._default || {})) {
+    for (const entry of Object.values(RedisClient._create || {})) {
       await entry.closeClients();
     }
   }