Caching Adapter

import { SyncServer } from '@gluonic/server'
import { PrismaAdapter } from '@gluonic/server-prisma'
import { CachingAdapter, RedisCache } from '@gluonic/caching-redis'
 
// 1. Create database adapter
const dbAdapter = PrismaAdapter({ prisma })
 
// 2. Create cache
const cache = RedisCache({ url: 'redis://localhost:6379' })
 
// 3. Wrap with caching
const database = CachingAdapter({
  adapter: dbAdapter,
  cache,
  strategies: {
    bootstrap: { ttl: 600 },       // Cache 10 minutes
    records: { ttl: 60 },           // Cache 1 minute
    syncActions: { ttl: 30 }        // Cache 30 seconds
  }
})
 
// 4. Use cached adapter
const server = SyncServer({
  database,  // Caching transparent! ✓
  auth
})

import { createRedisCache } from '@gluonic/server/adapters'
 
const cache = createRedisCache('redis://localhost:6379', {
  keyPrefix: 'gluonic:',
  maxRetries: 3,
  retryDelay: 100
})

import { createMemoryCache } from '@gluonic/server/adapters'
 
const cache = createMemoryCache({
  maxSize: 1000,      // Max entries
  ttl: 300            // Default TTL (seconds)
})

import { createNoOpCache } from '@gluonic/server/adapters'
 
const cache = createNoOpCache()  // Pass-through, no caching

strategies: {
  bootstrap: {
    ttl: 600,                    // 10 minutes
    keyPattern: 'bootstrap:{orgId}',
    invalidateOn: ['mutation']   // Clear on any mutation
  }
}

strategies: {
  records: {
    ttl: 60,                     // 1 minute
    keyPattern: '{model}:{id}',
    invalidateOn: ['update', 'delete']
  }
}

strategies: {
  queries: {
    ttl: 30,                     // 30 seconds
    keyPattern: 'query:{model}:{hash}',
    invalidateOn: ['mutation']
  }
}

// When mutation happens:
await adapter.applyMutations(orgId, userId, [
  { type: 'post', id: '123', op: 'u', patch: { title: 'New' } }
])
 
// Adapter automatically invalidates:
cache.invalidate('post:123')           // Record cache
cache.invalidate('bootstrap:*')        // Bootstrap caches
cache.invalidate('query:post:*')       // Post queries
 
// Next request gets fresh data ✓

// Clear specific key
await cache.invalidate('post:123')
 
// Clear pattern
await cache.invalidate('post:*')
 
// Clear all
await cache.invalidateAll()

GET /sync/v1/bootstrap
  → Query database (1200ms)
  → Serialize (100ms)
  → Total: 1300ms 😔

GET /sync/v1/bootstrap (first)
  → Query database (1200ms)
  → Serialize (100ms)
  → Cache result
  → Total: 1300ms

GET /sync/v1/bootstrap (cached)
  → Read from Redis (15ms)
  → Total: 15ms ✓

Improvement: 86x faster! 🎉

interface CachingAdapter {
  get(key: string): Promise<any | null>
  set(key: string, value: any, ttl?: number): Promise<void>
  invalidate(pattern: string): Promise<void>
  wrap<T>(key: string, fn: () => Promise<T>, ttl?: number): Promise<T>
}

// Automatic caching with wrap()
const data = await cache.wrap(
  'bootstrap:org-123',
  async () => {
    // Only called if cache miss
    return await adapter.bootstrap('org-123')
  },
  600  // TTL: 10 minutes
)

const metrics = await cache.getMetrics()
 
console.log({
  hits: metrics.hits,           // Cache hits
  misses: metrics.misses,       // Cache misses
  hitRate: metrics.hitRate,     // Hit rate %
  evictions: metrics.evictions  // Evicted entries
})

const cacheAdapter = createCachingAdapter({
  adapter: dbAdapter,
  cache,
  onCacheHit: (key, duration) => {
    console.log(`Cache hit: ${key} (${duration}ms saved)`)
  },
  onCacheMiss: (key) => {
    console.log(`Cache miss: ${key}`)
  }
})