@outofsync/memory-cache
    TypeScript icon, indicating that this package has built-in type declarations

    1.4.1 • Public • Published

    memory-cache

    NPM

    Actual version published on npm Master build Total npm module downloads Codacy Badge Codacy Coverate Badge Dependencies badge

    memory-cache is a simple, Redis-like, in-memory cache written in pure Javascript.

    Memory Cache is designed to be a fully-functional stand-in replacement for mocking Redis and fail-over in production systems for when Redis is not available. This package is intentionally designed to mimic the behavior of the node redis module and can be used with nearly all commands supported by Redis.

    Unlike some other Redis mocking library, thought has been put into achieving full Redis command coverage. Many other libraries only provide incomplete coverage by providing only the most commonly used commands. MemoryCache currently provides 224 of 267 (~85%) of the available Redis commands. With coverage for the remaining commands planned. All commands have been rigorously tested with over 500 unit test.

    See below

    Installation

    npm install @outofsync/memory-cache

    Usage

    const MemoryCache = require('@outofsync/memory-cache');
    const client = new MemoryCache({ bypassUnsupported: true });
    
    client.createClient();
    client.set("TestKey", 10);
    client.get("TestKey");

    API Reference

    constructor(options)

    Create a new MemoryCache client with the passed options. MemoryCache only supports one option bypassUnsupported which if set true causes any unsupported commands to fail silently instead of throwing an error.

    const MemoryCache = require('@outofsync/memory-cache');
    const client = new MemoryCache({ bypassUnsupported: true });

    MemoryCache.createClient()

    Connect to the memory cache and emits the connect and ready events.

    MemoryCache.quit()

    Disconnects from the memory cache and emits the end event.

    MemoryCache.end()

    Disconnects from the memory cache and emits the end event. Unlike the Redis client this is identical to calling quit.

    Command simplification

    Where possible, this module mimics the return data behavior of the Redis module. For example, the .hmset will accept a single object hash to set multiple fields. Similar .hmget will return an object hash.

    Multiple parameters

    Many Redis commands like set, mget, etc. accept multiple parameters. The memory cache library support passing all additional parameters.

    For example:

      client.mget('key1', 'key2', 'key3', 'key4');

    Additionally, if a command is multiple words, then the additional portion of the command may be passed as the first parameter.

    For example:

      client.flushall('async');

    Using Promises

    Every Redis command can be called with *Async at the end. This will invoke the Promisified variant of the command and return a Promise.

    For Example:

      client.getAsync('testkey')
      .then((res) => {
        // Do something useful
      })
      .catch((err) => {
        // Do something useful
      });

    Redis Commands

    MemoryCache support all but a select few Redis Commands and returns then data as close to identically as possible to the redis module. Any errors are thrown as exceptions which should be caught. The commands which are unavailable are as follows:

    • BGREWRITEAOF
    • BITFIELD
    • BITPOS
    • BLPOP
    • BRPOP
    • BRPOPLPUSH
    • CLIENT *
    • CLUSTER
    • COMMAND *
    • CONFIG *
    • DEBUG *
    • EVAL
    • EVALSHA
    • GEORADIUS
    • GEORADIUSBYMEMBER
    • HSCAN
    • MIGRATE
    • MONITOR
    • OBJECT
    • PFADD
    • PFCOUNT
    • PFMERGE
    • PSUBSCRIBE
    • PUBLISH
    • PUBSUB
    • PUNSUBSCRIBE
    • READONLY
    • READWRITE
    • REPLICAOF
    • SCAN
    • SCRIPT *
    • SHUTDOWN
    • SLAVEOF
    • SLOWLOG
    • SORT
    • SSCAN
    • SUBSCRIBE
    • SYNC
    • UNSUBSCRIBE
    • UNWATCH
    • WAIT
    • WATCH
    • ZINTERSTORE
    • ZSCAN
    • ZUNIONSTORE

    If an unavailable command is issued, then the module throws a MemoryCacheError -- "MemoryCache does not support that operation". This thrown error can be bypassed by passing the option bypassUnsupported as true in the constructor. Or by directly setting your MemoryCache instance instance.options.bypassUnsupported = true

    License

    Copyright (c) 2018-2019 Jay Reardon Copyright (c) 2019-2021 Out of Sync Studios LLC -- Licensed under the MIT license.

    Install

    npm i @outofsync/memory-cache

    DownloadsWeekly Downloads

    79

    Version

    1.4.1

    License

    MIT

    Unpacked Size

    227 kB

    Total Files

    16

    Last publish

    Collaborators

    • chronosis
    • skycoop