@bejibun/redis 0.1.34 → 0.1.35

package/CHANGELOG.md

@@ -3,6 +3,28 @@ All notable changes to this project will be documented in this file.
 
 ---
 
+## [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/builders/RedisBuilder.d.ts

@@ -1,7 +1,8 @@
-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): Record<string, Function>;
     static connection(name: string): Record<string, Function>;
     static connect(name?: string): Promise<Bun.RedisClient>;
     static disconnect(name?: string): Promise<void>;
@@ -22,5 +23,4 @@ export default class RedisBuilder {
     private static serialize;
     private static deserialize;
     private static ensureExitHooks;
-    private static setupExitHooks;
 }

package/builders/RedisBuilder.js

@@ -8,6 +8,21 @@ 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);
+        }
+        return {
+            del: (key) => this.del(key, connectionName),
+            get: (key) => this.get(key, connectionName),
+            pipeline: (fn) => this.pipeline(fn, connectionName),
+            publish: (channel, message) => this.publish(channel, message, connectionName),
+            set: (key, value, ttl) => this.set(key, value, ttl, connectionName),
+            subscribe: (channel, listener) => this.subscribe(channel, listener, connectionName),
+        };
+    }
     static connection(name) {
         return {
             del: (key) => this.del(key, name),
@@ -43,35 +58,69 @@ export default class RedisBuilder {
         }
     }
     static async get(key, connection) {
-        const response = await this.getClient(connection).get(key);
-        return this.deserialize(response);
+        try {
+            const response = await this.getClient(connection).get(key);
+            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;
+        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);
+            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);
+        try {
+            return await this.getClient(connection).del(key);
+        }
+        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,
@@ -177,10 +226,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): 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) {
+        return RedisBuilder.setClient(cfg);
+    }
     static connection(name) {
         return RedisBuilder.connection(name);
     }

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@bejibun/redis",
-    "version": "0.1.34",
+    "version": "0.1.35",
     "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.24"
     }
 }