@bejibun/cache 0.1.13 → 0.1.15

package/CHANGELOG.md

@@ -3,10 +3,53 @@ All notable changes to this project will be documented in this file.
 
 ---
 
-## [v0.1.13](https://github.com/crenata/bejibun-cache/compare/v0.1.12...v0.1.13) - 2025-12-12
+## [v0.1.15](https://github.com/crenata/bejibun-cache/compare/v0.1.14...v0.1.15) - 2025-12-14
 
 ### 🩹 Fixes
 
+### 📖 Changes
+What's New :
+- Added `connection()` to override cache connection.
+
+Makes it more flexible by overriding connections at runtime.
+
+- Added `driver` configuration.
+
+#### What's its use?
+The cache connection name is no longer static as before.
+
+e.g. :
+```text
+connections: {
+    local: {
+        path: App.Path.storagePath("cache") // absolute path
+    }
+}
+```
+
+You can now create a connection with any name and specify which driver to use.
+
+```text
+connections: {
+    custom_name: {
+        driver: CacheDriverEnum.Local, // "local", "redis"
+        path: App.Path.storagePath("custom-cache")
+    }
+}
+```
+
+### ❤️Contributors
+- Havea Crenata ([@crenata](https://github.com/crenata))
+
+**Full Changelog**: https://github.com/crenata/bejibun-cache/blob/master/CHANGELOG.md
+
+---
+
+## [v0.1.14](https://github.com/crenata/bejibun-cache/compare/v0.1.12...v0.1.14) - 2025-12-12
+
+### 🩹 Fixes
+- Redis connection with Cache own configuration - [#1](https://github.com/crenata/bejibun-core/issues/1)
+
 ### 📖 Changes
 What's New :
 - Adding `ttl` supports for file scheme.

package/README.md

@@ -39,17 +39,20 @@ config/cache.ts
 
 ```ts
 import App from "@bejibun/app";
+import CacheDriverEnum from "@bejibun/utils/enums/CacheDriverEnum";
 
 const config: Record<string, any> = {
     connection: "local",
 
     connections: {
         local: {
+            driver: CacheDriverEnum.Local,
             path: App.Path.storagePath("cache") // absolute path
         },
 
         redis: {
-            host: "127.0.0.100",
+            driver: CacheDriverEnum.Redis,
+            host: "127.0.0.1",
             port: 6379,
             password: "",
             database: 0

package/builders/CacheBuilder.d.ts

@@ -1,14 +1,18 @@
 export default class CacheBuilder {
     protected conf: Record<string, any>;
+    protected conn?: string;
     protected prefix: string;
+    protected redis: Record<string, Function>;
     constructor();
     private get config();
+    private get currentConnection();
+    private get driver();
     private key;
-    private connection;
     private filePath;
     private file;
     private setFile;
     private getFile;
+    connection(conn: string): CacheBuilder;
     remember(key: string, callback: Function, ttl?: number): Promise<any>;
     has(key: string): Promise<boolean>;
     get(key: string): Promise<any>;

package/builders/CacheBuilder.js

@@ -3,13 +3,17 @@ import Logger from "@bejibun/logger";
 import Redis from "@bejibun/redis";
 import Luxon from "@bejibun/utils/facades/Luxon";
 import { defineValue, isEmpty, isNotEmpty } from "@bejibun/utils";
+import Enum from "@bejibun/utils/facades/Enum";
 import fs from "fs";
 import path from "path";
 import CacheConfig from "../config/cache";
 import CacheException from "../exceptions/CacheException";
+import CacheDriverEnum from "../enums/CacheDriverEnum";
 export default class CacheBuilder {
     conf;
+    conn;
     prefix;
+    redis;
     constructor() {
         const configPath = App.Path.configPath("cache.ts");
         let config;
@@ -17,31 +21,56 @@ export default class CacheBuilder {
             config = require(configPath).default;
         else
             config = CacheConfig;
+        const redisConnection = defineValue(config.connections?.redis, {
+            host: "127.0.0.1",
+            port: 6379,
+            password: "",
+            database: 0
+        });
         this.conf = config;
         this.prefix = "bejibun-cache";
+        this.redis = Redis.setClient({
+            host: redisConnection.host,
+            port: redisConnection.port,
+            password: redisConnection.password,
+            database: redisConnection.database
+        });
     }
     get config() {
         if (isEmpty(this.conf))
             throw new CacheException("There is no config provided.");
         return this.conf;
     }
-    key(key) {
-        const defaultKey = `${this.prefix}-${key.replaceAll("/", "-").replaceAll(" ", "-")}`;
-        return defaultKey;
-        /*if (forceDefault) return defaultKey;
-
-        switch (this.config.connection) {
+    get currentConnection() {
+        return this.config.connections[defineValue(this.conn, this.config.connection)];
+    }
+    get driver() {
+        const driver = defineValue(this.currentConnection?.driver);
+        if (isEmpty(driver))
+            throw new CacheException(`Missing "driver" on cache config.`);
+        if (!Enum.setEnums(CacheDriverEnum).hasValue(driver))
+            throw new CacheException(`Not supported "driver" cache.`);
+        switch (driver) {
             case "local":
-                return `${Luxon.DateTime.now().toUnixInteger()}-${defaultKey}`;
+                if (isEmpty(this.currentConnection?.path))
+                    throw new CacheException(`Missing "path" for "local" cache configuration.`);
+                break;
+            case "redis":
+                if (isEmpty(this.currentConnection?.host))
+                    throw new CacheException(`Missing "host" for "redis" cache configuration.`);
+                if (isEmpty(this.currentConnection?.port))
+                    throw new CacheException(`Missing "port" for "redis" cache configuration.`);
+                break;
             default:
-                return defaultKey;
-        }*/
+                break;
+        }
+        return driver;
     }
-    connection() {
-        return this.config.connections[this.config.connection];
+    key(key) {
+        return `${this.prefix}-${key.replaceAll("/", "-").replaceAll(" ", "-")}`;
     }
     filePath(key) {
-        return path.resolve(this.connection().path, `${this.key(key)}.cache`);
+        return path.resolve(this.currentConnection.path, `${this.key(key)}.cache`);
     }
     file(key) {
         return Bun.file(this.filePath(key));
@@ -50,7 +79,7 @@ export default class CacheBuilder {
         ttl = defineValue(ttl, "");
         if (isNotEmpty(ttl))
             ttl = Luxon.DateTime.now().toUnixInteger() + ttl;
-        await fs.promises.mkdir(this.connection().path, { recursive: true });
+        await fs.promises.mkdir(this.currentConnection.path, { recursive: true });
         return await Bun.write(this.filePath(key), `${ttl}|${data}`);
     }
     async getFile(key) {
@@ -74,9 +103,13 @@ export default class CacheBuilder {
         }
         return metadata;
     }
+    connection(conn) {
+        this.conn = conn;
+        return this;
+    }
     async remember(key, callback, ttl) {
         let data;
-        switch (this.config.connection) {
+        switch (this.driver) {
             case "local":
                 const raw = await this.getFile(key);
                 data = raw.data;
@@ -86,10 +119,10 @@ export default class CacheBuilder {
                 }
                 break;
             case "redis":
-                data = await Redis.get(this.key(key));
+                data = await this.redis.get(this.key(key));
                 if (isEmpty(data)) {
                     data = callback();
-                    await Redis.set(this.key(key), data, ttl);
+                    await this.redis.set(this.key(key), data, ttl);
                 }
                 break;
             default:
@@ -100,13 +133,13 @@ export default class CacheBuilder {
     }
     async has(key) {
         let data;
-        switch (this.config.connection) {
+        switch (this.driver) {
             case "local":
                 const raw = await this.getFile(key);
                 data = raw.data;
                 break;
             case "redis":
-                data = await Redis.get(this.key(key));
+                data = await this.redis.get(this.key(key));
                 break;
             default:
                 data = false;
@@ -116,13 +149,13 @@ export default class CacheBuilder {
     }
     async get(key) {
         let data;
-        switch (this.config.connection) {
+        switch (this.driver) {
             case "local":
                 const raw = await this.getFile(key);
                 data = raw.data;
                 break;
             case "redis":
-                data = await Redis.get(this.key(key));
+                data = await this.redis.get(this.key(key));
                 break;
             default:
                 data = false;
@@ -134,25 +167,25 @@ export default class CacheBuilder {
         let status = true;
         let data;
         try {
-            switch (this.config.connection) {
+            switch (this.driver) {
                 case "local":
                     const raw = await this.getFile(key);
                     data = raw.data;
                     break;
                 case "redis":
-                    data = await Redis.get(this.key(key));
+                    data = await this.redis.get(this.key(key));
                     break;
                 default:
                     data = null;
                     break;
             }
             if (isEmpty(data)) {
-                switch (this.config.connection) {
+                switch (this.driver) {
                     case "local":
                         await this.setFile(key, value, ttl);
                         break;
                     case "redis":
-                        await Redis.set(this.key(key), value, ttl);
+                        await this.redis.set(this.key(key), value, ttl);
                         break;
                     default:
                         break;
@@ -172,12 +205,12 @@ export default class CacheBuilder {
     async put(key, value, ttl) {
         let status = true;
         try {
-            switch (this.config.connection) {
+            switch (this.driver) {
                 case "local":
                     await this.setFile(key, value, ttl);
                     break;
                 case "redis":
-                    await Redis.set(this.key(key), value, ttl);
+                    await this.redis.set(this.key(key), value, ttl);
                     break;
                 default:
                     break;
@@ -190,7 +223,7 @@ export default class CacheBuilder {
         return status;
     }
     async forget(key) {
-        switch (this.config.connection) {
+        switch (this.driver) {
             case "local":
                 try {
                     await this.file(key).delete();
@@ -200,7 +233,7 @@ export default class CacheBuilder {
                 }
                 break;
             case "redis":
-                await Redis.del(this.key(key));
+                await this.redis.del(this.key(key));
                 break;
             default:
                 break;
@@ -208,7 +241,7 @@ export default class CacheBuilder {
     }
     async increment(key, ttl) {
         let data;
-        switch (this.config.connection) {
+        switch (this.driver) {
             case "local":
                 const raw = await this.getFile(key);
                 data = Number(raw.data);
@@ -222,14 +255,14 @@ export default class CacheBuilder {
                 }
                 break;
             case "redis":
-                data = Number(await Redis.get(this.key(key)));
+                data = Number(await this.redis.get(this.key(key)));
                 if (isEmpty(data)) {
                     data = 1;
-                    await Redis.set(this.key(key), data, ttl);
+                    await this.redis.set(this.key(key), data, ttl);
                 }
                 else {
                     data++;
-                    await Redis.set(this.key(key), data, ttl);
+                    await this.redis.set(this.key(key), data, ttl);
                 }
                 break;
             default:
@@ -240,7 +273,7 @@ export default class CacheBuilder {
     }
     async decrement(key, ttl) {
         let data;
-        switch (this.config.connection) {
+        switch (this.driver) {
             case "local":
                 const raw = await this.getFile(key);
                 data = Number(raw.data);
@@ -254,14 +287,14 @@ export default class CacheBuilder {
                 }
                 break;
             case "redis":
-                data = Number(await Redis.get(this.key(key)));
+                data = Number(await this.redis.get(this.key(key)));
                 if (isEmpty(data)) {
                     data = -1;
-                    await Redis.set(this.key(key), data, ttl);
+                    await this.redis.set(this.key(key), data, ttl);
                 }
                 else {
                     data--;
-                    await Redis.set(this.key(key), data, ttl);
+                    await this.redis.set(this.key(key), data, ttl);
                 }
                 break;
             default:

package/config/cache.js

@@ -1,12 +1,15 @@
 import App from "@bejibun/app";
+import CacheDriverEnum from "../enums/CacheDriverEnum";
 const config = {
     connection: "local",
     connections: {
         local: {
+            driver: CacheDriverEnum.Local,
             path: App.Path.storagePath("cache") // absolute path
         },
         redis: {
-            host: "127.0.0.100",
+            driver: CacheDriverEnum.Redis,
+            host: "127.0.0.1",
             port: 6379,
             password: "",
             database: 0

package/enums/CacheDriverEnum.d.ts

@@ -0,0 +1,5 @@
+declare enum CacheDriverEnum {
+    Local = "local",
+    Redis = "redis"
+}
+export default CacheDriverEnum;

package/enums/CacheDriverEnum.js

@@ -0,0 +1,6 @@
+var CacheDriverEnum;
+(function (CacheDriverEnum) {
+    CacheDriverEnum["Local"] = "local";
+    CacheDriverEnum["Redis"] = "redis";
+})(CacheDriverEnum || (CacheDriverEnum = {}));
+export default CacheDriverEnum;

package/enums/index.d.ts

@@ -0,0 +1 @@
+export * from "../enums/CacheDriverEnum";

package/enums/index.js

@@ -0,0 +1 @@
+export * from "../enums/CacheDriverEnum";

package/facades/Cache.d.ts

@@ -1,4 +1,6 @@
+import CacheBuilder from "../builders/CacheBuilder";
 export default class Cache {
+    static connection(connection: string): CacheBuilder;
     static remember(key: string, callback: Function, ttl?: number): Promise<any>;
     static has(key: string): Promise<boolean>;
     static get(key: string): Promise<any>;

package/facades/Cache.js

@@ -1,5 +1,8 @@
 import CacheBuilder from "../builders/CacheBuilder";
 export default class Cache {
+    static connection(connection) {
+        return new CacheBuilder().connection(connection);
+    }
     static async remember(key, callback, ttl) {
         return new CacheBuilder().remember(key, callback, ttl);
     }

package/index.d.ts

@@ -1,2 +1,3 @@
 export { default } from "./facades/Cache";
+export * from "./enums/index";
 export * from "./facades/index";

package/index.js

@@ -1,2 +1,3 @@
 export { default } from "./facades/Cache";
+export * from "./enums/index";
 export * from "./facades/index";

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@bejibun/cache",
-    "version": "0.1.13",
+    "version": "0.1.15",
     "author": "Havea Crenata <havea.crenata@gmail.com>",
     "repository": {
         "type": "git",
@@ -29,7 +29,7 @@
         "alias": "bunx tsc-alias -p tsconfig.json",
         "rsync": "rsync -a dist/ ./",
         "clean": "rm -rf dist",
-        "build": "bunx tsc -p tsconfig.json && bun run alias && bun run rsync && bun run clean",
+        "build": "bun run clean && bunx tsc -p tsconfig.json && bun run alias && bun run rsync && bun run clean",
         "deploy": "bun run build && bun publish --access public"
     },
     "type": "module",
@@ -38,6 +38,6 @@
         "@bejibun/app": "^0.1.22",
         "@bejibun/logger": "^0.1.22",
         "@bejibun/redis": "^0.1.36",
-        "@bejibun/utils": "^0.1.27"
+        "@bejibun/utils": "^0.1.28"
     }
 }