potato-cache

A simple file caching package

Downloads in past

Stats

StarsIssuesVersionUpdatedCreatedSize
potato-cache
1.0.176 years ago6 years agoMinified + gzip package size for potato-cache in KB

Readme


Securely store ``JSON`` data and normal data
Used in PotatoDetection

Installation ##

npm install --save potato-cache

Setup ##

  • Require the package
  • Setup the cache path and secret key
  • Set to true if mkdirp the directory doesnt exist. default ``false``
const PotatoCache = require('potato-cache')

PotatoCache.setup(path, secret, true)

API ##

write(key, data, callback) ###

Write data to cache asynchronously and callback a function with the given data written
``throws`` error
``returns`` data written
var obj = {name: 'KitKat', owner: 'Nestle'}
PotatoCache.write('chocolate', obj, (data) => {
  ...
})

writeSync(key, data) ###

Write data synchronously and return the given data written
``throws`` error
``returns`` data written
var obj = {name: 'KitKat', age: 21}
var cached = PotatoCache.write('chocolate', obj)
console.log(cached)

read(key, callback) ###

Read data asynchronously and callback a function with the data
``throws`` error
``returns`` data from cache
PotatoCache.read('chocolate', (data) => {
  ...
})

readSync(key, callback) ###

Read data synchronously and callback a function with the data
``throws`` error
``returns`` data from cache
var data = PotatoCache.readSync('chocolate')
console.log(data)

exists(key) ###

Checks if a cache exists
``returns`` promise
PotatoCache.exists('chocolate')
  .then(() => {
    ...
  })
  .catch(() => {
    var obj = {name: 'KitKat', owner: 'Nestle'}
    PotatoCache.writeSync('chocolate', obj)
  })

existsThenRead(key) ###

Checks if a cache exists, and if it does, it will return the data in the Promise resolve
``returns`` promise and data
PotatoCache.existsThenRead('chocoloate')
  .then(data => {
      ...
  })
  .catch(() => {
      ...
  })

isNotExpired(key, maxAge)

Checks if a cache exists and is not expired
``maxAge`` checks if the cache is older than x minutes default value is 3 hours
``returns`` promise
PotatoCache.isNotExpired('chocolate')
  .then(() => {
    ...
  })
  .catch(res => {
    console.log(res) // 'File is x minutes too old'
    var obj = {name: 'KitKat', owner: 'Nestle'}
    PotatoCache.writeSync('chocolate', obj)
  })

isNotExpiredThenRead(key, maxAge)

Checks if a cache exists and is not expired then reads the data and returns it
``maxAge`` checks if the cache is older than x minutes
default value is 3 hours
``returns`` promise and data
PotatoCache.isNotExpiredThenRead('chocolate')
  .then(data => {
    console.log(data)
  })
  .catch(res => {
    console.log(res) // 'File is x minutes too old'
    var obj = {name: 'KitKat', owner: 'Nestle'}
    PotatoCache.writeSync('chocolate', obj)
  })

getPath(key) ###

``throws`` error
``returns`` the given path and hashed md5 filename for the cache
console.log(PotatoCache.getPath('chocolate'))

purge(key) ###

Deletes a cache asynchronously
``throws error``
PotatoCache.purge('chocolate', () => {
  ...
})

purgeSync(key) ###

Deletes a cache synchronously
``throws error``
PotatoCache.purgeSync('chocolate')

trash() ###

Clears the entire cache folder asynchronously
``throws error``
PotatoCache.trash(() => {
  ...
})

trashSync() ###

Clears the entire cache folder synchronously
``throws error``
PotatoCache.trashSync()

getSize(callback) ###

``returns`` the size of the cache folder in megabytes asynchronously
``throws error``
PotatoCache.getSize(size => {
  ...
})