How to use node-cache - 10 common examples

import EventEmitter from 'events'

// Configurations
const port = process.env.DNSPORT || 53,
      resolvers = {
        ipv4: [
          process.env.DNSALT1 || '8.8.8.8',
          process.env.DNSALT2 || '8.8.4.4'
        ],
        ipv6: [
          process.env.DNS6ALT1 || '2001:4860:4860::8888',
          process.env.DNS6ALT2 || '2001:4860:4860::8844'
        ]
      },
      verboseLog = ( process.env.VERBOSE == 'true' ),
      entries = new NodeCache({
        // From 
        // "You should set false if you want to save mutable objects or other complex types with mutability involved and wanted."
        useClones: false
      }),
      // Supported resources
      dnsResources = process.env.DNSRESOURCES ? process.env.DNSRESOURCES.split( ',' ) : 'A,AAAA,NS,CNAME,PTR,NAPTR,TXT,MX,SRV,SOA,TLSA'.split( ',' ),
      // Server Handlers
      tcpServer  = dns.createTCPServer(),
      udp4Server = dns.createServer( { dgram_type: { type: 'udp4', reuseAddr: true } } ),
      udp6Server = dns.createServer( { dgram_type: { type: 'udp6', reuseAddr: true } } )

function emitAsPromise( resolve, reject, me, eventName, data ) {
  const listeners = me.listeners( eventName ),
        promises = []

  if ( verboseLog )

/* eslint-env node */

import { graphql } from '@octokit/graphql'
import NodeCache from 'node-cache'

const cache = new NodeCache({ stdTTL: 900 })

const dev = process.env.NODE_ENV === 'development'

export default async (_, res) => {
  if (!process.env.GITHUB_TOKEN) {
    res.status(200).json({ issues: [] })
  } else {
    if (cache.get('issues')) {
      if (dev) console.log('Using cache for "issues"')

      res.status(200).json({ issues: cache.get('issues') })
    } else {
      console.log('Not using cache for "issues"')
    }

    try {

/**
 * houston/controller/api/downloads.js
 * Shows total download counts
 *
 * @exports {Object} - Koa router
 */

import Cache from 'node-cache'
import Router from 'koa-router'

import Download from 'lib/database/download'

const cache = new Cache({ stdTTL: 600 })
const route = new Router({
  prefix: '/downloads'
})

/**
 * Finds a list of downloads for a project based on a time type
 *
 * @async
 * @param {String} type - "year" "month" "day" time frame
 * @return {Object[]}
 */
const findDownloads = async (type) => {
  // I'm so sorry about how bad this query is. Mongodb sucks. Weird hacks
  // and questionable tactics incoming.
  const raw = await Download.aggregate([
    { $match: { type } },

export default function bootstrap(app, express) {
  let viewPath = path.join(__dirname, 'backend', 'views')
  let publicPath = path.join(path.dirname(__dirname), 'public')
  // NOTE: We compile ES6 at runtime, in server.js, hence transformViews is
  // false due to some weirdness in express-react-views
  // https://github.com/reactjs/express-react-views/issues/40
  let viewEngine = createEngine({transformViews: false})
  let backendCache = new NodeCache()

  app.set('config', config)
  app.set('port', config.get('port'))
  app.set('cache', backendCache)
  app.set('views', viewPath)
  app.set('view engine', 'jsx')
  app.engine('jsx', viewEngine)
  app.use(express.static(publicPath))
  app.use([
    middlewares.getInstance,
    middlewares.getDB,
    middlewares.setLocals
  ])
  app.use('', routes())
  return app
}

License along with this library; if not, write to the Free Software
  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301
  USA
*/

import Promise from 'bluebird';
import db from '../../../../db';
import config from '../../../../config';
import TSNE from 'tsne-js';
import { groupBy } from 'lodash';
import clustering from 'density-clustering';
import colors from './clusterColors.js';
import logger from 'winston';
import NodeCache from 'node-cache';

const tsneCache = new NodeCache({ stdTTL: 60 * 60 * 24, checkperiod: 120 });

export default async function(teamId, startDate = null, endDate = null, currentUser = null, interval = '1 day') {
  logger.info(`Getting PeopleLand for ${teamId}, ${startDate}, ${endDate}`);

  const rawData = await db.any(`SELECT user_id, channel_id, is_member FROM membership
    WHERE team_id = $(teamId) AND user_id <> 'USLACKBOT';`,
    {
      teamId,
    });

  const groupedByUser = groupBy(rawData, row => row.user_id);

  const opt = {
    epsilon: 50, // epsilon is learning rate (10 = default)
    perplexity: 100, // roughly how many neighbors each point influences (30 = default)
    dim: 2, // dimensionality of the embedding (2 = default)

if (this.__del(key)) this.log.debug('Removed key %s from memcache.', key);
    else this.log.debug('Failed to remove key %s from memcache.', key);

    // Also remove file if applicable
    try {
      fs.unlinkSync(path.join(this.cacheDir, key));
    } catch (e) {
      this.log.debug('No file cache with key %s', key);
    }
  };
};

/*
 * Stores the old get method.
 */
Cache.prototype.__get = NodeCache.prototype.get;

/*
 * Stores the old set method.
 */
Cache.prototype.__set = NodeCache.prototype.set;

/*
 * Stores the old del method.
 */
Cache.prototype.__del = NodeCache.prototype.del;

/*
 * Return the class
 */
module.exports = Cache;

it("works", () => {
    const cache = new NodeCache({ stdTTL: 60 });
    cache.set("foo", 42);
    cache.set("foo", "this is fine");
    (cache.get("foo"): mixed);
    cache.del("foo");
    cache.del(["foo"]);
    cache.flushAll();
  });
});

/**
 * houston/controller/api/list.js
 * Publishes some GET lists for AppCenter
 *
 * @exports {Object} - Koa router
 */

import Cache from 'node-cache'
import moment from 'moment'
import Router from 'koa-router'

import Download from 'lib/database/download'
import Project from 'lib/database/project'

const cache = new Cache({ stdTTL: 600 })
const route = new Router({
  prefix: '/newest'
})

/**
 * findReleases
 * Finds the projects with the newest releases.
 *
 * @return {string[]}
 */
const findReleases = async () => {
  const cachedRes = cache.get('findReleases')

  if (cachedRes != null) {
    return cachedRes
  }

import NodeCache from "node-cache";
import { CACHE_TTL, CACHE_CHECK_PERIOD } from "../config";
import { query } from "./mysql";
import { CacheCategories } from "../interfaces/enum";
import { RESOURCE_NOT_FOUND } from "@staart/errors";

const cache = new NodeCache({
  stdTTL: CACHE_TTL,
  checkperiod: CACHE_CHECK_PERIOD
});

const generateKey = (category: CacheCategories, item: number | string) =>
  `${category}_${item}`;

/**
 * Get an item from the cache
 */
export const getItemFromCache = (
  category: CacheCategories,
  item: number | string
) => {
  const key = generateKey(category, item);
  return cache.get(key);

import NodeCache from 'node-cache';
import PreviewCache from './PreviewCache';
import FsCache from '../models/FsCache';

const nodeCache = new NodeCache({ stdTTL: 2, checkperiod: 120, useClones: false });

class FsCacheFactory {
  static create(projectId, workspaceId, cacheType, requestor) {
    const cacheKey = `${workspaceId}:${cacheType}`;
    let fsCache = nodeCache.get(cacheKey);

    if (fsCache === undefined) {
      fsCache = new FsCache(projectId, workspaceId, cacheType, requestor);
      nodeCache.set(cacheKey, fsCache);
    }
    return fsCache;
  }

  static createPreviewCache(projectId, workspaceId, requestor) {
    const cacheKey = `${workspaceId}:preview_cache`;
    let cache = nodeCache.get(cacheKey);