@feardread/feature-factory 1.1.2

package/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "@feardread/feature-factory",
+  "version": "1.1.2",
+  "main": "dist/index.js",
+  "scripts": {
+    "build": "rollup -c",
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "author": "Garrett Haptonstall (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"
+  },
+  "devDependencies": {
+    "@babel/preset-env": "^7.25.4",
+    "@babel/preset-react": "^7.24.7",
+    "@rollup/plugin-babel": "^6.0.4",
+    "@rollup/plugin-commonjs": "^28.0.0",
+    "@rollup/plugin-json": "^6.1.0",
+    "@rollup/plugin-node-resolve": "^15.3.0",
+    "rollup": "^4.22.4",
+    "rollup-plugin-postcss": "^4.0.2"
+  },
+  "description": ""
+}

package/rollup.config.mjs

@@ -0,0 +1,44 @@
+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 pkg from "./package.json" assert { type: 'json' };
+
+export default [
+	{
+		input: 'src/index.js',
+		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()
+		]
+	},  
+];

package/src/api/api.js

@@ -0,0 +1,72 @@
+import axios from "axios";
+import qs from "qs";
+import cache from "../cache/cache.js";
+
+
+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, { indices: 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/cache.js

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

@@ -0,0 +1,81 @@
+import { createSlice, createAsyncThunk } from '@reduxjs/toolkit';
+import API from "../api/api.js";
+
+const StateFactory = (entity, data = null) => ({
+    [entity]: data,
+    loading: false,
+    success: false,
+    error: null
+});
+const FeatureFactory = (name, endpoint, options = {}) => {
+    const { initialData, transform } = options;
+    const apiurl = `${name}/${endpoint}`;
+
+    const fetch = createAsyncThunk(
+        apiurl,
+        async (_, { rejectWithValue }) => {
+            return await API.get(apiurl)
+                .then((response) => {
+                    console.log('factory resp = ', response);
+                    if (response.data && response.data.success) {
+                        return response.data.result;
+                    }
+                })
+                .catch((error) => {
+                    return rejectWithValue('Error :: ', error);
+                })
+        }
+    )  
+
+    const fetchOne = (id) => {
+        return createAsyncThunk(
+        `${name}/${id}`,
+        async (_, { rejectWithValue }) => {
+            return await API.get(`${name}/${id}`)
+                .then((response) => {
+                    console.log('factory resp = ', response);
+                    if (response.data && response.data.success) {
+                        return response.data.result;
+                    }
+                })
+                .catch((error) => {
+                    return rejectWithValue('Error :: ', error);
+                })
+            }
+        )
+    }
+
+    const slice = createSlice({
+        name,
+        initialState: StateFactory(name, initialData),
+        reducers: {},
+        extraReducers: (builder) => {
+            builder
+                .addCase(fetch.pending, (state) => {
+                    state.loading = true;
+                })
+                .addCase(fetch.fulfilled, (state, action) => {
+                    state.loading = false;
+                    state.success = true;
+                    state[name] = action.payload;
+                })
+                .addCase(fetch.rejected, (state, action) => {
+                    state.error = action.error;
+                    state.loading = false;
+                    state.success = false;
+                })
+        }
+    })
+
+    return {
+        reducer: slice.reducer,
+        actions: slice.actions,
+        asyncActions: {
+            fetch,
+            fetchOne
+        }
+    }
+
+}
+
+export default FeatureFactory;

package/src/index.js

@@ -0,0 +1,2 @@
+
+export { default as FeatureFactory } from "./factory/factory.js";