@feardread/feature-factory 5.0.8 → 5.1.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@feardread/feature-factory",
-  "version": "5.0.8",
+  "version": "5.1.0",
   "description": "Library to interact with redux toolkit and reduce boilerplate / repeated code",
   "main": "dist/index.js",
   "scripts": {
@@ -32,7 +32,7 @@
     "@rollup/plugin-json": "^6.1.0",
     "@rollup/plugin-node-resolve": "^15.3.0",
     "@rollup/plugin-terser": "^0.4.4",
-    "rollup": "^4.22.4",
+    "rollup": "^4.51.0",
     "rollup-plugin-dts": "^6.1.1",
     "rollup-plugin-peer-deps-external": "^2.2.4",
     "rollup-plugin-polyfill-node": "^0.13.0"

package/rollup.config.mjs

@@ -2,30 +2,7 @@ import terser from '@rollup/plugin-terser';
 import resolve from "@rollup/plugin-node-resolve";
 import commonjs from "@rollup/plugin-commonjs";
 import json from "@rollup/plugin-json";
-import polyfill from "rollup-plugin-polyfill-node";
 import peerDepsExternal from 'rollup-plugin-peer-deps-external';
-import typescript from '@rollup/plugin-typescript'
-import pkg from "./package.json" assert { type: 'json' };
-import dts from 'rollup-plugin-dts'
-const config = [
-  {
-    input: 'src/index.js',
-    output: {
-      file: 'refactory.js',
-      format: 'cjs',
-      sourcemap: true,
-    },
-    external: ['axios', 'os', 'url'],
-    plugins: [typescript()]
-  }, {
-    input: 'src/index.d.ts',
-    output: {
-      file: 'refactory.d.ts',
-      format: 'es'
-    },
-    plugins: [dts()]
-  }
-];
 
 const jsconfig = [{
 		input: 'src/index.js',
@@ -47,7 +24,7 @@ const jsconfig = [{
 				format: 'iife',
 				name: 'version',
 				plugins: [terser()]
-			}
+			},
 		],
 		plugins: [
 			peerDepsExternal(),
@@ -58,46 +35,9 @@ const jsconfig = [{
 			commonjs(),
       		json(),
 			terser()
-		]
+		],
+		context: "this",
 	},  
 ];
 
 export default jsconfig;
-/*
-export default [
-	{
-		input: 'src/index.ts',
-		output: [
-			{
-				file: 'dist/index.js',
-				format: 'cjs',
-        		exports: 'named',
-				sourcemap: true,
-			},
-			{
-				file: 'dist/index.esm.js',
-				format: "esm",
-        		exports: 'named',
-				sourcemap: true,
-			},
-		  	{
-				file: 'dist/bundle.min.js',
-				format: 'iife',
-				name: 'version',
-				plugins: [terser()]
-			}
-		],
-		plugins: [
-			peerDepsExternal(),
-      		resolve({
-        		browser: true,
-        		preferBuiltins: false,
-      		}),
-			commonjs(),
-      		json(),
-			terser(),
-			typescript()
-		]
-	},  
-];
-*/

package/src/factory/api.js

@@ -31,6 +31,7 @@ const setBaseUrl = (uri) => {
   CONFIG.BASE_URL = uri || CONFIG.baseUrls['development'];
   getBaseUrl();
 };
+
 /**
  * Gets the appropriate base URL for the current environment
  * @returns {string} Base URL
@@ -45,9 +46,9 @@ const getBaseUrl = () => {
  * Gets authentication data from cache
  * @returns {Object|null} Auth data or null
  */
-const getAuthData = async () => {
+const getAuthData = () => {
   try {
-    const authData = await CacheFactory.local.get(CONFIG.cacheKeys.auth);
+    const authData = CacheFactory.local.get(CONFIG.cacheKeys.auth);
     return authData && typeof authData === 'object' ? authData : null;
   } catch (error) {
     console.warn('Failed to retrieve auth data:', error);
@@ -78,8 +79,8 @@ const isTokenExpired = (token) => {
  */
 const refreshAuthToken = async () => {
   try {
-    const authData = await getAuthData();
-    const refreshToken = authData?.refreshToken || await CacheFactory.local.get(CONFIG.cacheKeys.refreshToken);
+    const authData = getAuthData();
+    const refreshToken = authData?.refreshToken || CacheFactory.local.get(CONFIG.cacheKeys.refreshToken);
     
     if (!refreshToken) {
       throw new Error('No refresh token available');
@@ -96,11 +97,11 @@ const refreshAuthToken = async () => {
       expiresAt: response.data.expiresAt,
     };
 
-    await CacheFactory.local.set(CONFIG.cacheKeys.auth, newAuthData);
+    CacheFactory.local.set(CONFIG.cacheKeys.auth, newAuthData);
     return newAuthData.token;
   } catch (error) {
     console.error('Token refresh failed:', error);
-    await clearAuthData();
+    clearAuthData();
     return null;
   }
 };
@@ -108,12 +109,10 @@ const refreshAuthToken = async () => {
 /**
  * Clears authentication data from cache
  */
-const clearAuthData = async () => {
+const clearAuthData = () => {
   try {
-    await Promise.all([
-      CacheFactory.local.remove(CONFIG.cacheKeys.auth),
-      CacheFactory.local.remove(CONFIG.cacheKeys.refreshToken),
-    ]);
+    CacheFactory.local.remove(CONFIG.cacheKeys.auth);
+    CacheFactory.local.remove(CONFIG.cacheKeys.refreshToken);
   } catch (error) {
     console.warn('Failed to clear auth data:', error);
   }
@@ -182,7 +181,7 @@ const requestInterceptor = async (config) => {
     config._retry = config._retry || 0;
 
     // Get authentication data
-    const authData = await getAuthData();
+    const authData = getAuthData();
     let token = authData?.token;
 
     // Check if token needs refresh
@@ -304,7 +303,7 @@ const responseErrorInterceptor = async (error) => {
     }
     
     // Clear auth data and redirect to login
-    await clearAuthData();
+    clearAuthData();
     
     // Dispatch auth failure event
     if (typeof window !== 'undefined') {
@@ -425,9 +424,9 @@ const API = {
    * Sets authentication token
    * @param {string} token - Auth token
    * @param {Object} userData - User data
-   * @returns {Promise<boolean>} Success status
+   * @returns {boolean} Success status
    */
-  setAuth: async (token, userData = {}) => {
+  setAuth: (token, userData = {}) => {
     try {
       const authData = {
         token,
@@ -436,8 +435,7 @@ const API = {
         expiresAt: userData.expiresAt,
       };
       
-      await CacheFactory.local.set(CONFIG.cacheKeys.auth, authData);
-      return true;
+      return CacheFactory.local.set(CONFIG.cacheKeys.auth, authData);
     } catch (error) {
       console.error('Failed to set auth:', error);
       return false;
@@ -446,11 +444,11 @@ const API = {
 
   /**
    * Clears authentication
-   * @returns {Promise<boolean>} Success status
+   * @returns {boolean} Success status
    */
-  clearAuth: async () => {
+  clearAuth: () => {
     try {
-      await clearAuthData();
+      clearAuthData();
       return true;
     } catch (error) {
       console.error('Failed to clear auth:', error);
@@ -460,10 +458,10 @@ const API = {
 
   /**
    * Gets current auth status
-   * @returns {Promise<Object>} Auth status
+   * @returns {Object} Auth status
    */
-  getAuthStatus: async () => {
-    const authData = await getAuthData();
+  getAuthStatus: () => {
+    const authData = getAuthData();
     const isAuthenticated = !!(authData?.token && !isTokenExpired(authData.token));
     
     return {
@@ -524,6 +522,84 @@ const API = {
     });
   },
 
+  // Cache utility methods
+  /**
+   * Gets cached data
+   * @param {string} key - Cache key
+   * @param {any} defaultValue - Default value if not found
+   * @returns {any} Cached data or default value
+   */
+  getCached: (key, defaultValue = null) => {
+    return CacheFactory.local.get(key, defaultValue);
+  },
+
+  /**
+   * Sets cached data
+   * @param {string} key - Cache key
+   * @param {any} value - Value to cache
+   * @returns {boolean} Success status
+   */
+  setCached: (key, value) => {
+    return CacheFactory.local.set(key, value);
+  },
+
+  /**
+   * Removes cached data
+   * @param {string} key - Cache key
+   * @returns {boolean} Success status
+   */
+  removeCached: (key) => {
+    return CacheFactory.local.remove(key);
+  },
+
+  /**
+   * Clears all cached data
+   * @returns {boolean} Success status
+   */
+  clearCache: () => {
+    return CacheFactory.local.clear();
+  },
+
+  /**
+   * Gets cache statistics
+   * @returns {Object} Cache stats
+   */
+  getCacheStats: () => {
+    return CacheFactory.local.getStats();
+  },
+
+  /**
+   * Bulk cache operations
+   */
+  cache: {
+    /**
+     * Gets multiple cached items
+     * @param {string[]} keys - Cache keys
+     * @returns {Object} Key-value pairs
+     */
+    getMultiple: (keys) => {
+      return CacheFactory.local.bulk.get(keys);
+    },
+
+    /**
+     * Sets multiple cached items
+     * @param {Object} items - Key-value pairs
+     * @returns {Object} Success status for each key
+     */
+    setMultiple: (items) => {
+      return CacheFactory.local.bulk.set(items);
+    },
+
+    /**
+     * Removes multiple cached items
+     * @param {string[]} keys - Cache keys
+     * @returns {Object} Success status for each key
+     */
+    removeMultiple: (keys) => {
+      return CacheFactory.local.bulk.remove(keys);
+    },
+  },
+
   // Configuration access
   config: CONFIG,
   getBaseUrl,

package/src/factory/cache.js

@@ -107,6 +107,30 @@ const safeParse = (value) => {
   }
 };
 
+/**
+ * Retries an operation with exponential backoff
+ * @param {Function} operation - Operation to retry
+ * @param {number} maxRetries - Maximum retry attempts
+ * @returns {any} Operation result
+ */
+const retryOperation = (operation, maxRetries) => {
+  let attempts = 0;
+  
+  while (attempts <= maxRetries) {
+    try {
+      return operation();
+    } catch (error) {
+      if (attempts === maxRetries) {
+        throw error;
+      }
+      attempts++;
+      // Simple synchronous delay simulation (not recommended for production)
+      // In a real scenario, you might want to remove retries for sync operations
+      // or handle them differently
+    }
+  }
+};
+
 /**
  * Creates a cache instance with the specified configuration
  * @param {Object} options - Configuration options
@@ -186,31 +210,12 @@ export const CacheFactory = (options = {}) => {
     }
   };
 
-  /**
-   * Retries an operation with exponential backoff
-   * @param {Function} operation - Operation to retry
-   * @param {number} attempts - Current attempt number
-   * @returns {Promise<any>} Operation result
-   */
-  const retryOperation = async (operation, attempts = 0) => {
-    try {
-      return await operation();
-    } catch (error) {
-      if (attempts < config.maxRetries) {
-        const delay = Math.pow(2, attempts) * 100; // Exponential backoff
-        await new Promise(resolve => setTimeout(resolve, delay));
-        return retryOperation(operation, attempts + 1);
-      }
-      throw error;
-    }
-  };
-
   return {
     /**
      * Checks if storage is available
      * @returns {boolean} Storage availability status
      */
-    isAvailable: () => {
+    isAvailable() {
       return storage !== null;
     },
 
@@ -218,7 +223,7 @@ export const CacheFactory = (options = {}) => {
      * Checks if using memory fallback
      * @returns {boolean} Whether using memory storage
      */
-    isUsingMemoryFallback: () => {
+    isUsingMemoryFallback() {
       return usingMemoryFallback;
     },
 
@@ -226,7 +231,7 @@ export const CacheFactory = (options = {}) => {
      * Gets storage type being used
      * @returns {string} Storage type name
      */
-    getStorageType: () => {
+    getStorageType() {
       return usingMemoryFallback ? 'memory' : storageType;
     },
 
@@ -234,9 +239,9 @@ export const CacheFactory = (options = {}) => {
      * Sets an item in storage
      * @param {string} key - Storage key
      * @param {any} value - Value to store
-     * @returns {Promise<boolean>} Success status
+     * @returns {boolean} Success status
      */
-    set: async (key, value) => {
+    set(key, value) {
       if (!storage) {
         console.error('CacheFactory: Storage not available');
         return false;
@@ -254,9 +259,9 @@ export const CacheFactory = (options = {}) => {
       }
 
       try {
-        await retryOperation(() => {
+        retryOperation(() => {
           storage.setItem(prefixedKey, serializedValue);
-        });
+        }, config.maxRetries);
         
         log('SET', key, value);
         return true;
@@ -270,9 +275,9 @@ export const CacheFactory = (options = {}) => {
      * Gets an item from storage
      * @param {string} key - Storage key
      * @param {any} defaultValue - Default value if key doesn't exist
-     * @returns {Promise<any>} Retrieved value or default
+     * @returns {any} Retrieved value or default
      */
-    get: async (key, defaultValue = null) => {
+    get(key, defaultValue = null) {
       if (!storage) {
         console.warn('CacheFactory: Storage not available');
         return defaultValue;
@@ -286,9 +291,9 @@ export const CacheFactory = (options = {}) => {
       const prefixedKey = getPrefixedKey(key);
 
       try {
-        const data = await retryOperation(() => {
+        const data = retryOperation(() => {
           return storage.getItem(prefixedKey);
-        });
+        }, config.maxRetries);
 
         if (data === null || data === 'undefined') {
           log('GET_MISS', key);
@@ -307,9 +312,9 @@ export const CacheFactory = (options = {}) => {
     /**
      * Removes an item from storage
      * @param {string} key - Storage key
-     * @returns {Promise<boolean>} Success status
+     * @returns {boolean} Success status
      */
-    remove: async (key) => {
+    remove(key) {
       if (!storage) {
         console.error('CacheFactory: Storage not available');
         return false;
@@ -323,9 +328,9 @@ export const CacheFactory = (options = {}) => {
       const prefixedKey = getPrefixedKey(key);
 
       try {
-        await retryOperation(() => {
+        retryOperation(() => {
           storage.removeItem(prefixedKey);
-        });
+        }, config.maxRetries);
         
         log('REMOVE', key);
         return true;
@@ -337,9 +342,9 @@ export const CacheFactory = (options = {}) => {
 
     /**
      * Clears all items from storage (respects prefix)
-     * @returns {Promise<boolean>} Success status
+     * @returns {boolean} Success status
      */
-    clear: async () => {
+    clear() {
       if (!storage) {
         console.error('CacheFactory: Storage not available');
         return false;
@@ -348,12 +353,12 @@ export const CacheFactory = (options = {}) => {
       try {
         if (config.prefix) {
           // Clear only prefixed items
-          const keys = await this.keys();
-          await Promise.all(keys.map(key => this.remove(key)));
+          const keys = this.keys();
+          keys.forEach(key => this.remove(key));
         } else {
-          await retryOperation(() => {
+          retryOperation(() => {
             storage.clear();
-          });
+          }, config.maxRetries);
         }
         
         log('CLEAR');
@@ -366,9 +371,9 @@ export const CacheFactory = (options = {}) => {
 
     /**
      * Gets all keys from storage (without prefix)
-     * @returns {Promise<string[]>} Array of keys
+     * @returns {string[]} Array of keys
      */
-    keys: async () => {
+    keys() {
       if (!storage) {
         console.warn('CacheFactory: Storage not available');
         return [];
@@ -400,9 +405,9 @@ export const CacheFactory = (options = {}) => {
     /**
      * Checks if a key exists in storage
      * @param {string} key - Storage key
-     * @returns {Promise<boolean>} Whether key exists
+     * @returns {boolean} Whether key exists
      */
-    has: async (key) => {
+    has(key) {
       if (!storage || !key || typeof key !== 'string') {
         return false;
       }
@@ -410,9 +415,9 @@ export const CacheFactory = (options = {}) => {
       const prefixedKey = getPrefixedKey(key);
 
       try {
-        const exists = await retryOperation(() => {
+        const exists = retryOperation(() => {
           return storage.getItem(prefixedKey) !== null;
-        });
+        }, config.maxRetries);
         
         log('HAS', key, exists);
         return exists;
@@ -424,10 +429,10 @@ export const CacheFactory = (options = {}) => {
 
     /**
      * Gets storage usage information
-     * @returns {Promise<Object>} Storage usage stats
+     * @returns {Object} Storage usage stats
      */
-    getStats: async () => {
-      const keys = await this.keys();
+    getStats() {
+      const keys = this.keys();
       
       return {
         keyCount: keys.length,
@@ -445,16 +450,14 @@ export const CacheFactory = (options = {}) => {
       /**
        * Sets multiple items at once
        * @param {Object} items - Key-value pairs to set
-       * @returns {Promise<Object>} Results of each operation
+       * @returns {Object} Results of each operation
        */
-      set: async (items) => {
+      set: (items) => {
         const results = {};
         
-        await Promise.all(
-          Object.entries(items).map(async ([key, value]) => {
-            results[key] = await this.set(key, value);
-          })
-        );
+        Object.entries(items).forEach(([key, value]) => {
+          results[key] = this.set(key, value);
+        });
         
         return results;
       },
@@ -462,16 +465,14 @@ export const CacheFactory = (options = {}) => {
       /**
        * Gets multiple items at once
        * @param {string[]} keys - Keys to retrieve
-       * @returns {Promise<Object>} Retrieved key-value pairs
+       * @returns {Object} Retrieved key-value pairs
        */
-      get: async (keys) => {
+      get: (keys) => {
         const results = {};
         
-        await Promise.all(
-          keys.map(async (key) => {
-            results[key] = await this.get(key);
-          })
-        );
+        keys.forEach(key => {
+          results[key] = this.get(key);
+        });
         
         return results;
       },
@@ -479,16 +480,14 @@ export const CacheFactory = (options = {}) => {
       /**
        * Removes multiple items at once
        * @param {string[]} keys - Keys to remove
-       * @returns {Promise<Object>} Results of each operation
+       * @returns {Object} Results of each operation
        */
-      remove: async (keys) => {
+      remove: (keys) => {
         const results = {};
         
-        await Promise.all(
-          keys.map(async (key) => {
-            results[key] = await this.remove(key);
-          })
-        );
+        keys.forEach(key => {
+          results[key] = this.remove(key);
+        });
         
         return results;
       },
@@ -499,7 +498,7 @@ export const CacheFactory = (options = {}) => {
 // Pre-configured instances for convenience
 CacheFactory.local = CacheFactory({ type: 'local' });
 CacheFactory.session = CacheFactory({ type: 'session' });
-
+exports.Cache = CacheFactory({type: 'local'});
 // Memory-only instance for testing or server-side use
 CacheFactory.memory = CacheFactory({ 
   type: 'session',