fabioricali / incache Goto Github PK

View Code? Open in Web Editor NEW

15.0 5.0 1.0 547 KB

Powerful key/value in-memory storage or on disk to persist data

JavaScript 99.30% Shell 0.28% HTML 0.42%

cache-storage singleton global javascript window storage session-management http-response nodejs memory-storage

incache's Introduction

Powerful key/value in-memory storage or on disk to persist data

What does?

InCache is a module that store any info in memory, it can be used for example for storing server sessions, caching http response or sharing singleton object in your apps. It also give you the possibility to save data on disk so you can avoid the data loss when the process exit or restart. In a browser scenario all data is saved on localStorage through a key.

Installation

Node.js

npm install incache --save

Examples

Basic

const InCache = require('incache');
const store = new InCache();

// Create a record with key 'my key'
store.set('my key', 'my value');

// Update 'my key'
store.set('my key', {a: 1, b: 2});

// Get key
store.get('my key');

// Remove 'my key'
store.remove('my key');

// Clear
store.clear();

// Expires after 2 seconds
store.set('my string', 'hello world', {maxAge: 2000});
// Or expires on...
store.set('my string', 'hello world', {expires: '2028-08-22 12:00:00'});

Auto remove expired records

const store = new InCache({
    autoRemovePeriod: 2 //checks every 2 seconds
});

store.set('my string', 'hello world', {maxAge: 4000});

setTimeout(()=>{
    console.log(store.count()) //=> 0
}, 6000);

Max cache size

const store = new InCache({
    maxRecordNumber: 5
});

store.set('k0', 'v0');
store.set('k1', 'v1');
store.set('k2', 'v2');
store.set('k3', 'v3');
store.set('k4', 'v4');
store.set('k5', 'v5');

console.log(store.count()); //=> 5
console.log(store.has('k0')); //=> false

Load manually

const store = new InCache({
    autoLoad: false
});

// This method returns a Promise
store.load('my-path/my-store.json').then(() => {
    console.log('loaded');
}).catch(err => {
    console.log(err);
});

Save on disk

By default this operation is running before the process is terminated

const store = new InCache({
    autoSave: true
});

Save when data is changed

const store = new InCache({
    autoSave: true,
    autoSaveMode: 'timer'
});

Save manually

const store = new InCache({
    filePath: 'my-path/my-store.json'
});

store.set('a key', 'a value');

// This method returns a Promise
store.save();

// or specify a path
store.save('a-path/a-file.json').then(()=>{
    console.log('saved');
    store.load('a-path/a-file.json');
}).catch(err => {
    console.log(err);
});

Browser scenario

In browser environment the file path becomes a string key for localStorage interface:

store.load('myLocalStorageKey');
store.save('myLocalStorageKey');

Events

// Triggered when a record has been deleted
incache.on('remove', key => {
    console.log(key);
});

// Triggered before create/update
incache.on('beforeSet', (key, value) => {
    console.log(key, value);
    if(foo)
        return false;
});

// Triggered when a record has been created
incache.on('create', (key, record) => {
    console.log(key, record);
});

//Triggered when a record has been updated
incache.on('update', (key, record) => {
    console.log(key, record);
});

//Triggered when the cache is saved on disk
incache.on('save', () => {
    console.log('saved on disk');
});

//Triggered when the cache exceed max size
incache.on('exceed', (diff) => {
    console.log(`exceeded for ${diff}`);
});

//... for more events see the documentation

API

Please see the full documentation for more details.

Browser

Local

<script src="node_modules/incache/dist/incache.min.js"></script>

CDN unpkg

<script src="https://unpkg.com/incache/dist/incache.min.js"></script>

CDN jsDeliver

<script src="https://cdn.jsdelivr.net/npm/incache/dist/incache.min.js"></script>

Changelog

You can view the changelog here

License

InCache is open-sourced software licensed under the MIT license

Author

Fabio Ricali

Contributor

Davide Polano

incache's People

Contributors

Stargazers

Watchers

Forkers

limitall

incache's Issues

autoSave: true in terminate mode will make the process cannot exit

const storage = new InCache({
  autoSave: true
})

[ Feature ] Load/Save automatically or manually

Hi,

I saw that the library exposes only a flag called save which defines if we want to save the current memory stack to a file in the disk. This is very useful, although the loading part feels a little bit undocumented and also is not really clear how to know when the memory is ready after load.

Therefore I purpose a little change that will greatly improve the overall development experience with this library. What we need to do are basically two things:

Expose two simple flags called autoload and autosave, which will provide transparency on which of the two ( or both ) actions do we need. An example will be:

const storage = new InCache({
  // Provide an autoloading mechanism in the constructor
  autoload: true,
  // Basically is the `save` flag, with a more transparent naming
  autosave: true
})

Expose two methods, that could also be used internally by the library, that are named .load() and .save(). These two methods, will obviously take care of loading and saving the internal memory. They must always return a Promise, and always resolve depending on the auto flag relatively set. An example would be:

const load = () => {
  return new Promise(
    ( resolve, reject ) => {
      if ( opts.autoload ) {
        // load the file from memory and resolve when done, reject if any error occours
      } else
        resolve()
    }
  )
}

Same applies for .save()

If you have any question feel free to reach me on this issue anytime.

Thank you in advance,
Julian

Share data between node applications

Hey,
I need to share data between parent and child nodes. I'm wondering whether I can use inCache for my purpose. I tried to do it, but unfortunately, the child process is not being able to read the stored object.

So, does the feature to share objects between processes is implemented or not?

Store data in file

If node process will be restarted we lost all data stored in cache.
This is not a problem in most of condition but there are few scenarios where this could be a problem, for example if you store information about sessions during a restart you probably get unverified session.
Is it possible to add an option that store data in a file ?

Wrong Webpack configuration

It took me actually a while to figure it out why I was having this issue once running the latest version of this library:

Unhandled Rejection at: Promise { <rejected> 'fs.writeFileSync is not a function' } reason: fs.writeFileSync is not a function

Once I found out that in your webpack config, you have this line that is very wrong if you build the library using webpack.

As suggested by Webpack itself, please use target: 'node' instead.

Thank you in advance :)

For whoever has an issue, this is the workaround you can use:

// Generic require way
const incache = require('incache/index')

// Import way
import incache from 'incache/index'

save as utf8?

hi, I have an issue while saving.. the cache is saved in ANSII encoding. Is there a way to force UTF8?

Cannot use without a physical cache file

I'd like to use this as purely in memory storage, with nothing saved to disk.

I get this error when I don't specify a physical file to store the cache in.
"ENOENT: no such file or directory, open '.incache'"

The library really should be able to function without actually specifying a file. When one is not specified, should fall back to memory only usage.