petty-cache 3.3.0 → 3.4.0

package/CHANGELOG.md

@@ -6,6 +6,10 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [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/index.js

@@ -1,5 +1,3 @@
-const util = require('util');
-
 const async = require('async');
 const lock = require('lock').Lock();
 const memoryCache = require('memory-cache');
@@ -336,7 +334,8 @@ function PettyCache() {
                                 }
 
                                 // Execute the specified function and place the results in cache before returning the data
-                                if (util.types.isAsyncFunction(func)) {
+                                if (func.length === 0) {
+                                    // If the function doesn't have any arguments, there wasn't a callback provided
                                     try {
                                         const data = await func();
 
@@ -347,6 +346,7 @@ function PettyCache() {
                                         callback(err);
                                     }
                                 } else {
+                                    // If the function has arguments, there was a callback provided
                                     func(function(err, data) {
                                         if (err) {
                                             return callback(err);
@@ -461,42 +461,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();
+                        });
+                    }, function(err) {
+                        if (err) {
+                            return reject(err);
+                        }
 
-                    callback();
+                        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,7 +1,7 @@
 {
   "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"
@@ -30,5 +30,5 @@
     "type": "git",
     "url": "https://github.com/mediocre/petty-cache.git"
   },
-  "version": "3.3.0"
+  "version": "3.4.0"
 }