@bejibun/redis 0.1.34 → 0.1.36

package/CHANGELOG.md

@@ -3,6 +3,44 @@ 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
+
+### 📖 Changes
+What's New :
+- Adding `.setClient(cfg: RedisConfig)` to override connection.
+
+By default, [@bejibun/redis](https://github.com/crenata/bejibun-redis) use connection from `config/redis.ts`.
+
+Now, you can override it by using `setClient()`.
+
+#### Upgrade [@bejibun/utils](https://github.com/crenata/bejibun-utils) to [v0.1.24](https://github.com/crenata/bejibun-utils/releases/tag/v0.1.24)
+- Fix empty validation for class
+
+### ❤️Contributors
+- Havea Crenata ([@crenata](https://github.com/crenata))
+
+**Full Changelog**: https://github.com/crenata/bejibun-redis/blob/master/CHANGELOG.md
+
+---
+
 ## [v0.1.34](https://github.com/crenata/bejibun-redis/compare/v0.1.33...v0.1.34) - 2025-11-23
 
 ### 🩹 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

@@ -1,16 +1,17 @@
-import type { RedisPipeline, RedisSubscribe } from "../types/redis";
+import type { RedisConfig, RedisPipeline, RedisSubscribe } from "../types/redis";
 export default class RedisBuilder {
     private static clients;
     private static emitter;
+    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();
@@ -22,5 +23,4 @@ export default class RedisBuilder {
     private static serialize;
     private static deserialize;
     private static ensureExitHooks;
-    private static setupExitHooks;
 }

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,6 +9,18 @@ import RedisException from "../exceptions/RedisException";
 export default class RedisBuilder {
     static clients = {};
     static emitter = new EventEmitter();
+    static setClient(cfg, name) {
+        const connectionName = defineValue(name, Str.random());
+        this.clients[connectionName] = this.createClient(connectionName, cfg);
+        return {
+            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, isNotEmpty(name)),
+            subscribe: (channel, listener) => this.subscribe(channel, listener, connectionName),
+        };
+    }
     static connection(name) {
         return {
             del: (key) => this.del(key, name),
@@ -42,43 +55,84 @@ export default class RedisBuilder {
             this.clients = {};
         }
     }
-    static async get(key, connection) {
-        const response = await this.getClient(connection).get(key);
-        return this.deserialize(response);
+    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) {
+            Logger.setContext("Redis").error("Failed to get value.").trace(error);
+            return null;
+        }
     }
-    static async set(key, value, ttl, connection) {
-        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);
-        return data;
+    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) {
+            Logger.setContext("Redis").error("Failed to set value.").trace(error);
+            return 0;
+        }
     }
-    static async del(key, connection) {
-        return await this.getClient(connection).del(key);
+    static async del(key, connection, disconnectAfter) {
+        try {
+            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);
+            return 0;
+        }
     }
     static async publish(channel, message, connection) {
-        const serialized = this.serialize(message);
-        return await this.getClient(connection).publish(channel, serialized);
+        try {
+            const serialized = this.serialize(message);
+            return await this.getClient(connection).publish(channel, serialized);
+        }
+        catch (error) {
+            Logger.setContext("Redis").error("Failed to publish channel.").trace(error);
+            return 0;
+        }
     }
     static async subscribe(channel, listener, connection) {
-        const cfg = this.getConfig(connection);
-        const client = this.createClient(this.config.default, cfg);
+        const client = this.getClient(connection);
         this.clients[channel] = client;
-        await client.subscribe(channel, (message, channel) => listener(this.deserialize(message), channel));
-        Logger.setContext("Redis").info(`Subscribed to "${channel}" channel.`);
+        try {
+            await client.subscribe(channel, (message, channel) => listener(this.deserialize(message), channel));
+            Logger.setContext("Redis").info(`Subscribed to "${channel}" channel.`);
+        }
+        catch (error) {
+            Logger.setContext("Redis").error(`Failed to subscribe "${channel}" channel.`).trace(error);
+        }
         const unsubscribe = async () => {
-            await client.unsubscribe(channel);
-            await client.close();
-            Logger.setContext("Redis").warn(`Unsubscribed from "${channel}" channel.`);
-            return true;
+            try {
+                await client.unsubscribe(channel);
+                await client.close();
+                Logger.setContext("Redis").warn(`Unsubscribed from "${channel}" channel.`);
+                return true;
+            }
+            catch (error) {
+                Logger.setContext("Redis").error(`Failed to unsubscribe from "${channel}" channel.`).trace(error);
+                return false;
+            }
         };
         return {
             client,
             unsubscribe: unsubscribe
         };
     }
-    static async pipeline(fn, connection) {
+    static async pipeline(fn, connection, disconnectAfter) {
         const client = this.getClient(connection);
         const ops = [];
         const pipe = {
@@ -98,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) {
@@ -177,10 +233,7 @@ export default class RedisBuilder {
             return value;
         }
     }
-    static ensureExitHooks() {
-        this.setupExitHooks();
-    }
-    static setupExitHooks = (() => {
+    static ensureExitHooks = (() => {
         let initialized = false;
         return () => {
             if (initialized)

package/facades/Redis.d.ts

@@ -1,5 +1,6 @@
-import type { RedisPipeline, RedisSubscribe } from "../types/redis";
+import type { RedisConfig, RedisPipeline, RedisSubscribe } from "../types/redis";
 export default class Redis {
+    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,5 +1,8 @@
 import RedisBuilder from "../builders/RedisBuilder";
 export default class Redis {
+    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.34",
+    "version": "0.1.36",
     "author": "Havea Crenata <havea.crenata@gmail.com>",
     "repository": {
         "type": "git",
@@ -36,8 +36,8 @@
     "type": "module",
     "types": "index.d.ts",
     "dependencies": {
-        "@bejibun/app": "^0.1.19",
-        "@bejibun/logger": "^0.1.18",
-        "@bejibun/utils": "^0.1.14"
+        "@bejibun/app": "^0.1.22",
+        "@bejibun/logger": "^0.1.22",
+        "@bejibun/utils": "^0.1.27"
     }
 }