@feardread/feature-factory 2.0.5 → 3.0.1

package/package.json

@@ -1,23 +1,27 @@
 {
   "name": "@feardread/feature-factory",
-  "version": "2.0.5",
+  "version": "3.0.1",
+  "description": "Library to interact with redux toolkit and reduce boilerplate / repeated code",
   "main": "dist/index.js",
   "scripts": {
-    "build": "rollup -c",
+    "build": "npx rollup -c ",
     "test": "echo \"Error: no test specified\" && exit 1"
   },
-  "author": "Garrett Haptonstall (FearDread)",
+  "keywords": [
+    "ecommerce",
+    "features",
+    "redux",
+    "toolkit"
+  ],
+  "author": "FearDread",
   "license": "MIT",
   "dependencies": {
-    "@reduxjs/toolkit": "^2.2.7",
-    "@rollup/plugin-terser": "^0.4.4",
-    "axios": "^1.7.7",
-    "react": "^18.3.1",
-    "react-dom": "^18.3.1",
-    "react-redux": "^9.1.2",
-    "react-toastify": "^10.0.5",
-    "rollup-plugin-peer-deps-external": "^2.2.4",
-    "rollup-plugin-polyfill-node": "^0.13.0"
+    "@babel/core": "^7.28.0",
+    "@reduxjs/toolkit": "^2.8.2",
+    "axios": "^1.11.0",
+    "react": "^19.1.0",
+    "react-redux": "^9.2.0",
+    "typescript": "^5.8.3"
   },
   "devDependencies": {
     "@babel/preset-env": "^7.25.4",
@@ -26,8 +30,22 @@
     "@rollup/plugin-commonjs": "^28.0.0",
     "@rollup/plugin-json": "^6.1.0",
     "@rollup/plugin-node-resolve": "^15.3.0",
+    "@rollup/plugin-terser": "^0.4.4",
     "rollup": "^4.22.4",
-    "rollup-plugin-postcss": "^4.0.2"
+    "rollup-plugin-dts": "^6.1.1",
+    "rollup-plugin-peer-deps-external": "^2.2.4",
+    "rollup-plugin-polyfill-node": "^0.13.0"
   },
-  "description": ""
+  "browserslist": {
+    "production": [
+      ">0.2%",
+      "not dead",
+      "not op_mini all"
+    ],
+    "development": [
+      "last 1 chrome version",
+      "last 1 firefox version",
+      "last 1 safari version"
+    ]
+  }
 }

package/rollup.config.mjs

@@ -4,11 +4,30 @@ 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()]
+  }
+];
 
-export default [
-	{
+const jsconfig = [{
 		input: 'src/index.js',
 		output: [
 			{
@@ -41,4 +60,44 @@ export default [
 			terser()
 		]
 	},  
-];
+];
+
+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/factories/api.js

@@ -0,0 +1,72 @@
+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

@@ -0,0 +1,72 @@
+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/{cache → factories}/cache.js

@@ -1,9 +1,9 @@
 
 
 // cache
-const cache = (options = {}) => {
+export const cache = (options = {}) => {
   var engine = options.type == 'local' ? 'localStorage' : 'sessionStorage';
- 
+
   return {
     check: () => {
       if (!window[engine]) {
@@ -25,9 +25,9 @@ const cache = (options = {}) => {
     },
     get: (key) => {
       try {
-        if ( key !== "undefined") {
-        const data = window[engine].getItem(key);
-        return data ? JSON.parse(data) : null;
+        if (key !== "undefined") {
+          const data = window[engine].getItem(key);
+          return data ? JSON.parse(data) : null;
         }
 
 
@@ -65,7 +65,7 @@ const cache = (options = {}) => {
   };
 }
 
-cache.local = cache({type: 'local'});
-cache.session = cache({type: 'session'});
+cache.local = cache({ type: 'local' });
+cache.session = cache({ type: 'session' });
 
 export default cache;

package/src/factories/cache.ts

@@ -0,0 +1,71 @@
+
+
+// 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/factory.js

@@ -0,0 +1,149 @@
+import { createSlice, createEntityAdapter, combineReducers } from '@reduxjs/toolkit';
+import ThunkFactory from './thunk';
+//import ApiFactory from './service';
+
+export const StateFactory = (namespace) => ({
+    [namespace]: {},
+    data: [],
+    loading: false,
+    success: false,
+    error: null
+});
+
+export function FeatureFactory(entity, reducers = {}, endpoints = null) {
+
+    const factory = {
+        entity,
+        reducers,
+        //api: ApiFactory,
+        thunk: ThunkFactory,
+        state: StateFactory,
+        adapter: createEntityAdapter()
+    };
+
+    factory.manager = (initialReducers) => {
+        const reducers = { ...initialReducers };
+        let combinedReducer = combineReducers(reducers);
+
+        return {
+            reduce: (state, action) => combinedReducer(state, action),
+            add: (key, reducer) => {
+                if (!key || reducers[key]) return;
+                reducers[key] = reducer;
+                combinedReducer = combineReducers(reducers);
+            },
+            remove: (key) => {
+                if (!key || !reducers[key]) return;
+                delete reducers[key];
+                combinedReducer = combineReducers(reducers);
+            },
+            getReducerMap: () => reducers,
+        };
+    }
+
+    factory.inject = (source, dest) => {
+        for (var prop in source) {
+            if (source.hasOwnProperty(prop)) {
+                dest[prop] = source[prop];
+            }
+        }
+        return dest;
+    }
+
+    factory.create = (options = { service: null, initialState: null }) => {
+        const { service, initialState } = options;
+        const sliceName = factory.entity;
+        const standard = {
+            fetch: factory.thunk.create(sliceName, 'all'),
+            fetchOne: factory.thunk.create(sliceName, 'one'),
+            search: factory.thunk.create(sliceName, 'search')
+        }
+
+        const factorySlice = createSlice({
+            name: sliceName,
+            initialState: StateFactory(sliceName),
+            reducers: factory.reducers,
+            extraReducers: (builder) => {
+                Object.key(standard).forEach( key => {
+                    builder
+                            .addCase(standard[key].pending, (state) => {
+                                state.loading = true;
+                                state.error = null;
+                            })
+                           .addCase(standard[key].fulfilled, (state, action) => {
+                                state.loading = false;
+                                state.success = true;
+                                state.data = action.payload;
+                                state[sliceName] = action.payload[0];
+                                if (act == 'fetchOne') {
+                                    state[sliceName] = action.payload[0];
+                                }
+                            })
+                            .addCase(standard[key].rejected, (state, action) => {
+                                state.loading = false;
+                                state.success = false;
+                                state.error = action.error;
+                            });
+                })
+                /*
+                for (var act in standard) {
+                    if (standard.hasOwnProperty(act)) {
+                        builder
+                            .addCase(standard[act].pending, (state) => {
+                                state.loading = true;
+                                state.error = null;
+                            })
+                            .addCase(standard[act].fulfilled, (state, action) => {
+                                state.loading = false;
+                                state.success = true;
+                                state.data = action.payload;
+                                state[sliceName] = action.payload[0];
+                                if (act == 'fetchOne') {
+                                    state[sliceName] = action.payload[0];
+                                }
+                            })
+                            .addCase(standard[act].rejected, (state, action) => {
+                                state.loading = false;
+                                state.success = false;
+                                state.error = action.error;
+                            });
+                    }
+                }
+                                            */
+                if (service) {
+                    for (var key in service) {
+                        if (service.hasOwnProperty(key) && !standard.hasOwnProperty(key)) {
+                            builder
+                                .addCase(service[key].pending, (state) => {
+                                    state.loading = true;
+                                    state.error = null;
+                                })
+                                .addCase(service[key].fulfilled, (state, action) => {
+                                    state.loading = false;
+                                    state.success = true;
+                                    state.data = action.payload;
+                                    console.log('action fulfilled :', state.data);
+                                })
+                                .addCase(service[key].rejected, (state, action) => {
+                                    state.loading = false;
+                                    state.success = false;
+                                    state.error = action.payload;
+                                });
+                        }
+                    }
+
+                }
+            }
+        });
+
+        const asyncActions = factory.inject(standard, (service) ? service : {});
+        console.log('async = ', asyncActions);
+        return {
+            slice: factorySlice,
+            asyncActions
+        };
+    }
+    return factory;
+}
+
+export default FeatureFactory;

package/src/factories/factory.ts

@@ -0,0 +1,158 @@
+import {
+  createSlice,
+  createEntityAdapter,
+  combineReducers,
+  EntityAdapter,
+  AsyncThunk,
+  Reducer,
+  AnyAction,
+  SliceCaseReducers,
+  PayloadAction,
+} from '@reduxjs/toolkit';
+import ThunkFactory from './thunk';
+
+// Define the shape of your feature state
+export interface FeatureState<T> {
+  loading: boolean;
+  success: boolean;
+  error: unknown | null;
+  data: T[];
+  [key: string]: any;
+}
+
+// A helper type for mapping service thunks
+export type ServiceMap = Record<string, AsyncThunk<any, any, any>>;
+
+// Manager API for dynamic reducer injection
+export interface ReducerManager {
+  reduce: (state: any, action: AnyAction) => any;
+  add: (key: string, reducer: Reducer<any, AnyAction>) => void;
+  remove: (key: string) => void;
+  getReducerMap: () => Record<string, Reducer<any, AnyAction>>;
+}
+
+// Assume you have a StateFactory function somewhere:
+function StateFactory<T>(name: string): FeatureState<T> {
+  return {
+    loading: false,
+    success: false,
+    error: null,
+    data: [],
+    [name]: null,
+  };
+}
+
+// The main factory, now generic in T
+export function FeatureFactory<T>(
+  entity: string,
+  reducers: SliceCaseReducers<FeatureState<T>> = {},      // → typed slices
+  endpoints: ServiceMap | null = null                     // → typed services
+) {
+  const factory = {
+    entity,
+    reducers,
+    manager: ReducerManager ,
+    thunk: ThunkFactory,
+    state: StateFactory as (name: string) => FeatureState<T>,
+    adapter: createEntityAdapter<T>() as EntityAdapter<T>, // → typed adapter
+  };
+
+  factory.manager = (initialReducers: Record<string, Reducer<any, AnyAction>> = {}) => {
+    const reducersMap = { ...initialReducers };
+    let combined = combineReducers(reducersMap);
+
+    const manager: ReducerManager = {
+      reduce: (state, action) => combined(state, action),
+      add: (key, reducer) => {
+        if (!key || reducersMap[key]) return;
+        reducersMap[key] = reducer;
+        combined = combineReducers(reducersMap);
+      },
+      remove: (key) => {
+        if (!key || !reducersMap[key]) return;
+        delete reducersMap[key];
+        combined = combineReducers(reducersMap);
+      },
+      getReducerMap: () => reducersMap,
+    };
+
+    return manager;
+  };
+
+  factory.inject = <S extends object, D extends object>(source: S, dest: D): D & S => {
+    Object.keys(source).forEach((k) => {
+      // @ts-ignore
+      dest[k] = source[k];
+    });
+    return dest as D & S;
+  };
+
+  factory.create = (options: { service?: ServiceMap; initialState?: FeatureState<T> } = {}) => {
+    const { service, initialState } = options;
+    const sliceName = factory.entity;
+
+    const standard: ServiceMap = {
+      fetch: factory.thunk.create(sliceName, 'all'),
+      fetchOne: factory.thunk.create(sliceName, 'one'),
+      search: factory.thunk.create(sliceName, 'search'),
+    };
+
+    const slice = createSlice({
+      name: sliceName,
+      initialState: initialState ?? StateFactory<T>(sliceName),
+      reducers: factory.reducers,
+      extraReducers: (builder) => {
+        // handle standard thunks
+        Object.entries(standard).forEach(([act, thunk]) => {
+          builder
+            .addCase(thunk.pending, (state) => {
+              state.loading = true;
+              state.error = null;
+            })
+            .addCase(thunk.fulfilled, (state, action: PayloadAction<T[]>) => {
+              state.loading = false;
+              state.success = true;
+              state.data = action.payload;
+              state[sliceName] = action.payload[0];
+            })
+            .addCase(thunk.rejected, (state, action) => {
+              state.loading = false;
+              state.success = false;
+              state.error = action.error;
+            });
+        });
+
+        // handle extra service thunks
+        if (service) {
+          Object.entries(service).forEach(([key, thunk]) => {
+            if (!standard[key]) {
+              builder
+                .addCase(thunk.pending, (state) => {
+                  state.loading = true;
+                  state.error = null;
+                })
+                .addCase(thunk.fulfilled, (state, action: PayloadAction<any>) => {
+                  state.loading = false;
+                  state.success = true;
+                  state.data = action.payload;
+                  console.log('action fulfilled :', state.data);
+                })
+                .addCase(thunk.rejected, (state, action) => {
+                  state.loading = false;
+                  state.success = false;
+                  state.error = action.payload;
+                });
+            }
+          });
+        }
+      },
+    });
+
+    const asyncActions = factory.inject(standard, service ?? {});
+    return { slice, asyncActions };
+  };
+
+  return factory;
+}
+
+export default FeatureFactory;