Items that get stored in constructor.cache do not ever seem to be freed up. Is there a way to make this an LRU cache with a fixed size?
Of course we can make it LRU with fixed size. But there may be some issues hard to debug. I thinking about disabling cache totally. Generally it is for tracking instances:
post = new Post
post.save (err, p) ->
// here p and post of course same object (single pointer)
Post.find post.id, (err, p2) ->
// here p2 and post the same pointer
But without caching p2 and p1 not the same object, so you can modify both, then save and lost some changes. Let's say we have some case when cached object was removed from constructor.cache, but still used by application code, in the next time we call Model.find new instance will be saved in cache, both instances live. This is a reason why it should be touched carefully.
But more complicated saving logic looks like solition:
IF object in cache?
IF cached object the same pointer?
THEN just save
ELSE update cached object, merge pointers, save
ELSE reload from database to cached instance, object.save()
on updating cached instances, need track dirty attributes. now we only have problem in situation where both cached and not cached objects have modifications on same attribute.
what do you think?
I think that unless you are guaranteed to be the only client of the database, you can never be sure that your cached object represents the current state of the database.
I think that all of these problems are preferable to my process crashing because it has run out of memory with cached objects!
Added contributors, MRU cache cleanup, closes #46