Thanks for this library!

I am using this library in an AWS Lambda, and ran into an interesting bug caused by the prefetch behavior. My app has code that looks like this:

async function doGetCredentials() {
  // ...async retrieval of credentials that expire after 1 hour...
  return credentials;
}

// memoize credentials while they are valid
const getCredentials = promiseMemoize(doGetCredentials, { maxAge: credentialExpiryAge } );

getCredentials().then(doStuff).then(returnResponse);

The issue I encountered is that AWS Lambdas can be immediately paused (i.e. JS execution stops) as soon as a response is returned, and then re-animated later to handle future requests. This can lead to a scenario where:

1. request comes in, doGetCredentials is called and the result is memoized
2. another request comes when the memoized result is "almost expired", so the prefetch request is triggered, but the memoized value is returned.
3. my code returns a response without waiting for the prefetch request to complete, so Lambda execution is frozen. This happens after the credential request has been made, but before the doGetCredentials promise is fully resolved (i.e. before the refreshed value is memoized).
4. another request comes in some time later, so Lambda execution resumes. finally the prefetch promise resolves, and the result is cached for maxAge. But the credentials being saved are from some time ago, so they could be already expired (or almost expired). Subsequent requests can get expired credentials.

I think the cleanest fix to this problem would be to just disable the prefetching behavior, so that my response always waits for the credential request to complete, and Lambda can't pause execution mid-way through the credential request.

I'm using this little lib a lot and find it extremely useful. However, I often find myself wanting to check whether or not something has already been received or not and let my program flow depend on that. Any chance this can be polled? A simple .has([args]) method would make me very happy.

Not sure if this is the correct approach but I needed to memoize functions of a class and they needed to refer to "this".

The change works for me and is only adds a new option "fnthis" (better names more than welcome).

In environments where the event loop takes longer to return than the timeout interval (this is possible with very short timeout intervals or very long running synchronous functions), it's possible for destroyCacheObj to run before askPrefetch, which creates a situation where askPrefetch will crash (and, at least in my case, take the entire application with it).

Support older versions of node (0.10) via transpiling into /es5 with babel, so, with older versions of node, you just require with

var promiseMemoize = require('promise-memoize/es5')

grumble grumble vendor still hasn't upgraded off of 0.10

from https://docs.npmjs.com/cli/run-script

In addition to the shell's pre-existing PATH, npm run adds node_modules/.bin to the PATH provided to scripts.

Hi, I've spent quite some time debugging an issue in my app and it seems that there is a problem caused by memoization, and I would greatly appreciate any help to dig deeper.

My app runs on NodeJS 9.5. The main issue is that a memoized function never resolves, e.g.:

// getUser is memoized
// this does not log anything
getUser(email)
    .then((user) => console.log('Got user: ', user))
    .catch((err) => console.log('Got error: ', err))

The issue does not occur constantly and kicks in only after the app is running for some time.

Upon further investigation (debugging of memoizedFn), I noticed that the values from cache are not cleared after a specified timeout (10sec). When I clean the cache manually all works well for some time. E.g.:

• There are caches for 4 keys A, B, C, and D;
• When I try to call the function with any of the above 4 keys the promise in never resolved nor rejected;
• I manually delete key C.
• When I run the function with param C all works as expected, the caching is happening and after 10 sec the C key is removed.
• The issue with A, B, and D persists as they are still in the cache, not removed automatically, and not resolving promises.

I understand that that data I provided may be insufficient to identify the issue, but maybe you can suggest me where to look for more? For example, how can I compare what is the difference between a "healthy" key C and dead keys A, B, D?