@objectstack/service-cache 4.0.3 → 4.0.5

package/README.md

@@ -0,0 +1,294 @@
+# @objectstack/service-cache
+
+Cache Service for ObjectStack — implements `ICacheService` with in-memory and Redis adapters.
+
+## Features
+
+- **Multiple Adapters**: In-memory (development) and Redis (production) support
+- **Type-Safe**: Full TypeScript support with generic value types
+- **TTL Support**: Automatic expiration with time-to-live
+- **Namespace Support**: Organize cache keys by namespace
+- **Pattern Matching**: Delete keys by pattern (e.g., `user:*`)
+- **Statistics**: Track hit/miss rates and memory usage
+- **JSON Serialization**: Automatic serialization of complex objects
+
+## Installation
+
+```bash
+pnpm add @objectstack/service-cache
+```
+
+For Redis adapter:
+```bash
+pnpm add ioredis
+```
+
+## Basic Usage
+
+```typescript
+import { defineStack } from '@objectstack/spec';
+import { ServiceCache } from '@objectstack/service-cache';
+
+const stack = defineStack({
+  services: [
+    ServiceCache.configure({
+      adapter: 'memory', // or 'redis'
+      defaultTTL: 300, // 5 minutes
+    }),
+  ],
+});
+```
+
+## Configuration
+
+### In-Memory Adapter (Development)
+
+```typescript
+ServiceCache.configure({
+  adapter: 'memory',
+  defaultTTL: 300,
+  maxSize: 1000, // Maximum number of entries
+});
+```
+
+### Redis Adapter (Production)
+
+```typescript
+ServiceCache.configure({
+  adapter: 'redis',
+  redis: {
+    host: 'localhost',
+    port: 6379,
+    password: process.env.REDIS_PASSWORD,
+    db: 0,
+  },
+  defaultTTL: 600,
+});
+```
+
+## Service API
+
+```typescript
+// Get cache service
+const cache = kernel.getService<ICacheService>('cache');
+```
+
+### Set/Get Operations
+
+```typescript
+// Set a value
+await cache.set('user:123', { name: 'John', email: 'john@example.com' });
+
+// Set with custom TTL (in seconds)
+await cache.set('session:abc', sessionData, { ttl: 3600 }); // 1 hour
+
+// Get a value
+const user = await cache.get('user:123');
+
+// Get with type safety
+const user = await cache.get<User>('user:123');
+
+// Get multiple keys
+const users = await cache.mget(['user:123', 'user:456']);
+```
+
+### Existence & Deletion
+
+```typescript
+// Check if key exists
+const exists = await cache.has('user:123');
+
+// Delete a key
+await cache.del('user:123');
+
+// Delete multiple keys
+await cache.del(['session:abc', 'session:def']);
+
+// Delete by pattern
+await cache.delPattern('user:*');
+```
+
+### Namespaced Operations
+
+```typescript
+// Create a namespaced cache instance
+const userCache = cache.namespace('user');
+
+// Set in namespace (key becomes 'user:123')
+await userCache.set('123', userData);
+
+// Get from namespace
+const user = await userCache.get('123');
+
+// Clear entire namespace
+await userCache.clear();
+```
+
+### TTL Management
+
+```typescript
+// Get remaining TTL (in seconds)
+const ttl = await cache.ttl('session:abc');
+
+// Update TTL
+await cache.expire('session:abc', 7200); // 2 hours
+
+// Make key permanent (remove expiration)
+await cache.persist('user:123');
+```
+
+### Atomic Operations
+
+```typescript
+// Increment (useful for counters)
+await cache.incr('page:views:123'); // Returns new value
+
+// Increment by amount
+await cache.incrby('score:user:123', 10);
+
+// Decrement
+await cache.decr('inventory:product:456');
+```
+
+### Batch Operations
+
+```typescript
+// Set multiple keys at once
+await cache.mset({
+  'user:123': user1Data,
+  'user:456': user2Data,
+  'user:789': user3Data,
+});
+
+// Get multiple keys
+const users = await cache.mget(['user:123', 'user:456', 'user:789']);
+```
+
+## Advanced Features
+
+### Cache Aside Pattern
+
+```typescript
+async function getUser(id: string): Promise<User> {
+  // Try cache first
+  const cached = await cache.get<User>(`user:${id}`);
+  if (cached) return cached;
+
+  // Load from database
+  const user = await db.findUser(id);
+
+  // Store in cache
+  await cache.set(`user:${id}`, user, { ttl: 600 });
+
+  return user;
+}
+```
+
+### Cache-Through Pattern
+
+```typescript
+async function getUserCacheThrough(id: string): Promise<User> {
+  return cache.getOrSet(`user:${id}`, async () => {
+    return await db.findUser(id);
+  }, { ttl: 600 });
+}
+```
+
+### Invalidation on Write
+
+```typescript
+async function updateUser(id: string, data: Partial<User>) {
+  // Update database
+  await db.updateUser(id, data);
+
+  // Invalidate cache
+  await cache.del(`user:${id}`);
+
+  // Or update cache immediately
+  const updated = await db.findUser(id);
+  await cache.set(`user:${id}`, updated);
+}
+```
+
+### Tagging & Invalidation
+
+```typescript
+// Tag cache entries
+await cache.set('product:123', productData, {
+  ttl: 600,
+  tags: ['products', 'category:electronics'],
+});
+
+// Invalidate by tag
+await cache.invalidateTag('category:electronics');
+```
+
+## Statistics & Monitoring
+
+```typescript
+// Get cache statistics
+const stats = await cache.stats();
+// {
+//   hits: 1250,
+//   misses: 325,
+//   hitRate: 0.794,
+//   keys: 450,
+//   memoryUsage: 1024000 // bytes
+// }
+
+// Reset statistics
+await cache.resetStats();
+```
+
+## REST API Endpoints
+
+```
+GET    /api/v1/cache/stats               # Get cache statistics
+POST   /api/v1/cache/clear                # Clear cache
+DELETE /api/v1/cache/:key                 # Delete specific key
+DELETE /api/v1/cache/pattern/:pattern     # Delete by pattern
+```
+
+## Best Practices
+
+1. **Use Namespaces**: Organize cache keys with namespaces
+2. **Set Appropriate TTLs**: Don't cache data longer than necessary
+3. **Handle Misses**: Always have fallback logic when cache misses
+4. **Invalidate on Write**: Clear stale cache after updates
+5. **Monitor Hit Rates**: Track cache effectiveness with statistics
+6. **Serialize Carefully**: Be mindful of what you serialize (avoid circular references)
+7. **Use Redis in Production**: In-memory adapter is for development only
+
+## Performance Considerations
+
+- **In-Memory Adapter**: Fast but limited by server memory, not shared across instances
+- **Redis Adapter**: Shared across instances, persistent, but network latency
+- **TTL Strategy**: Balance between freshness and cache hit rate
+- **Key Patterns**: Use consistent naming conventions for easier invalidation
+
+## Contract Implementation
+
+Implements `ICacheService` from `@objectstack/spec/contracts`:
+
+```typescript
+interface ICacheService {
+  get<T>(key: string): Promise<T | null>;
+  set<T>(key: string, value: T, options?: CacheOptions): Promise<void>;
+  del(key: string | string[]): Promise<void>;
+  has(key: string): Promise<boolean>;
+  ttl(key: string): Promise<number>;
+  expire(key: string, ttl: number): Promise<void>;
+  clear(): Promise<void>;
+  namespace(name: string): ICacheService;
+}
+```
+
+## License
+
+Apache-2.0
+
+## See Also
+
+- [Redis Documentation](https://redis.io/documentation)
+- [@objectstack/spec/contracts](../../spec/src/contracts/)
+- [Caching Best Practices](/content/docs/guides/caching/)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@objectstack/service-cache",
-  "version": "4.0.3",
+  "version": "4.0.5",
   "license": "Apache-2.0",
   "description": "Cache Service for ObjectStack — implements ICacheService with in-memory and Redis adapters",
   "type": "module",
@@ -14,13 +14,37 @@
     }
   },
   "dependencies": {
-    "@objectstack/core": "4.0.3",
-    "@objectstack/spec": "4.0.3"
+    "@objectstack/core": "4.0.5",
+    "@objectstack/spec": "4.0.5"
   },
   "devDependencies": {
-    "@types/node": "^25.6.0",
-    "typescript": "^6.0.2",
-    "vitest": "^4.1.4"
+    "@types/node": "^25.6.2",
+    "typescript": "^6.0.3",
+    "vitest": "^4.1.5"
+  },
+  "keywords": [
+    "objectstack",
+    "service",
+    "cache",
+    "redis"
+  ],
+  "author": "ObjectStack",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/objectstack-ai/framework.git",
+    "directory": "packages/services/service-cache"
+  },
+  "homepage": "https://objectstack.ai/docs",
+  "bugs": "https://github.com/objectstack-ai/framework/issues",
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "engines": {
+    "node": ">=18.0.0"
   },
   "scripts": {
     "build": "tsup --config ../../../tsup.config.ts",

package/.turbo/turbo-build.log

@@ -1,22 +0,0 @@
-
-> @objectstack/service-cache@4.0.3 build /home/runner/work/framework/framework/packages/services/service-cache
-> tsup --config ../../../tsup.config.ts
-
-CLI Building entry: src/index.ts
-CLI Using tsconfig: tsconfig.json
-CLI tsup v8.5.1
-CLI Using tsup config: /home/runner/work/framework/framework/tsup.config.ts
-CLI Target: es2020
-CLI Cleaning output folder
-ESM Build start
-CJS Build start
-CJS dist/index.cjs     4.09 KB
-CJS dist/index.cjs.map 9.50 KB
-CJS ⚡️ Build success in 94ms
-ESM dist/index.js     2.98 KB
-ESM dist/index.js.map 8.94 KB
-ESM ⚡️ Build success in 99ms
-DTS Build start
-DTS ⚡️ Build success in 12340ms
-DTS dist/index.d.ts  3.56 KB
-DTS dist/index.d.cts 3.56 KB

package/CHANGELOG.md

@@ -1,169 +0,0 @@
-# @objectstack/service-cache
-
-## 4.0.3
-
-### Patch Changes
-
-- @objectstack/spec@4.0.3
-- @objectstack/core@4.0.3
-
-## 4.0.2
-
-### Patch Changes
-
-- Updated dependencies [5f659e9]
-  - @objectstack/spec@4.0.2
-  - @objectstack/core@4.0.2
-
-## 4.0.0
-
-### Patch Changes
-
-- Updated dependencies [f08ffc3]
-- Updated dependencies [e0b0a78]
-  - @objectstack/spec@4.0.0
-  - @objectstack/core@4.0.0
-
-## 3.3.1
-
-### Patch Changes
-
-- @objectstack/spec@3.3.1
-- @objectstack/core@3.3.1
-
-## 3.3.0
-
-### Patch Changes
-
-- @objectstack/spec@3.3.0
-- @objectstack/core@3.3.0
-
-## 3.2.9
-
-### Patch Changes
-
-- @objectstack/spec@3.2.9
-- @objectstack/core@3.2.9
-
-## 3.2.8
-
-### Patch Changes
-
-- @objectstack/spec@3.2.8
-- @objectstack/core@3.2.8
-
-## 3.2.7
-
-### Patch Changes
-
-- @objectstack/spec@3.2.7
-- @objectstack/core@3.2.7
-
-## 3.2.6
-
-### Patch Changes
-
-- @objectstack/spec@3.2.6
-- @objectstack/core@3.2.6
-
-## 3.2.5
-
-### Patch Changes
-
-- @objectstack/spec@3.2.5
-- @objectstack/core@3.2.5
-
-## 3.2.4
-
-### Patch Changes
-
-- @objectstack/spec@3.2.4
-- @objectstack/core@3.2.4
-
-## 3.2.3
-
-### Patch Changes
-
-- @objectstack/spec@3.2.3
-- @objectstack/core@3.2.3
-
-## 3.2.2
-
-### Patch Changes
-
-- Updated dependencies [46defbb]
-  - @objectstack/spec@3.2.2
-  - @objectstack/core@3.2.2
-
-## 3.2.1
-
-### Patch Changes
-
-- Updated dependencies [850b546]
-  - @objectstack/spec@3.2.1
-  - @objectstack/core@3.2.1
-
-## 3.2.0
-
-### Patch Changes
-
-- Updated dependencies [5901c29]
-  - @objectstack/spec@3.2.0
-  - @objectstack/core@3.2.0
-
-## 3.1.1
-
-### Patch Changes
-
-- Updated dependencies [953d667]
-  - @objectstack/spec@3.1.1
-  - @objectstack/core@3.1.1
-
-## 3.1.0
-
-### Patch Changes
-
-- Updated dependencies [0088830]
-  - @objectstack/spec@3.1.0
-  - @objectstack/core@3.1.0
-
-## 3.0.11
-
-### Patch Changes
-
-- Updated dependencies [92d9d99]
-  - @objectstack/spec@3.0.11
-  - @objectstack/core@3.0.11
-
-## 3.0.10
-
-### Patch Changes
-
-- Updated dependencies [d1e5d31]
-  - @objectstack/spec@3.0.10
-  - @objectstack/core@3.0.10
-
-## 3.0.9
-
-### Patch Changes
-
-- Updated dependencies [15e0df6]
-  - @objectstack/spec@3.0.9
-  - @objectstack/core@3.0.9
-
-## 3.0.8
-
-### Patch Changes
-
-- Updated dependencies [5a968a2]
-  - @objectstack/spec@3.0.8
-  - @objectstack/core@3.0.8
-
-## 3.0.7
-
-### Patch Changes
-
-- Updated dependencies [0119bd7]
-- Updated dependencies [5426bdf]
-  - @objectstack/spec@3.0.7
-  - @objectstack/core@3.0.7

package/src/cache-service-plugin.ts

@@ -1,63 +0,0 @@
-// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.
-
-import type { Plugin, PluginContext } from '@objectstack/core';
-import { MemoryCacheAdapter } from './memory-cache-adapter.js';
-import type { MemoryCacheAdapterOptions } from './memory-cache-adapter.js';
-
-/**
- * Configuration options for the CacheServicePlugin.
- */
-export interface CacheServicePluginOptions {
-  /** Cache adapter type (default: 'memory') */
-  adapter?: 'memory' | 'redis';
-  /** Options for the memory cache adapter */
-  memory?: MemoryCacheAdapterOptions;
-  /** Redis connection URL (used when adapter is 'redis') */
-  redisUrl?: string;
-}
-
-/**
- * CacheServicePlugin — Production ICacheService implementation.
- *
- * Registers a cache service with the kernel during the init phase.
- * Supports in-memory and Redis adapters.
- *
- * @example
- * ```ts
- * import { ObjectKernel } from '@objectstack/core';
- * import { CacheServicePlugin } from '@objectstack/service-cache';
- *
- * const kernel = new ObjectKernel();
- * kernel.use(new CacheServicePlugin({ adapter: 'memory', memory: { maxSize: 1000 } }));
- * await kernel.bootstrap();
- *
- * const cache = kernel.getService('cache');
- * await cache.set('key', 'value', 60);
- * ```
- */
-export class CacheServicePlugin implements Plugin {
-  name = 'com.objectstack.service.cache';
-  version = '1.0.0';
-  type = 'standard';
-
-  private readonly options: CacheServicePluginOptions;
-
-  constructor(options: CacheServicePluginOptions = {}) {
-    this.options = { adapter: 'memory', ...options };
-  }
-
-  async init(ctx: PluginContext): Promise<void> {
-    const adapter = this.options.adapter;
-    if (adapter === 'redis') {
-      // Redis adapter is a skeleton — throw an informative error for now
-      throw new Error(
-        'Redis cache adapter is not yet implemented. ' +
-        'Use adapter: "memory" or provide a custom ICacheService via ctx.registerService("cache", impl).'
-      );
-    }
-
-    const cache = new MemoryCacheAdapter(this.options.memory);
-    ctx.registerService('cache', cache);
-    ctx.logger.info('CacheServicePlugin: registered memory cache adapter');
-  }
-}

package/src/index.ts

@@ -1,8 +0,0 @@
-// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.
-
-export { CacheServicePlugin } from './cache-service-plugin.js';
-export type { CacheServicePluginOptions } from './cache-service-plugin.js';
-export { MemoryCacheAdapter } from './memory-cache-adapter.js';
-export type { MemoryCacheAdapterOptions } from './memory-cache-adapter.js';
-export { RedisCacheAdapter } from './redis-cache-adapter.js';
-export type { RedisCacheAdapterOptions } from './redis-cache-adapter.js';

package/src/memory-cache-adapter.test.ts

@@ -1,107 +0,0 @@
-// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.
-
-import { describe, it, expect } from 'vitest';
-import { MemoryCacheAdapter } from './memory-cache-adapter';
-import type { ICacheService } from '@objectstack/spec/contracts';
-
-describe('MemoryCacheAdapter', () => {
-  it('should implement ICacheService contract', () => {
-    const cache: ICacheService = new MemoryCacheAdapter();
-    expect(typeof cache.get).toBe('function');
-    expect(typeof cache.set).toBe('function');
-    expect(typeof cache.delete).toBe('function');
-    expect(typeof cache.has).toBe('function');
-    expect(typeof cache.clear).toBe('function');
-    expect(typeof cache.stats).toBe('function');
-  });
-
-  it('should set and get a value', async () => {
-    const cache = new MemoryCacheAdapter();
-    await cache.set('key1', 'value1');
-    expect(await cache.get('key1')).toBe('value1');
-  });
-
-  it('should return undefined for missing key', async () => {
-    const cache = new MemoryCacheAdapter();
-    expect(await cache.get('nonexistent')).toBeUndefined();
-  });
-
-  it('should delete a key', async () => {
-    const cache = new MemoryCacheAdapter();
-    await cache.set('key1', 'value1');
-    expect(await cache.delete('key1')).toBe(true);
-    expect(await cache.get('key1')).toBeUndefined();
-  });
-
-  it('should return false when deleting missing key', async () => {
-    const cache = new MemoryCacheAdapter();
-    expect(await cache.delete('missing')).toBe(false);
-  });
-
-  it('should check if a key exists with has()', async () => {
-    const cache = new MemoryCacheAdapter();
-    expect(await cache.has('key1')).toBe(false);
-    await cache.set('key1', 'value1');
-    expect(await cache.has('key1')).toBe(true);
-  });
-
-  it('should clear all entries', async () => {
-    const cache = new MemoryCacheAdapter();
-    await cache.set('a', 1);
-    await cache.set('b', 2);
-    await cache.clear();
-    expect(await cache.has('a')).toBe(false);
-    expect(await cache.has('b')).toBe(false);
-  });
-
-  it('should expire entries based on TTL', async () => {
-    const cache = new MemoryCacheAdapter();
-    await cache.set('temp', 'data', 0.001); // 1ms TTL
-    await new Promise(r => setTimeout(r, 20));
-    expect(await cache.get('temp')).toBeUndefined();
-  });
-
-  it('should track hit/miss stats', async () => {
-    const cache = new MemoryCacheAdapter();
-    await cache.set('key1', 'value1');
-    await cache.get('key1');      // hit
-    await cache.get('missing');   // miss
-    const stats = await cache.stats();
-    expect(stats.hits).toBe(1);
-    expect(stats.misses).toBe(1);
-    expect(stats.keyCount).toBe(1);
-  });
-
-  it('should apply defaultTtl when no TTL is provided', async () => {
-    const cache = new MemoryCacheAdapter({ defaultTtl: 0.001 });
-    await cache.set('key', 'value');
-    await new Promise(r => setTimeout(r, 20));
-    expect(await cache.get('key')).toBeUndefined();
-  });
-
-  it('should evict oldest entry when maxSize is reached', async () => {
-    const cache = new MemoryCacheAdapter({ maxSize: 2 });
-    await cache.set('a', 1);
-    await cache.set('b', 2);
-    await cache.set('c', 3); // should evict 'a'
-    expect(await cache.has('a')).toBe(false);
-    expect(await cache.get('b')).toBe(2);
-    expect(await cache.get('c')).toBe(3);
-  });
-
-  it('should not evict when updating existing key at maxSize', async () => {
-    const cache = new MemoryCacheAdapter({ maxSize: 2 });
-    await cache.set('a', 1);
-    await cache.set('b', 2);
-    await cache.set('a', 10); // update, not new entry
-    expect(await cache.get('a')).toBe(10);
-    expect(await cache.get('b')).toBe(2);
-  });
-
-  it('should handle has() with expired TTL', async () => {
-    const cache = new MemoryCacheAdapter();
-    await cache.set('expiring', 'val', 0.001);
-    await new Promise(r => setTimeout(r, 20));
-    expect(await cache.has('expiring')).toBe(false);
-  });
-});

package/src/memory-cache-adapter.ts

@@ -1,90 +0,0 @@
-// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.
-
-import type { ICacheService, CacheStats } from '@objectstack/spec/contracts';
-
-/**
- * In-memory cache entry with optional TTL expiry.
- */
-interface CacheEntry<T = unknown> {
-  value: T;
-  expires?: number;
-}
-
-/**
- * Configuration options for MemoryCacheAdapter.
- */
-export interface MemoryCacheAdapterOptions {
-  /** Maximum number of entries before eviction (0 = unlimited) */
-  maxSize?: number;
-  /** Default TTL in seconds (0 = no expiry) */
-  defaultTtl?: number;
-}
-
-/**
- * In-memory cache adapter implementing ICacheService.
- *
- * Uses a Map-backed store with TTL-based expiry and LRU-style eviction.
- * Suitable for single-process environments, development, and testing.
- */
-export class MemoryCacheAdapter implements ICacheService {
-  private readonly store = new Map<string, CacheEntry>();
-  private hits = 0;
-  private misses = 0;
-  private readonly maxSize: number;
-  private readonly defaultTtl: number;
-
-  constructor(options: MemoryCacheAdapterOptions = {}) {
-    this.maxSize = options.maxSize ?? 0;
-    this.defaultTtl = options.defaultTtl ?? 0;
-  }
-
-  async get<T = unknown>(key: string): Promise<T | undefined> {
-    const entry = this.store.get(key);
-    if (!entry || (entry.expires && Date.now() > entry.expires)) {
-      if (entry) this.store.delete(key);
-      this.misses++;
-      return undefined;
-    }
-    this.hits++;
-    return entry.value as T;
-  }
-
-  async set<T = unknown>(key: string, value: T, ttl?: number): Promise<void> {
-    const effectiveTtl = ttl ?? this.defaultTtl;
-    if (this.maxSize > 0 && !this.store.has(key) && this.store.size >= this.maxSize) {
-      // Evict oldest entry (first key in Map insertion order)
-      const firstKey = this.store.keys().next().value;
-      if (firstKey !== undefined) this.store.delete(firstKey);
-    }
-    this.store.set(key, {
-      value,
-      expires: effectiveTtl > 0 ? Date.now() + effectiveTtl * 1000 : undefined,
-    });
-  }
-
-  async delete(key: string): Promise<boolean> {
-    return this.store.delete(key);
-  }
-
-  async has(key: string): Promise<boolean> {
-    const entry = this.store.get(key);
-    if (!entry) return false;
-    if (entry.expires && Date.now() > entry.expires) {
-      this.store.delete(key);
-      return false;
-    }
-    return true;
-  }
-
-  async clear(): Promise<void> {
-    this.store.clear();
-  }
-
-  async stats(): Promise<CacheStats> {
-    return {
-      hits: this.hits,
-      misses: this.misses,
-      keyCount: this.store.size,
-    };
-  }
-}

package/src/redis-cache-adapter.ts

@@ -1,63 +0,0 @@
-// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.
-
-import type { ICacheService, CacheStats } from '@objectstack/spec/contracts';
-
-/**
- * Configuration for the Redis cache adapter.
- */
-export interface RedisCacheAdapterOptions {
-  /** Redis connection URL (e.g. 'redis://localhost:6379') */
-  url: string;
-  /** Key prefix for namespacing (default: 'os:') */
-  keyPrefix?: string;
-  /** Default TTL in seconds (0 = no expiry) */
-  defaultTtl?: number;
-}
-
-/**
- * Redis cache adapter skeleton implementing ICacheService.
- *
- * This is a placeholder for future Redis integration.
- * Concrete implementation will use `ioredis` or `redis` client.
- *
- * @example
- * ```ts
- * const cache = new RedisCacheAdapter({ url: 'redis://localhost:6379' });
- * await cache.set('user:1', { name: 'Alice' }, 3600);
- * ```
- */
-export class RedisCacheAdapter implements ICacheService {
-  private readonly url: string;
-  private readonly keyPrefix: string;
-  private readonly defaultTtl: number;
-
-  constructor(options: RedisCacheAdapterOptions) {
-    this.url = options.url;
-    this.keyPrefix = options.keyPrefix ?? 'os:';
-    this.defaultTtl = options.defaultTtl ?? 0;
-  }
-
-  async get<T = unknown>(_key: string): Promise<T | undefined> {
-    throw new Error(`RedisCacheAdapter not yet implemented (url: ${this.url}, prefix: ${this.keyPrefix}, ttl: ${this.defaultTtl})`);
-  }
-
-  async set<T = unknown>(_key: string, _value: T, _ttl?: number): Promise<void> {
-    throw new Error('RedisCacheAdapter not yet implemented');
-  }
-
-  async delete(_key: string): Promise<boolean> {
-    throw new Error('RedisCacheAdapter not yet implemented');
-  }
-
-  async has(_key: string): Promise<boolean> {
-    throw new Error('RedisCacheAdapter not yet implemented');
-  }
-
-  async clear(): Promise<void> {
-    throw new Error('RedisCacheAdapter not yet implemented');
-  }
-
-  async stats(): Promise<CacheStats> {
-    throw new Error('RedisCacheAdapter not yet implemented');
-  }
-}

package/tsconfig.json

@@ -1,17 +0,0 @@
-{
-  "extends": "../../../tsconfig.json",
-  "compilerOptions": {
-    "outDir": "dist",
-    "rootDir": "src",
-    "types": [
-      "node"
-    ]
-  },
-  "include": [
-    "src"
-  ],
-  "exclude": [
-    "node_modules",
-    "dist"
-  ]
-}