@fjell/cache 4.6.10 → 4.6.13

package/docs/public/examples-README.md

@@ -0,0 +1,302 @@
+# Fjell-Cache Examples
+
+This directory contains examples demonstrating how to use fjell-cache for caching data models and managing complex business relationships with different patterns and complexity levels.
+
+## Examples
+
+### 1. `basic-cache-example.ts` ⭐ **Start Here!**
+**Perfect for beginners!** Demonstrates the fundamental way to use fjell-cache for data caching:
+- **Basic cache operations** - Create caches with coordinates and registries, use operations API
+- **Simple data models** - User and Task entities with mock storage
+- **Cache-as-Instance architecture** - Caches extend Instance from fjell-registry
+- **Cache hits vs misses** - Understand cache behavior and performance benefits
+- **Cache management** - Updates, deletions, and data consistency through operations
+
+Great for understanding the fundamentals of fjell-cache data management.
+
+### 2. `aggregator-example.ts` 🏗️ **Advanced Business Relationships**
+**Complete business relationship management!** Demonstrates advanced caching patterns with entity relationships:
+- **Multiple interconnected models**: Customer, Order, Product, SupportTicket
+- **Automatic reference population**: Orders automatically include customer data
+- **Required vs optional aggregates**: Flexible relationship management
+- **Complex business scenarios**: E-commerce platform with customer management
+- **Performance optimization**: Cache efficiency through aggregated data
+
+Shows how fjell-cache handles enterprise data relationship patterns.
+
+### 3. `cache-map-example.ts` 🔧 **Low-Level Cache Operations**
+**Direct cache management!** Demonstrates lower-level CacheMap functionality:
+- **Direct CacheMap usage**: Create and manage cache maps without higher-level abstractions
+- **Primary and composite keys**: Handle both simple and complex key structures
+- **Location-based operations**: Filter contained items by location hierarchy
+- **Performance characteristics**: Bulk operations and efficiency testing
+- **Cache lifecycle**: Cloning, cleanup, and memory management
+
+Perfect for understanding the underlying cache mechanisms and advanced use cases.
+
+## Key Concepts Demonstrated
+
+### Basic Caching Operations (basic-cache-example.ts)
+```typescript
+// Import fjell-cache functionality
+import { createCache } from '@fjell/cache';
+import { createCoordinate, createRegistry } from '@fjell/registry';
+import { ClientApi } from '@fjell/client-api';
+
+// Create a registry for cache management
+const registry = createRegistry();
+
+// Create a cache instance with API integration
+const userApi = createUserApi(); // Your API implementation
+const userCache = await createCache(userApi, createCoordinate('user'), registry);
+
+// Cache is now an instance - no need for separate createInstance call
+// Perform cache operations through the operations API
+const [cacheMap, allUsers] = await userCache.operations.all();
+const [, cachedUser] = await userCache.operations.get(userKey);
+const [, retrievedUser] = await userCache.operations.retrieve(userKey); // Cache hit!
+
+await userCache.operations.set(userKey, updatedUser);
+```
+
+### Advanced Aggregation (aggregator-example.ts)
+```typescript
+// Create aggregated cache with relationships
+const orderAggregator = await createAggregator(orderCache, {
+  aggregates: {
+    customer: { cache: customerCache, optional: false }, // Required reference
+    product: { cache: productCache, optional: true },    // Optional reference
+  },
+  events: {}
+});
+
+// Automatically populate related entities
+const populatedOrder = await orderAggregator.populate(order);
+if (populatedOrder.aggs?.customer?.item) {
+  const customer = populatedOrder.aggs.customer.item;
+  console.log(`Order for: ${customer.name} (${customer.email})`);
+}
+
+// Aggregator is now itself an instance - access operations directly
+const [, orders] = await orderAggregator.all();
+```
+
+### Direct Cache Management (cache-map-example.ts)
+```typescript
+// Create CacheMap instances directly
+const documentCacheMap = new CacheMap<Document, 'document'>(['document']);
+const commentCacheMap = new CacheMap<Comment, 'comment', 'document'>(['comment', 'document']);
+
+// Basic operations
+documentCacheMap.set(documentKey, document);
+const retrievedDoc = documentCacheMap.get(documentKey);
+const hasDoc = documentCacheMap.includesKey(documentKey);
+
+// Bulk operations
+const allDocuments = documentCacheMap.allIn([]);
+const allKeys = documentCacheMap.keys();
+const allValues = documentCacheMap.values();
+
+// Location-based filtering for contained items
+const commentsInDoc = commentCacheMap.allIn([{ kt: 'document', lk: documentId }]);
+
+// Performance operations
+const clonedCache = documentCacheMap.clone();
+documentCacheMap.delete(documentKey);
+```
+
+### Data Model Patterns
+
+#### Primary Items
+- Standalone entities (User, Customer, Document)
+- No location hierarchy constraints
+- Simple key structure: `Item<'keyType'>`
+
+#### Contained Items
+- Nested within other entities or locations
+- Multi-level location keys for organization
+- Complex key structure: `Item<'keyType', 'location1', 'location2', ...>`
+
+#### Aggregated Items
+- Items with automatic reference population
+- Business relationships through cache aggregation
+- Performance optimized through cached references
+
+## Running Examples
+
+```bash
+# Start with the basic example (recommended)
+npx tsx examples/basic-cache-example.ts
+
+# Run the aggregator example
+npx tsx examples/aggregator-example.ts
+
+# Run the cache map example
+npx tsx examples/cache-map-example.ts
+
+# Or with Node.js
+node -r esbuild-register examples/basic-cache-example.ts
+```
+
+## Integration with Real Applications
+
+All examples use the actual fjell-cache functionality! In production applications:
+
+```typescript
+import { createCache, createRegistry, createInstance, createAggregator } from '@fjell/cache';
+import { ClientApi } from '@fjell/client-api';
+
+// Basic cache setup
+const registry = createRegistry();
+
+const userCache = await createCache(userApi, 'user');
+const userInstance = createInstance(registry, createCoordinate('user'), userCache);
+
+// With aggregation for business relationships
+const orderAggregator = await createAggregator(orderCache, {
+  aggregates: {
+    customer: { cache: customerCache, optional: false },
+    items: { cache: productCache, optional: true }
+  },
+  events: {
+    orderUpdated: async (key, item) => {
+      // Custom event handling
+      await notifyCustomer(item);
+    }
+  }
+});
+
+// Advanced cache configuration
+const options = {
+  cacheSize: 10000,
+  ttl: 3600000, // 1 hour
+  refreshThreshold: 0.8,
+  compression: true
+};
+```
+
+## Cache Operation Types
+
+### Basic Operations
+- **all()**: Get all items and update cache
+- **get()**: Get item by key, fetch from API if not cached
+- **retrieve()**: Get item by key, return null if not cached
+- **set()**: Store item in cache
+- **one()**: Get single item
+- **find()**: Search items with finder methods
+
+### Aggregation Operations
+- **populate()**: Automatically populate item with related entities
+- **populateAggregate()**: Populate specific aggregate relationship
+- **populateEvent()**: Handle population events
+
+### Cache Management
+- **allIn()**: Get items by location (for contained items)
+- **queryIn()**: Query items by location with filtering
+- **clone()**: Create independent cache copy
+- **delete()**: Remove item from cache
+- **clear()**: Clear all cache contents
+
+### Business Operations
+```typescript
+// Cache with business logic integration
+const cache = await createCache(api, 'order', {
+  hooks: {
+    beforeGet: async (key) => { /* validation */ },
+    afterSet: async (key, item) => { /* notifications */ }
+  },
+  validators: {
+    status: (status) => ['pending', 'shipped', 'delivered'].includes(status)
+  },
+  aggregates: {
+    customer: customerCache,
+    items: productCache
+  }
+});
+```
+
+## When to Use What
+
+**Use `basic-cache-example.ts` approach when:**
+- Learning fjell-cache fundamentals
+- Building simple applications with caching needs
+- Need basic get/set cache operations
+- Working with independent data models
+
+**Use `aggregator-example.ts` approach when:**
+- Managing complex business relationships
+- Need automatic population of related entities
+- Building enterprise applications with interconnected data
+- Require performance optimization through aggregated caching
+- Working with customer/order/product type relationships
+
+**Use `cache-map-example.ts` approach when:**
+- Need direct control over cache operations
+- Building custom caching solutions
+- Working with contained items and location hierarchies
+- Require maximum performance and minimal overhead
+- Implementing cache-based data structures
+
+## Advanced Features
+
+### Cache Aggregation
+```typescript
+// Complex aggregation with optional and required references
+const ticketAggregator = await createAggregator(ticketCache, {
+  aggregates: {
+    customer: { cache: customerCache, optional: false },    // Always populated
+    order: { cache: orderCache, optional: true },           // Only if orderId exists
+    assignee: { cache: userCache, optional: true }          // Only if assigned
+  },
+  events: {
+    ticketAssigned: async (key, ticket) => {
+      await notifyAssignee(ticket);
+    }
+  }
+});
+
+// Automatic population includes all available references
+const populatedTicket = await ticketAggregator.populate(ticket);
+```
+
+### Performance Optimization
+```typescript
+// Cache with coordinate and registry
+const cache = await createCache(api, createCoordinate('product'), registry);
+
+// Bulk operations for efficiency
+const [cacheMap, allProducts] = await cache.operations.all();
+const productMap = new Map(allProducts.map(p => [p.id, p]));
+
+// Access cache properties for optimization
+console.log(`Cache coordinate: ${cache.coordinate.kta.join(', ')}`);
+console.log(`Cached items: ${cache.cacheMap.size()}`);
+```
+
+### Storage Integration
+Fjell-cache works with any storage backend through the ClientApi interface:
+- SQL databases (PostgreSQL, MySQL, SQLite)
+- NoSQL databases (MongoDB, DynamoDB, Redis)
+- REST APIs and GraphQL endpoints
+- In-memory stores and mock data
+- File systems and cloud storage
+- Custom data sources
+
+### Error Handling and Resilience
+```typescript
+// Cache with proper error handling through the API layer
+const resilientCache = await createCache(api, createCoordinate('user'), registry);
+
+// Error handling in operations
+try {
+  const [, user] = await resilientCache.operations.get(userKey);
+  return user;
+} catch (error) {
+  // Handle cache errors gracefully
+  console.error('Cache operation failed:', error);
+  // Fallback to direct API call
+  return await api.get(userKey);
+}
+```
+
+This provides the foundation for building scalable, maintainable applications with intelligent caching using fjell-cache.

package/docs/src/index.css

@@ -0,0 +1,3 @@
+/* Custom styles for fjell-cache docs */
+
+/* Additional styles can be added here to customize the cache theme */

package/docs/src/main.tsx

@@ -0,0 +1,12 @@
+import React from 'react'
+import ReactDOM from 'react-dom/client'
+import { DocsApp } from '@fjell/docs-template'
+import '@fjell/docs-template/dist/index.css'
+import config from '../docs.config'
+import './index.css'
+
+ReactDOM.createRoot(document.getElementById('root')!).render(
+  <React.StrictMode>
+    <DocsApp config={config} />
+  </React.StrictMode>
+)

package/docs/src/test/setup.ts

@@ -0,0 +1 @@
+import '@testing-library/jest-dom'

package/docs/tsconfig.node.json

@@ -0,0 +1,15 @@
+{
+  "compilerOptions": {
+    "composite": true,
+    "skipLibCheck": true,
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "allowSyntheticDefaultImports": true,
+    "strict": true,
+    "noEmit": true
+  },
+  "include": [
+    "vite.config.ts",
+    "docs.config.ts"
+  ]
+}

package/examples/README.md

@@ -6,11 +6,11 @@ This directory contains examples demonstrating how to use fjell-cache for cachin
 
 ### 1. `basic-cache-example.ts` ⭐ **Start Here!**
 **Perfect for beginners!** Demonstrates the fundamental way to use fjell-cache for data caching:
-- **Basic cache operations** - Create caches, get/set items, manage cache lifecycle
+- **Basic cache operations** - Create caches with coordinates and registries, use operations API
 - **Simple data models** - User and Task entities with mock storage
-- **Registry and Instance creation** - Set up cache model instances
+- **Cache-as-Instance architecture** - Caches extend Instance from fjell-registry
 - **Cache hits vs misses** - Understand cache behavior and performance benefits
-- **Cache management** - Updates, deletions, and data consistency
+- **Cache management** - Updates, deletions, and data consistency through operations
 
 Great for understanding the fundamentals of fjell-cache data management.
 
@@ -39,7 +39,8 @@ Perfect for understanding the underlying cache mechanisms and advanced use cases
 ### Basic Caching Operations (basic-cache-example.ts)
 ```typescript
 // Import fjell-cache functionality
-import { createCache, createRegistry, createInstance } from '@fjell/cache';
+import { createCache } from '@fjell/cache';
+import { createCoordinate, createRegistry } from '@fjell/registry';
 import { ClientApi } from '@fjell/client-api';
 
 // Create a registry for cache management
@@ -47,17 +48,15 @@ const registry = createRegistry();
 
 // Create a cache instance with API integration
 const userApi = createUserApi(); // Your API implementation
-const userCache = await createCache(userApi, 'user');
-
-// Create cache model instance
-const userInstance = createInstance(registry, createCoordinate('user'), userCache);
+const userCache = await createCache(userApi, createCoordinate('user'), registry);
 
-// Perform cache operations
-const [cacheMap, allUsers] = await userInstance.cache.all();
-const [, cachedUser] = await userInstance.cache.get(userKey);
-const [, retrievedUser] = await userInstance.cache.retrieve(userKey); // Cache hit!
+// Cache is now an instance - no need for separate createInstance call
+// Perform cache operations through the operations API
+const [cacheMap, allUsers] = await userCache.operations.all();
+const [, cachedUser] = await userCache.operations.get(userKey);
+const [, retrievedUser] = await userCache.operations.retrieve(userKey); // Cache hit!
 
-await userInstance.cache.set(userKey, updatedUser);
+await userCache.operations.set(userKey, updatedUser);
 ```
 
 ### Advanced Aggregation (aggregator-example.ts)
@@ -78,8 +77,8 @@ if (populatedOrder.aggs?.customer?.item) {
   console.log(`Order for: ${customer.name} (${customer.email})`);
 }
 
-// Create aggregated cache instance
-const orderInstance = createInstance(registry, createCoordinate('order'), orderAggregator);
+// Aggregator is now itself an instance - access operations directly
+const [, orders] = await orderAggregator.all();
 ```
 
 ### Direct Cache Management (cache-map-example.ts)
@@ -262,18 +261,16 @@ const populatedTicket = await ticketAggregator.populate(ticket);
 
 ### Performance Optimization
 ```typescript
-// Cache with performance tuning
-const cache = await createCache(api, 'product', {
-  batchSize: 100,          // Batch operations
-  prefetch: true,          // Prefetch related items
-  compression: true,       // Compress cached data
-  ttl: 3600000,           // 1 hour cache lifetime
-  maxSize: 10000          // Maximum cached items
-});
+// Cache with coordinate and registry
+const cache = await createCache(api, createCoordinate('product'), registry);
 
 // Bulk operations for efficiency
-const [cacheMap, allProducts] = await cache.all();
+const [cacheMap, allProducts] = await cache.operations.all();
 const productMap = new Map(allProducts.map(p => [p.id, p]));
+
+// Access cache properties for optimization
+console.log(`Cache coordinate: ${cache.coordinate.kta.join(', ')}`);
+console.log(`Cached items: ${cache.cacheMap.size()}`);
 ```
 
 ### Storage Integration
@@ -287,21 +284,19 @@ Fjell-cache works with any storage backend through the ClientApi interface:
 
 ### Error Handling and Resilience
 ```typescript
-// Cache with error handling
-const resilientCache = await createCache(api, 'user', {
-  fallback: async (key) => {
-    // Fallback to secondary storage
-    return await secondaryStorage.get(key);
-  },
-  retryPolicy: {
-    attempts: 3,
-    backoff: 'exponential'
-  },
-  circuit: {
-    failureThreshold: 5,
-    resetTimeout: 30000
-  }
-});
+// Cache with proper error handling through the API layer
+const resilientCache = await createCache(api, createCoordinate('user'), registry);
+
+// Error handling in operations
+try {
+  const [, user] = await resilientCache.operations.get(userKey);
+  return user;
+} catch (error) {
+  // Handle cache errors gracefully
+  console.error('Cache operation failed:', error);
+  // Fallback to direct API call
+  return await api.get(userKey);
+}
 ```
 
 This provides the foundation for building scalable, maintainable applications with intelligent caching using fjell-cache.

package/examples/aggregator-example.ts

@@ -128,6 +128,7 @@ const createSupportTicket = (
   priority: 'low' | 'medium' | 'high' | 'urgent',
   status: 'open' | 'in-progress' | 'resolved' | 'closed',
   description: string,
+  // eslint-disable-next-line max-params
   orderId?: string): SupportTicket => {
   const ticket: SupportTicket = {
     id, customerId, subject, priority, status, description, orderId,
@@ -181,10 +182,10 @@ export const runAggregatorExample = async (): Promise<void> => {
   const productApi = createMockApi(mockProducts) as ClientApi<Product, 'product'>;
   const ticketApi = createMockApi(mockTickets) as ClientApi<SupportTicket, 'ticket'>;
 
-  const customerCache = await createCache(customerApi, 'customer');
-  const orderCache = await createCache(orderApi, 'order');
-  const productCache = await createCache(productApi, 'product');
-  const ticketCache = await createCache(ticketApi, 'ticket');
+  const customerCache = await createCache(customerApi, createCoordinate('customer'), registry);
+  const orderCache = await createCache(orderApi, createCoordinate('order'), registry);
+  const productCache = await createCache(productApi, createCoordinate('product'), registry);
+  const ticketCache = await createCache(ticketApi, createCoordinate('ticket'), registry);
 
   console.log('✅ Created individual caches for each entity type');
 
@@ -209,19 +210,13 @@ export const runAggregatorExample = async (): Promise<void> => {
     events: {}
   });
 
-  console.log('✅ Created aggregated caches with relationship mappings');
-
-  // Create instances for easier management
-  const orderInstance = createInstance(registry, createCoordinate('order'), orderAggregator);
-  const ticketInstance = createInstance(registry, createCoordinate('ticket'), ticketAggregator);
-
-  console.log('✅ Created aggregated cache instances\n');
+  console.log('✅ Created aggregated caches with relationship mappings (aggregators are now instances)\n');
 
   // Step 4: Basic aggregation - Fetch orders with customer data
   console.log('Step 4: Order aggregation with customer data');
   console.log('--------------------------------------------');
 
-  const [, orders] = await orderInstance.cache.all();
+  const [, orders] = await orderAggregator.all();
   console.log(`📋 Fetched ${orders.length} orders`);
 
   for (const order of orders) {
@@ -243,7 +238,7 @@ export const runAggregatorExample = async (): Promise<void> => {
   console.log('\n\nStep 5: Support ticket aggregation with multiple references');
   console.log('----------------------------------------------------------');
 
-  const [, tickets] = await ticketInstance.cache.all();
+  const [, tickets] = await ticketAggregator.all();
   console.log(`🎫 Fetched ${tickets.length} support tickets`);
 
   for (const ticket of tickets) {
@@ -275,7 +270,7 @@ export const runAggregatorExample = async (): Promise<void> => {
   console.log('\n\nStep 6: Individual item retrieval with aggregation');
   console.log('-------------------------------------------------');
 
-  const [, specificOrder] = await orderInstance.cache.get(order1.key);
+  const [, specificOrder] = await orderAggregator.get(order1.key);
   if (specificOrder) {
     console.log(`🔍 Retrieved specific order: ${specificOrder.id}`);
 

package/examples/basic-cache-example.ts

@@ -146,12 +146,9 @@ export const runBasicCacheExample = async (): Promise<void> => {
   const taskApi = createTaskApi() as ClientApi<Task, 'task'>;
   console.log('✅ Created mock APIs for users and tasks');
 
-  const userCache = await createCache(userApi, 'user');
-  const taskCache = await createCache(taskApi, 'task');
-  console.log('✅ Created cache instances');
-
-  const userInstance = createInstance(registry, createCoordinate('user'), userCache);
-  const taskInstance = createInstance(registry, createCoordinate('task'), taskCache);
+  const userCache = await createCache(userApi, createCoordinate('user'), registry);
+  const taskCache = await createCache(taskApi, createCoordinate('task'), registry);
+  console.log('✅ Created cache instances (which are now also instances)');
   console.log('✅ Created cache model instances\n');
 
   // Step 2: Create some test data
@@ -170,21 +167,21 @@ export const runBasicCacheExample = async (): Promise<void> => {
   console.log('Step 3: Cache operations - Fetching all items');
   console.log('----------------------------------------------');
 
-  const [, allUsers] = await userInstance.cache.all();
-  console.log(`📋 Cached ${allUsers.length} users:`, allUsers.map(u => u.name));
+  const [, allUsers] = await userCache.operations.all();
+  console.log(`📋 Cached ${allUsers.length} users:`, allUsers.map((u: User) => u.name));
 
-  const [, allTasks] = await taskInstance.cache.all();
-  console.log(`📋 Cached ${allTasks.length} tasks:`, allTasks.map(t => t.title));
+  const [, allTasks] = await taskCache.operations.all();
+  console.log(`📋 Cached ${allTasks.length} tasks:`, allTasks.map((t: Task) => t.title));
   console.log('');
 
   // Step 4: Individual item retrieval from cache
   console.log('Step 4: Individual item retrieval');
   console.log('---------------------------------');
 
-  const [, cachedUser1] = await userInstance.cache.get(user1.key);
+  const [, cachedUser1] = await userCache.operations.get(user1.key);
   console.log(`👤 Retrieved from cache: ${cachedUser1?.name} (${cachedUser1?.email})`);
 
-  const [, cachedTask1] = await taskInstance.cache.get(task1.key);
+  const [, cachedTask1] = await taskCache.operations.get(task1.key);
   console.log(`📝 Retrieved from cache: ${cachedTask1?.title} - Status: ${cachedTask1?.status}`);
   console.log('');
 
@@ -194,14 +191,14 @@ export const runBasicCacheExample = async (): Promise<void> => {
 
   // This should hit the cache (no API call)
   console.log('🎯 Second retrieval (should hit cache):');
-  const [, cachedUser1Again] = await userInstance.cache.retrieve(user1.key);
+  const [, cachedUser1Again] = await userCache.operations.retrieve(user1.key);
   console.log(`👤 Retrieved: ${cachedUser1Again?.name} (cache hit)`);
 
   // Create a new user and demonstrate cache miss
   const user3 = createTestUser('user-3', 'Charlie Brown', 'charlie@example.com', 'guest');
 
   console.log('🎯 New item retrieval (cache miss, will fetch from API):');
-  const [, cachedUser3] = await userInstance.cache.get(user3.key);
+  const [, cachedUser3] = await userCache.operations.get(user3.key);
   console.log(`👤 Retrieved: ${cachedUser3?.name} (fetched from API and cached)`);
   console.log('');
 
@@ -213,7 +210,7 @@ export const runBasicCacheExample = async (): Promise<void> => {
   mockTaskStorage.set(task2.id, updatedTask2);
 
   // Update cache with new version
-  await taskInstance.cache.set(updatedTask2.key, updatedTask2);
+  await taskCache.operations.set(updatedTask2.key, updatedTask2);
   console.log(`🔄 Updated task in cache: ${updatedTask2.title} - New status: ${updatedTask2.status}`);
   console.log('');
 
@@ -221,10 +218,10 @@ export const runBasicCacheExample = async (): Promise<void> => {
   console.log('Step 7: Query operations');
   console.log('-----------------------');
 
-  const [, foundTasks] = await taskInstance.cache.find('all');
+  const [, foundTasks] = await taskCache.operations.find('all');
   console.log(`🔍 Found ${foundTasks.length} tasks through cache query`);
 
-  const [, oneTask] = await taskInstance.cache.one();
+  const [, oneTask] = await taskCache.operations.one();
   console.log(`📝 Retrieved one task: ${oneTask?.title}`);
   console.log('');
 
@@ -235,8 +232,8 @@ export const runBasicCacheExample = async (): Promise<void> => {
   console.log('📊 Cache Statistics:');
   console.log(`   👥 Users in cache: ${allUsers.length}`);
   console.log(`   📝 Tasks in cache: ${allTasks.length}`);
-  console.log(`   🎯 User cache coordinate: ${userInstance.coordinate.kta[0]}`);
-  console.log(`   🎯 Task cache coordinate: ${taskInstance.coordinate.kta[0]}`);
+  console.log(`   🎯 User cache coordinate: ${userCache.coordinate.kta[0]}`);
+  console.log(`   🎯 Task cache coordinate: ${taskCache.coordinate.kta[0]}`);
   console.log('');
 
   // Step 9: Cleanup demonstration
@@ -247,11 +244,11 @@ export const runBasicCacheExample = async (): Promise<void> => {
   console.log('🗑️ Removed user from storage');
 
   // Cache still has the old data until next fetch
-  const [, stillCachedUser3] = await userInstance.cache.retrieve(user3.key);
+  const [, stillCachedUser3] = await userCache.operations.retrieve(user3.key);
   console.log(`🎯 Cache still contains removed user: ${stillCachedUser3?.name || 'null'}`);
 
   // Fresh fetch will update cache
-  const [, freshAllUsers] = await userInstance.cache.all();
+  const [, freshAllUsers] = await userCache.operations.all();
   console.log(`📋 Fresh fetch shows ${freshAllUsers.length} users (cache updated)`);
   console.log('');