@basaltkit/cache 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Machize Contributors
+
+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,255 @@
+# @basaltkit/cache
+
+Basalt's cache layer: stores the results of slow operations (database queries, external API calls, heavy computations) so they can be returned instantly next time. You need this module when your application repeats the same work over and over and you want to make it faster and cheaper.
+
+## What this module solves
+
+**Cache** is temporary memory: instead of fetching the same information from the database (or an external API) on every request, you store the result once and reuse it for a period of time. That period is called the **TTL** (*time to live*) — once it passes, the value expires and is recomputed.
+
+This module gives you a `Cache` class with a simple API (`get`, `put`, `remember`, `forget`, `flush`, `tags`) that works over two interchangeable **drivers**: **memory** (inside the Node.js process itself — ideal for development and testing) and **Redis** (an external cache server, shared across multiple processes — ideal for production).
+
+It also solves three problems that are normally a hassle:
+
+1. **Tenant isolation** — in a multi-tenant SaaS application (several customers/organizations in the same app), each tenant sees only its own cache entries, automatically, without you having to compose keys by hand.
+2. **Stampede protection** — if 100 requests arrive at the same time and the value is not cached, the expensive function runs **exactly once**; the other 99 requests wait and receive the same result.
+3. **Tag-based invalidation** — you can group related entries (e.g. everything related to "plans") and clear them all at once with a single line.
+
+## Installation
+
+```bash
+pnpm add @basaltkit/cache
+```
+
+The package depends on `@basaltkit/core` (the framework core) and already includes the Redis client (`ioredis`) — you don't need to install anything else.
+
+## Getting started in 5 minutes
+
+Step by step, from zero to having a working cache:
+
+1. **Create the app and register the plugin.** `cachePlugin` registers a `Cache` instance in the application's dependency container (the "container" is where Basalt keeps its shared services).
+
+2. **Get the cache via the `CACHE` token** and use it.
+
+```ts
+import { createApp } from '@basaltkit/core'
+import { CACHE, cachePlugin } from '@basaltkit/cache'
+
+// 1. Register the plugin (driver 'memory' — no external servers needed)
+const app = await createApp({
+  plugins: [cachePlugin({ driver: 'memory' })],
+}).boot()
+
+// 2. Get the Cache instance
+const cache = app.container.get(CACHE)
+
+// 3. Store a value for 5 minutes
+await cache.put('greeting', 'hello world', '5m')
+
+// 4. Read the value (returns undefined if it doesn't exist or has expired)
+console.log(await cache.get('greeting')) // 'hello world'
+
+// 5. At the end of the application, shut everything down (the driver is disconnected)
+await app.shutdown()
+```
+
+For production with Redis, just change the plugin options:
+
+```ts
+import { cachePlugin } from '@basaltkit/cache'
+
+cachePlugin({ driver: 'redis', url: 'redis://localhost:6379' })
+```
+
+## Usage guide
+
+### Reading and writing values (`get` / `put`)
+
+```ts
+import { Cache, MemoryCacheDriver } from '@basaltkit/cache'
+
+const cache = new Cache(new MemoryCacheDriver())
+
+await cache.put('config', { theme: 'dark' })         // no TTL: stays until deleted
+await cache.put('session', 'abc123', '30s')          // expires in 30 seconds
+await cache.put('token', 'xyz', 60_000)              // TTL also accepts milliseconds
+
+await cache.get('config')                            // { theme: 'dark' }
+await cache.get('missing')                           // undefined
+await cache.get('missing', 'default-value')          // 'default-value' (fallback)
+```
+
+TTLs accept a number in milliseconds **or** a human-readable string: `'500ms'`, `'30s'`, `'5m'`, `'2h'`, `'7d'`.
+
+### `remember` — the most useful pattern (cache-aside in one line)
+
+Instead of writing "check if it's cached; if not, compute and store it", `remember` does all of that for you — with stampede protection (concurrent calls for the same key share **one** execution of the function):
+
+```ts
+import { Cache, MemoryCacheDriver } from '@basaltkit/cache'
+
+const cache = new Cache(new MemoryCacheDriver())
+
+const plans = await cache.remember('plans', '1h', async () => {
+  // This function only runs when the value is NOT cached.
+  return fetchPlansFromDatabase()
+})
+```
+
+### Deleting entries (`forget` / `flush`)
+
+```ts
+await cache.forget('plans')   // deletes a key; returns true if it existed
+await cache.flush()           // deletes ALL keys in this prefix/scope
+                              // (never wipes the whole Redis instance — only your keys)
+```
+
+### Tags — invalidating groups of entries
+
+A **tag** is a label that associates several entries with the same group. When the source data changes, you invalidate the whole group:
+
+```ts
+import { Cache, MemoryCacheDriver } from '@basaltkit/cache'
+
+const cache = new Cache(new MemoryCacheDriver())
+
+await cache.tags('plans').put('plan:free', { price: 0 })
+await cache.tags('plans').put('plan:pro', { price: 29 })
+await cache.put('something-else', 'stays')
+
+// remember also works with tags:
+await cache.tags('plans').remember('plan:enterprise', '1h', () => fetchPlan('enterprise'))
+
+// Someone changed the plans? Invalidate the whole group:
+await cache.tags('plans').flush()
+
+await cache.get('plan:free')     // undefined
+await cache.get('something-else') // 'stays' (didn't have the tag)
+```
+
+### Automatic tenant isolation
+
+If your application uses Basalt's tenancy system, every cache operation reads the tenant from the **request context** (`ctx().tenant.id`) and prefixes keys with `tenant:<id>`. Each tenant thus gets its own "drawer" — no extra code required:
+
+```ts
+import { runWithContext } from '@basaltkit/core'
+import { Cache, MemoryCacheDriver } from '@basaltkit/cache'
+
+const cache = new Cache(new MemoryCacheDriver())
+
+await runWithContext({ tenant: { id: 'acme' } }, () => cache.put('config', 'from-acme'))
+await runWithContext({ tenant: { id: 'globex' } }, () => cache.put('config', 'from-globex'))
+await cache.put('config', 'central') // outside any tenant
+
+await runWithContext({ tenant: { id: 'acme' } }, () => cache.get('config')) // 'from-acme'
+await cache.get('config')                                                   // 'central'
+
+// flush() on one tenant does not touch other tenants or the central space
+await runWithContext({ tenant: { id: 'acme' } }, () => cache.flush())
+```
+
+In normal HTTP requests you don't need to call `runWithContext` — the framework does it for you. To disable isolation, pass `scope: null` in the options.
+
+### Using an existing Redis driver (Advanced)
+
+```ts
+import { Redis } from 'ioredis'
+import { Cache, RedisCacheDriver } from '@basaltkit/cache'
+
+// From a URL:
+const cacheA = new Cache(RedisCacheDriver.fromUrl('redis://localhost:6379'))
+
+// Or reusing your own ioredis connection:
+const redis = new Redis('redis://localhost:6379')
+const cacheB = new Cache(new RedisCacheDriver(redis))
+```
+
+## API reference
+
+### `class Cache`
+
+`new Cache(driver: CacheDriver, options?: CacheOptions)`
+
+| Method | Signature | Description |
+|---|---|---|
+| `get` | `get<T>(key: string): Promise<T \| undefined>` / `get<T>(key: string, fallback: T): Promise<T>` | Reads a value; returns `undefined` (or the `fallback`) on miss/expiration. |
+| `put` | `put(key: string, value: unknown, ttl?: DurationInput): Promise<void>` | Stores a value, with an optional TTL. |
+| `remember` | `remember<T>(key: string, ttl: DurationInput, factory: () => Promise<T> \| T): Promise<T>` | Returns the cached value or runs the `factory` (only once, even with concurrent calls) and stores the result. |
+| `forget` | `forget(key: string): Promise<boolean>` | Deletes a key; `true` if it existed. |
+| `flush` | `flush(): Promise<void>` | Deletes all keys in the current prefix/scope. |
+| `tags` | `tags(...tags: string[])` | Returns an object with `put`, `remember` and `flush` scoped to the given tags. |
+
+#### `CacheOptions`
+
+| Option | Type | Required? | Default | Description |
+|---|---|---|---|---|
+| `prefix` | `string` | No | `'basalt'` | Root prefix for all keys. |
+| `scope` | `(() => string \| undefined) \| null` | No | reads `ctx().tenant.id` → `tenant:<id>` | Dynamic prefix segment, resolved on each operation. `null` disables tenant isolation. |
+
+### `cachePlugin(options?: CachePluginOptions)`
+
+Registers `Cache` in the container under the `CACHE` token and disconnects the driver on application `shutdown`.
+
+#### `CachePluginOptions` (extends `CacheOptions`)
+
+| Option | Type | Required? | Default | Description |
+|---|---|---|---|---|
+| `driver` | `'memory' \| 'redis'` | No | `'memory'` | Which driver to use. |
+| `url` | `string` | Yes, with `driver: 'redis'` | — | Redis connection URL (e.g. `redis://localhost:6379`). |
+| `prefix`, `scope` | — | No | see `CacheOptions` | Inherited from `CacheOptions`. |
+
+### `CACHE`
+
+Dependency injection token: `app.container.get(CACHE)` returns the `Cache` instance.
+
+### `interface CacheDriver` (Advanced)
+
+Contract that any driver must implement — implement it to create your own storage:
+
+| Method | Signature | Description |
+|---|---|---|
+| `get` | `get(key: string): Promise<unknown>` | `undefined` on miss/expiration. |
+| `set` | `set(key: string, value: unknown, ttlMs?: number, tags?: string[]): Promise<void>` | Stores the value (TTL in milliseconds). |
+| `delete` | `delete(key: string): Promise<boolean>` | Deletes a key. |
+| `flushPrefix` | `flushPrefix(prefix: string): Promise<void>` | Deletes all keys starting with the prefix. |
+| `flushTags` | `flushTags(tags: string[]): Promise<void>` | Deletes all keys associated with any of the tags. |
+| `disconnect` | `disconnect(): Promise<void>` | Releases resources/connections. |
+
+### `class MemoryCacheDriver` (Advanced)
+
+`new MemoryCacheDriver()` — stores everything in a `Map` inside the process. No options. Perfect for development and testing; data is lost when the process ends and is not shared across processes.
+
+### `class RedisCacheDriver` (Advanced)
+
+| Member | Signature | Description |
+|---|---|---|
+| constructor | `new RedisCacheDriver(redis: Redis)` | Takes an already-created `ioredis` instance. |
+| `fromUrl` | `static fromUrl(url: string): RedisCacheDriver` | Creates the connection from a URL. |
+
+Values are serialized with `JSON.stringify`/`JSON.parse` — you can only store JSON-serializable values (no functions, `Date` becomes a string, etc.).
+
+## Common errors and solutions (FAQ)
+
+**`get` always returns `undefined` after I did a `put`.**
+The `put` and `get` probably ran in different tenant contexts (or one inside and one outside a tenant) — the keys end up under different prefixes. Check the context, or pass `scope: null` if you don't want isolation.
+
+**`DURATION_INVALID` error when passing a TTL.**
+The TTL must be a number (milliseconds) or a string in the format `'500ms'`, `'30s'`, `'5m'`, `'2h'`, `'7d'`. `'5 minutos'` or `'1w'` are not accepted.
+
+**I stored an object in Redis and got back something "different".**
+The Redis driver serializes to JSON. Class instances, `Date`, `Map`, functions — all of that is lost or turned into a JSON representation. Store plain data (objects, arrays, strings, numbers, booleans).
+
+**Stampede protection doesn't work across servers.**
+This is by design: `remember`'s deduplication is **per process** (it uses an in-memory map of in-flight promises). Two different servers can run the factory at the same time — but within each server it runs only once.
+
+**`flush()` deleted less than I expected.**
+`flush()` only deletes keys under the current prefix + scope (that's the safety guarantee: it never does `FLUSHALL` on Redis). To clear a tenant's keys, call `flush()` inside that tenant's context.
+
+**I configured `driver: 'redis'` and the application fails to boot/use the cache.**
+With `driver: 'redis'`, the `url` option is required. Also verify that the Redis server is reachable at that URL.
+
+## How it connects to other modules
+
+- **`@basaltkit/core`** — provides `createApp`, the dependency container, the request context (`ctx`/`runWithContext`) from which tenant isolation comes, and the `parseDuration` used for TTLs.
+- **`@basaltkit/tenancy`** — when the tenancy plugin identifies the request's tenant and puts it in the context, the cache automatically starts isolating keys per tenant.
+- **`@basaltkit/prisma`** — pairs well with `cache.remember(...)` to store the results of expensive database queries.
+- **`@basaltkit/flags`, `@basaltkit/permissions`, etc.** — any module can get the cache via `container.get(CACHE)` to speed up its own operations.

package/dist/index.d.ts

@@ -0,0 +1,86 @@
+import * as _basaltkit_core from '@basaltkit/core';
+import { DurationInput } from '@basaltkit/core';
+import { Redis } from 'ioredis';
+
+/** Cache driver contract. Every driver passes the same conformance suite. */
+interface CacheDriver {
+    /** Returns the value, or undefined on miss/expired. */
+    get(key: string): Promise<unknown>;
+    set(key: string, value: unknown, ttlMs?: number, tags?: string[]): Promise<void>;
+    delete(key: string): Promise<boolean>;
+    /** Removes all keys starting with the prefix. */
+    flushPrefix(prefix: string): Promise<void>;
+    /** Removes all keys associated with any of the tags. */
+    flushTags(tags: string[]): Promise<void>;
+    disconnect(): Promise<void>;
+}
+
+declare class MemoryCacheDriver implements CacheDriver {
+    private readonly store;
+    get(key: string): Promise<unknown>;
+    set(key: string, value: unknown, ttlMs?: number, tags?: string[]): Promise<void>;
+    delete(key: string): Promise<boolean>;
+    flushPrefix(prefix: string): Promise<void>;
+    flushTags(tags: string[]): Promise<void>;
+    disconnect(): Promise<void>;
+}
+
+declare class RedisCacheDriver implements CacheDriver {
+    private readonly redis;
+    constructor(redis: Redis);
+    static fromUrl(url: string): RedisCacheDriver;
+    get(key: string): Promise<unknown>;
+    set(key: string, value: unknown, ttlMs?: number, tags?: string[]): Promise<void>;
+    delete(key: string): Promise<boolean>;
+    flushPrefix(prefix: string): Promise<void>;
+    flushTags(tags: string[]): Promise<void>;
+    disconnect(): Promise<void>;
+}
+
+interface CacheOptions {
+    /** Root prefix for all keys. Default: 'basalt' */
+    prefix?: string;
+    /**
+     * Dynamic segment of the prefix, resolved on every operation. The default reads
+     * `ctx().tenant.id` — automatic per-tenant isolation. Pass `null` to disable.
+     */
+    scope?: (() => string | undefined) | null;
+}
+declare class Cache {
+    private readonly driver;
+    private readonly prefix;
+    private readonly scope;
+    /** dedupe of in-flight factories — per-process stampede protection */
+    private readonly pending;
+    constructor(driver: CacheDriver, options?: CacheOptions);
+    get<T>(key: string): Promise<T | undefined>;
+    get<T>(key: string, fallback: T): Promise<T>;
+    put(key: string, value: unknown, ttl?: DurationInput): Promise<void>;
+    /**
+     * One-line cache-aside, with stampede protection: concurrent calls
+     * for the same key share ONE execution of the factory.
+     */
+    remember<T>(key: string, ttl: DurationInput, factory: () => Promise<T> | T): Promise<T>;
+    forget(key: string): Promise<boolean>;
+    /** Clears only the keys under this prefix/scope — never the entire Redis. */
+    flush(): Promise<void>;
+    /** Tag-scoped operations: `cache.tags('plans').flush()` invalidates the group. */
+    tags(...tags: string[]): {
+        put: (key: string, value: unknown, ttl?: DurationInput) => Promise<void>;
+        remember: <T>(key: string, ttl: DurationInput, factory: () => Promise<T> | T) => Promise<T>;
+        flush: () => Promise<void>;
+    };
+    private rememberWithTags;
+    private root;
+    private key;
+}
+declare const CACHE: _basaltkit_core.Token<Cache>;
+interface CachePluginOptions extends CacheOptions {
+    /** 'memory' (default), 'redis' (needs `url`), or a custom `CacheDriver` instance. */
+    driver?: 'memory' | 'redis' | CacheDriver;
+    /** Required with the 'redis' driver. */
+    url?: string;
+}
+declare function cachePlugin(options?: CachePluginOptions): _basaltkit_core.BasaltPlugin<unknown>;
+
+export { CACHE, Cache, type CacheDriver, type CacheOptions, type CachePluginOptions, MemoryCacheDriver, RedisCacheDriver, cachePlugin };

package/dist/index.js

@@ -0,0 +1,203 @@
+// src/index.ts
+import {
+  createToken,
+  definePlugin,
+  parseDuration,
+  tryCtx
+} from "@basaltkit/core";
+
+// src/drivers/memory.ts
+var MemoryCacheDriver = class {
+  store = /* @__PURE__ */ new Map();
+  async get(key) {
+    const entry = this.store.get(key);
+    if (!entry) return void 0;
+    if (entry.expiresAt !== void 0 && Date.now() >= entry.expiresAt) {
+      this.store.delete(key);
+      return void 0;
+    }
+    return entry.value;
+  }
+  async set(key, value, ttlMs, tags = []) {
+    this.store.set(key, {
+      value,
+      ...ttlMs !== void 0 ? { expiresAt: Date.now() + ttlMs } : {},
+      tags: new Set(tags)
+    });
+  }
+  async delete(key) {
+    return this.store.delete(key);
+  }
+  async flushPrefix(prefix) {
+    for (const key of this.store.keys()) {
+      if (key.startsWith(prefix)) this.store.delete(key);
+    }
+  }
+  async flushTags(tags) {
+    for (const [key, entry] of this.store) {
+      if (tags.some((tag) => entry.tags.has(tag))) this.store.delete(key);
+    }
+  }
+  async disconnect() {
+    this.store.clear();
+  }
+};
+
+// src/drivers/redis.ts
+import { Redis } from "ioredis";
+var TAG_PREFIX = "__tags__:";
+var RedisCacheDriver = class _RedisCacheDriver {
+  constructor(redis) {
+    this.redis = redis;
+  }
+  redis;
+  static fromUrl(url) {
+    return new _RedisCacheDriver(new Redis(url));
+  }
+  async get(key) {
+    const raw = await this.redis.get(key);
+    return raw === null ? void 0 : JSON.parse(raw);
+  }
+  async set(key, value, ttlMs, tags = []) {
+    const raw = JSON.stringify(value);
+    if (ttlMs !== void 0) {
+      await this.redis.set(key, raw, "PX", Math.max(1, Math.ceil(ttlMs)));
+    } else {
+      await this.redis.set(key, raw);
+    }
+    for (const tag of tags) {
+      await this.redis.sadd(TAG_PREFIX + tag, key);
+    }
+  }
+  async delete(key) {
+    return await this.redis.del(key) > 0;
+  }
+  async flushPrefix(prefix) {
+    let cursor = "0";
+    do {
+      const [next, keys] = await this.redis.scan(cursor, "MATCH", `${prefix}*`, "COUNT", 200);
+      cursor = next;
+      if (keys.length > 0) await this.redis.del(...keys);
+    } while (cursor !== "0");
+  }
+  async flushTags(tags) {
+    for (const tag of tags) {
+      const tagKey = TAG_PREFIX + tag;
+      const keys = await this.redis.smembers(tagKey);
+      if (keys.length > 0) await this.redis.del(...keys);
+      await this.redis.del(tagKey);
+    }
+  }
+  async disconnect() {
+    await this.redis.quit();
+  }
+};
+
+// src/index.ts
+var defaultScope = () => {
+  const tenant = tryCtx()?.["tenant"];
+  return tenant?.id ? `tenant:${tenant.id}` : void 0;
+};
+var Cache = class {
+  constructor(driver, options = {}) {
+    this.driver = driver;
+    this.prefix = options.prefix ?? "basalt";
+    this.scope = options.scope === void 0 ? defaultScope : options.scope;
+  }
+  driver;
+  prefix;
+  scope;
+  /** dedupe of in-flight factories — per-process stampede protection */
+  pending = /* @__PURE__ */ new Map();
+  async get(key, fallback) {
+    const value = await this.driver.get(this.key(key));
+    return value === void 0 ? fallback : value;
+  }
+  async put(key, value, ttl) {
+    await this.driver.set(
+      this.key(key),
+      value,
+      ttl === void 0 ? void 0 : parseDuration(ttl)
+    );
+  }
+  /**
+   * One-line cache-aside, with stampede protection: concurrent calls
+   * for the same key share ONE execution of the factory.
+   */
+  async remember(key, ttl, factory) {
+    return this.rememberWithTags(key, ttl, factory, []);
+  }
+  async forget(key) {
+    return this.driver.delete(this.key(key));
+  }
+  /** Clears only the keys under this prefix/scope — never the entire Redis. */
+  async flush() {
+    await this.driver.flushPrefix(this.root());
+  }
+  /** Tag-scoped operations: `cache.tags('plans').flush()` invalidates the group. */
+  tags(...tags) {
+    const scopedTags = tags.map((tag) => `${this.root()}${tag}`);
+    return {
+      put: async (key, value, ttl) => {
+        await this.driver.set(
+          this.key(key),
+          value,
+          ttl === void 0 ? void 0 : parseDuration(ttl),
+          scopedTags
+        );
+      },
+      remember: (key, ttl, factory) => this.rememberWithTags(key, ttl, factory, scopedTags),
+      flush: async () => {
+        await this.driver.flushTags(scopedTags);
+      }
+    };
+  }
+  async rememberWithTags(key, ttl, factory, tags) {
+    const fullKey = this.key(key);
+    const cached = await this.driver.get(fullKey);
+    if (cached !== void 0) return cached;
+    const inFlight = this.pending.get(fullKey);
+    if (inFlight) return inFlight;
+    const computation = (async () => {
+      try {
+        const value = await factory();
+        await this.driver.set(fullKey, value, parseDuration(ttl), tags);
+        return value;
+      } finally {
+        this.pending.delete(fullKey);
+      }
+    })();
+    this.pending.set(fullKey, computation);
+    return computation;
+  }
+  root() {
+    const scope = this.scope?.();
+    return scope ? `${this.prefix}:${scope}:` : `${this.prefix}:`;
+  }
+  key(key) {
+    return this.root() + key;
+  }
+};
+var CACHE = createToken("cache");
+function cachePlugin(options = {}) {
+  let driver;
+  return definePlugin({
+    name: "basalt:cache",
+    register({ container }) {
+      container.singleton(CACHE, () => {
+        driver = typeof options.driver === "object" ? options.driver : options.driver === "redis" ? RedisCacheDriver.fromUrl(options.url) : new MemoryCacheDriver();
+        return new Cache(driver, options);
+      });
+    },
+    async shutdown() {
+      await driver?.disconnect();
+    }
+  });
+}
+export {
+  CACHE,
+  Cache,
+  MemoryCacheDriver,
+  RedisCacheDriver,
+  cachePlugin
+};

package/package.json

@@ -0,0 +1,48 @@
+{
+  "name": "@basaltkit/cache",
+  "version": "1.0.0",
+  "description": "Basalt cache layer: Redis and Memory drivers, tags, TTL, stampede protection and automatic per-tenant isolation.",
+  "license": "MIT",
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "ioredis": "^5.6.0",
+    "@basaltkit/core": "^1.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.15.0",
+    "tsup": "^8.4.0",
+    "typescript": "^5.8.0",
+    "vitest": "^3.1.0",
+    "@basaltkit/tsconfig": "^0.24.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Zebedeu/basalt.git",
+    "directory": "packages/cache"
+  },
+  "homepage": "https://github.com/Zebedeu/basalt/tree/main/packages/cache#readme",
+  "bugs": "https://github.com/Zebedeu/basalt/issues",
+  "keywords": [
+    "basalt",
+    "typescript",
+    "cache",
+    "redis"
+  ],
+  "scripts": {
+    "build": "tsup src/index.ts --format esm --dts --clean",
+    "test": "vitest run",
+    "typecheck": "tsc --noEmit"
+  }
+}