@feardread/feature-factory 3.0.2 → 4.0.2

package/src/factory/thunk.js

@@ -1,53 +1,279 @@
-import { createAsyncThunk } from "@reduxjs/toolkit"
-import API from "./api"
+import { createAsyncThunk } from '@reduxjs/toolkit';
+import API from './api';
 
-// Async Thunk Factory Function
-// This factory creates a specific createAsyncThunk for a given 'itemType'
-export const ThunkFactory = {
+/**
+ * HTTP methods supported by the ThunkFactory
+ */
+const HTTP_METHODS = {
+  GET: 'GET',
+  POST: 'POST',
+  PUT: 'PUT',
+  PATCH: 'PATCH',
+  DELETE: 'DELETE',
+};
 
-  create: (entity, prefix) => { 
+/**
+ * Standard operation prefixes and their configurations
+ */
+const STANDARD_OPERATIONS = {
+  all: { method: HTTP_METHODS.GET, useParams: false },
+  one: { method: HTTP_METHODS.GET, useParams: false, useIdInUrl: true },
+  search: { method: HTTP_METHODS.GET, useParams: true },
+  create: { method: HTTP_METHODS.POST, useParams: false },
+  update: { method: HTTP_METHODS.PUT, useParams: false, useIdInUrl: true },
+  patch: { method: HTTP_METHODS.PATCH, useParams: false, useIdInUrl: true },
+  delete: { method: HTTP_METHODS.DELETE, useParams: false, useIdInUrl: true },
+};
 
-    return (
-      createAsyncThunk(
+/**
+ * Validates input parameters for thunk creation
+ * @param {string} entity - The entity name
+ * @param {string} prefix - The operation prefix
+ * @throws {Error} If validation fails
+ */
+const validateThunkParams = (entity, prefix) => {
+  if (!entity || typeof entity !== 'string') {
+    throw new Error('Entity must be a non-empty string');
+  }
+  if (!prefix || typeof prefix !== 'string') {
+    throw new Error('Prefix must be a non-empty string');
+  }
+};
 
-        `${entity}/${prefix}`,
+/**
+ * Builds the URL for the API call
+ * @param {string} entity - The entity name
+ * @param {string} prefix - The operation prefix
+ * @param {Object} params - Parameters object
+ * @param {boolean} useIdInUrl - Whether to append ID to URL
+ * @returns {string} The constructed URL
+ */
+const buildUrl = (entity, prefix, params = {}, useIdInUrl = false) => {
+  let url = `${entity}`;
+  
+  if (useIdInUrl && params?.id) {
+    url += `/${params.id}`;
+  } else if (!useIdInUrl || prefix !== 'one') {
+    url += `/${prefix}`;
+  }
+  
+  return url;
+};
+
+/**
+ * Handles API response consistently
+ * @param {Object} response - API response object
+ * @returns {any} The response data
+ */
+const handleResponse = (response) => {
+  // Handle different response structures
+  if (response?.data?.result !== undefined) {
+    return response.data.result;
+  }
+  if (response?.data !== undefined) {
+    return response.data;
+  }
+  return response;
+};
 
-        async ( params, thunkApi ) => {
-          let url = `${entity}/${prefix}`;
+/**
+ * Handles API errors consistently
+ * @param {Error} error - Error object
+ * @param {Object} thunkApi - Redux Toolkit thunk API
+ * @returns {any} Rejected value
+ */
+const handleError = (error, thunkApi) => {
+  const errorMessage = error?.response?.data?.message || 
+                      error?.message || 
+                      'An unknown error occurred';
+  
+  const errorPayload = {
+    message: errorMessage,
+    status: error?.response?.status,
+    code: error?.code,
+  };
 
-          if ( prefix == 'one' ) url = `${entity}/${params.id}`
+  return thunkApi.rejectWithValue(errorPayload);
+};
 
-          return API.get(url, (prefix == 'search') ? {params} : {})                           
-            
-            .then((response) => response.data.result )
-            
-            .catch((error) => thunkApi.rejectWithValue(error.message) )
+/**
+ * Creates a generic async thunk with configurable HTTP method and behavior
+ * @param {string} entity - The entity name
+ * @param {string} prefix - The operation prefix
+ * @param {Object} options - Configuration options
+ * @returns {Function} The created async thunk
+ */
+const createGenericThunk = (entity, prefix, options = {}) => {
+  validateThunkParams(entity, prefix);
+  
+  const config = {
+    method: HTTP_METHODS.GET,
+    useParams: false,
+    useIdInUrl: false,
+    customUrl: null,
+    ...options,
+  };
+
+  return createAsyncThunk(
+    `${entity}/${prefix}`,
+    async (payload = {}, thunkApi) => {
+      try {
+        const url = config.customUrl || buildUrl(entity, prefix, payload, config.useIdInUrl);
+        
+        let apiCall;
+        const apiConfig = config.useParams ? { params: payload } : {};
+
+        switch (config.method) {
+          case HTTP_METHODS.GET:
+            apiCall = API.get(url, apiConfig);
+            break;
+          case HTTP_METHODS.POST:
+            apiCall = API.post(url, payload, apiConfig);
+            break;
+          case HTTP_METHODS.PUT:
+            apiCall = API.put(url, payload, apiConfig);
+            break;
+          case HTTP_METHODS.PATCH:
+            apiCall = API.patch(url, payload, apiConfig);
+            break;
+          case HTTP_METHODS.DELETE:
+            apiCall = API.delete(url, apiConfig);
+            break;
+          default:
+            throw new Error(`Unsupported HTTP method: ${config.method}`);
         }
-      )
-    )
+
+        const response = await apiCall;
+        return handleResponse(response);
+      } catch (error) {
+        return handleError(error, thunkApi);
+      }
+    }
+  );
+};
+
+/**
+ * Factory for creating Redux async thunks with standardized patterns
+ */
+export const ThunkFactory = {
+  /**
+   * Creates a GET request thunk (legacy method for backward compatibility)
+   * @param {string} entity - The entity name
+   * @param {string} prefix - The operation prefix
+   * @returns {Function} The created async thunk
+   */
+  create: (entity, prefix) => {
+    validateThunkParams(entity, prefix);
+    
+    const operation = STANDARD_OPERATIONS[prefix];
+    if (operation) {
+      return createGenericThunk(entity, prefix, operation);
+    }
+    
+    // Fallback to original behavior for custom prefixes
+    const useParams = prefix === 'search';
+    const useIdInUrl = prefix === 'one';
+    
+    return createGenericThunk(entity, prefix, {
+      method: HTTP_METHODS.GET,
+      useParams,
+      useIdInUrl,
+    });
   },
 
+  /**
+   * Creates a POST request thunk (legacy method for backward compatibility)
+   * @param {string} entity - The entity name
+   * @param {string} prefix - The operation prefix
+   * @returns {Function} The created async thunk
+   */
   post: (entity, prefix) => {
-    return ( 
-      createAsyncThunk(
-        
-        `${entity}/${prefix}`,
+    return createGenericThunk(entity, prefix, {
+      method: HTTP_METHODS.POST,
+      useParams: false,
+    });
+  },
 
-        async ( data, thunkApi ) => {
-          
-          return API.post(`${entity}/${prefix}`, data)
-            
-            .then((response) => {
+  /**
+   * Creates a PUT request thunk
+   * @param {string} entity - The entity name
+   * @param {string} prefix - The operation prefix
+   * @returns {Function} The created async thunk
+   */
+  put: (entity, prefix) => {
+    return createGenericThunk(entity, prefix, {
+      method: HTTP_METHODS.PUT,
+      useIdInUrl: prefix === 'update',
+    });
+  },
 
-              return response.data.result;
+  /**
+   * Creates a PATCH request thunk
+   * @param {string} entity - The entity name
+   * @param {string} prefix - The operation prefix
+   * @returns {Function} The created async thunk
+   */
+  patch: (entity, prefix) => {
+    return createGenericThunk(entity, prefix, {
+      method: HTTP_METHODS.PATCH,
+      useIdInUrl: true,
+    });
+  },
 
-            })
-            
-            .catch((error) => thunkApi.rejectWithValue(error.message) )
-        }
-      )
-    )
-  }
-}
+  /**
+   * Creates a DELETE request thunk
+   * @param {string} entity - The entity name
+   * @param {string} prefix - The operation prefix
+   * @returns {Function} The created async thunk
+   */
+  delete: (entity, prefix) => {
+    return createGenericThunk(entity, prefix, {
+      method: HTTP_METHODS.DELETE,
+      useIdInUrl: true,
+    });
+  },
+
+  /**
+   * Creates a custom thunk with full control over configuration
+   * @param {string} entity - The entity name
+   * @param {string} prefix - The operation prefix
+   * @param {Object} options - Custom configuration options
+   * @returns {Function} The created async thunk
+   */
+  custom: (entity, prefix, options = {}) => {
+    return createGenericThunk(entity, prefix, options);
+  },
+
+  /**
+   * Creates standard CRUD thunks for an entity
+   * @param {string} entity - The entity name
+   * @returns {Object} Object containing all CRUD thunks
+   */
+  createCrud: (entity) => {
+    validateThunkParams(entity, 'crud');
+    
+    return {
+      fetchAll: ThunkFactory.create(entity, 'all'),
+      fetchOne: ThunkFactory.create(entity, 'one'),
+      create: ThunkFactory.post(entity, 'create'),
+      update: ThunkFactory.put(entity, 'update'),
+      patch: ThunkFactory.patch(entity, 'patch'),
+      delete: ThunkFactory.delete(entity, 'delete'),
+      search: ThunkFactory.create(entity, 'search'),
+    };
+  },
+
+  /**
+   * Gets available HTTP methods
+   * @returns {Object} HTTP methods object
+   */
+  getHttpMethods: () => ({ ...HTTP_METHODS }),
+
+  /**
+   * Gets standard operations configuration
+   * @returns {Object} Standard operations object
+   */
+  getStandardOperations: () => ({ ...STANDARD_OPERATIONS }),
+};
 
-export default ThunkFactory;
+export default ThunkFactory;

package/src/factories/api.js

@@ -1,72 +0,0 @@
-import axios from "axios";
-import qs from "qs";
-import cache from "./cache";
-
-
-const API_BASE_URL = (process.env.NODE_ENV === "production")
-                 ? "http://fear.master.com:4000/fear/api/" 
-                 : "http://localhost:4000/fear/api/";
-
-const ACCESS_TOKEN_NAME = (process.env.JWT_TOKEN) 
-                ? process.env.JWT_TOKEN 
-                : "x-token";
-
-const instance = axios.create({
-    baseURL: `${API_BASE_URL}`,
-    headers: {
-        Accept: "application/json",
-        "Content-Type": "application/json",
-    },
-    paramsSerializer: (params) => {
-        return qs.stringify(params, { indexes: false });
-    },
-     credentials: true
-    //httpsAgent: new https.Agent({ rejectUnauthorized: false })
-});
-
-instance.interceptors.request.use(
-    (config) => {
-        const isAuth = cache.local.get("auth") ? cache.local.get("auth") : null;
-        let token = isAuth !== null ? isAuth.token : "";
-    
-        config.headers = {
-            Authorization: `Bearer ${token}`,
-            [ACCESS_TOKEN_NAME]: token
-        };
-
-        return config;
-    },
-    (error) => { Promise.reject(error) }
-);
-
-instance.interceptors.response.use(
-    (response) => {
-        console.log("API RES :: ", response);
-        const messages = response.data.message;
-
-        if (response.status === 200 || 203) { 
-            return response;
-        }
-        if (messages) return Promise.reject({ messages: [messages] });
-        
-        return Promise.reject({ messages: ["got errors"] });
-    },
-    (error) => {
-        console.log("API ERROR :: ", error);
-        if (error.response) {
-            if (error.response.status === 401) {
-                cache.local.remove("auth");
-                return Promise.reject(error.response);
-            }
-            if (error.response.status === 500) {
-                return Promise.reject(error.response);
-            }
-        }
-        return Promise.reject(error);
-    }
-);
-
-
-export const API = instance;
-
-export default API;

package/src/factories/api.ts

@@ -1,72 +0,0 @@
-import axios from "axios";
-import qs from "qs";
-import cache from "./cache";
-
-
-const API_BASE_URL = (process.env.NODE_ENV === "production")
-                 ? "http://fear.master.com:4000/fear/api/" 
-                 : "http://localhost:4000/fear/api/";
-
-const ACCESS_TOKEN_NAME = (process.env.JWT_TOKEN) 
-                ? process.env.JWT_TOKEN 
-                : "x-token";
-
-const instance = axios.create({
-    baseURL: `${API_BASE_URL}`,
-    headers: {
-        Accept: "application/json",
-        "Content-Type": "application/json",
-    },
-    paramsSerializer: (params) => {
-        return qs.stringify(params, { indexes: false });
-    },
-     credentials: true
-    //httpsAgent: new https.Agent({ rejectUnauthorized: false })
-});
-
-instance.interceptors.request.use(
-    (config) => {
-        const isAuth = cache.local.get("auth") ? cache.local.get("auth") : null;
-        let token = isAuth !== null ? isAuth.token : "";
-    
-        config.headers = {
-            Authorization: `Bearer ${token}`,
-            [ACCESS_TOKEN_NAME]: token
-        };
-
-        return config;
-    },
-    (error) => { Promise.reject(error) }
-);
-
-instance.interceptors.response.use(
-    (response) => {
-        console.log("API RES :: ", response);
-        const messages = response.data.message;
-
-        if (response.status === 200 || 203) { 
-            return response;
-        }
-        if (messages) return Promise.reject({ messages: [messages] });
-        
-        return Promise.reject({ messages: ["got errors"] });
-    },
-    (error) => {
-        console.log("API ERROR :: ", error);
-        if (error.response) {
-            if (error.response.status === 401) {
-                cache.local.remove("auth");
-                return Promise.reject(error.response);
-            }
-            if (error.response.status === 500) {
-                return Promise.reject(error.response);
-            }
-        }
-        return Promise.reject(error);
-    }
-);
-
-
-export const API = instance;
-
-export default API;

package/src/factories/cache.js

@@ -1,71 +0,0 @@
-
-
-// cache
-export const cache = (options = {}) => {
-  var engine = options.type == 'local' ? 'localStorage' : 'sessionStorage';
-
-  return {
-    check: () => {
-      if (!window[engine]) {
-        return false;
-      }
-      return true;
-    },
-    set: (key, value) => {
-      if (!key) throw Error('Error:> Invalid key');
-
-      try {
-        window[engine].setItem(key, JSON.stringify(value));
-
-      } catch (error) {
-        console.error(`Error setting item ${key}:`, error);
-        return false;
-      }
-      return true;
-    },
-    get: (key) => {
-      try {
-        if (key !== "undefined") {
-          const data = window[engine].getItem(key);
-          return data ? JSON.parse(data) : null;
-        }
-
-
-      } catch (error) {
-        console.error(`Error getting item ${key}:`, error);
-        return null;
-      }
-    },
-    remove: function (key) {
-      window[engine].removeItem(key);
-    },
-    clear: () => {
-      window[engine].clear();
-    },
-    keys: () => {
-      return Object.keys(window[engine]);
-    },
-    has: (key) => {
-      return window[engine].getItem(key) !== null;
-    },
-    /*
-    _extend: () => {
-      const destination = typeof arguments[0] === 'object' ? arguments[0] : {};
-
-      for (var i = 1; i < arguments.length; i++) {
-        if (arguments[i] && typeof arguments[i] === 'object') {
-          for (var property in arguments[i])
-            destination[property] = arguments[i][property];
-        }
-      }
-
-      return destination;
-    }
-      */
-  };
-}
-
-cache.local = cache({ type: 'local' });
-cache.session = cache({ type: 'session' });
-
-export default cache;

package/src/factories/cache.ts

@@ -1,71 +0,0 @@
-
-
-// cache
-export const cache = (options = {}) => {
-  var engine = options.type == 'local' ? 'localStorage' : 'sessionStorage';
-
-  return {
-    check: () => {
-      if (!window[engine]) {
-        return false;
-      }
-      return true;
-    },
-    set: (key, value) => {
-      if (!key) throw Error('Error:> Invalid key');
-
-      try {
-        window[engine].setItem(key, JSON.stringify(value));
-
-      } catch (error) {
-        console.error(`Error setting item ${key}:`, error);
-        return false;
-      }
-      return true;
-    },
-    get: (key) => {
-      try {
-        if (key !== "undefined") {
-          const data = window[engine].getItem(key);
-          return data ? JSON.parse(data) : null;
-        }
-
-
-      } catch (error) {
-        console.error(`Error getting item ${key}:`, error);
-        return null;
-      }
-    },
-    remove: function (key) {
-      window[engine].removeItem(key);
-    },
-    clear: () => {
-      window[engine].clear();
-    },
-    keys: () => {
-      return Object.keys(window[engine]);
-    },
-    has: (key) => {
-      return window[engine].getItem(key) !== null;
-    },
-    /*
-    _extend: () => {
-      const destination = typeof arguments[0] === 'object' ? arguments[0] : {};
-
-      for (var i = 1; i < arguments.length; i++) {
-        if (arguments[i] && typeof arguments[i] === 'object') {
-          for (var property in arguments[i])
-            destination[property] = arguments[i][property];
-        }
-      }
-
-      return destination;
-    }
-      */
-  };
-}
-
-cache.local = cache({ type: 'local' });
-cache.session = cache({ type: 'session' });
-
-export default cache;