edwinm / memoize-cache-decorator

Add @memoize() to your class methods to have the result cached for future method calls.

memoize-cache-decorator's Issues

if two subsequent calls with different parameters are called its a cache hit

timeout is reset if there are two subsequent calls to a function with different parameters (first call is a miss, the second is a hit, even tho it shouldnt be)

I resolved it like so:

const isTimeUp = Date.now() > (map.get(key)?.timeout ?? Infinity)
		if (map.has(key) && (!config.ttl || !isTimeUp)) {
			return map.get(key)?.result
		}
		else {
			const result = originalFunction.apply(this, args)
			let timeout = Infinity
			if (config.ttl) {
				timeout = Date.now() + config.ttl
			}
			map.set(key, {
				result,
				timeout
			})
			return result
		}

btw I use stringify from the library json-stringify-safe in case there are circular dependencies.

whole code:

import stringify from "json-stringify-safe"
const cacheMap = new Map()
export interface IConfig {
	resolver?: (...args: any[]) => string | number
	ttl?: number
}
interface IMapCacheObject {
	result: unknown
	timeout?: number
}
export const memoize = (config: IConfig = {}) => (
	// eslint-disable-next-line @typescript-eslint/ban-types
	target: object,
	propertyName: string,
	propertyDescriptor: PropertyDescriptor
): PropertyDescriptor => {
	const prop = propertyDescriptor.value
		? "value"
		: "get"
	const originalFunction = propertyDescriptor[prop]
	const map: Map<string|number|undefined, IMapCacheObject> = new Map()
	propertyDescriptor[prop] = function (...args: unknown[]): unknown {
		const key = config.resolver
			? config.resolver.apply(this, args)
			: stringify(args)
		const isTimeUp = Date.now() > (map.get(key)?.timeout ?? Infinity)
		if (map.has(key) && (!config.ttl || !isTimeUp)) {
			return map.get(key)?.result
		}
		else {
			const result = originalFunction.apply(this, args)
			let timeout = Infinity
			if (config.ttl) {
				timeout = Date.now() + config.ttl
			}
			map.set(key, {
				result,
				timeout
			})
			return result
		}
	}
	cacheMap.set(propertyDescriptor[prop], map)
	return propertyDescriptor
}
export const clear = (fn: () => any): void => {
	const map = cacheMap.get(fn)
	if (map) {
		map.clear()
	}
}

Allow ttl to be a function.

If ttl is configurable, then we need to allow ttl param to be a sync function.

Question | Does memoize-cache-decorator works across node workers?

Hi Edwin,

We are using your package in our company's node backend server.
We were wondering if the cache is persisted across different workers in the node process or is it per worker?

Thank you,
Tal