spice-js 2.6.57 → 2.6.58

package/build/cache/providers/SpiceCache.js

@@ -12,7 +12,8 @@ var crypto = require("crypto");
 
 function generateCacheKey(input) {
   // Create an MD5 hash of the input string and return it in hexadecimal format
-  return crypto.createHash("md5").update(input).digest("hex");
+  //return crypto.createHash("md5").update(input).digest("hex");
+  return input;
 }
 
 module.exports = class SpiceCache {
@@ -53,8 +54,9 @@ module.exports = class SpiceCache {
         namespace = ""
       } = working_options;
       var workingKey = namespace + key;
+      var cacheKey = generateCacheKey(workingKey);
 
-      _this2.client.set(generateCacheKey(workingKey), value, ttl == undefined ? 60 : ttl);
+      _this2.client.set(cacheKey, value, ttl === undefined ? 60 : ttl);
     })();
   }
 
@@ -79,11 +81,19 @@ module.exports = class SpiceCache {
     })();
   }
 
-  exists(key) {
+  exists(key, options) {
     var _this4 = this;
 
     return _asyncToGenerator(function* () {
-      var cacheKey = generateCacheKey(key);
+      if (options === void 0) {
+        options = {};
+      }
+
+      var {
+        namespace = ""
+      } = options;
+      var workingKey = namespace + key;
+      var cacheKey = generateCacheKey(workingKey);
       return yield _this4.client.has(cacheKey);
     })();
   }

package/build/models/SpiceModel.js

@@ -573,7 +573,7 @@ class SpiceModel {
         }
 
         if (_.isString(args.id)) {
-          if (args.skip_hooks != true) {
+          if (args.skip_hooks !== true) {
             yield _this4.run_hook(args, "get", "before");
           }
 
@@ -581,34 +581,43 @@ class SpiceModel {
           var results = {};
 
           if (_this4.shouldUseCache(_this4.type)) {
-            var cached_results = yield _this4.getCacheProviderObject(_this4.type).get(key);
-            results = cached_results == null ? void 0 : cached_results.value;
+            // Retrieve the cached results
+            var cached_results = yield _this4.getCacheProviderObject(_this4.type).get(key); // Check if the cache is empty
+
+            var isCacheEmpty = (cached_results == null ? void 0 : cached_results.value) === undefined; // Check if the cached result should be refreshed
 
-            if ((cached_results == null ? void 0 : cached_results.value) === undefined || (yield _this4.shouldForceRefresh(cached_results)) || _this4.type == "workflow") {
+            var shouldRefresh = yield _this4.shouldForceRefresh(cached_results); // Force a refresh for "workflow" type if needed
+
+            if (isCacheEmpty || shouldRefresh) {
+              // Retrieve from the database and update cache
               results = yield _this4.database.get(args.id);
               yield _this4.getCacheProviderObject(_this4.type).set(key, {
                 value: results,
                 time: new Date().getTime()
               }, _this4.getCacheConfig(_this4.type));
+            } else {
+              // Use the cached value
+              results = cached_results.value;
             }
           } else {
+            // Directly fetch from the database if caching is disabled
             results = yield _this4.database.get(args.id);
           }
 
-          if (results.type != undefined) {
-            if (results.type != _this4.type) throw new Error(_this4.type + " does not exist type");
+          if (results.type !== undefined && results.type !== _this4.type) {
+            throw new Error(_this4.type + " does not exist type");
           }
 
-          if (results._type != undefined) {
-            if (results._type != _this4.type) throw new Error(_this4.type + " does not exist _type");
+          if (results._type !== undefined && results._type !== _this4.type) {
+            throw new Error(_this4.type + " does not exist _type");
           }
 
-          if (results.deleted == undefined || results.deleted == false) {
-            if (args.skip_read_serialize != true && args.skip_serialize != true) {
+          if (results.deleted === undefined || results.deleted === false) {
+            if (args.skip_read_serialize !== true && args.skip_serialize !== true) {
               results = yield _this4.do_serialize(results, "read", {}, args, (yield _this4.propsToBeRemoved(results)));
             }
 
-            if (args.skip_hooks != true) {
+            if (args.skip_hooks !== true) {
               yield _this4.run_hook(results, "get", "after");
             }
 
@@ -995,10 +1004,10 @@ class SpiceModel {
     parts[0] = "`" + parts[0] + "`";
     return parts.join(" ");
   }
-
-  removeSpaceAndSpecialCharacters(str) {
+  /* removeSpaceAndSpecialCharacters(str) {
     return str.replace(/[^a-zA-Z0-9]/g, "");
-  }
+  } */
+
 
   fixColumnName(columns) {
     // Guard clause: if columns is not provided or not a string, return it as-is.
@@ -1115,24 +1124,25 @@ class SpiceModel {
           yield _this12.run_hook(_this12, "list", "before");
         }
 
-        var cacheKey = _this12.removeSpaceAndSpecialCharacters("list::" + _this12.type + "::" + args._join + "::" + query + "::" + args.limit + "::" + args.offset + "::" + args.sort + "::" + args.do_count + "::" + args.statement_consistent + "::" + args.columns + "::" + args.is_full_text + "::" + args.is_custom_query);
-
+        var cacheKey = "list::" + _this12.type + "::" + args._join + "::" + query + "::" + args.limit + "::" + args.offset + "::" + args.sort + "::" + args.do_count + "::" + args.statement_consistent + "::" + args.columns + "::" + args.is_full_text + "::" + args.is_custom_query;
         var results;
 
         if (_this12.shouldUseCache(_this12.type)) {
           var cachedResults = yield _this12.getCacheProviderObject(_this12.type).get(cacheKey);
-          results = cachedResults == null ? void 0 : cachedResults.value;
+          results = cachedResults == null ? void 0 : cachedResults.value; // Check if there is no cached value
 
-          if ((cachedResults == null ? void 0 : cachedResults.value) === undefined) {
+          var isCacheEmpty = (cachedResults == null ? void 0 : cachedResults.value) === undefined; // Check if the cached value should be refreshed (e.g., due to the monitor's timestamp)
+
+          var shouldRefresh = yield _this12.shouldForceRefresh(cachedResults); // Always force a refresh for "workflow" type
+
+          if (isCacheEmpty || shouldRefresh) {
+            // Force a database read and cache update
             results = yield _this12.fetchResults(args, query);
-          } else {
-            if (!results || (yield _this12.shouldForceRefresh(cachedResults))) {
-              results = yield _this12.fetchResults(args, query);
-              yield _this12.getCacheProviderObject(_this12.type).set(cacheKey, {
-                value: results,
-                time: new Date().getTime()
-              }, _this12.getCacheConfig(_this12.type));
-            }
+
+            _this12.getCacheProviderObject(_this12.type).set(cacheKey, {
+              value: results,
+              time: new Date().getTime()
+            }, _this12.getCacheConfig(_this12.type));
           }
         } else {
           results = yield _this12.fetchResults(args, query);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "spice-js",
-  "version": "2.6.57",
+  "version": "2.6.58",
   "description": "spice",
   "main": "build/index.js",
   "repository": {

package/src/cache/providers/SpiceCache.js

@@ -3,7 +3,8 @@ const crypto = require("crypto");
 
 function generateCacheKey(input) {
   // Create an MD5 hash of the input string and return it in hexadecimal format
-  return crypto.createHash("md5").update(input).digest("hex");
+  //return crypto.createHash("md5").update(input).digest("hex");
+  return input;
 }
 
 module.exports = class SpiceCache {
@@ -20,11 +21,8 @@ module.exports = class SpiceCache {
     let working_options = { ...this.options, ...options };
     const { ttl, namespace = "" } = working_options;
     const workingKey = namespace + key;
-    this.client.set(
-      generateCacheKey(workingKey),
-      value,
-      ttl == undefined ? 60 : ttl
-    );
+    const cacheKey = generateCacheKey(workingKey);
+    this.client.set(cacheKey, value, ttl === undefined ? 60 : ttl);
   }
 
   async get(key, options = {}) {
@@ -38,8 +36,10 @@ module.exports = class SpiceCache {
     }
   }
 
-  async exists(key) {
-    const cacheKey = generateCacheKey(key);
+  async exists(key, options = {}) {
+    const { namespace = "" } = options;
+    const workingKey = namespace + key;
+    const cacheKey = generateCacheKey(workingKey);
     return await this.client.has(cacheKey);
   }
 };

package/src/models/SpiceModel.js

@@ -489,45 +489,51 @@ export default class SpiceModel {
         args = {};
       }
       if (_.isString(args.id)) {
-        if (args.skip_hooks != true) {
+        if (args.skip_hooks !== true) {
           await this.run_hook(args, "get", "before");
         }
         let key = `get::${this.type}::${args.id}`;
         let results = {};
-        if (this.shouldUseCache(this.type)) {
-          let cached_results = await this.getCacheProviderObject(this.type).get(
-            key
-          );
 
-          results = cached_results?.value;
-          if (
-            cached_results?.value === undefined ||
-            (await this.shouldForceRefresh(cached_results)) ||
-            this.type == "workflow"
-          ) {
+        if (this.shouldUseCache(this.type)) {
+          // Retrieve the cached results
+          const cached_results = await this.getCacheProviderObject(
+            this.type
+          ).get(key);
+          // Check if the cache is empty
+          const isCacheEmpty = cached_results?.value === undefined;
+          // Check if the cached result should be refreshed
+          const shouldRefresh = await this.shouldForceRefresh(cached_results);
+          // Force a refresh for "workflow" type if needed
+
+          if (isCacheEmpty || shouldRefresh) {
+            // Retrieve from the database and update cache
             results = await this.database.get(args.id);
             await this.getCacheProviderObject(this.type).set(
               key,
               { value: results, time: new Date().getTime() },
               this.getCacheConfig(this.type)
             );
+          } else {
+            // Use the cached value
+            results = cached_results.value;
           }
         } else {
+          // Directly fetch from the database if caching is disabled
           results = await this.database.get(args.id);
         }
 
-        if (results.type != undefined) {
-          if (results.type != this.type)
-            throw new Error(`${this.type} does not exist type`);
+        if (results.type !== undefined && results.type !== this.type) {
+          throw new Error(`${this.type} does not exist type`);
         }
-
-        if (results._type != undefined) {
-          if (results._type != this.type)
-            throw new Error(`${this.type} does not exist _type`);
+        if (results._type !== undefined && results._type !== this.type) {
+          throw new Error(`${this.type} does not exist _type`);
         }
-
-        if (results.deleted == undefined || results.deleted == false) {
-          if (args.skip_read_serialize != true && args.skip_serialize != true) {
+        if (results.deleted === undefined || results.deleted === false) {
+          if (
+            args.skip_read_serialize !== true &&
+            args.skip_serialize !== true
+          ) {
             results = await this.do_serialize(
               results,
               "read",
@@ -536,7 +542,7 @@ export default class SpiceModel {
               await this.propsToBeRemoved(results)
             );
           }
-          if (args.skip_hooks != true) {
+          if (args.skip_hooks !== true) {
             await this.run_hook(results, "get", "after");
           }
           return results;
@@ -918,9 +924,9 @@ export default class SpiceModel {
     return parts.join(" ");
   }
 
-  removeSpaceAndSpecialCharacters(str) {
+  /* removeSpaceAndSpecialCharacters(str) {
     return str.replace(/[^a-zA-Z0-9]/g, "");
-  }
+  } */
 
   fixColumnName(columns) {
     // Guard clause: if columns is not provided or not a string, return it as-is.
@@ -1051,10 +1057,7 @@ export default class SpiceModel {
         await this.run_hook(this, "list", "before");
       }
 
-      const cacheKey = this.removeSpaceAndSpecialCharacters(
-        `list::${this.type}::${args._join}::${query}::${args.limit}::${args.offset}::${args.sort}::${args.do_count}::${args.statement_consistent}::${args.columns}::${args.is_full_text}::${args.is_custom_query}`
-      );
-
+      const cacheKey = `list::${this.type}::${args._join}::${query}::${args.limit}::${args.offset}::${args.sort}::${args.do_count}::${args.statement_consistent}::${args.columns}::${args.is_full_text}::${args.is_custom_query}`;
       let results;
       if (this.shouldUseCache(this.type)) {
         const cachedResults = await this.getCacheProviderObject(this.type).get(
@@ -1062,17 +1065,21 @@ export default class SpiceModel {
         );
         results = cachedResults?.value;
 
-        if (cachedResults?.value === undefined) {
+        // Check if there is no cached value
+        const isCacheEmpty = cachedResults?.value === undefined;
+
+        // Check if the cached value should be refreshed (e.g., due to the monitor's timestamp)
+        const shouldRefresh = await this.shouldForceRefresh(cachedResults);
+
+        // Always force a refresh for "workflow" type
+        if (isCacheEmpty || shouldRefresh) {
+          // Force a database read and cache update
           results = await this.fetchResults(args, query);
-        } else {
-          if (!results || (await this.shouldForceRefresh(cachedResults))) {
-            results = await this.fetchResults(args, query);
-            await this.getCacheProviderObject(this.type).set(
-              cacheKey,
-              { value: results, time: new Date().getTime() },
-              this.getCacheConfig(this.type)
-            );
-          }
+          this.getCacheProviderObject(this.type).set(
+            cacheKey,
+            { value: results, time: new Date().getTime() },
+            this.getCacheConfig(this.type)
+          );
         }
       } else {
         results = await this.fetchResults(args, query);