I am using this for years in Java, so I thought it would be great to use this approach also in the JavaScript world: The ValueHolder. The class allows to easily define „cachable“ code and it’s result, without having to handle the memcached part and – maybe in the future – background processing stuff.
To give you an idea what it is for here is a small example:
const allDummyDocs = new ValueHolder('allDummyDocs', 60, async () => {
// get all documents with the Form 'dummy'
return useServer(serverConfig).then(
async server => {
const db = await server.useDatabase(databaseConfig);
const response = await db.bulkReadDocuments({
query: "Form = 'dummy'"
});
return JSON.stringify(response);
}).catch(err => {
console.log(err);
return err;
});
});The first parameter is the key used to store/retreive the value from memcached. The second one is the time how long the value should be cached. And the third parameter is the code to execute:
- Get all documents from the database with Form = ‚dummy‘
- Convert the resulting collection object to JSON.
The JSON String is then stored in the cache for 60 seconds, and everytime the get method is called again the Domino server is not queried.
To use the definition in the application, you now have to use the get method of the value holder:
router.get('/showAllDummyDocs', (req, res) => {
allDummyDocs.get(
(error, result) => {
if (error) {
res.render('error', { title: 'Error', error });
} else {
res.render('index', { title: 'Express', result: `Result: ${result}` });
}
}
);
}
);The ValueHolder checks now automatically, if the result is stored in the cache. If not, the code is executed and stored in the cache.
Here is the ValueHolder.js file (which has to be created in the /app/classes folder):
const mf = require('../classes/MemcachedFactory');
const nullHelper = '###NULL###';
/**
* Helper class for cached values
*
* @author Sven Hasselbach
* @version 0.1
*/
class ValueHolder {
/**
*
* @param {string} key
* unique identifier
* @param {number} ttl
* time-to-live in seconds
* @param {function} code
* code to execute to calculate the value
*/
constructor(key, ttl, code) {
this.key = key;
this.code = code;
this.ttl = ttl;
}
/**
* loads the value from cache or
* computes it and stores it in the cache
*
* @param {function} callback
* @returns Promise
*/
async get(callback) {
const { code, ttl, key } = this;
// check if value is in cache...
mf.getInstance().get(key, (error, value) => {
if (error) {
callback(error);
return;
}
if (value != null) {
console.debug(`Found '${key}' in cache.`);
if (value === nullHelper) {
// result is "special", so let's return null
callback(error, null);
} else {
console.log(value);
callback(error, JSON.parse(value));
}
} else {
console.debug(`Computing '${key}' and adding to cache with ttl ${ttl}.`);
// execute the computation
code().then((result) => {
// check if result must be stored "special" or not
if (result === null) {
mf.getInstance().set(key, nullHelper, ttl);
} else {
mf.getInstance().set(key, JSON.stringify(result), ttl);
}
callback(error, result);
});
}
});
}
}
module.exports = ValueHolder;
