@feardread/feature-factory 1.1.6 → 1.1.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@feardread/feature-factory",
-  "version": "1.1.6",
+  "version": "1.1.8",
   "main": "dist/index.js",
   "scripts": {
     "build": "rollup -c",

package/src/api/factory.js

@@ -0,0 +1,80 @@
+import axios from "axios";
+import qs from "qs";
+import cache from "../cache/cache.js";
+
+
+
+
+const InstanceFactory = ( options ) => {
+
+    const API_BASE_URL = (options.API_BASE_URL)
+    ? options.API_BASE_URL
+    : "http://fear.master.com:4000/fear/api/";
+
+    const ACCESS_TOKEN_NAME = (options.JWT_TOKEN)
+    ? options.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);
+        }
+    );
+
+    return instance;
+}
+
+
+
+
+
+export default InstanceFactory;

package/src/factory/factory.js

@@ -1,5 +1,5 @@
 import { createSlice, createAsyncThunk } from '@reduxjs/toolkit';
-import API from "../api/api.js";
+import InstanceFactory from "../api/factory.js";
 
 const StateFactory = (entity, data = null) => ({
     [entity]: data,
@@ -8,30 +8,33 @@ const StateFactory = (entity, data = null) => ({
     error: null
 });
 
-const FeatureFactory = (name, endpoint, options = {}) => {
-    const { initialData, service } = options;
-    const apiurl = `${name}/${endpoint}`;
+const FeatureFactory = (sliceName, endpoint, options = {}) => {
+    const apiEndpoint = `${sliceName}/${endpoint}`;
+    const apiInstance = InstanceFactory({
+        API_BASE_URL: 'http://fear.master.com:4000/fear/api',
+        JWT_TOKEN: 'fear-x-token'
+    });
 
     const fetch = createAsyncThunk(
-        apiurl,
+        apiEndpoint,
         async (_, { rejectWithValue }) => {
-            return await API.get(apiurl)
+            return await apiInstance.get(apiEndpoint)
                 .then((response) => {
                     if (response.data && response.data.success) {
                         return response.data.result;
                     }
+                    return response.data;
                 })
                 .catch((error) => {
-                    return rejectWithValue('Error :: ', error);
+                    return rejectWithValue('Error :: ', error.message);
                 })
         }
-    )  
+    );
 
-    const fetchOne = async (id) => {
-        return createAsyncThunk(
-        `${name}/${id}`,
-        async (_, { rejectWithValue }) => {
-            return await API.get(`${name}/${id}`)
+    const fetchOne = createAsyncThunk(
+        `${sliceName}/one`,
+        async (id, { rejectWithValue }) => {
+            return await apiInstance.get(`${sliceName}/${id}`)
                 .then((response) => {
                     if (response.data && response.data.success) {
                         return response.data.result;
@@ -40,33 +43,30 @@ const FeatureFactory = (name, endpoint, options = {}) => {
                 .catch((error) => {
                     return rejectWithValue('Error :: ', error);
                 })
-            }
-        )
-    }
+        }
+    );
 
-    const search = async (query) => {
-        return createAsyncThunk(
-        `${name}/search?${query}`,
-        async (_, { rejectWithValue }) => {
-            return await API.get(`${name}/search?${query}`)
+    const search = createAsyncThunk(
+        `${sliceName}/search`,
+        async (query, { rejectWithValue }) => {
+            return await apiInstance.get(`${sliceName}/search?${query}`)
                 .then((response) => {
                     if (response.data && response.data.success) {
                         return response.data.result;
                     }
                 })
                 .catch((error) => {
-                    return rejectWithValue('Error :: ', error);
+                    return rejectWithValue('Error :: ', error.message);
                 })
-            }
-        )
-    }
+        }
+    );
 
     const slice = createSlice({
-        name,
-        initialState: StateFactory(name, initialData),
+        sliceName,
+        initialState: StateFactory(sliceName, initialData),
         reducers: {
             clearData: (state) => {
-                state[name] = null;
+                state[sliceName] = null;
             }
         },
         extraReducers: (builder) => {
@@ -77,25 +77,51 @@ const FeatureFactory = (name, endpoint, options = {}) => {
                 .addCase(fetch.fulfilled, (state, action) => {
                     state.loading = false;
                     state.success = true;
-                    state[name] = action.payload;
+                    state[sliceName] = action.payload;
                 })
                 .addCase(fetch.rejected, (state, action) => {
                     state.error = action.error;
                     state.loading = false;
                     state.success = false;
                 })
+                .addCase(fetchOne.pending, (state) => {
+                    state.loading = true;
+                })
+                .addCase(fetchOne.fulfilled, (state, action) => {
+                    state.loading = false;
+                    state.success = true;
+                    state[sliceName] = action.payload;
+                })
+                .addCase(fetchOne.rejected, (state, action) => {
+                    state.error = action.error;
+                    state.loading = false;
+                    state.success = false;
+                })
+                .addCase(search.pending, (state) => {
+                    state.loading = true;
+                })
+                .addCase(search.fulfilled, (state, action) => {
+                    state.loading = false;
+                    state.success = true;
+                    state[sliceName] = action.payload;
+                })
+                .addCase(search.rejected, (state, action) => {
+                    state.error = action.error;
+                    state.loading = false;
+                    state.success = false;
+                })
         }
     })
 
     return {
-        API,
         reducer: slice.reducer,
         actions: slice.actions,
+        instance: apiInstance,
         asyncActions: {
             fetch,
             fetchOne,
             search,
-            services: (service) ? service : {}
+            service: (options.service) ? options.service : null
         },
 
     }

package/src/index.js

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

package/src/api/api.js

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