@feardread/feature-factory 5.0.8 → 5.1.1

package/src/factory/index.js

@@ -1,25 +1,25 @@
 import { createSlice, createEntityAdapter, combineReducers } from '@reduxjs/toolkit';
 import ThunkFactory from './thunk';
 import StateFactory from './state';
+import UtilsFactory from './utils';
 
 /**
  * Creates a Redux feature with standardized structure including slice, async actions, and reducers
  * @param {string} entity - The entity name for the feature
- * @param {Object} reducers - Custom reducers to include in the slice
+ * @param {Object} customReducers - Custom reducers to include in the slice
  * @param {Object|null} endpoints - API endpoints (currently unused)
  * @returns {Object} Feature factory instance with methods to create slices and manage reducers
  */
-export function FeatureFactory(entity, reducers = {}, endpoints = null) {
+export function FeatureFactory(entity, customReducers = {}, endpoints = null) {
   if (!entity || typeof entity !== 'string') {
     throw new Error('Entity name must be provided as a string');
   }
 
   const adapter = createEntityAdapter();
+  const commonReducers = UtilsFactory.createReducers(entity, adapter);
 
   /**
    * Creates a dynamic reducer manager for adding/removing reducers at runtime
-   * @param {Object} initialReducers - Initial set of reducers
-   * @returns {Object} Reducer manager with methods to manipulate reducers
    */
   const createReducerManager = (initialReducers = {}) => {
     const reducersMap = { ...initialReducers };
@@ -27,7 +27,7 @@ export function FeatureFactory(entity, reducers = {}, endpoints = null) {
 
     return {
       reduce: (state, action) => combinedReducer(state, action),
-      
+
       add: (key, reducer) => {
         if (!key || typeof key !== 'string') {
           console.warn('Invalid reducer key provided');
@@ -37,36 +37,33 @@ export function FeatureFactory(entity, reducers = {}, endpoints = null) {
           console.warn(`Reducer with key '${key}' already exists`);
           return;
         }
-        
+
         reducersMap[key] = reducer;
         combinedReducer = combineReducers(reducersMap);
       },
-      
+
       remove: (key) => {
         if (!key || !reducersMap[key]) {
           console.warn(`Reducer with key '${key}' does not exist`);
           return;
         }
-        
+
         delete reducersMap[key];
         combinedReducer = combineReducers(reducersMap);
       },
-      
+
       getReducerMap: () => ({ ...reducersMap }),
     };
   };
 
   /**
    * Merges properties from source object into destination object
-   * @param {Object} source - Source object
-   * @param {Object} destination - Destination object
-   * @returns {Object} Merged destination object
    */
   const mergeObjects = (source, destination) => {
     if (!source || !destination) {
       throw new Error('Both source and destination objects must be provided');
     }
-    
+
     return Object.keys(source).reduce((acc, key) => {
       if (Object.prototype.hasOwnProperty.call(source, key)) {
         acc[key] = source[key];
@@ -75,73 +72,57 @@ export function FeatureFactory(entity, reducers = {}, endpoints = null) {
     }, { ...destination });
   };
 
-  /**
-   * Creates standard async thunks for common operations
-   * @param {string} sliceName - Name of the slice
-   * @returns {Object} Standard async thunks
-   */
-  const createStandardThunks = (sliceName) => ({
-    fetch: ThunkFactory.create(sliceName, 'all'),
-    fetchOne: ThunkFactory.create(sliceName, 'one'),
-    search: ThunkFactory.post(sliceName, 'search'),
-  });
-
-  /**
-   * Adds standard async action handlers to builder
-   * @param {Object} builder - RTK builder object
-   * @param {Object} asyncActions - Async actions to handle
-   * @param {string} sliceName - Name of the slice
-   */
-  const addAsyncActionHandlers = (builder, asyncActions, sliceName) => {
-    Object.entries(asyncActions).forEach(([key, action]) => {
-      builder
-        .addCase(action.pending, (state) => {
-          state.loading = true;
-          state.error = null;
-        })
-        .addCase(action.fulfilled, (state, actionPayload) => {
-          state.loading = false;
-          state.success = true;
-          state.data = actionPayload.payload;
-          
-          // Handle single item for fetchOne operation
-          if (key === 'fetchOne' && Array.isArray(actionPayload.payload)) {
-            state[sliceName] = actionPayload.payload[0];
-          } else if (Array.isArray(actionPayload.payload) && actionPayload.payload.length > 0) {
-            state[sliceName] = actionPayload.payload[0];
-          }
-        })
-        .addCase(action.rejected, (state, actionPayload) => {
-          state.loading = false;
-          state.success = false;
-          state.error = actionPayload.error || actionPayload.payload;
-        });
-    });
-  };
-
   /**
    * Creates a Redux slice with standard and custom async actions
    * @param {Object} options - Configuration options
    * @param {Object} options.service - Custom service actions
    * @param {Object} options.initialState - Custom initial state
+   * @param {Object} options.stateOptions - State factory configuration
+   * @param {Object} options.operations - Which standard operations to include
+   * @param {boolean} options.includeCommonReducers - Whether to include common reducers
+   * @param {Array} options.excludeReducers - List of common reducers to exclude
    * @returns {Object} Created slice and async actions
    */
   const createFactorySlice = (options = {}) => {
-    const { service = null, initialState = null } = options;
+    const {
+      service = null,
+      initialState = null,
+      stateOptions = {},
+      operations = {},
+      includeCommonReducers = true,
+      excludeReducers = [],
+    } = options;
+
     const sliceName = entity;
-    
-    // Create standard thunks
-    const standardThunks = createStandardThunks(sliceName);
-    
+
+    // Create standard thunks based on operations config
+    const standardThunks = UtilsFactory.createThunks(sliceName, operations);
+
+    // Filter common reducers based on exclude list
+    const filteredCommonReducers = includeCommonReducers
+      ? Object.entries(commonReducers).reduce((acc, [key, reducer]) => {
+        if (!excludeReducers.includes(key)) {
+          acc[key] = reducer;
+        }
+        return acc;
+      }, {})
+      : {};
+
+    // Merge all reducers (common + custom)
+    const allReducers = {
+      ...filteredCommonReducers,
+      ...customReducers,
+    };
+
     // Create the slice
     const factorySlice = createSlice({
       name: sliceName,
-      initialState: initialState || StateFactory(sliceName),
-      reducers,
+      initialState: initialState || StateFactory(sliceName, stateOptions),
+      reducers: allReducers,
       extraReducers: (builder) => {
         // Add standard async action handlers
-        addAsyncActionHandlers(builder, standardThunks, sliceName);
-        
+        UtilsFactory.addHandlers(builder, standardThunks, sliceName);
+
         // Add custom service action handlers
         if (service && typeof service === 'object') {
           const customActions = Object.entries(service).reduce((acc, [key, action]) => {
@@ -151,35 +132,100 @@ export function FeatureFactory(entity, reducers = {}, endpoints = null) {
             }
             return acc;
           }, {});
-          
-          addAsyncActionHandlers(builder, customActions, sliceName);
+
+          UtilsFactory.addHandlers(builder, customActions, sliceName);
         }
       },
     });
 
     // Merge standard and custom async actions
-    const asyncActions = service 
+    const asyncActions = service
       ? mergeObjects(standardThunks, service)
       : standardThunks;
 
     return {
       slice: factorySlice,
       asyncActions,
+      reducers: allReducers,
     };
   };
 
+  /**
+   * Creates a complete CRUD feature with all operations
+   */
+  const createCrudFeature = (options = {}) => {
+    return createFactorySlice({
+      ...options,
+      operations: {
+        fetch: true,
+        fetchOne: true,
+        search: true,
+        create: true,
+        update: true,
+        patch: true,
+        delete: true,
+      },
+    });
+  };
+
+  /**
+   * Creates a read-only feature (fetch, fetchOne, search only)
+   */
+  const createBasicFeature = (options = {}) => {
+    return createFactorySlice({
+      ...options,
+      operations: {
+        fetch: true,
+        fetchOne: true,
+        search: true,
+        create: false,
+        update: false,
+        patch: false,
+        delete: false,
+      },
+    });
+  };
+
   // Public API
   return {
     entity,
-    reducers,
     adapter,
+    reducers: commonReducers,
     manager: createReducerManager,
-    inject: mergeObjects,                    
+
+    // Utilities
+    inject: mergeObjects,
+    createReducer: (handler) => handler,
+    createHandler: (builder, action, handlers) => {
+      if (handlers.pending) {
+        builder.addCase(action.pending, handlers.pending);
+      }
+      if (handlers.fulfilled) {
+        builder.addCase(action.fulfilled, handlers.fulfilled);
+      }
+      if (handlers.rejected) {
+        builder.addCase(action.rejected, handlers.rejected);
+      }
+    },
+    // Creators
     create: createFactorySlice,
-    // Utility methods
+    createCrud: createCrudFeature,
+    createBasic: createBasicFeature,
+    createThunks: (operations) => UtilsFactor.createThunks(entity, operations),
+    createCustomThunk: (prefix, options) => ThunkFactory.custom(entity, prefix, options),
+
+    // Getters
     getEntityName: () => entity,
     getAdapter: () => adapter,
-  };
+    getCommonReducers: (exclude = []) => {
+      return Object.entries(commonReducers).reduce((acc, [key, reducer]) => {
+        if (!exclude.includes(key)) {
+          acc[key] = reducer;
+        }
+        return acc;
+      }, {});
+    },
+  }
 }
 
 export default FeatureFactory;

package/src/factory/thunk.js

@@ -17,7 +17,7 @@ const HTTP_METHODS = {
  */
 const STANDARD_OPERATIONS = {
   all: { method: HTTP_METHODS.GET, useParams: false },
-  one: { method: HTTP_METHODS.GET, useParams: false, useIdInUrl: true },
+  one: { method: HTTP_METHODS.GET, useParams: true, useIdInUrl: true },
   search: { method: HTTP_METHODS.POST, useParams: true },
   new: { method: HTTP_METHODS.POST, useParams: false },
   create: { method: HTTP_METHODS.POST, useParams: false },
@@ -52,9 +52,9 @@ const validateThunkParams = (entity, prefix) => {
 const buildUrl = (entity, prefix, params = {}, useIdInUrl = false) => {
   let url = `${entity}`;
 
-  if (useIdInUrl && params?.id) {
+  if (params?.id || useIdInUrl) {
     url += `/${params.id}`;
-  } else if (!useIdInUrl || prefix !== 'one') {
+  } else {
     url += `/${prefix}`;
   }
   

package/src/factory/utils.js

@@ -0,0 +1,355 @@
+import { ThunkFactory } from "./thunk";
+import { StateFactory } from "./state";
+
+/**
+ * Common reducer actions that can be dynamically added to any slice
+ */
+export const createReducers = (entity, adapter) => ({
+  // Entity management
+  setEntity: (state, action) => {
+    state[entity] = action.payload;
+    state.error = null;
+  },
+
+  clearEntity: (state) => {
+    state[entity] = null;
+    state.data = [];
+  },
+
+  // Data management
+  setData: (state, action) => {
+    state.data = action.payload;
+    state.error = null;
+  },
+
+  appendData: (state, action) => {
+    state.data = [...state.data, ...action.payload];
+  },
+
+  prependData: (state, action) => {
+    state.data = [...action.payload, ...state.data];
+  },
+
+  updateDataItem: (state, action) => {
+    const { id, updates } = action.payload;
+    const index = state.data.findIndex(item => item.id === id);
+    if (index !== -1) {
+      state.data[index] = { ...state.data[index], ...updates };
+    }
+  },
+
+  removeDataItem: (state, action) => {
+    const id = action.payload;
+    state.data = state.data.filter(item => item.id !== id);
+  },
+
+  // Loading state management
+  setLoading: (state, action) => {
+    state.loading = action.payload;
+  },
+
+  setSuccess: (state, action) => {
+    state.success = action.payload;
+  },
+
+  setError: (state, action) => {
+    state.error = action.payload;
+    state.loading = false;
+    state.success = false;
+  },
+
+  clearError: (state) => {
+    state.error = null;
+  },
+
+  // Reset operations
+  resetState: (state, action) => {
+    const namespace = action.payload?.namespace || entity;
+    const options = action.payload?.options || {};
+    return StateFactory(namespace, options);
+  },
+
+  resetData: (state) => {
+    state.data = [];
+    state[entity] = null;
+    state.error = null;
+  },
+
+  resetStatus: (state) => {
+    state.loading = false;
+    state.success = false;
+    state.error = null;
+  },
+
+  // Pagination reducers (if enabled)
+  setPagination: (state, action) => {
+    if (state.pagination) {
+      state.pagination = { ...state.pagination, ...action.payload };
+    }
+  },
+
+  setCurrentPage: (state, action) => {
+    if (state.pagination) {
+      state.pagination.currentPage = action.payload;
+    }
+  },
+
+  setPageSize: (state, action) => {
+    if (state.pagination) {
+      state.pagination.pageSize = action.payload;
+      state.pagination.currentPage = 1; // Reset to first page
+    }
+  },
+
+  // Filtering reducers (if enabled)
+  setFilters: (state, action) => {
+    if (state.filtering) {
+      state.filtering.filters = action.payload;
+      state.filtering.activeFilters = Object.keys(action.payload).filter(
+        key => action.payload[key] !== null && action.payload[key] !== undefined
+      );
+    }
+  },
+
+  clearFilters: (state) => {
+    if (state.filtering) {
+      state.filtering.filters = {};
+      state.filtering.activeFilters = [];
+      state.filtering.searchTerm = '';
+    }
+  },
+
+  setSearchTerm: (state, action) => {
+    if (state.filtering) {
+      state.filtering.searchTerm = action.payload;
+    }
+  },
+
+  // Sorting reducers (if enabled)
+  setSorting: (state, action) => {
+    if (state.sorting) {
+      state.sorting.sortBy = action.payload.sortBy;
+      state.sorting.sortOrder = action.payload.sortOrder || 'asc';
+    }
+  },
+
+  toggleSortOrder: (state) => {
+    if (state.sorting) {
+      state.sorting.sortOrder = state.sorting.sortOrder === 'asc' ? 'desc' : 'asc';
+    }
+  },
+
+  // Selection reducers (if enabled)
+  setSelectedItems: (state, action) => {
+    if (state.selection) {
+      state.selection.selectedItems = action.payload;
+      state.selection.selectedIds = action.payload.map(item => item.id);
+    }
+  },
+
+  toggleItemSelection: (state, action) => {
+    if (state.selection) {
+      const id = action.payload;
+      const index = state.selection.selectedIds.indexOf(id);
+
+      if (index > -1) {
+        state.selection.selectedIds.splice(index, 1);
+        state.selection.selectedItems = state.selection.selectedItems.filter(
+          item => item.id !== id
+        );
+      } else {
+        const item = state.data.find(item => item.id === id);
+        if (item) {
+          state.selection.selectedIds.push(id);
+          state.selection.selectedItems.push(item);
+        }
+      }
+
+      state.selection.allSelected =
+        state.selection.selectedIds.length === state.data.length && state.data.length > 0;
+    }
+  },
+
+  selectAll: (state) => {
+    if (state.selection) {
+      state.selection.selectedItems = [...state.data];
+      state.selection.selectedIds = state.data.map(item => item.id);
+      state.selection.allSelected = true;
+    }
+  },
+
+  clearSelection: (state) => {
+    if (state.selection) {
+      state.selection.selectedItems = [];
+      state.selection.selectedIds = [];
+      state.selection.allSelected = false;
+    }
+  },
+
+  // Metadata reducers (if enabled)
+  updateMetadata: (state, action) => {
+    if (state.metadata) {
+      state.metadata = { ...state.metadata, ...action.payload };
+    }
+  },
+
+  markAsStale: (state) => {
+    if (state.metadata) {
+      state.metadata.stale = true;
+    }
+  },
+
+  markAsFresh: (state) => {
+    if (state.metadata) {
+      state.metadata.stale = false;
+      state.metadata.lastFetch = new Date().toISOString();
+    }
+  },
+});
+
+/**
+ * Creates standard async thunks with configurable operations
+ */
+export const createThunks = (entity, operations = {}) => {
+  const defaultOperations = {
+    fetch: true,
+    fetchOne: true,
+    search: true,
+    create: true,
+    update: true,
+    patch: true,
+    delete: true,
+  };
+
+  const config = { ...defaultOperations, ...operations };
+  const thunks = {};
+
+  if (config.fetch) {
+    thunks.fetch = ThunkFactory.create(entity, 'all');
+  }
+
+  if (config.fetchOne) {
+    thunks.fetchOne = ThunkFactory.create(entity, 'one');
+  }
+
+  if (config.search) {
+    thunks.search = ThunkFactory.post(entity, 'search');
+  }
+
+  if (config.create) {
+    thunks.create = ThunkFactory.post(entity, 'create');
+  }
+
+  if (config.update) {
+    thunks.update = ThunkFactory.put(entity, 'update');
+  }
+
+  if (config.patch) {
+    thunks.patch = ThunkFactory.patch(entity, 'patch');
+  }
+
+  if (config.delete) {
+    thunks.delete = ThunkFactory.delete(entity, 'delete');
+  }
+
+  return thunks;
+};
+
+/**
+ * Adds standard async action handlers to builder with enhanced logic
+ */
+export const addHandlers = (builder, asyncActions, entity) => {
+  Object.entries(asyncActions).forEach(([key, action]) => {
+    builder
+      .addCase(action.pending, (state) => {
+        state.loading = true;
+        state.error = null;
+        state.loadingState = 'pending';
+
+        if (state.async?.operations) {
+          state.async.operations[key] = {
+            loading: true,
+            success: false,
+            error: null,
+            lastRun: new Date().toISOString(),
+          };
+        }
+      })
+      .addCase(action.fulfilled, (state, actionPayload) => {
+        state.loading = false;
+        state.success = true;
+        state.loadingState = 'fulfilled';
+
+        // Handle different response structures
+        const payload = actionPayload.payload;
+        console.log('payload = ', payload);
+        // Update data based on operation type
+        if (key === 'fetch' || key === 'search') {
+          state.data = Array.isArray(payload) ? payload : (payload?.data.result || []);
+        } else if (key === 'fetchOne') {
+          state[entity] = Array.isArray(payload) ? payload[0] : payload;
+        } else if (key === 'create') {
+          if (Array.isArray(state.data)) {
+            state.data.push(payload);
+          }
+        } else if (key === 'update' || key === 'patch') {
+          if (Array.isArray(state.data)) {
+            const index = state.data.findIndex(item => item.id === payload.id);
+            if (index !== -1) {
+              state.data[index] = payload;
+            }
+          }
+          if (state[entity]?.id === payload.id) {
+            state[entity] = payload;
+          }
+        } else if (key === 'delete') {
+          if (Array.isArray(state.data)) {
+            state.data = state.data.filter(item => item.id !== actionPayload.meta.arg?.id);
+          }
+        }
+
+        // Update metadata
+        if (state.metadata) {
+          state.metadata.lastUpdate = new Date().toISOString();
+          state.metadata.stale = false;
+          if (key === 'fetch' || key === 'fetchOne' || key === 'search') {
+            state.metadata.lastFetch = new Date().toISOString();
+          }
+        }
+
+        // Update async operations tracking
+        if (state.async?.operations) {
+          state.async.operations[key] = {
+            loading: false,
+            success: true,
+            error: null,
+            lastRun: new Date().toISOString(),
+          };
+        }
+      })
+      .addCase(action.rejected, (state, actionPayload) => {
+        state.loading = false;
+        state.success = false;
+        state.error = actionPayload.error?.message || actionPayload.payload || 'An error occurred';
+        state.loadingState = 'rejected';
+
+        if (state.async?.operations) {
+          state.async.operations[key] = {
+            loading: false,
+            success: false,
+            error: state.error,
+            lastRun: new Date().toISOString(),
+          };
+        }
+      });
+  });
+};
+
+
+export const UtilsFactory = {
+    createReducers,
+    createThunks,
+    addHandlers
+}
+
+export default UtilsFactory;