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

package/src/__tests__/codec.test.ts

@@ -1,162 +0,0 @@
-/** @jest-environment node */
-import zlib from 'node:zlib'
-import {
-  DEFAULT_COMPRESSION_MIN_BYTES,
-  MAX_DECOMPRESSED_BYTES,
-  decodeCacheText,
-  encodeCacheText,
-  parseCacheCompression,
-  parseCacheCompressionMinBytes,
-  resolveCacheCodecConfig,
-} from '../codec'
-import type { CacheCodecConfig } from '../codec'
-
-const ZSTD_MAGIC = [0x28, 0xb5, 0x2f, 0xfd]
-const GZIP_MAGIC = [0x1f, 0x8b]
-
-function listPayload(rows: number): string {
-  return JSON.stringify({
-    items: Array.from({ length: rows }, (_, index) => ({
-      id: `00000000-0000-4000-8000-${String(index).padStart(12, '0')}`,
-      displayName: `Contact ${index}`,
-      primaryEmail: `contact.${index}@example.com`,
-      status: index % 2 ? 'active' : 'lead',
-    })),
-    total: rows,
-  })
-}
-
-function startsWith(raw: string | Buffer, magic: number[]): boolean {
-  return Buffer.isBuffer(raw) && magic.every((byte, index) => raw[index] === byte)
-}
-
-describe.each([
-  ['zstd', ZSTD_MAGIC],
-  ['gzip', GZIP_MAGIC],
-] as const)('cache codec (%s)', (compression, magic) => {
-  const config: CacheCodecConfig = { compression, minBytes: DEFAULT_COMPRESSION_MIN_BYTES }
-
-  it('round-trips a large entry through a compressed frame', () => {
-    const json = listPayload(100)
-    const encoded = encodeCacheText(json, config)
-
-    expect(startsWith(encoded, magic)).toBe(true)
-    expect((encoded as Buffer).length).toBeLessThan(Buffer.byteLength(json) / 4)
-    expect(decodeCacheText(encoded)).toBe(json)
-  })
-
-  it('keeps entries below the threshold as plain JSON', () => {
-    const json = listPayload(2)
-    expect(Buffer.byteLength(json)).toBeLessThan(DEFAULT_COMPRESSION_MIN_BYTES)
-
-    expect(encodeCacheText(json, config)).toBe(json)
-  })
-
-  it('stores the JSON when compression would not shrink it', () => {
-    const json = JSON.stringify({ id: 'a1' })
-
-    expect(encodeCacheText(json, { compression, minBytes: 1 })).toBe(json)
-  })
-
-  it('reads entries written by the other codec and by the off setting', () => {
-    const json = listPayload(100)
-    const other: CacheCodecConfig = { compression: compression === 'zstd' ? 'gzip' : 'zstd', minBytes: 1024 }
-
-    expect(decodeCacheText(encodeCacheText(json, other))).toBe(json)
-    expect(decodeCacheText(encodeCacheText(json, { compression: 'off', minBytes: 1024 }))).toBe(json)
-  })
-
-  it('rejects a corrupt frame', () => {
-    const encoded = encodeCacheText(listPayload(100), config) as Buffer
-    const corrupt = Buffer.concat([encoded.subarray(0, magic.length), Buffer.alloc(32, 0xff)])
-
-    expect(() => decodeCacheText(corrupt)).toThrow()
-  })
-})
-
-describe('cache codec format detection', () => {
-  it('reads legacy JSON stored as a string or as UTF-8 bytes', () => {
-    const json = listPayload(100)
-
-    expect(decodeCacheText(json)).toBe(json)
-    expect(decodeCacheText(Buffer.from(json, 'utf8'))).toBe(json)
-  })
-
-  it('never compresses with compression off', () => {
-    const json = listPayload(100)
-    expect(encodeCacheText(json, { compression: 'off', minBytes: 1 })).toBe(json)
-  })
-
-  it('skips compression above the decode cap so a legitimate entry can always be read back', () => {
-    const encodeSpy = jest.spyOn(zlib, 'gzipSync')
-    const json = 'x'.repeat(MAX_DECOMPRESSED_BYTES + 1)
-
-    expect(encodeCacheText(json, { compression: 'gzip', minBytes: 1 })).toBe(json)
-    expect(encodeSpy).not.toHaveBeenCalled()
-    encodeSpy.mockRestore()
-  })
-
-  it('caps the decompressed size of a hostile frame', () => {
-    const bomb = zlib.zstdCompressSync(Buffer.alloc(MAX_DECOMPRESSED_BYTES + 1024, 0x20))
-
-    expect(() => decodeCacheText(bomb)).toThrow()
-  })
-})
-
-describe('cache codec configuration', () => {
-  afterEach(() => {
-    jest.restoreAllMocks()
-  })
-
-  it('parses known compression values case-insensitively', () => {
-    expect(parseCacheCompression('zstd')).toBe('zstd')
-    expect(parseCacheCompression(' GZIP ')).toBe('gzip')
-    expect(parseCacheCompression('off')).toBe('off')
-    expect(parseCacheCompression(undefined)).toBe('off')
-    expect(parseCacheCompression('')).toBe('off')
-  })
-
-  it('treats an unknown value as off and warns once', () => {
-    const warn = jest.spyOn(console, 'warn').mockImplementation(() => {})
-
-    expect(parseCacheCompression('brotli-codec-test')).toBe('off')
-    expect(parseCacheCompression('brotli-codec-test')).toBe('off')
-
-    expect(warn).toHaveBeenCalledTimes(1)
-  })
-
-  it('accepts only a positive min-bytes value', () => {
-    expect(parseCacheCompressionMinBytes('2048')).toBe(2048)
-    expect(parseCacheCompressionMinBytes('0')).toBeUndefined()
-    expect(parseCacheCompressionMinBytes('-5')).toBeUndefined()
-    expect(parseCacheCompressionMinBytes('abc')).toBeUndefined()
-    expect(parseCacheCompressionMinBytes(undefined)).toBeUndefined()
-  })
-
-  it('defaults to off with a 1 KB threshold', () => {
-    expect(resolveCacheCodecConfig()).toEqual({ compression: 'off', minBytes: DEFAULT_COMPRESSION_MIN_BYTES })
-    expect(resolveCacheCodecConfig({ compression: 'zstd', compressionMinBytes: 0 })).toEqual({
-      compression: 'zstd',
-      minBytes: DEFAULT_COMPRESSION_MIN_BYTES,
-    })
-  })
-
-  it('falls back to gzip when the runtime has no zstd', () => {
-    jest.isolateModules(() => {
-      jest.doMock('node:zlib', () => {
-        const actual = jest.requireActual<typeof import('node:zlib')>('node:zlib')
-        return { ...actual, zstdCompressSync: undefined, zstdDecompressSync: undefined }
-      })
-      const warn = jest.spyOn(console, 'warn').mockImplementation(() => {})
-      const isolated = require('../codec') as typeof import('../codec')
-
-      const config = isolated.resolveCacheCodecConfig({ compression: 'zstd' })
-      const encoded = isolated.encodeCacheText(listPayload(100), config)
-
-      expect(config.compression).toBe('gzip')
-      expect(startsWith(encoded, GZIP_MAGIC)).toBe(true)
-      expect(warn).toHaveBeenCalledWith(expect.stringContaining('zstd is not available'))
-    })
-    jest.dontMock('node:zlib')
-  })
-})

package/src/__tests__/redis.compression.live.test.ts

@@ -1,41 +0,0 @@
-/** @jest-environment node */
-import { randomUUID } from 'node:crypto'
-import { createRedisStrategy } from '../strategies/redis'
-
-const redisUrl = process.env.CACHE_REDIS_URL
-const describeWithRedis = redisUrl ? describe : describe.skip
-
-describeWithRedis('redis strategy value compression against a live Redis', () => {
-  const largeValue = {
-    items: Array.from({ length: 100 }, (_, index) => ({ id: `row-${index}`, name: `Contact ${index}`, status: 'active' })),
-  }
-  const runId = randomUUID()
-
-  it.each(['zstd', 'gzip'] as const)('round-trips %s frames and legacy JSON over the binary-safe path', async (compression) => {
-    const legacy = createRedisStrategy(redisUrl, { compression: 'off' })
-    const compressed = createRedisStrategy(redisUrl, { compression })
-    const legacyKey = `compression-live:${runId}:${compression}:legacy`
-    const compressedKey = `compression-live:${runId}:${compression}:compressed`
-    const tag = `compression-live:${runId}:${compression}`
-
-    try {
-      await legacy.set(legacyKey, largeValue, { ttl: 60_000, tags: [tag] })
-      await compressed.set(compressedKey, largeValue, { ttl: 60_000, tags: [tag] })
-
-      expect(await compressed.get(legacyKey)).toEqual(largeValue)
-      expect(await compressed.get(compressedKey)).toEqual(largeValue)
-      expect(await legacy.get(compressedKey)).toEqual(largeValue)
-      expect(await compressed.has(compressedKey)).toBe(true)
-
-      await compressed.set(compressedKey, largeValue, { ttl: 60_000, tags: [`${tag}:next`] })
-      expect(await compressed.deleteByTags([tag])).toBe(1)
-      expect(await compressed.deleteByTags([`${tag}:next`])).toBe(1)
-      expect(await compressed.get(compressedKey)).toBeNull()
-    } finally {
-      await legacy.delete(legacyKey)
-      await compressed.delete(compressedKey)
-      await legacy.close?.()
-      await compressed.close?.()
-    }
-  })
-})

package/src/codec.ts

@@ -1,94 +0,0 @@
-import zlib from 'node:zlib'
-
-export type CacheCompression = 'off' | 'zstd' | 'gzip'
-
-export type CacheCodecConfig = {
-  compression: CacheCompression
-  minBytes: number
-}
-
-export type CacheCodecOptions = {
-  compression?: CacheCompression
-  compressionMinBytes?: number
-}
-
-export const DEFAULT_COMPRESSION_MIN_BYTES = 1024
-
-/** Upper bound for one decompressed entry; larger JSON is never compressed, so no legitimate entry can hit it. */
-export const MAX_DECOMPRESSED_BYTES = 64 * 1024 * 1024
-
-const ZSTD_LEVEL = 1
-const COMPRESSIONS: CacheCompression[] = ['off', 'zstd', 'gzip']
-
-const warnedMessages = new Set<string>()
-
-function warnOnce(message: string): void {
-  if (warnedMessages.has(message)) return
-  warnedMessages.add(message)
-  console.warn(message)
-}
-
-export function isZstdAvailable(): boolean {
-  return typeof zlib.zstdCompressSync === 'function' && typeof zlib.zstdDecompressSync === 'function'
-}
-
-export function parseCacheCompression(raw: string | undefined): CacheCompression {
-  const value = raw?.trim().toLowerCase()
-  if (!value) return 'off'
-  if (COMPRESSIONS.includes(value as CacheCompression)) return value as CacheCompression
-  warnOnce(`[cache] Unknown CACHE_COMPRESSION value "${raw}". Compression stays off.`)
-  return 'off'
-}
-
-export function parseCacheCompressionMinBytes(raw: string | undefined): number | undefined {
-  if (!raw) return undefined
-  const parsed = Number.parseInt(raw, 10)
-  return Number.isFinite(parsed) && parsed > 0 ? parsed : undefined
-}
-
-export function resolveCacheCodecConfig(options?: CacheCodecOptions): CacheCodecConfig {
-  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: Buffer, compression: Exclude<CacheCompression, 'off'>): Buffer {
-  if (compression === 'zstd') {
-    return zlib.zstdCompressSync(input, { params: { [zlib.constants.ZSTD_c_compressionLevel]: ZSTD_LEVEL } })
-  }
-  return zlib.gzipSync(input)
-}
-
-export function encodeCacheText(json: string, config: CacheCodecConfig): string | Buffer {
-  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: Buffer): boolean {
-  return raw.length >= 4 && raw[0] === 0x28 && raw[1] === 0xb5 && raw[2] === 0x2f && raw[3] === 0xfd
-}
-
-function isGzipStream(raw: Buffer): boolean {
-  return raw.length >= 2 && raw[0] === 0x1f && raw[1] === 0x8b
-}
-
-/** Detects the format from the stored bytes, so entries stay readable whatever CACHE_COMPRESSION is set to now. */
-export function decodeCacheText(raw: string | Buffer): string {
-  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')
-}