petty-cache 3.3.1 → 3.5.0

package/CHANGELOG.md

@@ -6,6 +6,14 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [3.5.0] - 2025-05-01
+### Changed
+- Added the ability for `pettyCache.del` functions to support callbacks and promises.
+
+## [3.4.0] - 2025-02-21
+### Changed
+- Added the ability for `pettyCache.mutex` functions to support callbacks and promises.
+
 ## [3.3.0] - 2024-07-03
 ### Changed
 - Added the ability for `pettyCache.fetch` to support async functions.

package/README.md

@@ -1,6 +1,6 @@
 # petty-cache
 
-[![Build Status](https://github.com/mediocre/petty-cache/actions/workflows/continuousIntegration.yaml/badge.svg?branch=main)](https://github.com/mediocre/petty-cache/actions?query=workflow%3Abuild+branch%3Amain)
+[![Build Status](https://github.com/mediocre/petty-cache/actions/workflows/test.yml/badge.svg?branch=main)](https://github.com/mediocre/petty-cache/actions?query=workflow%3Abuild+branch%3Amain)
 [![Coverage Status](https://coveralls.io/repos/github/mediocre/petty-cache/badge.svg?branch=main)](https://coveralls.io/github/mediocre/petty-cache?branch=main)
 
 A cache module for Node.js that uses a two-level cache (in-memory cache for recently accessed data plus Redis for distributed caching) with automatic serialization plus some extra features to avoid cache stampedes and thundering herds.

package/eslint.config.js

@@ -0,0 +1,44 @@
+const globals = require('globals');
+const js = require('@eslint/js');
+
+module.exports = [
+    js.configs.recommended,
+    {
+        ignores: ['node_modules/*'],
+        languageOptions: {
+            ecmaVersion: 2020,
+            sourceType: 'module',
+            parserOptions: {
+                ecmaFeatures: {
+                    jsx: true
+                }
+            },
+            globals: {
+                ...globals.es2020,
+                ...globals.mocha,
+                ...globals.node,
+                //added for 'fetch()' access
+                ...globals.serviceworker
+            }
+        },
+        rules: {
+            'brace-style': ['error', '1tbs', { allowSingleLine: true }],
+            'comma-dangle': ['error', 'never'],
+            'dot-notation': 'error',
+            'no-array-constructor': 'error',
+            'no-console': 'error',
+            'no-fallthrough': 'off',
+            'no-inline-comments': 'warn',
+            'no-trailing-spaces': 'error',
+            'no-unused-vars': ['error', { caughtErrors: 'none' }],
+            'object-curly-spacing': ['error', 'always'],
+            quotes: ['error', 'single'],
+            semi: ['error', 'always'],
+            'space-before-function-paren': ['error', {
+                anonymous: 'never',
+                named: 'never',
+                asyncArrow: 'always'
+            }]
+        }
+    }
+];

package/index.js

@@ -13,6 +13,7 @@ function PettyCache() {
         redisClient = redis.createClient(...arguments);
     }
 
+    //eslint-disable-next-line no-console
     redisClient.on('error', err => console.warn(`Warning: Redis reported a client error: ${err}`));
 
     function bulkGetFromRedis(keys, callback) {
@@ -254,14 +255,24 @@ function PettyCache() {
     };
 
     this.del = function(key, callback) {
-        redisClient.del(key, function(err) {
-            if (err) {
-                return callback(err);
-            }
+        const executor = () => {
+            return new Promise((resolve, reject) => {
+                redisClient.del(key, function(err) {
+                    if (err) {
+                        return reject(err);
+                    }
 
-            memoryCache.del(key);
-            callback();
-        });
+                    memoryCache.del(key);
+                    resolve();
+                });
+            });
+        };
+
+        if (callback) {
+            executor().then(result => callback(null, result)).catch(callback);
+        } else {
+            return executor();
+        }
     };
 
     // Returns data from cache if available;
@@ -461,42 +472,72 @@ function PettyCache() {
     };
 
     this.mutex = {
-        lock: function(key, options, callback) {
+        lock: (key, options, callback) => {
             // Options are optional
             if (!callback && typeof options === 'function') {
                 callback = options;
                 options = {};
             }
 
-            callback = callback || function() {};
             options = options || {};
 
-            options.retry = Object.prototype.hasOwnProperty.call(options, 'retry') ? options.retry : {};
-            options.retry.interval = Object.prototype.hasOwnProperty.call(options.retry, 'interval') ? options.retry.interval : 100;
-            options.retry.times = Object.prototype.hasOwnProperty.call(options.retry, 'times') ? options.retry.times : 1;
-            options.ttl = Object.prototype.hasOwnProperty.call(options, 'ttl') ? options.ttl : 1000;
+            options.retry = Object.hasOwn(options, 'retry') ? options.retry : {};
+            options.retry.interval = Object.hasOwn(options.retry, 'interval') ? options.retry.interval : 100;
+            options.retry.times = Object.hasOwn(options.retry, 'times') ? options.retry.times : 1;
+            options.ttl = Object.hasOwn(options, 'ttl') ? options.ttl : 1000;
 
-            async.retry({ interval: options.retry.interval, times: options.retry.times }, function(callback) {
-                redisClient.set(key, '1', 'NX', 'PX', options.ttl, function(err, res) {
-                    if (err) {
-                        return callback(err);
-                    }
+            const executor = () => {
+                return new Promise((resolve, reject) => {
+                    async.retry({ interval: options.retry.interval, times: options.retry.times }, callback => {
+                        redisClient.set(key, '1', 'NX', 'PX', options.ttl, function(err, res) {
+                            if (err) {
+                                return callback(err);
+                            }
 
-                    if (!res) {
-                        return callback(new Error());
-                    }
+                            if (!res) {
+                                return callback(new Error());
+                            }
 
-                    if (res !== 'OK') {
-                        return callback(new Error(res));
-                    }
+                            if (res !== 'OK') {
+                                return callback(new Error(res));
+                            }
 
-                    callback();
+                            callback();
+                        });
+                    }, function(err) {
+                        if (err) {
+                            return reject(err);
+                        }
+
+                        resolve();
+                    });
                 });
-            }, callback);
+            };
+
+            if (callback) {
+                executor().then(result => callback(null, result)).catch(callback);
+            } else {
+                return executor();
+            }
         },
-        unlock: function(key, callback) {
-            callback = callback || function() {};
-            redisClient.del(key, callback);
+        unlock: (key, callback) => {
+            const executor = () => {
+                return new Promise((resolve, reject) => {
+                    redisClient.del(key, function(err) {
+                        if (err) {
+                            return reject(err);
+                        }
+
+                        resolve();
+                    });
+                });
+            };
+
+            if (callback) {
+                executor().then(result => callback(null, result)).catch(callback);
+            } else {
+                return executor();
+            }
         }
     };
 

package/package.json

@@ -1,12 +1,14 @@
 {
   "description": "A cache module for node.js that uses a two-level cache (in-memory cache for recently accessed data plus Redis for distributed caching) with some extra features to avoid cache stampedes and thundering herds.",
   "dependencies": {
-    "async": "~3.2.0",
+    "async": "~3.2.6",
     "lock": "~1.1.0",
     "memory-cache": "~0.2.0",
     "redis": "~3.1.0"
   },
   "devDependencies": {
+    "@eslint/js": "*",
+    "globals": "*",
     "coveralls": "*",
     "mocha": "*",
     "nyc": "*"
@@ -30,5 +32,5 @@
     "type": "git",
     "url": "https://github.com/mediocre/petty-cache.git"
   },
-  "version": "3.3.1"
+  "version": "3.5.0"
 }