Node.js garbage collection and synchronized objects

Sounds like a job for a Map object used as a cache storing the object as the value (along with a count) and the ID as the key. When you want an object, you first look up its ID in the Map. If it's found there, you use the returned object (which will be shared by all). If it's not found there, you fetch it from the database and insert it into the Map (for others to find).

Then, to make it so that the Map doesn't grow forever, the code that fetches something from the Map would also need to release an object from the Map. When the useCnt goes to zero upon a release, you would remove an object from the Map.

This can be made entirely transparent to the caller by creating some sort of cache object that contains the Map and has methods for getting an object or releasing an object and it would be entirely responsible for maintaining the refCnt on each object in the Map.

Note: you will likely have to write the code that fetches it from the DB and inserts it into the Map carefully in order to not create a race condition because the fetching form the database is likely asynchronous and you could get multiple callers all not finding it in the Map and all in the process of getting it from the database. How to avoid that race condition depends upon the exact database you have and how you're using it. One possibility is for the first caller to insert a place holder in the Map so subsequent callers will know to wait for some promise to resolve before the object is inserted in the Map and available to them to use.

Here's a general idea for how such an ObjCache could work. You call cache.get(id) when you want to retrieve an item. This always returns a promise that resolves to the object (or rejects if there's an error getting it from the DB). If the object is in the cache already, the promise it returns will be already resolved. If the object is not in the cache yet, the promise will resolve when it has been fetched from the DB. This works even when multiple parts of your code request an object that is "in the process" of being fetched from the DB. They all get the same promise that is resolved with the same object when the object has been retrieved from the DB. Every call to cache.get(id) increases the refCnt for that object in the cache.

You then call cache.release(id) when a given piece of code is done with an object. That will decrement the internal refCnt and remove the object from the cache if the refCnt hits zero.

class ObjCache() {
    constructor() {
        this.cache = new Map();
    }
    get(id) {
        let cacheItem = this.cache.get(id);
        if (cacheItem) {
            ++cacheItem.refCnt;
            if (cacheItem.obj) {
                // already have the object
                return Promise.resolve(cacheItem.obj);
            }
            else {
                // object is pending, return the promise
                return cacheItem.promise;
            }
        } else {
            // not in the cache yet
            let cacheItem = {refCnt: 1, promise: null, obj: null};
            let p = myDB.get(id).then(function(obj) {
                // replace placeholder promise with actual object
                cacheItem.obj = obj;
                cacheItem.promise = null;
                return obj;
            });
            // set placeholder as promise for others to find
            cacheItem.promise = p;
            this.cache.set(id, cacheItem);
            return p;

        }
    }
    release(id) {
        let cacheItem = this.cache.get(id);
        if (cacheItem) {
            if (--cacheItem.refCnt === 0) {
                this.cache.delete(id);
            }
        }
    }
}

Ok, for anyone who faces similar problems, I found a solution. jfriend00 pushed me towards this solution by mentioning WeakMaps which were not exactly the solution themselves, but pointed my focus on weak references.

There is an npm module simply called weak that will do the trick. It holds a weak reference to an object and safely returns an empty object once the object was garbage collected (thus, there is a way to identify a collected object).

So I created a class called WeakCache using a DataObject:

class DataObject{

    constructor( objectID ){
        this.objectID = objectID;
        this.dataLoaded = new Promise(function(resolve, reject){
            loadTheDataFromTheDatabase(function(data, error){ // some pseudo db call
                if (error)
                {
                    reject(error);
                    return;
                }

                resolve(data);
            }); 
        });
    }

    loadData(){
        return this.dataLoaded;
    }   
}

class WeakCache{

    constructor(){
        this.cache = {};
    }

    getDataObjectAsync( objectID, onObjectReceived ){
        if (this.cache[objectID] === undefined || this.cache[objectID].loadData === undefined){ // object was not cached yet or dereferenced, recreate it

            this.cache[objectID] = weak(new DataObject( objectID )function(){
                // Remove the reference from the cache when it got collected anyway
                delete this.cache[this.objectID];
            }.bind({cache:this, objectID:objectID});
        }

        this.cache[objectID].loadData().then(onObjectReceived);
    }

}

This class is still in progress but at least this is a way how it could work. The only downside to this (but this is true for all database-based data, pun alert!, therefore not such a big deal), is that all data access has to be asynchronous.

What will happen here, is that the cache at some point may hold an empty reference to every possible object id.