@bejibun/redis 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Havea Crenata
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,62 @@
+<div align="center">
+
+![GitHub top language](https://img.shields.io/github/languages/top/crenata/bejibun-redis)
+![GitHub all releases](https://img.shields.io/github/downloads/crenata/bejibun-redis/total)
+![GitHub issues](https://img.shields.io/github/issues/crenata/bejibun-redis)
+![GitHub](https://img.shields.io/github/license/crenata/bejibun-redis)
+![GitHub release (latest by date including pre-releases)](https://img.shields.io/github/v/release/crenata/bejibun-redis?display_name=tag&include_prereleases)
+
+</div>
+
+# Redis for Bejibun
+Redis package with Built-in Bun for Bejibun Framework.
+
+## Usage
+
+### Installation
+Install the package.
+
+```bash
+# Using Bun
+bun add @bejibun/redis
+
+# Using Bejibun
+bun ace install @bejibun/redis
+```
+
+### How to Use
+How to use tha package.
+
+```ts
+import Redis from "@bejibun/Redis";
+import {BunRequest} from "bun";
+import BaseController from "@/app/controllers/BaseController";
+
+export default class TestController extends BaseController {
+    public async redis(request: BunRequest): Promise<Response> {
+        await Redis.set("redis", {hello: "world"});
+        const redis = await Redis.get("redis");
+
+        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");
+
+            pipe.get("redis-pipeline-1");
+            pipe.get("redis-pipeline-2");
+        });
+
+        const subscriber = await Redis.subscribe("redis-subscribe", (message: string, channel: string) => {
+            console.log(`[${channel}]: ${message}`);
+        });
+        await Redis.publish("redis-subscribe", "Hai redis subscriber!");
+        setTimeout(async () => {
+            await subscriber.unsubscribe();
+        }, 500);
+
+        return super.response.setData({redis, pipeline}).send();
+    }
+}
+```
+
+## Contributors
+- [Havea Crenata](mailto:havea.crenata@gmail.com)

package/dist/Redis.d.ts

@@ -0,0 +1,14 @@
+import { RedisClient } from "bun";
+export default class Redis {
+    static connection(name: string): Record<string, Function>;
+    static connect(name?: string): Promise<RedisClient>;
+    static disconnect(name?: string): Promise<void>;
+    static get(key: RedisClient.KeyLike, connection?: string): Promise<any>;
+    static set(key: RedisClient.KeyLike, value: any, ttl?: number, connection?: string): Promise<number | "OK">;
+    static del(key: RedisClient.KeyLike, connection?: string): Promise<number>;
+    static publish(channel: string, message: any, connection?: string): Promise<number>;
+    static subscribe(channel: string, listener: RedisClient.StringPubSubListener, connection?: string): Promise<RedisSubscribe>;
+    static pipeline(fn: (pipe: RedisPipeline) => void, connection?: string): 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;
+}

package/dist/Redis.js

@@ -0,0 +1,36 @@
+import RedisBuilder from "./builders/RedisBuilder";
+export default class Redis {
+    static connection(name) {
+        return RedisBuilder.connection(name);
+    }
+    static async connect(name) {
+        return RedisBuilder.connect(name);
+    }
+    static async disconnect(name) {
+        return RedisBuilder.disconnect(name);
+    }
+    static async get(key, connection) {
+        return RedisBuilder.get(key, connection);
+    }
+    static async set(key, value, ttl, connection) {
+        return RedisBuilder.set(key, value, ttl, connection);
+    }
+    static async del(key, connection) {
+        return RedisBuilder.del(key, connection);
+    }
+    static async publish(channel, message, connection) {
+        return RedisBuilder.publish(channel, message, connection);
+    }
+    static async subscribe(channel, listener, connection) {
+        return RedisBuilder.subscribe(channel, listener, connection);
+    }
+    static async pipeline(fn, connection) {
+        return RedisBuilder.pipeline(fn, connection);
+    }
+    static on(event, listener) {
+        return RedisBuilder.on(event, listener);
+    }
+    static off(event, listener) {
+        return RedisBuilder.off(event, listener);
+    }
+}

package/dist/builders/RedisBuilder.d.ts

@@ -0,0 +1,25 @@
+import { RedisClient } from "bun";
+export default class RedisBuilder {
+    private static clients;
+    private static emitter;
+    static connection(name: string): Record<string, Function>;
+    static connect(name?: string): Promise<RedisClient>;
+    static disconnect(name?: string): Promise<void>;
+    static get(key: RedisClient.KeyLike, connection?: string): Promise<any>;
+    static set(key: RedisClient.KeyLike, value: any, ttl?: number, connection?: string): Promise<number | "OK">;
+    static del(key: RedisClient.KeyLike, connection?: string): Promise<number>;
+    static publish(channel: string, message: any, connection?: string): Promise<number>;
+    static subscribe(channel: string, listener: RedisClient.StringPubSubListener, connection?: string): Promise<RedisSubscribe>;
+    static pipeline(fn: (pipe: RedisPipeline) => void, connection?: string): 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 buildUrl;
+    private static createClient;
+    private static getOptions;
+    private static getConfig;
+    private static getClient;
+    private static serialize;
+    private static deserialize;
+    private static ensureExitHooks;
+    private static setupExitHooks;
+}

package/dist/builders/RedisBuilder.js

@@ -0,0 +1,201 @@
+var _a;
+import { defineValue, isEmpty, isNotEmpty } from "@bejibun/core";
+import { RedisClient } from "bun";
+import { EventEmitter } from "events";
+import config from "../config/redis";
+class RedisBuilder {
+    static connection(name) {
+        return {
+            del: (key) => this.del(key, name),
+            get: (key) => this.get(key, name),
+            pipeline: (fn) => this.pipeline(fn, name),
+            publish: (channel, message) => this.publish(channel, message, name),
+            set: (key, value, ttl) => this.set(key, value, ttl, name),
+            subscribe: (channel, listener) => this.subscribe(channel, listener, name),
+        };
+    }
+    static async connect(name) {
+        const client = this.getClient(name);
+        await client.connect();
+        console.log(`[Redis]: Connected manually to "${defineValue(name, "default")}" connection.`);
+        this.emitter.emit("connect", defineValue(name, "default"));
+        return client;
+    }
+    static async disconnect(name) {
+        if (isNotEmpty(name)) {
+            const client = this.clients[name];
+            if (isNotEmpty(client)) {
+                await client.close();
+                delete this.clients[name];
+                console.log(`[Redis]: Disconnected manually from "${name}" connection.`);
+            }
+        }
+        else {
+            for (const [connectionName, client] of Object.entries(this.clients)) {
+                await client.close();
+                console.log(`[Redis]: Disconnected manually from "${connectionName}" connection.`);
+            }
+            this.clients = {};
+        }
+    }
+    static async get(key, connection) {
+        const response = await this.getClient(connection).get(key);
+        return this.deserialize(response);
+    }
+    static async set(key, value, ttl, connection) {
+        const client = this.getClient(connection);
+        const serialized = this.serialize(value);
+        if (ttl)
+            return await client.expire(key, ttl);
+        return await client.set(key, serialized);
+    }
+    static async del(key, connection) {
+        return await this.getClient(connection).del(key);
+    }
+    static async publish(channel, message, connection) {
+        const serialized = this.serialize(message);
+        return await this.getClient(connection).publish(channel, serialized);
+    }
+    static async subscribe(channel, listener, connection) {
+        const cfg = this.getConfig(connection);
+        const client = this.createClient(config.default, cfg);
+        this.clients[channel] = client;
+        await client.subscribe(channel, (message, channel) => listener(this.deserialize(message), channel));
+        console.log(`[Redis]: Subscribed to "${channel}" channel.`);
+        const unsubscribe = async () => {
+            await client.unsubscribe(channel);
+            console.log(`[Redis]: Unsubscribed from "${channel}" channel.`);
+            await client.close();
+            return true;
+        };
+        return {
+            client,
+            unsubscribe: unsubscribe
+        };
+    }
+    static async pipeline(fn, connection) {
+        const client = this.getClient(connection);
+        const ops = [];
+        const pipe = {
+            del: (key) => {
+                ops.push(client.del(key));
+            },
+            get: (key) => {
+                ops.push(client.get(key));
+            },
+            set: (key, value, ttl) => {
+                const serialized = this.serialize(value);
+                if (isNotEmpty(ttl))
+                    ops.push(client.expire(key, ttl));
+                ops.push(client.set(key, serialized));
+            }
+        };
+        fn(pipe);
+        const results = await Promise.all(ops);
+        return results.map((result) => this.deserialize(result));
+    }
+    static on(event, listener) {
+        this.emitter.on(event, listener);
+    }
+    static off(event, listener) {
+        this.emitter.off(event, listener);
+    }
+    static buildUrl(cfg) {
+        const url = new URL(`redis://${cfg.host}:${cfg.port}`);
+        if (isNotEmpty(cfg.password))
+            url.password = cfg.password;
+        if (isNotEmpty(cfg.database))
+            url.pathname = `/${cfg.database}`;
+        return url.toString();
+    }
+    static createClient(name, cfg) {
+        const url = this.buildUrl(cfg);
+        const client = new RedisClient(url, this.getOptions(cfg));
+        client.onconnect = () => {
+            console.log(`[Redis]: Connected to "${name}" connection.`);
+            this.emitter.emit("connect", name);
+        };
+        client.onclose = (error) => {
+            console.warn(`[Redis]: Disconnected from "${name}" connection.`, error.message);
+            this.emitter.emit("disconnect", name, error);
+        };
+        return client;
+    }
+    static getOptions(cfg) {
+        return {
+            autoReconnect: true,
+            maxRetries: cfg.maxRetries
+        };
+    }
+    static getConfig(name) {
+        const connectionName = defineValue(name, config.default);
+        const connection = config.connections[connectionName];
+        if (isEmpty(connection))
+            throw new RedisException(`[Redis]: Connection "${connectionName}" not found.`);
+        return connection;
+    }
+    static getClient(name) {
+        const connectionName = defineValue(name, config.default);
+        this.ensureExitHooks();
+        if (isEmpty(this.clients[connectionName])) {
+            const cfg = this.getConfig(connectionName);
+            this.clients[connectionName] = this.createClient(connectionName, cfg);
+        }
+        return this.clients[connectionName];
+    }
+    static serialize(value) {
+        if (isEmpty(value))
+            return "";
+        if (typeof value === "object")
+            return JSON.stringify(value);
+        if (typeof value === "number" || typeof value === "boolean")
+            return String(value);
+        return value;
+    }
+    static deserialize(value) {
+        if (isEmpty(value))
+            return null;
+        try {
+            return JSON.parse(value);
+        }
+        catch (error) {
+            return value;
+        }
+    }
+    static ensureExitHooks() {
+        this.setupExitHooks();
+    }
+}
+_a = RedisBuilder;
+RedisBuilder.clients = {};
+RedisBuilder.emitter = new EventEmitter();
+RedisBuilder.setupExitHooks = (() => {
+    let initialized = false;
+    return () => {
+        if (initialized)
+            return;
+        initialized = true;
+        const handleExit = async (signal) => {
+            try {
+                await _a.disconnect();
+                console.log(`[Redis]: Disconnected on "${defineValue(signal, "exit")}".`);
+            }
+            catch (error) {
+                console.error("[Redis]: Error during disconnect.", error.message);
+            }
+            finally {
+                process.exit(0);
+            }
+        };
+        process.on("exit", async () => {
+            await handleExit();
+        });
+        process.on("SIGINT", async () => {
+            await handleExit("SIGINT");
+        });
+        process.on("SIGTERM", async () => {
+            await handleExit("SIGTERM");
+        });
+    };
+})();
+export default RedisBuilder;

package/dist/config/redis.d.ts

@@ -0,0 +1,2 @@
+declare const config: Record<string, any>;
+export default config;

package/dist/config/redis.js

@@ -0,0 +1,13 @@
+const config = {
+    default: process.env.REDIS_CONNECTION,
+    connections: {
+        local: {
+            host: process.env.REDIS_HOST,
+            port: process.env.REDIS_PORT,
+            password: process.env.REDIS_PASSWORD,
+            database: process.env.REDIS_DATABASE,
+            maxRetries: Number(process.env.REDIS_MAX_RETRIES)
+        }
+    }
+};
+export default config;

package/dist/exceptions/RedisException.d.ts

@@ -0,0 +1,4 @@
+export default class RedisException extends Error {
+    code: number;
+    constructor(message?: string, code?: number);
+}

package/dist/exceptions/RedisException.js

@@ -0,0 +1,11 @@
+import { defineValue } from "@bejibun/core";
+export default class RedisException extends Error {
+    constructor(message, code) {
+        super(message);
+        this.name = "RedisException";
+        this.code = defineValue(code, 503);
+        if (Error.captureStackTrace) {
+            Error.captureStackTrace(this, RedisException);
+        }
+    }
+}

package/package.json

@@ -0,0 +1,51 @@
+{
+    "name": "@bejibun/redis",
+    "version": "0.1.0",
+    "description": "Redis for Bejibun Framework",
+    "keywords": [
+        "bun",
+        "bun framework",
+        "redis",
+        "bejibun",
+        "typescript"
+    ],
+    "homepage": "https://github.com/crenata/bejibun-redis#readme",
+    "bugs": {
+        "url": "https://github.com/crenata/bejibun-redis/issues"
+    },
+    "repository": {
+        "type": "git",
+        "url": "git+https://github.com/crenata/bejibun-redis.git"
+    },
+    "license": "MIT",
+    "author": "Havea Crenata <havea.crenata@gmail.com>",
+    "type": "module",
+    "main": "./dist/index.js",
+    "module": "./dist/index.js",
+    "types": "./dist/index.d.ts",
+    "exports": {
+        ".": {
+            "import": "./dist/index.js",
+            "types": "./dist/index.d.ts"
+        },
+        "./*": "./dist/*"
+    },
+    "files": [
+        "dist"
+    ],
+    "scripts": {
+        "clean": "rm -rf dist",
+        "build": "bun run clean && tsc -p tsconfig.json && tsc-alias -p tsconfig.json"
+    },
+    "dependencies": {
+        "@bejibun/core": "^0.1.18"
+    },
+    "devDependencies": {
+        "@types/bun": "latest",
+        "tsc-alias": "^1.8.16",
+        "typescript": "^5.9.3"
+    },
+    "peerDependencies": {
+        "typescript": "^5"
+    }
+}