@bejibun/redis 0.1.35 → 0.1.36

package/CHANGELOG.md

@@ -3,6 +3,22 @@ All notable changes to this project will be documented in this file.
 
 ---
 
+## [v0.1.36](https://github.com/crenata/bejibun-redis/compare/v0.1.35...v0.1.36) - 2025-12-11
+
+### 🩹 Fixes
+
+### 📖 Changes
+- Set random connection name for `.setClient()` and disconnect after used then clear the connection lists.
+
+#### Upgrade [@bejibun/utils](https://github.com/crenata/bejibun-utils) to [v0.1.27](https://github.com/crenata/bejibun-utils/releases/tag/v0.1.24)
+
+### ❤️Contributors
+- Havea Crenata ([@crenata](https://github.com/crenata))
+
+**Full Changelog**: https://github.com/crenata/bejibun-redis/blob/master/CHANGELOG.md
+
+---
+
 ## [v0.1.35](https://github.com/crenata/bejibun-redis/compare/v0.1.34...v0.1.35) - 2025-12-07
 
 ### 🩹 Fixes

package/README.md

@@ -74,6 +74,15 @@ export default class TestController extends BaseController {
         await Redis.connection("local").set("connection", "This is using custom connection.");
         const connection = await Redis.connection("local").get("connection");
 
+        await Redis.setClient({
+            host: "127.0.0.1",
+            port: 6379,
+            password: "",
+            database: 0,
+            maxRetries: 10
+        }, "optional-connection-name").set("redis", {hello: "world"});
+        // for publish and subscibe recommended using custom connection name to make sure connection matched
+
         const pipeline = await Redis.pipeline((pipe: RedisPipeline) => {
             pipe.set("redis-pipeline-1", "This is redis pipeline 1");
             pipe.set("redis-pipeline-2", "This is redis pipeline 2");

package/builders/RedisBuilder.d.ts

@@ -2,16 +2,16 @@ import type { RedisConfig, RedisPipeline, RedisSubscribe } from "../types/redis"
 export default class RedisBuilder {
     private static clients;
     private static emitter;
-    static setClient(cfg: RedisConfig): Record<string, Function>;
+    static setClient(cfg: RedisConfig, name?: string): Record<string, Function>;
     static connection(name: string): Record<string, Function>;
     static connect(name?: string): Promise<Bun.RedisClient>;
     static disconnect(name?: string): Promise<void>;
-    static get(key: Bun.RedisClient.KeyLike, connection?: string): Promise<any>;
-    static set(key: Bun.RedisClient.KeyLike, value: any, ttl?: number, connection?: string): Promise<number | "OK">;
-    static del(key: Bun.RedisClient.KeyLike, connection?: string): Promise<number>;
+    static get(key: Bun.RedisClient.KeyLike, connection?: string, disconnectAfter?: boolean): Promise<any>;
+    static set(key: Bun.RedisClient.KeyLike, value: any, ttl?: number, connection?: string, disconnectAfter?: boolean): Promise<number | "OK">;
+    static del(key: Bun.RedisClient.KeyLike, connection?: string, disconnectAfter?: boolean): Promise<number>;
     static publish(channel: string, message: any, connection?: string): Promise<number>;
     static subscribe(channel: string, listener: Bun.RedisClient.StringPubSubListener, connection?: string): Promise<RedisSubscribe>;
-    static pipeline(fn: (pipe: RedisPipeline) => void, connection?: string): Promise<any[]>;
+    static pipeline(fn: (pipe: RedisPipeline) => void, connection?: string, disconnectAfter?: boolean): Promise<any[]>;
     static on(event: "connect" | "disconnect" | "error", listener: (...args: Array<any>) => void): void;
     static off(event: "connect" | "disconnect" | "error", listener: (...args: Array<any>) => void): void;
     private static get config();

package/builders/RedisBuilder.js

@@ -1,6 +1,7 @@
 import App from "@bejibun/app";
 import Logger from "@bejibun/logger";
 import { defineValue, isEmpty, isNotEmpty } from "@bejibun/utils";
+import Str from "@bejibun/utils/facades/Str";
 import { EventEmitter } from "events";
 import fs from "fs";
 import RedisConf from "../config/redis";
@@ -8,18 +9,15 @@ import RedisException from "../exceptions/RedisException";
 export default class RedisBuilder {
     static clients = {};
     static emitter = new EventEmitter();
-    static setClient(cfg) {
-        const connectionName = "override";
-        this.ensureExitHooks();
-        if (isEmpty(this.clients[connectionName])) {
-            this.clients[connectionName] = this.createClient(connectionName, cfg);
-        }
+    static setClient(cfg, name) {
+        const connectionName = defineValue(name, Str.random());
+        this.clients[connectionName] = this.createClient(connectionName, cfg);
         return {
-            del: (key) => this.del(key, connectionName),
-            get: (key) => this.get(key, connectionName),
-            pipeline: (fn) => this.pipeline(fn, connectionName),
+            del: (key) => this.del(key, connectionName, isNotEmpty(name)),
+            get: (key) => this.get(key, connectionName, isNotEmpty(name)),
+            pipeline: (fn) => this.pipeline(fn, connectionName, isNotEmpty(name)),
             publish: (channel, message) => this.publish(channel, message, connectionName),
-            set: (key, value, ttl) => this.set(key, value, ttl, connectionName),
+            set: (key, value, ttl) => this.set(key, value, ttl, connectionName, isNotEmpty(name)),
             subscribe: (channel, listener) => this.subscribe(channel, listener, connectionName),
         };
     }
@@ -57,9 +55,11 @@ export default class RedisBuilder {
             this.clients = {};
         }
     }
-    static async get(key, connection) {
+    static async get(key, connection, disconnectAfter) {
         try {
             const response = await this.getClient(connection).get(key);
+            if (disconnectAfter)
+                await this.disconnect(connection);
             return this.deserialize(response);
         }
         catch (error) {
@@ -67,13 +67,15 @@ export default class RedisBuilder {
             return null;
         }
     }
-    static async set(key, value, ttl, connection) {
+    static async set(key, value, ttl, connection, disconnectAfter) {
         try {
             const client = this.getClient(connection);
             const serialized = this.serialize(value);
             const data = await client.set(key, serialized);
             if (isNotEmpty(ttl))
                 return await client.expire(key, ttl);
+            if (disconnectAfter)
+                await this.disconnect(connection);
             return data;
         }
         catch (error) {
@@ -81,9 +83,12 @@ export default class RedisBuilder {
             return 0;
         }
     }
-    static async del(key, connection) {
+    static async del(key, connection, disconnectAfter) {
         try {
-            return await this.getClient(connection).del(key);
+            const data = await this.getClient(connection).del(key);
+            if (disconnectAfter)
+                await this.disconnect(connection);
+            return data;
         }
         catch (error) {
             Logger.setContext("Redis").error("Failed to delete key.").trace(error);
@@ -127,7 +132,7 @@ export default class RedisBuilder {
             unsubscribe: unsubscribe
         };
     }
-    static async pipeline(fn, connection) {
+    static async pipeline(fn, connection, disconnectAfter) {
         const client = this.getClient(connection);
         const ops = [];
         const pipe = {
@@ -147,6 +152,8 @@ export default class RedisBuilder {
         };
         fn(pipe);
         const results = await Promise.all(ops);
+        if (disconnectAfter)
+            await this.disconnect(connection);
         return results.map((result) => this.deserialize(result));
     }
     static on(event, listener) {

package/facades/Redis.d.ts

@@ -1,6 +1,6 @@
 import type { RedisConfig, RedisPipeline, RedisSubscribe } from "../types/redis";
 export default class Redis {
-    static setClient(cfg: RedisConfig): Record<string, Function>;
+    static setClient(cfg: RedisConfig, name?: string): Record<string, Function>;
     static connection(name: string): Record<string, Function>;
     static connect(name?: string): Promise<Bun.RedisClient>;
     static disconnect(name?: string): Promise<void>;

package/facades/Redis.js

@@ -1,7 +1,7 @@
 import RedisBuilder from "../builders/RedisBuilder";
 export default class Redis {
-    static setClient(cfg) {
-        return RedisBuilder.setClient(cfg);
+    static setClient(cfg, name) {
+        return RedisBuilder.setClient(cfg, name);
     }
     static connection(name) {
         return RedisBuilder.connection(name);

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@bejibun/redis",
-    "version": "0.1.35",
+    "version": "0.1.36",
     "author": "Havea Crenata <havea.crenata@gmail.com>",
     "repository": {
         "type": "git",
@@ -38,6 +38,6 @@
     "dependencies": {
         "@bejibun/app": "^0.1.22",
         "@bejibun/logger": "^0.1.22",
-        "@bejibun/utils": "^0.1.24"
+        "@bejibun/utils": "^0.1.27"
     }
 }