@open-mercato/cache 0.9.1-develop.7573.1.d0ccc51d5b → 0.9.1-develop.7575.1.8480826a9b

package/src/__tests__/redis.strategy.test.ts

@@ -5,7 +5,7 @@ import { createRedisStrategy } from '../strategies/redis'
 type PipelineOp = () => void
 
 class FakeRedis {
-  values = new Map<string, string | Buffer>()
+  values = new Map<string, string>()
   sets = new Map<string, Set<string>>()
   /** Records the shape of each reap script call so tests can assert its cost. */
   evalCalls: { numKeys: number; memberCount: number }[] = []
@@ -15,23 +15,15 @@ class FakeRedis {
   }
 
   async get(key: string): Promise<string | null> {
-    const value = this.values.get(key)
-    if (value === undefined) return null
-    return Buffer.isBuffer(value) ? value.toString('utf8') : value
+    return this.values.get(key) ?? null
   }
 
-  async getBuffer(key: string): Promise<Buffer | null> {
-    const value = this.values.get(key)
-    if (value === undefined) return null
-    return Buffer.isBuffer(value) ? value : Buffer.from(value, 'utf8')
-  }
-
-  async set(key: string, value: string | Buffer): Promise<unknown> {
+  async set(key: string, value: string): Promise<unknown> {
     this.values.set(key, value)
     return 'OK'
   }
 
-  async setex(key: string, _ttlSeconds: number, value: string | Buffer): Promise<unknown> {
+  async setex(key: string, _ttlSeconds: number, value: string): Promise<unknown> {
     this.values.set(key, value)
     return 'OK'
   }
@@ -83,11 +75,11 @@ class FakeRedis {
   pipeline() {
     const ops: PipelineOp[] = []
     const chain = {
-      set: (key: string, value: string | Buffer) => {
+      set: (key: string, value: string) => {
         ops.push(() => void this.values.set(key, value))
         return chain
       },
-      setex: (key: string, _ttlSeconds: number, value: string | Buffer) => {
+      setex: (key: string, _ttlSeconds: number, value: string) => {
         ops.push(() => void this.values.set(key, value))
         return chain
       },
@@ -210,9 +202,9 @@ describe('redis strategy tag index', () => {
     // deleteByTags walks members one round trip at a time, so an entry it read
     // as missing can be rebuilt before the reap runs. Land that write in the
     // window by hooking the GET that reports the key absent.
-    const readValue = currentRedis.getBuffer.bind(currentRedis)
+    const readValue = currentRedis.get.bind(currentRedis)
     let rebuilt = false
-    currentRedis.getBuffer = async (key: string) => {
+    currentRedis.get = async (key: string) => {
       const result = await readValue(key)
       if (!rebuilt && key === 'cache:nav:user-1' && result === null) {
         rebuilt = true
@@ -222,7 +214,7 @@ describe('redis strategy tag index', () => {
     }
 
     await strategy.deleteByTags(['rbac:tenant:t1'])
-    currentRedis.getBuffer = readValue
+    currentRedis.get = readValue
 
     // The rebuilt entry must stay in the index, or it silently outlives every
     // future invalidation of this tag and serves stale data until its TTL.
@@ -284,95 +276,3 @@ describe('redis strategy tag index', () => {
     expect(await currentRedis.smembers('tag:tag-b')).toEqual(['key-1'])
   })
 })
-
-describe('redis strategy value compression', () => {
-  let urlCounter = 0
-  const largeValue = {
-    items: Array.from({ length: 100 }, (_, index) => ({ id: `row-${index}`, name: `Contact ${index}`, status: 'active' })),
-  }
-
-  function createStrategy(compression: 'off' | 'zstd' | 'gzip'): CacheStrategy {
-    urlCounter += 1
-    return createRedisStrategy(`redis://cache-compression-test-${urlCounter}`, { compression })
-  }
-
-  beforeEach(() => {
-    currentRedis = new FakeRedis()
-  })
-
-  it.each([
-    ['zstd', [0x28, 0xb5, 0x2f, 0xfd]],
-    ['gzip', [0x1f, 0x8b]],
-  ] as const)('stores large entries as %s frames and reads them back', async (compression, magic) => {
-    const strategy = createStrategy(compression)
-
-    await strategy.set('list:page:1', largeValue, { ttl: 60_000, tags: ['customers'] })
-
-    const stored = currentRedis.values.get('cache:list:page:1')
-    expect(Buffer.isBuffer(stored)).toBe(true)
-    expect(magic.every((byte, index) => (stored as Buffer)[index] === byte)).toBe(true)
-    expect(await strategy.get('list:page:1')).toEqual(largeValue)
-    expect(await strategy.has('list:page:1')).toBe(true)
-    await strategy.close?.()
-  })
-
-  it('keeps small entries as plain JSON strings', async () => {
-    const strategy = createStrategy('zstd')
-
-    await strategy.set('small', { id: 1 })
-
-    expect(typeof currentRedis.values.get('cache:small')).toBe('string')
-    expect(await strategy.get('small')).toEqual({ id: 1 })
-    await strategy.close?.()
-  })
-
-  it('reads legacy and compressed entries side by side in either direction', async () => {
-    const legacy = createStrategy('off')
-    await legacy.set('legacy', largeValue)
-    const compressed = createStrategy('zstd')
-    await compressed.set('compressed', largeValue)
-
-    expect(typeof currentRedis.values.get('cache:legacy')).toBe('string')
-    expect(await compressed.get('legacy')).toEqual(largeValue)
-    expect(await legacy.get('compressed')).toEqual(largeValue)
-    await legacy.close?.()
-    await compressed.close?.()
-  })
-
-  it('moves tag memberships when a compressed entry is overwritten', async () => {
-    const strategy = createStrategy('zstd')
-
-    await strategy.set('list', largeValue, { tags: ['old-tag'] })
-    await strategy.set('list', largeValue, { tags: ['new-tag'] })
-
-    expect(await currentRedis.smembers('tag:old-tag')).toEqual([])
-    expect(await currentRedis.smembers('tag:new-tag')).toEqual(['list'])
-    expect(await strategy.deleteByTags(['new-tag'])).toBe(1)
-    expect(currentRedis.values.has('cache:list')).toBe(false)
-    expect(await currentRedis.smembers('tag:new-tag')).toEqual([])
-    await strategy.close?.()
-  })
-
-  it('counts and cleans up expired compressed entries', async () => {
-    const strategy = createStrategy('gzip')
-    await strategy.set('fresh', largeValue, { ttl: 60_000, tags: ['t'] })
-    await strategy.set('stale', largeValue, { ttl: 1, tags: ['t'] })
-    await new Promise((resolve) => setTimeout(resolve, 5))
-
-    expect(await strategy.stats()).toEqual({ size: 2, expired: 1 })
-    expect(await strategy.cleanup?.()).toBe(1)
-    expect(currentRedis.values.has('cache:fresh')).toBe(true)
-    expect(currentRedis.values.has('cache:stale')).toBe(false)
-    expect(await currentRedis.smembers('tag:t')).toEqual(['fresh'])
-    await strategy.close?.()
-  })
-
-  it('drops a corrupt frame as a miss', async () => {
-    const strategy = createStrategy('zstd')
-    currentRedis.values.set('cache:broken', Buffer.from([0x28, 0xb5, 0x2f, 0xfd, 0xff, 0xff, 0xff]))
-
-    expect(await strategy.get('broken')).toBeNull()
-    expect(currentRedis.values.has('cache:broken')).toBe(false)
-    await strategy.close?.()
-  })
-})

package/src/__tests__/service.test.ts

@@ -392,57 +392,3 @@ describe('Cache Service stats() counter gating', () => {
     expect(stats.lastSweepReclaimed).toBe(3)
   })
 })
-
-describe('Cache Service compression resolution (CACHE_COMPRESSION)', () => {
-  afterEach(() => {
-    delete process.env.CACHE_COMPRESSION
-    delete process.env.CACHE_COMPRESSION_MIN_BYTES
-    jest.restoreAllMocks()
-  })
-
-  const captureSqliteOptions = () => {
-    const spy = jest.spyOn(sqliteStrategyModule, 'createSqliteStrategy')
-    spy.mockImplementation((_path, options) => {
-      return memoryStrategyModule.createMemoryStrategy({ defaultTtl: options?.defaultTtl })
-    })
-    return spy
-  }
-
-  it('passes the env compression settings to persistent strategies', () => {
-    process.env.CACHE_COMPRESSION = 'zstd'
-    process.env.CACHE_COMPRESSION_MIN_BYTES = '2048'
-    const spy = captureSqliteOptions()
-
-    createCacheService({ strategy: 'sqlite' })
-
-    expect(spy.mock.calls[0][1]).toMatchObject({ compression: 'zstd', compressionMinBytes: 2048 })
-  })
-
-  it('lets explicit options override the env', () => {
-    process.env.CACHE_COMPRESSION = 'zstd'
-    const spy = captureSqliteOptions()
-
-    createCacheService({ strategy: 'sqlite', compression: 'gzip', compressionMinBytes: 512 })
-
-    expect(spy.mock.calls[0][1]).toMatchObject({ compression: 'gzip', compressionMinBytes: 512 })
-  })
-
-  it('keeps compression off for an unknown env value and warns', () => {
-    process.env.CACHE_COMPRESSION = 'lz4-service-test'
-    const warn = jest.spyOn(console, 'warn').mockImplementation(() => {})
-    const spy = captureSqliteOptions()
-
-    createCacheService({ strategy: 'sqlite' })
-
-    expect(spy.mock.calls[0][1]).toMatchObject({ compression: 'off' })
-    expect(warn).toHaveBeenCalledWith(expect.stringContaining('lz4-service-test'))
-  })
-
-  it('defaults to off with no env and no options', () => {
-    const spy = captureSqliteOptions()
-
-    createCacheService({ strategy: 'sqlite' })
-
-    expect(spy.mock.calls[0][1]).toMatchObject({ compression: 'off', compressionMinBytes: undefined })
-  })
-})

package/src/__tests__/sqlite.strategy.test.ts

@@ -3,7 +3,7 @@ import os from 'node:os'
 import path from 'node:path'
 import { createSqliteStrategy } from '../strategies/sqlite'
 
-type CacheEntry = { value: string | Buffer; expires_at: number | null; created_at: number }
+type CacheEntry = { value: string; expires_at: number | null; created_at: number }
 
 class MockSqliteDatabase {
   static instances: MockSqliteDatabase[] = []
@@ -90,7 +90,7 @@ class MockSqliteDatabase {
     if (sql.startsWith('INSERT OR REPLACE INTO cache_entries')) {
       const [key, value, expiresAt, createdAt] = args
       this.entries.set(String(key), {
-        value: Buffer.isBuffer(value) ? value : String(value),
+        value: String(value),
         expires_at: expiresAt === null ? null : Number(expiresAt),
         created_at: Number(createdAt),
       })
@@ -161,54 +161,3 @@ describe('SQLite Cache Strategy', () => {
     await cache.close?.()
   })
 })
-
-describe('SQLite Cache Strategy value compression (better-sqlite3)', () => {
-  const largeValue = {
-    items: Array.from({ length: 100 }, (_, index) => ({ id: `row-${index}`, name: `Contact ${index}`, status: 'active' })),
-  }
-  let tempDir: string
-  let dbPath: string
-
-  beforeEach(() => {
-    tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'open-mercato-cache-compression-'))
-    dbPath = path.join(tempDir, 'cache.db')
-  })
-
-  afterEach(() => {
-    fs.rmSync(tempDir, { recursive: true, force: true })
-  })
-
-  function storedTypes(): Record<string, string> {
-    const Database = require('better-sqlite3') as typeof import('better-sqlite3')
-    const db = new Database(dbPath, { readonly: true })
-    try {
-      const rows = db.prepare('SELECT key, typeof(value) AS type FROM cache_entries').all() as { key: string; type: string }[]
-      return Object.fromEntries(rows.map((row) => [row.key, row.type]))
-    } finally {
-      db.close()
-    }
-  }
-
-  it.each(['zstd', 'gzip'] as const)('stores large %s entries as BLOBs next to legacy TEXT rows', async (compression) => {
-    const legacy = createSqliteStrategy(dbPath, { compression: 'off' })
-    await legacy.set('legacy', largeValue, { tags: ['customers'] })
-    await legacy.close?.()
-
-    const cache = createSqliteStrategy(dbPath, { compression })
-    await cache.set('compressed', largeValue, { tags: ['customers'] })
-    await cache.set('small', { id: 1 }, { tags: ['customers'] })
-
-    expect(await cache.get('legacy')).toEqual(largeValue)
-    expect(await cache.get('compressed')).toEqual(largeValue)
-    expect(await cache.get('small')).toEqual({ id: 1 })
-    await cache.close?.()
-
-    expect(storedTypes()).toEqual({ legacy: 'text', compressed: 'blob', small: 'text' })
-
-    const off = createSqliteStrategy(dbPath, { compression: 'off' })
-    expect(await off.get('compressed')).toEqual(largeValue)
-    expect(await off.deleteByTags(['customers'])).toBe(3)
-    expect(await off.get('compressed')).toBeNull()
-    await off.close?.()
-  })
-})

package/src/service.ts

@@ -7,8 +7,6 @@ import { getCurrentCacheTenant } from './tenantContext'
 import { createHash } from 'node:crypto'
 import { CacheDependencyUnavailableError } from './errors'
 import { matchCacheKeyPattern } from './patterns'
-import { parseCacheCompression, parseCacheCompressionMinBytes } from './codec'
-import type { CacheCodecOptions } from './codec'
 
 function normalizeTenantKey(raw: string | null | undefined): string {
   const value = typeof raw === 'string' ? raw.trim() : ''
@@ -262,12 +260,7 @@ function createConfiguredTenantAwareStrategy(options?: CacheServiceOptions): Ten
   const parsedEnvMaxEntries = envMaxEntries ? Number.parseInt(envMaxEntries, 10) : undefined
   const maxEntries = options?.maxEntries ?? (typeof parsedEnvMaxEntries === 'number' && Number.isFinite(parsedEnvMaxEntries) ? parsedEnvMaxEntries : undefined)
 
-  const codecOptions: CacheCodecOptions = {
-    compression: options?.compression ?? parseCacheCompression(process.env.CACHE_COMPRESSION),
-    compressionMinBytes: options?.compressionMinBytes ?? parseCacheCompressionMinBytes(process.env.CACHE_COMPRESSION_MIN_BYTES),
-  }
-
-  const baseStrategy = createStrategyForType(strategyType, options, defaultTtl, maxEntries, codecOptions)
+  const baseStrategy = createStrategyForType(strategyType, options, defaultTtl, maxEntries)
   const resilientStrategy = withDependencyFallback(baseStrategy, strategyType, defaultTtl, maxEntries)
   const reportsBoundedCounters = strategyType === 'memory'
 
@@ -283,8 +276,6 @@ function createConfiguredTenantAwareStrategy(options?: CacheServiceOptions): Ten
  * - CACHE_REDIS_URL: Redis connection URL (for redis strategy)
  * - CACHE_SQLITE_PATH: SQLite database file path (for sqlite strategy)
  * - CACHE_JSON_FILE_PATH: JSON file path (for jsonfile strategy)
- * - CACHE_COMPRESSION: 'off' | 'zstd' | 'gzip' value compression for redis/sqlite (default: 'off')
- * - CACHE_COMPRESSION_MIN_BYTES: smallest serialized entry that gets compressed (default: 1024)
  *
  * @example
  * const cache = createCacheService({ strategy: 'memory', defaultTtl: 60000 })
@@ -382,12 +373,12 @@ export class CacheService implements CacheStrategy {
   }
 }
 
-function createStrategyForType(strategyType: CacheStrategyName, options?: CacheServiceOptions, defaultTtl?: number, maxEntries?: number, codecOptions?: CacheCodecOptions): CacheStrategy {
+function createStrategyForType(strategyType: CacheStrategyName, options?: CacheServiceOptions, defaultTtl?: number, maxEntries?: number): CacheStrategy {
   switch (strategyType) {
     case 'redis':
-      return createRedisStrategy(options?.redisUrl, { defaultTtl, ...codecOptions })
+      return createRedisStrategy(options?.redisUrl, { defaultTtl })
     case 'sqlite':
-      return createSqliteStrategy(options?.sqlitePath, { defaultTtl, ...codecOptions })
+      return createSqliteStrategy(options?.sqlitePath, { defaultTtl })
     case 'jsonfile':
       return createJsonFileStrategy(options?.jsonFilePath, { defaultTtl })
     case 'memory':

package/src/strategies/redis.ts

@@ -3,12 +3,10 @@ import { CacheDependencyUnavailableError } from '../errors'
 import { getRedisUrlOrThrow, REDIS_WIRE_PROTOCOL } from '@open-mercato/shared/lib/redis/connection'
 import type { RedisProtocolVersion } from '@open-mercato/shared/lib/redis/connection'
 import { matchCacheKeyPattern } from '../patterns'
-import { decodeCacheText, encodeCacheText, resolveCacheCodecConfig } from '../codec'
-import type { CacheCodecOptions } from '../codec'
 
 type RedisPipeline = {
-  set(key: string, value: string | Buffer): RedisPipeline
-  setex(key: string, ttlSeconds: number, value: string | Buffer): RedisPipeline
+  set(key: string, value: string): RedisPipeline
+  setex(key: string, ttlSeconds: number, value: string): RedisPipeline
   sadd(key: string, value: string): RedisPipeline
   srem(key: string, member: string): RedisPipeline
   del(key: string): RedisPipeline
@@ -19,9 +17,8 @@ type RedisPipeline = {
 type RedisClient = {
   ping(): Promise<string>
   get(key: string): Promise<string | null>
-  getBuffer(key: string): Promise<Buffer | null>
-  set(key: string, value: string | Buffer): Promise<unknown>
-  setex(key: string, ttlSeconds: number, value: string | Buffer): Promise<unknown>
+  set(key: string, value: string): Promise<unknown>
+  setex(key: string, ttlSeconds: number, value: string): Promise<unknown>
   del(key: string): Promise<unknown>
   exists(key: string): Promise<number>
   keys(pattern: string): Promise<string[]>
@@ -189,9 +186,8 @@ async function releaseRedisEntry(key: string, entry: RedisRegistryEntry): Promis
   }
 }
 
-export function createRedisStrategy(redisUrl?: string, options?: { defaultTtl?: number } & CacheCodecOptions): CacheStrategy {
+export function createRedisStrategy(redisUrl?: string, options?: { defaultTtl?: number }): CacheStrategy {
   const defaultTtl = options?.defaultTtl
-  const codec = resolveCacheCodecConfig(options)
   const keyPrefix = 'cache:'
   const tagPrefix = 'tag:'
   const connectionUrl = redisUrl || getRedisUrlOrThrow('CACHE')
@@ -221,12 +217,12 @@ export function createRedisStrategy(redisUrl?: string, options?: { defaultTtl?:
   const get = async (key: string, options?: CacheGetOptions): Promise<CacheValue | null> => {
     const client = await getRedisClient()
     const cacheKey = getCacheKey(key)
-    const data = await client.getBuffer(cacheKey)
+    const data = await client.get(cacheKey)
 
     if (!data) return null
 
     try {
-      const entry: CacheEntry = JSON.parse(decodeCacheText(data))
+      const entry: CacheEntry = JSON.parse(data)
 
       if (isExpired(entry)) {
         if (options?.returnExpired) {
@@ -250,10 +246,10 @@ export function createRedisStrategy(redisUrl?: string, options?: { defaultTtl?:
     const cacheKey = getCacheKey(key)
 
     // Remove old entry from tag index if it exists
-    const oldData = await client.getBuffer(cacheKey)
+    const oldData = await client.get(cacheKey)
     if (oldData) {
       try {
-        const oldEntry: CacheEntry = JSON.parse(decodeCacheText(oldData))
+        const oldEntry: CacheEntry = JSON.parse(oldData)
         // Remove from old tags
         const pipeline = client.pipeline()
         for (const tag of oldEntry.tags) {
@@ -280,7 +276,7 @@ export function createRedisStrategy(redisUrl?: string, options?: { defaultTtl?:
     const pipeline = client.pipeline()
 
     // Store the entry
-    const serialized = encodeCacheText(JSON.stringify(entry), codec)
+    const serialized = JSON.stringify(entry)
     if (ttl) {
       pipeline.setex(cacheKey, Math.ceil(ttl / 1000), serialized)
     } else {
@@ -303,11 +299,11 @@ export function createRedisStrategy(redisUrl?: string, options?: { defaultTtl?:
     if (!exists) return false
 
     // Check if expired
-    const data = await client.getBuffer(cacheKey)
+    const data = await client.get(cacheKey)
     if (!data) return false
 
     try {
-      const entry: CacheEntry = JSON.parse(decodeCacheText(data))
+      const entry: CacheEntry = JSON.parse(data)
       if (isExpired(entry)) {
         await deleteKey(key)
         return false
@@ -323,11 +319,11 @@ export function createRedisStrategy(redisUrl?: string, options?: { defaultTtl?:
     const cacheKey = getCacheKey(key)
 
     // Get entry to remove from tag index
-    const data = await client.getBuffer(cacheKey)
+    const data = await client.get(cacheKey)
     if (!data) return false
 
     try {
-      const entry: CacheEntry = JSON.parse(decodeCacheText(data))
+      const entry: CacheEntry = JSON.parse(data)
       const pipeline = client.pipeline()
 
       // Remove from tag index
@@ -451,10 +447,10 @@ export function createRedisStrategy(redisUrl?: string, options?: { defaultTtl?:
     
     let expired = 0
     for (const cacheKey of cacheKeys) {
-      const data = await client.getBuffer(cacheKey)
+      const data = await client.get(cacheKey)
       if (data) {
         try {
-          const entry: CacheEntry = JSON.parse(decodeCacheText(data))
+          const entry: CacheEntry = JSON.parse(data)
           if (isExpired(entry)) {
             expired++
           }
@@ -473,10 +469,10 @@ export function createRedisStrategy(redisUrl?: string, options?: { defaultTtl?:
     
     let removed = 0
     for (const cacheKey of cacheKeys) {
-      const data = await client.getBuffer(cacheKey)
+      const data = await client.get(cacheKey)
       if (data) {
         try {
-          const entry: CacheEntry = JSON.parse(decodeCacheText(data))
+          const entry: CacheEntry = JSON.parse(data)
           if (isExpired(entry)) {
             const key = cacheKey.substring(keyPrefix.length)
             await deleteKey(key)

package/src/strategies/sqlite.ts

@@ -5,8 +5,6 @@ import path from 'node:path'
 import { CacheDependencyUnavailableError } from '../errors'
 import { DEFAULT_SQLITE_CACHE_PATH } from '../defaults'
 import { matchCacheKeyPattern } from '../patterns'
-import { decodeCacheText, encodeCacheText, resolveCacheCodecConfig } from '../codec'
-import type { CacheCodecOptions } from '../codec'
 
 type SqliteStatement<TResult = unknown> = {
   get(...args: unknown[]): TResult | undefined
@@ -25,7 +23,7 @@ type SqliteDatabase = {
 
 type SqliteConstructor = new (file: string) => SqliteDatabase
 type SqliteModule = SqliteConstructor | { default: SqliteConstructor }
-type SqliteStrategyOptions = { defaultTtl?: number; databaseConstructor?: SqliteConstructor } & CacheCodecOptions
+type SqliteStrategyOptions = { defaultTtl?: number; databaseConstructor?: SqliteConstructor }
 
 const sqliteRequire = createRequire(path.join(process.cwd(), 'package.json'))
 
@@ -40,7 +38,6 @@ const sqliteRequire = createRequire(path.join(process.cwd(), 'package.json'))
 export function createSqliteStrategy(dbPath?: string, options?: SqliteStrategyOptions): CacheStrategy {
   let db: SqliteDatabase | null = null
   const defaultTtl = options?.defaultTtl
-  const codec = resolveCacheCodecConfig(options)
   const filePath = dbPath || process.env.CACHE_SQLITE_PATH || DEFAULT_SQLITE_CACHE_PATH
 
   async function getDb(): Promise<SqliteDatabase> {
@@ -96,7 +93,7 @@ export function createSqliteStrategy(dbPath?: string, options?: SqliteStrategyOp
     return Date.now() > expiresAt
   }
 
-  type EntryRow = { value: string | Buffer; expires_at: number | null }
+  type EntryRow = { value: string; expires_at: number | null }
   type ExpiresRow = { expires_at: number | null }
   type CountRow = { count: number }
   type KeyRow = { key: string }
@@ -110,7 +107,7 @@ export function createSqliteStrategy(dbPath?: string, options?: SqliteStrategyOp
     if (!row) return null
 
     try {
-      const value = JSON.parse(decodeCacheText(row.value)) as CacheValue
+      const value = JSON.parse(row.value) as CacheValue
       const expiresAt = row.expires_at
 
       if (isExpired(expiresAt)) {
@@ -137,7 +134,7 @@ export function createSqliteStrategy(dbPath?: string, options?: SqliteStrategyOp
     const expiresAt = ttl ? Date.now() + ttl : null
     const createdAt = Date.now()
 
-    const serialized = encodeCacheText(JSON.stringify(value), codec)
+    const serialized = JSON.stringify(value)
 
     database.transaction(() => {
       // Delete old tags

package/src/types.ts

@@ -120,15 +120,4 @@ export type CacheServiceOptions = {
    * disables the cap.
    */
   maxEntries?: number
-  /**
-   * Value compression for the redis and sqlite strategies. Falls back to
-   * `CACHE_COMPRESSION`, then `off`. Reads detect the stored format, so
-   * entries written under any setting stay readable.
-   */
-  compression?: 'off' | 'zstd' | 'gzip'
-  /**
-   * Smallest serialized entry, in bytes, that gets compressed. Falls back to
-   * `CACHE_COMPRESSION_MIN_BYTES`, then 1024.
-   */
-  compressionMinBytes?: number
 }

package/dist/codec.js

@@ -1,75 +0,0 @@
-import zlib from "node:zlib";
-const DEFAULT_COMPRESSION_MIN_BYTES = 1024;
-const MAX_DECOMPRESSED_BYTES = 64 * 1024 * 1024;
-const ZSTD_LEVEL = 1;
-const COMPRESSIONS = ["off", "zstd", "gzip"];
-const warnedMessages = /* @__PURE__ */ new Set();
-function warnOnce(message) {
-  if (warnedMessages.has(message)) return;
-  warnedMessages.add(message);
-  console.warn(message);
-}
-function isZstdAvailable() {
-  return typeof zlib.zstdCompressSync === "function" && typeof zlib.zstdDecompressSync === "function";
-}
-function parseCacheCompression(raw) {
-  const value = raw?.trim().toLowerCase();
-  if (!value) return "off";
-  if (COMPRESSIONS.includes(value)) return value;
-  warnOnce(`[cache] Unknown CACHE_COMPRESSION value "${raw}". Compression stays off.`);
-  return "off";
-}
-function parseCacheCompressionMinBytes(raw) {
-  if (!raw) return void 0;
-  const parsed = Number.parseInt(raw, 10);
-  return Number.isFinite(parsed) && parsed > 0 ? parsed : void 0;
-}
-function resolveCacheCodecConfig(options) {
-  const minBytes = options?.compressionMinBytes && options.compressionMinBytes > 0 ? options.compressionMinBytes : DEFAULT_COMPRESSION_MIN_BYTES;
-  let compression = options?.compression ?? "off";
-  if (compression === "zstd" && !isZstdAvailable()) {
-    warnOnce("[cache] zstd is not available in this Node.js runtime. Falling back to gzip cache compression.");
-    compression = "gzip";
-  }
-  return { compression, minBytes };
-}
-function compress(input, compression) {
-  if (compression === "zstd") {
-    return zlib.zstdCompressSync(input, { params: { [zlib.constants.ZSTD_c_compressionLevel]: ZSTD_LEVEL } });
-  }
-  return zlib.gzipSync(input);
-}
-function encodeCacheText(json, config) {
-  if (config.compression === "off") return json;
-  const size = Buffer.byteLength(json);
-  if (size < config.minBytes || size > MAX_DECOMPRESSED_BYTES) return json;
-  const compressed = compress(Buffer.from(json, "utf8"), config.compression);
-  return compressed.length < size ? compressed : json;
-}
-function isZstdFrame(raw) {
-  return raw.length >= 4 && raw[0] === 40 && raw[1] === 181 && raw[2] === 47 && raw[3] === 253;
-}
-function isGzipStream(raw) {
-  return raw.length >= 2 && raw[0] === 31 && raw[1] === 139;
-}
-function decodeCacheText(raw) {
-  if (typeof raw === "string") return raw;
-  if (isZstdFrame(raw)) {
-    return zlib.zstdDecompressSync(raw, { maxOutputLength: MAX_DECOMPRESSED_BYTES }).toString("utf8");
-  }
-  if (isGzipStream(raw)) {
-    return zlib.gunzipSync(raw, { maxOutputLength: MAX_DECOMPRESSED_BYTES }).toString("utf8");
-  }
-  return raw.toString("utf8");
-}
-export {
-  DEFAULT_COMPRESSION_MIN_BYTES,
-  MAX_DECOMPRESSED_BYTES,
-  decodeCacheText,
-  encodeCacheText,
-  isZstdAvailable,
-  parseCacheCompression,
-  parseCacheCompressionMinBytes,
-  resolveCacheCodecConfig
-};
-//# sourceMappingURL=codec.js.map

package/dist/codec.js.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../src/codec.ts"],
-  "sourcesContent": ["import zlib from 'node:zlib'\n\nexport type CacheCompression = 'off' | 'zstd' | 'gzip'\n\nexport type CacheCodecConfig = {\n  compression: CacheCompression\n  minBytes: number\n}\n\nexport type CacheCodecOptions = {\n  compression?: CacheCompression\n  compressionMinBytes?: number\n}\n\nexport const DEFAULT_COMPRESSION_MIN_BYTES = 1024\n\n/** Upper bound for one decompressed entry; larger JSON is never compressed, so no legitimate entry can hit it. */\nexport const MAX_DECOMPRESSED_BYTES = 64 * 1024 * 1024\n\nconst ZSTD_LEVEL = 1\nconst COMPRESSIONS: CacheCompression[] = ['off', 'zstd', 'gzip']\n\nconst warnedMessages = new Set<string>()\n\nfunction warnOnce(message: string): void {\n  if (warnedMessages.has(message)) return\n  warnedMessages.add(message)\n  console.warn(message)\n}\n\nexport function isZstdAvailable(): boolean {\n  return typeof zlib.zstdCompressSync === 'function' && typeof zlib.zstdDecompressSync === 'function'\n}\n\nexport function parseCacheCompression(raw: string | undefined): CacheCompression {\n  const value = raw?.trim().toLowerCase()\n  if (!value) return 'off'\n  if (COMPRESSIONS.includes(value as CacheCompression)) return value as CacheCompression\n  warnOnce(`[cache] Unknown CACHE_COMPRESSION value \"${raw}\". Compression stays off.`)\n  return 'off'\n}\n\nexport function parseCacheCompressionMinBytes(raw: string | undefined): number | undefined {\n  if (!raw) return undefined\n  const parsed = Number.parseInt(raw, 10)\n  return Number.isFinite(parsed) && parsed > 0 ? parsed : undefined\n}\n\nexport function resolveCacheCodecConfig(options?: CacheCodecOptions): CacheCodecConfig {\n  const minBytes = options?.compressionMinBytes && options.compressionMinBytes > 0\n    ? options.compressionMinBytes\n    : DEFAULT_COMPRESSION_MIN_BYTES\n  let compression = options?.compression ?? 'off'\n  if (compression === 'zstd' && !isZstdAvailable()) {\n    warnOnce('[cache] zstd is not available in this Node.js runtime. Falling back to gzip cache compression.')\n    compression = 'gzip'\n  }\n  return { compression, minBytes }\n}\n\nfunction compress(input: Buffer, compression: Exclude<CacheCompression, 'off'>): Buffer {\n  if (compression === 'zstd') {\n    return zlib.zstdCompressSync(input, { params: { [zlib.constants.ZSTD_c_compressionLevel]: ZSTD_LEVEL } })\n  }\n  return zlib.gzipSync(input)\n}\n\nexport function encodeCacheText(json: string, config: CacheCodecConfig): string | Buffer {\n  if (config.compression === 'off') return json\n  const size = Buffer.byteLength(json)\n  if (size < config.minBytes || size > MAX_DECOMPRESSED_BYTES) return json\n  const compressed = compress(Buffer.from(json, 'utf8'), config.compression)\n  return compressed.length < size ? compressed : json\n}\n\nfunction isZstdFrame(raw: Buffer): boolean {\n  return raw.length >= 4 && raw[0] === 0x28 && raw[1] === 0xb5 && raw[2] === 0x2f && raw[3] === 0xfd\n}\n\nfunction isGzipStream(raw: Buffer): boolean {\n  return raw.length >= 2 && raw[0] === 0x1f && raw[1] === 0x8b\n}\n\n/** Detects the format from the stored bytes, so entries stay readable whatever CACHE_COMPRESSION is set to now. */\nexport function decodeCacheText(raw: string | Buffer): string {\n  if (typeof raw === 'string') return raw\n  if (isZstdFrame(raw)) {\n    return zlib.zstdDecompressSync(raw, { maxOutputLength: MAX_DECOMPRESSED_BYTES }).toString('utf8')\n  }\n  if (isGzipStream(raw)) {\n    return zlib.gunzipSync(raw, { maxOutputLength: MAX_DECOMPRESSED_BYTES }).toString('utf8')\n  }\n  return raw.toString('utf8')\n}\n"],
-  "mappings": "AAAA,OAAO,UAAU;AAcV,MAAM,gCAAgC;AAGtC,MAAM,yBAAyB,KAAK,OAAO;AAElD,MAAM,aAAa;AACnB,MAAM,eAAmC,CAAC,OAAO,QAAQ,MAAM;AAE/D,MAAM,iBAAiB,oBAAI,IAAY;AAEvC,SAAS,SAAS,SAAuB;AACvC,MAAI,eAAe,IAAI,OAAO,EAAG;AACjC,iBAAe,IAAI,OAAO;AAC1B,UAAQ,KAAK,OAAO;AACtB;AAEO,SAAS,kBAA2B;AACzC,SAAO,OAAO,KAAK,qBAAqB,cAAc,OAAO,KAAK,uBAAuB;AAC3F;AAEO,SAAS,sBAAsB,KAA2C;AAC/E,QAAM,QAAQ,KAAK,KAAK,EAAE,YAAY;AACtC,MAAI,CAAC,MAAO,QAAO;AACnB,MAAI,aAAa,SAAS,KAAyB,EAAG,QAAO;AAC7D,WAAS,4CAA4C,GAAG,2BAA2B;AACnF,SAAO;AACT;AAEO,SAAS,8BAA8B,KAA6C;AACzF,MAAI,CAAC,IAAK,QAAO;AACjB,QAAM,SAAS,OAAO,SAAS,KAAK,EAAE;AACtC,SAAO,OAAO,SAAS,MAAM,KAAK,SAAS,IAAI,SAAS;AAC1D;AAEO,SAAS,wBAAwB,SAA+C;AACrF,QAAM,WAAW,SAAS,uBAAuB,QAAQ,sBAAsB,IAC3E,QAAQ,sBACR;AACJ,MAAI,cAAc,SAAS,eAAe;AAC1C,MAAI,gBAAgB,UAAU,CAAC,gBAAgB,GAAG;AAChD,aAAS,gGAAgG;AACzG,kBAAc;AAAA,EAChB;AACA,SAAO,EAAE,aAAa,SAAS;AACjC;AAEA,SAAS,SAAS,OAAe,aAAuD;AACtF,MAAI,gBAAgB,QAAQ;AAC1B,WAAO,KAAK,iBAAiB,OAAO,EAAE,QAAQ,EAAE,CAAC,KAAK,UAAU,uBAAuB,GAAG,WAAW,EAAE,CAAC;AAAA,EAC1G;AACA,SAAO,KAAK,SAAS,KAAK;AAC5B;AAEO,SAAS,gBAAgB,MAAc,QAA2C;AACvF,MAAI,OAAO,gBAAgB,MAAO,QAAO;AACzC,QAAM,OAAO,OAAO,WAAW,IAAI;AACnC,MAAI,OAAO,OAAO,YAAY,OAAO,uBAAwB,QAAO;AACpE,QAAM,aAAa,SAAS,OAAO,KAAK,MAAM,MAAM,GAAG,OAAO,WAAW;AACzE,SAAO,WAAW,SAAS,OAAO,aAAa;AACjD;AAEA,SAAS,YAAY,KAAsB;AACzC,SAAO,IAAI,UAAU,KAAK,IAAI,CAAC,MAAM,MAAQ,IAAI,CAAC,MAAM,OAAQ,IAAI,CAAC,MAAM,MAAQ,IAAI,CAAC,MAAM;AAChG;AAEA,SAAS,aAAa,KAAsB;AAC1C,SAAO,IAAI,UAAU,KAAK,IAAI,CAAC,MAAM,MAAQ,IAAI,CAAC,MAAM;AAC1D;AAGO,SAAS,gBAAgB,KAA8B;AAC5D,MAAI,OAAO,QAAQ,SAAU,QAAO;AACpC,MAAI,YAAY,GAAG,GAAG;AACpB,WAAO,KAAK,mBAAmB,KAAK,EAAE,iBAAiB,uBAAuB,CAAC,EAAE,SAAS,MAAM;AAAA,EAClG;AACA,MAAI,aAAa,GAAG,GAAG;AACrB,WAAO,KAAK,WAAW,KAAK,EAAE,iBAAiB,uBAAuB,CAAC,EAAE,SAAS,MAAM;AAAA,EAC1F;AACA,SAAO,IAAI,SAAS,MAAM;AAC5B;",
-  "names": []
-}