honojs-plugin-memory 0.0.0

package/README.md

@@ -0,0 +1,128 @@
+# @honojs-plugins/memory
+
+Cache plugin for HonoJS. Supports two drivers:
+
+- **`memory`** — in-process LRU cache (`lru-cache`)
+- **`redis`** — distributed cache (`ioredis`)
+
+Both drivers implement the same `CacheDriver` interface, so they are interchangeable.
+
+## Install
+
+```bash
+pnpm add @honojs-plugins/memory
+```
+
+## Folder structure
+
+```
+src/
+├── index.ts              # Cache.create() factory + exports
+├── memory/                # MemoryCache driver (lru-cache backed)
+├── redis/                 # RedisCache driver (ioredis backed)
+├── schema/
+│   ├── index.ts            # CacheSchema (driver: 'memory' | 'redis')
+│   ├── memory.ts            # MemorySchema ({ max, ttl })
+│   └── redis.ts             # RedisSchema ({ host, port, password, db, keyPrefix, ttl })
+└── types/
+    └── cache.ts             # CacheDriver interface, CacheType, CacheParams, CacheInstance
+```
+
+## Usage
+
+### 1. In-memory (LRU) cache
+
+```ts
+import Cache, { MemoryCache } from '@honojs-plugins/memory'
+
+const cache = Cache.create({
+  cacheType: 'memory',
+  params: {
+    max: 500,   // max entries
+    ttl: 60,    // default TTL in seconds (optional)
+  },
+}) as MemoryCache
+
+await cache.set('user:1', { id: 1, name: 'Alice' })
+const user = await cache.get('user:1')
+const exists = await cache.has('user:1')
+await cache.del('user:1')
+await cache.clear()
+```
+
+### 2. Redis cache
+
+```ts
+import Cache, { RedisCache } from '@honojs-plugins/memory'
+
+const cache = Cache.create({
+  cacheType: 'redis',
+  params: {
+    host: '127.0.0.1',
+    port: 6379,
+    password: process.env.REDIS_PASSWORD,
+    db: 0,
+    keyPrefix: 'myapp:',
+    ttl: 60, // default TTL in seconds (optional)
+  },
+}) as RedisCache
+
+await cache.set('session:abc', { userId: 1 }, 300) // TTL override, seconds
+const session = await cache.get('session:abc')
+await cache.del('session:abc')
+
+// access underlying ioredis client for advanced usage
+cache.client.ping()
+```
+
+## Example: Hono route with caching
+
+```ts
+import { Hono } from 'hono'
+import Cache, { RedisCache } from '@honojs-plugins/memory'
+
+const app = new Hono()
+
+const cache = Cache.create({
+  cacheType: 'redis',
+  params: { host: '127.0.0.1', port: 6379, ttl: 60 },
+}) as RedisCache
+
+app.get('/users/:id', async (c) => {
+  const id = c.req.param('id')
+  const cacheKey = `user:${id}`
+
+  const cached = await cache.get(cacheKey)
+  if (cached) return c.json(cached)
+
+  const user = await fetchUserFromDb(id) // your own data source
+  await cache.set(cacheKey, user)
+
+  return c.json(user)
+})
+
+export default app
+
+async function fetchUserFromDb(id: string) {
+  return { id, name: 'Alice' }
+}
+```
+
+## API
+
+### `Cache.create({ cacheType, params })`
+
+| `cacheType` | `params` shape |
+|---|---|
+| `'memory'` | `MemoryConfig` — `{ max?: number (default 500), ttl?: number }` |
+| `'redis'` | `RedisConfig` — `{ host?: string (default '127.0.0.1'), port?: number (default 6379), password?, db?, keyPrefix?, ttl? }` |
+
+### `CacheDriver` interface (implemented by both drivers)
+
+| Method | Description |
+|---|---|
+| `get<T>(key)` | Returns the cached value, or `undefined` if missing/expired |
+| `set<T>(key, value, ttl?)` | Stores `value`, optionally overriding the default TTL (seconds) |
+| `has(key)` | Returns `true` if `key` exists |
+| `del(key)` | Removes `key` from the cache |
+| `clear()` | Clears the entire cache (or Redis DB via `flushdb` for `RedisCache`) |

package/dist/index.cjs

@@ -0,0 +1,196 @@
+Object.defineProperties(exports, {
+	__esModule: { value: true },
+	[Symbol.toStringTag]: { value: "Module" }
+});
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+//#endregion
+let lru_cache = require("lru-cache");
+let ioredis = require("ioredis");
+let zod = require("zod");
+zod = __toESM(zod, 1);
+//#region src/memory/index.ts
+var MemoryCache = class {
+	_client;
+	_defaultTtl;
+	constructor(params) {
+		this._defaultTtl = params.ttl;
+		this._client = new lru_cache.LRUCache({
+			max: params.max,
+			ttlAutopurge: false,
+			...params.ttl ? { ttl: params.ttl * 1e3 } : {}
+		});
+	}
+	/**
+	* Get a value from the cache
+	*/
+	async get(key) {
+		return this._client.get(key)?.value;
+	}
+	/**
+	* Set a value in the cache
+	*/
+	async set(key, value, ttl) {
+		const expires = ttl ?? this._defaultTtl;
+		if (expires) {
+			this._client.set(key, { value }, { ttl: expires * 1e3 });
+			return;
+		}
+		this._client.set(key, { value });
+	}
+	/**
+	* Check if a key exists in the cache
+	*/
+	async has(key) {
+		return this._client.has(key);
+	}
+	/**
+	* Delete a value from the cache
+	*/
+	async del(key) {
+		this._client.delete(key);
+	}
+	/**
+	* Clear the cache
+	*/
+	async clear() {
+		this._client.clear();
+	}
+};
+//#endregion
+//#region src/redis/index.ts
+/**
+* Distributed cache backed by Redis
+*/
+var RedisCache = class {
+	client;
+	_defaultTtl;
+	constructor(params) {
+		this._defaultTtl = params.ttl;
+		this.client = new ioredis.Redis({
+			host: params.host,
+			port: params.port,
+			password: params.password,
+			db: params.db,
+			keyPrefix: params.keyPrefix
+		});
+	}
+	/**
+	* Get a value from the cache
+	*/
+	async get(key) {
+		const value = await this.client.get(key);
+		if (value === null) return;
+		return JSON.parse(value);
+	}
+	/**
+	* Set a value in the cache
+	*/
+	async set(key, value, ttl) {
+		const serialized = JSON.stringify(value);
+		const expires = ttl ?? this._defaultTtl;
+		if (expires) {
+			await this.client.set(key, serialized, "EX", expires);
+			return;
+		}
+		await this.client.set(key, serialized);
+	}
+	/**
+	* Check if a key exists in the cache
+	*/
+	async has(key) {
+		return await this.client.exists(key) === 1;
+	}
+	/**
+	* Delete a value from the cache
+	*/
+	async del(key) {
+		await this.client.del(key);
+	}
+	/**
+	* Clear the cache
+	*/
+	async clear() {
+		await this.client.flushdb();
+	}
+};
+//#endregion
+//#region src/schema/index.ts
+const CacheSchema = zod.default.object({ driver: zod.default.enum(["memory", "redis"]) });
+//#endregion
+//#region src/schema/memory.ts
+const MemorySchema = zod.default.object({
+	max: zod.default.number().int().positive().default(500),
+	ttl: zod.default.number().int().positive().optional()
+});
+//#endregion
+//#region src/schema/redis.ts
+const RedisSchema = zod.default.object({
+	host: zod.default.string().default("127.0.0.1"),
+	port: zod.default.number().int().positive().default(6379),
+	password: zod.default.string().optional(),
+	db: zod.default.number().int().nonnegative().optional(),
+	keyPrefix: zod.default.string().optional(),
+	ttl: zod.default.number().int().positive().optional()
+});
+//#endregion
+//#region src/index.ts
+/**
+* Cache service
+*/
+var Cache = class {
+	/**
+	* Create a cache service instance
+	* @param params - Cache parameters
+	* @returns Cache service instance
+	*/
+	static create({ cacheType, params }) {
+		const parsed = CacheSchema.safeParse({ driver: cacheType });
+		if (!parsed.success) {
+			console.log(parsed.error);
+			throw new Error("Invalid cache driver");
+		}
+		switch (parsed.data.driver) {
+			case "memory": {
+				const config = MemorySchema.safeParse(params);
+				if (!config.success) {
+					console.log(config.error);
+					throw new Error("Invalid memory cache configuration");
+				}
+				return new MemoryCache(config.data);
+			}
+			case "redis": {
+				const config = RedisSchema.safeParse(params);
+				if (!config.success) {
+					console.log(config.error);
+					throw new Error("Invalid redis cache configuration");
+				}
+				return new RedisCache(config.data);
+			}
+			default: throw new Error("Invalid cache type");
+		}
+	}
+};
+//#endregion
+exports.MemoryCache = MemoryCache;
+exports.RedisCache = RedisCache;
+exports.default = Cache;

package/dist/index.d.cts

@@ -0,0 +1,107 @@
+import z from "zod";
+import { Redis } from "ioredis";
+//#region src/schema/memory.d.ts
+declare const MemorySchema: z.ZodObject<{
+  max: z.ZodDefault<z.ZodNumber>;
+  ttl: z.ZodOptional<z.ZodNumber>;
+}>;
+type MemoryConfig = z.infer<typeof MemorySchema>;
+//#endregion
+//#region src/memory/index.d.ts
+declare class MemoryCache implements CacheDriver {
+  private _client;
+  private _defaultTtl;
+  constructor(params: MemoryConfig);
+  /**
+   * Get a value from the cache
+   */
+  get<T = unknown>(key: string): Promise<T | undefined>;
+  /**
+   * Set a value in the cache
+   */
+  set<T = unknown>(key: string, value: T, ttl?: number): Promise<void>;
+  /**
+   * Check if a key exists in the cache
+   */
+  has(key: string): Promise<boolean>;
+  /**
+   * Delete a value from the cache
+   */
+  del(key: string): Promise<void>;
+  /**
+   * Clear the cache
+   */
+  clear(): Promise<void>;
+}
+//#endregion
+//#region src/schema/redis.d.ts
+declare const RedisSchema: z.ZodObject<{
+  host: z.ZodDefault<z.ZodString>;
+  port: z.ZodDefault<z.ZodNumber>;
+  password: z.ZodOptional<z.ZodString>;
+  db: z.ZodOptional<z.ZodNumber>;
+  keyPrefix: z.ZodOptional<z.ZodString>;
+  ttl: z.ZodOptional<z.ZodNumber>;
+}>;
+type RedisConfig = z.infer<typeof RedisSchema>;
+//#endregion
+//#region src/redis/index.d.ts
+/**
+ * Distributed cache backed by Redis
+ */
+declare class RedisCache implements CacheDriver {
+  client: Redis;
+  private _defaultTtl;
+  constructor(params: RedisConfig);
+  /**
+   * Get a value from the cache
+   */
+  get<T = unknown>(key: string): Promise<T | undefined>;
+  /**
+   * Set a value in the cache
+   */
+  set<T = unknown>(key: string, value: T, ttl?: number): Promise<void>;
+  /**
+   * Check if a key exists in the cache
+   */
+  has(key: string): Promise<boolean>;
+  /**
+   * Delete a value from the cache
+   */
+  del(key: string): Promise<void>;
+  /**
+   * Clear the cache
+   */
+  clear(): Promise<void>;
+}
+//#endregion
+//#region src/types/cache.d.ts
+type CacheType = "memory" | "redis";
+type CacheParams = {
+  cacheType: CacheType;
+  params: MemoryConfig | RedisConfig;
+};
+type CacheInstance = MemoryCache | RedisCache;
+interface CacheDriver {
+  get<T = unknown>(key: string): Promise<T | undefined>;
+  set<T = unknown>(key: string, value: T, ttl?: number): Promise<void>;
+  has(key: string): Promise<boolean>;
+  del(key: string): Promise<void>;
+  clear(): Promise<void>;
+}
+//#endregion
+//#region src/index.d.ts
+/**
+ * Cache service
+ */
+declare class Cache {
+  /**
+   * Create a cache service instance
+   * @param params - Cache parameters
+   * @returns Cache service instance
+   */
+  static create({ cacheType, params }: CacheParams): CacheInstance;
+}
+//#endregion
+export { type CacheDriver, type CacheInstance, type CacheParams, type CacheType, MemoryCache, RedisCache, Cache as default };
+//# sourceMappingURL=index.d.cts.map

package/dist/index.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.cts","names":[],"sources":["../src/schema/memory.ts","../src/memory/index.ts","../src/schema/redis.ts","../src/redis/index.ts","../src/types/cache.ts","../src/index.ts"],"mappings":";;;cAEa,cAAc,EAAE;EAC3B,KAAK,EAAE,WAAW,EAAE;EACpB,KAAK,EAAE,YAAY,EAAE;;KAMX,eAAe,EAAE,aAAa;;;cCDrB,uBAAuB;UAClC;UACA;EAER,YAAY,QAAQ;;;;EAapB,IAAU,aAAa,cAAc,QAAQ;;;;EAQ7C,IAAU,aAAa,aAAa,OAAO,GAAG,eAAe;;;;EAc7D,IAAU,cAAc;;;;EAOxB,IAAU,cAAc;;;;EAOxB,SAAe;;;;cC5DJ,aAAa,EAAE;EAC1B,MAAM,EAAE,WAAW,EAAE;EACrB,MAAM,EAAE,WAAW,EAAE;EACrB,UAAU,EAAE,YAAY,EAAE;EAC1B,IAAI,EAAE,YAAY,EAAE;EACpB,WAAW,EAAE,YAAY,EAAE;EAC3B,KAAK,EAAE,YAAY,EAAE;;KAUX,cAAc,EAAE,aAAa;;;;;;cCXpB,sBAAsB;EACzC,QAAe;UACP;EAER,YAAY,QAAQ;;;;EAepB,IAAU,aAAa,cAAc,QAAQ;;;;EAY7C,IAAU,aAAa,aAAa,OAAO,GAAG,eAAe;;;;EAe7D,IAAU,cAAc;;;;EAQxB,IAAU,cAAc;;;;EAOxB,SAAe;;;;KC/DL;KAEA;EACV,WAAW;EACX,QAAQ,eAAe;;KAGb,gBAAgB,cAAc;UAEzB;EACf,IAAI,aAAa,cAAc,QAAQ;EACvC,IAAI,aAAa,aAAa,OAAO,GAAG,eAAe;EACvD,IAAI,cAAc;EAClB,IAAI,cAAc;EAClB,SAAS;;;;;;;cCTU;;;;;;SAMZ,SAAS,WAAW,UAAU,cAAc"}

package/dist/index.d.mts

@@ -0,0 +1,107 @@
+import { Redis } from "ioredis";
+import z from "zod";
+//#region src/schema/memory.d.ts
+declare const MemorySchema: z.ZodObject<{
+  max: z.ZodDefault<z.ZodNumber>;
+  ttl: z.ZodOptional<z.ZodNumber>;
+}>;
+type MemoryConfig = z.infer<typeof MemorySchema>;
+//#endregion
+//#region src/memory/index.d.ts
+declare class MemoryCache implements CacheDriver {
+  private _client;
+  private _defaultTtl;
+  constructor(params: MemoryConfig);
+  /**
+   * Get a value from the cache
+   */
+  get<T = unknown>(key: string): Promise<T | undefined>;
+  /**
+   * Set a value in the cache
+   */
+  set<T = unknown>(key: string, value: T, ttl?: number): Promise<void>;
+  /**
+   * Check if a key exists in the cache
+   */
+  has(key: string): Promise<boolean>;
+  /**
+   * Delete a value from the cache
+   */
+  del(key: string): Promise<void>;
+  /**
+   * Clear the cache
+   */
+  clear(): Promise<void>;
+}
+//#endregion
+//#region src/schema/redis.d.ts
+declare const RedisSchema: z.ZodObject<{
+  host: z.ZodDefault<z.ZodString>;
+  port: z.ZodDefault<z.ZodNumber>;
+  password: z.ZodOptional<z.ZodString>;
+  db: z.ZodOptional<z.ZodNumber>;
+  keyPrefix: z.ZodOptional<z.ZodString>;
+  ttl: z.ZodOptional<z.ZodNumber>;
+}>;
+type RedisConfig = z.infer<typeof RedisSchema>;
+//#endregion
+//#region src/redis/index.d.ts
+/**
+ * Distributed cache backed by Redis
+ */
+declare class RedisCache implements CacheDriver {
+  client: Redis;
+  private _defaultTtl;
+  constructor(params: RedisConfig);
+  /**
+   * Get a value from the cache
+   */
+  get<T = unknown>(key: string): Promise<T | undefined>;
+  /**
+   * Set a value in the cache
+   */
+  set<T = unknown>(key: string, value: T, ttl?: number): Promise<void>;
+  /**
+   * Check if a key exists in the cache
+   */
+  has(key: string): Promise<boolean>;
+  /**
+   * Delete a value from the cache
+   */
+  del(key: string): Promise<void>;
+  /**
+   * Clear the cache
+   */
+  clear(): Promise<void>;
+}
+//#endregion
+//#region src/types/cache.d.ts
+type CacheType = "memory" | "redis";
+type CacheParams = {
+  cacheType: CacheType;
+  params: MemoryConfig | RedisConfig;
+};
+type CacheInstance = MemoryCache | RedisCache;
+interface CacheDriver {
+  get<T = unknown>(key: string): Promise<T | undefined>;
+  set<T = unknown>(key: string, value: T, ttl?: number): Promise<void>;
+  has(key: string): Promise<boolean>;
+  del(key: string): Promise<void>;
+  clear(): Promise<void>;
+}
+//#endregion
+//#region src/index.d.ts
+/**
+ * Cache service
+ */
+declare class Cache {
+  /**
+   * Create a cache service instance
+   * @param params - Cache parameters
+   * @returns Cache service instance
+   */
+  static create({ cacheType, params }: CacheParams): CacheInstance;
+}
+//#endregion
+export { type CacheDriver, type CacheInstance, type CacheParams, type CacheType, MemoryCache, RedisCache, Cache as default };
+//# sourceMappingURL=index.d.mts.map

package/dist/index.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.mts","names":[],"sources":["../src/schema/memory.ts","../src/memory/index.ts","../src/schema/redis.ts","../src/redis/index.ts","../src/types/cache.ts","../src/index.ts"],"mappings":";;;cAEa,cAAc,EAAE;EAC3B,KAAK,EAAE,WAAW,EAAE;EACpB,KAAK,EAAE,YAAY,EAAE;;KAMX,eAAe,EAAE,aAAa;;;cCDrB,uBAAuB;UAClC;UACA;EAER,YAAY,QAAQ;;;;EAapB,IAAU,aAAa,cAAc,QAAQ;;;;EAQ7C,IAAU,aAAa,aAAa,OAAO,GAAG,eAAe;;;;EAc7D,IAAU,cAAc;;;;EAOxB,IAAU,cAAc;;;;EAOxB,SAAe;;;;cC5DJ,aAAa,EAAE;EAC1B,MAAM,EAAE,WAAW,EAAE;EACrB,MAAM,EAAE,WAAW,EAAE;EACrB,UAAU,EAAE,YAAY,EAAE;EAC1B,IAAI,EAAE,YAAY,EAAE;EACpB,WAAW,EAAE,YAAY,EAAE;EAC3B,KAAK,EAAE,YAAY,EAAE;;KAUX,cAAc,EAAE,aAAa;;;;;;cCXpB,sBAAsB;EACzC,QAAe;UACP;EAER,YAAY,QAAQ;;;;EAepB,IAAU,aAAa,cAAc,QAAQ;;;;EAY7C,IAAU,aAAa,aAAa,OAAO,GAAG,eAAe;;;;EAe7D,IAAU,cAAc;;;;EAQxB,IAAU,cAAc;;;;EAOxB,SAAe;;;;KC/DL;KAEA;EACV,WAAW;EACX,QAAQ,eAAe;;KAGb,gBAAgB,cAAc;UAEzB;EACf,IAAI,aAAa,cAAc,QAAQ;EACvC,IAAI,aAAa,aAAa,OAAO,GAAG,eAAe;EACvD,IAAI,cAAc;EAClB,IAAI,cAAc;EAClB,SAAS;;;;;;;cCTU;;;;;;SAMZ,SAAS,WAAW,UAAU,cAAc"}

package/dist/index.mjs

@@ -0,0 +1,169 @@
+import { LRUCache } from "lru-cache";
+import { Redis } from "ioredis";
+import z from "zod";
+//#region src/memory/index.ts
+var MemoryCache = class {
+	_client;
+	_defaultTtl;
+	constructor(params) {
+		this._defaultTtl = params.ttl;
+		this._client = new LRUCache({
+			max: params.max,
+			ttlAutopurge: false,
+			...params.ttl ? { ttl: params.ttl * 1e3 } : {}
+		});
+	}
+	/**
+	* Get a value from the cache
+	*/
+	async get(key) {
+		return this._client.get(key)?.value;
+	}
+	/**
+	* Set a value in the cache
+	*/
+	async set(key, value, ttl) {
+		const expires = ttl ?? this._defaultTtl;
+		if (expires) {
+			this._client.set(key, { value }, { ttl: expires * 1e3 });
+			return;
+		}
+		this._client.set(key, { value });
+	}
+	/**
+	* Check if a key exists in the cache
+	*/
+	async has(key) {
+		return this._client.has(key);
+	}
+	/**
+	* Delete a value from the cache
+	*/
+	async del(key) {
+		this._client.delete(key);
+	}
+	/**
+	* Clear the cache
+	*/
+	async clear() {
+		this._client.clear();
+	}
+};
+//#endregion
+//#region src/redis/index.ts
+/**
+* Distributed cache backed by Redis
+*/
+var RedisCache = class {
+	client;
+	_defaultTtl;
+	constructor(params) {
+		this._defaultTtl = params.ttl;
+		this.client = new Redis({
+			host: params.host,
+			port: params.port,
+			password: params.password,
+			db: params.db,
+			keyPrefix: params.keyPrefix
+		});
+	}
+	/**
+	* Get a value from the cache
+	*/
+	async get(key) {
+		const value = await this.client.get(key);
+		if (value === null) return;
+		return JSON.parse(value);
+	}
+	/**
+	* Set a value in the cache
+	*/
+	async set(key, value, ttl) {
+		const serialized = JSON.stringify(value);
+		const expires = ttl ?? this._defaultTtl;
+		if (expires) {
+			await this.client.set(key, serialized, "EX", expires);
+			return;
+		}
+		await this.client.set(key, serialized);
+	}
+	/**
+	* Check if a key exists in the cache
+	*/
+	async has(key) {
+		return await this.client.exists(key) === 1;
+	}
+	/**
+	* Delete a value from the cache
+	*/
+	async del(key) {
+		await this.client.del(key);
+	}
+	/**
+	* Clear the cache
+	*/
+	async clear() {
+		await this.client.flushdb();
+	}
+};
+//#endregion
+//#region src/schema/index.ts
+const CacheSchema = z.object({ driver: z.enum(["memory", "redis"]) });
+//#endregion
+//#region src/schema/memory.ts
+const MemorySchema = z.object({
+	max: z.number().int().positive().default(500),
+	ttl: z.number().int().positive().optional()
+});
+//#endregion
+//#region src/schema/redis.ts
+const RedisSchema = z.object({
+	host: z.string().default("127.0.0.1"),
+	port: z.number().int().positive().default(6379),
+	password: z.string().optional(),
+	db: z.number().int().nonnegative().optional(),
+	keyPrefix: z.string().optional(),
+	ttl: z.number().int().positive().optional()
+});
+//#endregion
+//#region src/index.ts
+/**
+* Cache service
+*/
+var Cache = class {
+	/**
+	* Create a cache service instance
+	* @param params - Cache parameters
+	* @returns Cache service instance
+	*/
+	static create({ cacheType, params }) {
+		const parsed = CacheSchema.safeParse({ driver: cacheType });
+		if (!parsed.success) {
+			console.log(parsed.error);
+			throw new Error("Invalid cache driver");
+		}
+		switch (parsed.data.driver) {
+			case "memory": {
+				const config = MemorySchema.safeParse(params);
+				if (!config.success) {
+					console.log(config.error);
+					throw new Error("Invalid memory cache configuration");
+				}
+				return new MemoryCache(config.data);
+			}
+			case "redis": {
+				const config = RedisSchema.safeParse(params);
+				if (!config.success) {
+					console.log(config.error);
+					throw new Error("Invalid redis cache configuration");
+				}
+				return new RedisCache(config.data);
+			}
+			default: throw new Error("Invalid cache type");
+		}
+	}
+};
+//#endregion
+export { MemoryCache, RedisCache, Cache as default };
+
+//# sourceMappingURL=index.mjs.map

package/dist/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","names":[],"sources":["../src/memory/index.ts","../src/redis/index.ts","../src/schema/index.ts","../src/schema/memory.ts","../src/schema/redis.ts","../src/index.ts"],"sourcesContent":["import { LRUCache } from 'lru-cache'\nimport { MemoryConfig } from '../schema/memory'\nimport { CacheDriver } from '../types/cache'\n\n/**\n * In-process memory cache backed by lru-cache\n */\ntype CacheEntry = { value: unknown }\n\nexport default class MemoryCache implements CacheDriver {\n  private _client: LRUCache<string, CacheEntry>\n  private _defaultTtl: number | undefined\n\n  constructor(params: MemoryConfig) {\n    this._defaultTtl = params.ttl\n\n    this._client = new LRUCache<string, CacheEntry>({\n      max: params.max,\n      ttlAutopurge: false,\n      ...(params.ttl ? { ttl: params.ttl * 1000 } : {}),\n    })\n  }\n\n  /**\n   * Get a value from the cache\n   */\n  async get<T = unknown>(key: string): Promise<T | undefined> {\n    const entry = this._client.get(key)\n    return entry?.value as T | undefined\n  }\n\n  /**\n   * Set a value in the cache\n   */\n  async set<T = unknown>(key: string, value: T, ttl?: number): Promise<void> {\n    const expires = ttl ?? this._defaultTtl\n\n    if (expires) {\n      this._client.set(key, { value }, { ttl: expires * 1000 })\n      return\n    }\n\n    this._client.set(key, { value })\n  }\n\n  /**\n   * Check if a key exists in the cache\n   */\n  async has(key: string): Promise<boolean> {\n    return this._client.has(key)\n  }\n\n  /**\n   * Delete a value from the cache\n   */\n  async del(key: string): Promise<void> {\n    this._client.delete(key)\n  }\n\n  /**\n   * Clear the cache\n   */\n  async clear(): Promise<void> {\n    this._client.clear()\n  }\n}\n","import { Redis } from 'ioredis'\nimport { RedisConfig } from '../schema/redis'\nimport { CacheDriver } from '../types/cache'\n\n/**\n * Distributed cache backed by Redis\n */\nexport default class RedisCache implements CacheDriver {\n  public client: Redis\n  private _defaultTtl: number | undefined\n\n  constructor(params: RedisConfig) {\n    this._defaultTtl = params.ttl\n\n    this.client = new Redis({\n      host: params.host,\n      port: params.port,\n      password: params.password,\n      db: params.db,\n      keyPrefix: params.keyPrefix,\n    })\n  }\n\n  /**\n   * Get a value from the cache\n   */\n  async get<T = unknown>(key: string): Promise<T | undefined> {\n    const value = await this.client.get(key)\n    if (value === null) {\n      return undefined\n    }\n\n    return JSON.parse(value) as T\n  }\n\n  /**\n   * Set a value in the cache\n   */\n  async set<T = unknown>(key: string, value: T, ttl?: number): Promise<void> {\n    const serialized = JSON.stringify(value)\n    const expires = ttl ?? this._defaultTtl\n\n    if (expires) {\n      await this.client.set(key, serialized, 'EX', expires)\n      return\n    }\n\n    await this.client.set(key, serialized)\n  }\n\n  /**\n   * Check if a key exists in the cache\n   */\n  async has(key: string): Promise<boolean> {\n    const exists = await this.client.exists(key)\n    return exists === 1\n  }\n\n  /**\n   * Delete a value from the cache\n   */\n  async del(key: string): Promise<void> {\n    await this.client.del(key)\n  }\n\n  /**\n   * Clear the cache\n   */\n  async clear(): Promise<void> {\n    await this.client.flushdb()\n  }\n}\n","import z from 'zod'\n\nexport const CacheSchema: z.ZodObject<{\n  driver: z.ZodEnum<{\n    memory: 'memory'\n    redis: 'redis'\n  }>\n}> = z.object({\n  driver: z.enum(['memory', 'redis']),\n})\n\nexport type CacheDriverType = z.infer<typeof CacheSchema>['driver']\n","import z from 'zod'\n\nexport const MemorySchema: z.ZodObject<{\n  max: z.ZodDefault<z.ZodNumber>\n  ttl: z.ZodOptional<z.ZodNumber>\n}> = z.object({\n  max: z.number().int().positive().default(500),\n  ttl: z.number().int().positive().optional(),\n})\n\nexport type MemoryConfig = z.infer<typeof MemorySchema>\n","import z from 'zod'\n\nexport const RedisSchema: z.ZodObject<{\n  host: z.ZodDefault<z.ZodString>\n  port: z.ZodDefault<z.ZodNumber>\n  password: z.ZodOptional<z.ZodString>\n  db: z.ZodOptional<z.ZodNumber>\n  keyPrefix: z.ZodOptional<z.ZodString>\n  ttl: z.ZodOptional<z.ZodNumber>\n}> = z.object({\n  host: z.string().default('127.0.0.1'),\n  port: z.number().int().positive().default(6379),\n  password: z.string().optional(),\n  db: z.number().int().nonnegative().optional(),\n  keyPrefix: z.string().optional(),\n  ttl: z.number().int().positive().optional(),\n})\n\nexport type RedisConfig = z.infer<typeof RedisSchema>\n","import MemoryCache from './memory'\nimport RedisCache from './redis'\nimport { CacheSchema } from './schema'\nimport { MemorySchema } from './schema/memory'\nimport { RedisSchema } from './schema/redis'\nimport { CacheInstance, CacheParams } from './types/cache'\n\n/**\n * Cache service\n */\nexport default class Cache {\n  /**\n   * Create a cache service instance\n   * @param params - Cache parameters\n   * @returns Cache service instance\n   */\n  static create({ cacheType, params }: CacheParams): CacheInstance {\n    const parsed = CacheSchema.safeParse({ driver: cacheType })\n    if (!parsed.success) {\n      console.log(parsed.error)\n      throw new Error('Invalid cache driver')\n    }\n\n    switch (parsed.data.driver) {\n      case 'memory': {\n        const config = MemorySchema.safeParse(params)\n        if (!config.success) {\n          console.log(config.error)\n          throw new Error('Invalid memory cache configuration')\n        }\n\n        return new MemoryCache(config.data)\n      }\n\n      case 'redis': {\n        const config = RedisSchema.safeParse(params)\n        if (!config.success) {\n          console.log(config.error)\n          throw new Error('Invalid redis cache configuration')\n        }\n\n        return new RedisCache(config.data)\n      }\n\n      default:\n        throw new Error('Invalid cache type')\n    }\n  }\n}\n\nexport { default as MemoryCache } from './memory'\nexport { default as RedisCache } from './redis'\nexport type { CacheDriver, CacheInstance, CacheParams, CacheType } from './types/cache'\n"],"mappings":"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"}

package/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "honojs-plugin-memory",
+  "version": "0.0.0",
+  "description": "Memory plugin for HonoJS",
+  "type": "module",
+  "sideEffects": false,
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.cts",
+  "files": [
+    "dist"
+  ],
+  "keywords": [],
+  "author": "masb0ymas <me@masb0ymas.com> (https://github.com/masb0ymas)",
+  "dependencies": {
+    "ioredis": "^5.11.1",
+    "lru-cache": "^11.5.2",
+    "zod": "^4.4.3"
+  },
+  "exports": {
+    ".": {
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.cjs"
+    },
+    "./package.json": "./package.json"
+  },
+  "license": "MIT",
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org",
+    "access": "public",
+    "provenance": true
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/masb0ymas/honojs-plugins.git",
+    "directory": "packages/memory"
+  },
+  "homepage": "https://github.com/masb0ymas/honojs-plugins",
+  "engines": {
+    "node": ">=20.0.0"
+  },
+  "scripts": {
+    "build": "pnpm -w run build:pkg",
+    "lint": "eslint",
+    "typecheck": "tsc -b tsconfig.json"
+  }
+}