Skip to content
Merged
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
22 changes: 19 additions & 3 deletions index.d.ts
Original file line number Diff line number Diff line change
Expand Up @@ -106,16 +106,32 @@ declare namespace CacheableResponse {

export type GetOpts = HttpContext & Props;

/**
* Stored when `compress` is enabled.
* Lifetimes sit beside the brotli payload so expiry does not depend on decompressing it.
* Entries written before that are still a raw `Buffer`.
*/
export interface CompressedEntry {
compressed: Buffer;
ttl: number;
staleTtl: number | boolean;
}

export interface CacheProvider<P extends Props, V = any> {
/** Returns the cached value, or the compressed buffer when compress option is set to true. */
get(key: string): Promise<Buffer | (Cache<V> & P) | undefined>;
/**
* Returns the cached value.
* With `compress` enabled this is a `CompressedEntry`, or a `Buffer` for older entries.
*/
get(
key: string
): Promise<Buffer | CompressedEntry | (Cache<V> & P) | undefined>;

/**
* Set a value. You can implements an expiry TTL in milliseconds.
*/
set(
key: string,
value: Buffer | (Cache<V> & P),
value: Buffer | CompressedEntry | (Cache<V> & P),
ttl: number
): Promise<true>;
}
Expand Down
48 changes: 40 additions & 8 deletions src/index.js
Original file line number Diff line number Diff line change
Expand Up @@ -33,6 +33,32 @@ const cacheableResponse = ({
...compressOpts
})

// memoize calls ttl/staleTtl on the stored value. A brotli payload is a
// Buffer, so those fields would be invisible and every entry would keep the
// default lifetime. Keep them beside the payload; raw buffers still load.
const isCompressedEntry = value =>
enableCompression &&
value != null &&
typeof value === 'object' &&
Object.prototype.hasOwnProperty.call(value, 'compressed')

const storeValue = async data => {
const payload = await compress(data)
if (!enableCompression || data == null || typeof data !== 'object') { return payload }
return {
compressed: payload,
ttl: ttl(data),
staleTtl: staleTtl(data)
}
}

const loadValue = data =>
isCompressedEntry(data) ? decompress(data.compressed) : decompress(data)

const ttlOf = value => (isCompressedEntry(value) ? value.ttl : ttl(value))
const staleTtlOf = value =>
isCompressedEntry(value) ? value.staleTtl : staleTtl(value)

const getEtag = input => require('etag')(serialize(input))

const get = opts =>
Expand All @@ -55,9 +81,9 @@ const cacheableResponse = ({
const memoGet = memoize(get, cache, {
key: memoKey,
objectMode: true,
staleTtl,
ttl,
value: compress
staleTtl: staleTtlOf,
ttl: ttlOf,
value: storeValue
})

const fn = async opts => {
Expand All @@ -67,19 +93,25 @@ const cacheableResponse = ({

if (res.writableEnded) return

const result = (await decompress(raw)) || {}
const result = (await loadValue(raw)) || {}
const isHit = !forceExpiration && !isExpired && hasValue
const preventCaching = raw == null

const {
createdAt = Date.now(),
data = null,
etag = getEtag(result),
staleTtl = memoGet.staleTtl(result),
ttl = memoGet.ttl(result),
staleTtl: resultStaleTtl,
ttl: resultTtl,
...props
} = result

// A cached value may itself have a `compressed` field. That is not the
// storage envelope, so don't read lifetimes with the envelope predicate.
const responseStaleTtl =
resultStaleTtl === undefined ? staleTtl(result) : resultStaleTtl
const responseTtl = resultTtl === undefined ? ttl(result) : resultTtl

const ifNoneMatch = req.headers['if-none-match']
const isModified = etag !== ifNoneMatch

Expand All @@ -103,8 +135,8 @@ const cacheableResponse = ({
isStale,
preventCaching,
res,
staleTtl,
ttl
staleTtl: responseStaleTtl,
ttl: responseTtl
})

if (hasValue && !forceExpiration && !isModified) {
Expand Down
48 changes: 48 additions & 0 deletions test/index.js
Original file line number Diff line number Diff line change
Expand Up @@ -37,6 +37,8 @@ test('compress support', async t => {
t,
cacheableResponse({
compress: true,
// Shorter than the default stale window; disable it so a fresh entry is a HIT.
staleTtl: false,
get: ({ req, res }) => {
return {
data: { foo: 'bar' },
Expand All @@ -57,6 +59,52 @@ test('compress support', async t => {
t.is(headersOne.etag, headersTwo.etag)
})

test('compressed entries written as raw buffers still hit', async t => {
const Keyv = require('@keyvhq/core')
const createCompress = require('compress-brotli')
const cache = new Keyv({ namespace: 'ssr' })
const { compress } = createCompress({ enable: true })
await cache.set(
'/compat',
await compress({ data: { foo: 'from-raw' }, createdAt: Date.now() }),
86400000
)

const url = await runServer(
t,
cacheableResponse({
cache,
compress: true,
staleTtl: false,
get: () => ({ data: { foo: 'fresh' } }),
send: ({ data, res }) => res.end(data.foo)
})
)

const { headers, body } = await got(`${url}/compat`)
t.is(headers['x-cache-status'], 'HIT')
t.is(body, 'from-raw')
})

test('uncompressed values keep their own compressed field', async t => {
const url = await runServer(
t,
cacheableResponse({
get: () => ({ data: { foo: 'bar' }, compressed: { algo: 'br' } }),
send: ({ data, compressed, res }) =>
res.end(`${data.foo}|${compressed.algo}`)
})
)

const miss = await got(`${url}/kikobeats`)
t.is(miss.headers['x-cache-status'], 'MISS')
t.is(miss.body, 'bar|br')

const hit = await got(`${url}/kikobeats`)
t.is(hit.headers['x-cache-status'], 'HIT')
t.is(hit.body, 'bar|br')
})

test('exit early is response was written', async t => {
let isEnd = false
const end = (res, msg) => {
Expand Down
145 changes: 145 additions & 0 deletions test/ttl.js
Original file line number Diff line number Diff line change
Expand Up @@ -97,3 +97,148 @@ test.serial(
t.is(parseCacheControl(hit)['max-age'], 3570)
}
)

test.serial('compressed entries expire on their own ttl', async t => {
const realNow = Date.now
let now = 1_700_000_000_000
Date.now = () => now
t.teardown(() => {
Date.now = realNow
})

let calls = 0
const url = await runServer(
t,
cacheableResponse({
compress: true,
ttl: 86400000,
staleTtl: false,
get: () => {
calls += 1
return { data: { n: calls }, ttl: 1000 }
},
send: ({ data, res }) => res.end(String(data.n))
})
)

const miss = await got(`${url}/kikobeats`)
t.is(miss.headers['x-cache-status'], 'MISS')
t.is(miss.body, '1')

now += 5000

const expired = await got(`${url}/kikobeats`)
t.is(expired.headers['x-cache-status'], 'EXPIRED')
t.is(expired.body, '2')
})

test.serial('compressed entries honor a per-entry staleTtl', async t => {
const realNow = Date.now
let now = 1_700_000_000_000
Date.now = () => now
t.teardown(() => {
Date.now = realNow
})

let calls = 0
const url = await runServer(
t,
cacheableResponse({
compress: true,
ttl: 86400000,
staleTtl: false,
get: () => {
calls += 1
return { data: { n: calls }, ttl: 20000, staleTtl: 15000 }
},
send: ({ data, res }) => res.end(String(data.n))
})
)

const miss = await got(`${url}/kikobeats`)
t.is(miss.headers['x-cache-status'], 'MISS')
t.is(miss.body, '1')

const hit = await got(`${url}/kikobeats`)
t.is(hit.headers['x-cache-status'], 'HIT')
t.is(hit.body, '1')

now += 6000

const stale = await got(`${url}/kikobeats`)
t.is(stale.headers['x-cache-status'], 'STALE')
t.is(stale.body, '1')
await new Promise(resolve => setImmediate(resolve))
t.is(calls, 2)
})

test.serial('compressed entries honor ttl and staleTtl functions', async t => {
const realNow = Date.now
let now = 1_700_000_000_000
Date.now = () => now
t.teardown(() => {
Date.now = realNow
})

let calls = 0
const url = await runServer(
t,
cacheableResponse({
compress: true,
ttl: value => value.seconds * 1000,
staleTtl: value => value.staleSeconds * 1000,
get: () => {
calls += 1
return { data: { n: calls }, seconds: 20, staleSeconds: 15 }
},
send: ({ data, res }) => res.end(String(data.n))
})
)

const miss = await got(`${url}/kikobeats`)
t.is(miss.headers['x-cache-status'], 'MISS')
t.is(miss.body, '1')
t.is(parseCacheControl(miss.headers)['max-age'], 20)
t.is(parseCacheControl(miss.headers)['stale-while-revalidate'], 15)

const hit = await got(`${url}/kikobeats`)
t.is(hit.headers['x-cache-status'], 'HIT')
t.is(hit.body, '1')

now += 6000

const stale = await got(`${url}/kikobeats`)
t.is(stale.headers['x-cache-status'], 'STALE')
t.is(stale.body, '1')
await new Promise(resolve => setImmediate(resolve))
t.is(calls, 2)
})

test('a compressed field on the value is not the storage envelope', async t => {
const url = await runServer(
t,
cacheableResponse({
compress: true,
ttl: 3600000,
staleTtl: 120000,
get: () => ({ data: { foo: 'bar' }, compressed: { algo: 'br' } }),
send: ({ data, compressed, res }) =>
res.end(`${data.foo}|${compressed.algo}`)
})
)

const miss = await got(`${url}/kikobeats`)
t.is(miss.headers['x-cache-status'], 'MISS')
t.is(miss.body, 'bar|br')
const missCache = parseCacheControl(miss.headers)
t.true([3600, 3599].includes(missCache['max-age']))
t.true([120, 119].includes(missCache['stale-while-revalidate']))
t.true([120, 119].includes(missCache['stale-if-error']))

const hit = await got(`${url}/kikobeats`)
t.is(hit.headers['x-cache-status'], 'HIT')
t.is(hit.body, 'bar|br')
const hitCache = parseCacheControl(hit.headers)
t.true([3600, 3599].includes(hitCache['max-age']))
t.true([120, 119].includes(hitCache['stale-while-revalidate']))
})
Loading