@feardread/feature-factory 2.0.5 → 3.0.1

package/src/factories/service.js

@@ -0,0 +1,28 @@
+// src/services/myApi.js
+import { createApi, fetchBaseQuery } from '@reduxjs/toolkit/query/react';
+const USERS_URL = "auth"
+
+const ApiFactory = ( sliceName ) => {
+    const _this = {};
+    _this.API_BASE_URL = _this.base_url || "http://localhost:4000/fear/api/";
+    _this.baseQuery = { baseUrl: _this.API_BASE_URL };
+        
+    _this.baseApi = createApi({
+            reducerPath: sliceName,
+            tagTypes: ["Product", "Order", "User", "Category"],
+            baseQuery: fetchBaseQuery(_this.baseQuery),
+            endpoints: () => ({})
+        });
+
+    _this.create = (routes) => {
+        const endpoints = (routes) ? routes : () => ({});
+        console.log('routes = ', routes);
+        const api = _this.baseApi.injectEndpoints((builder) => (routes));
+
+        return api;
+    }
+
+    return _this;
+}
+
+export default ApiFactory;

package/src/factories/service.ts

@@ -0,0 +1,28 @@
+// src/services/myApi.js
+import { createApi, fetchBaseQuery } from '@reduxjs/toolkit/query/react';
+const USERS_URL = "auth"
+
+const ApiFactory = ( sliceName ) => {
+    const _this = {};
+    _this.API_BASE_URL = _this.base_url || "http://localhost:4000/fear/api/";
+    _this.baseQuery = { baseUrl: _this.API_BASE_URL };
+        
+    _this.baseApi = createApi({
+            reducerPath: sliceName,
+            tagTypes: ["Product", "Order", "User", "Category"],
+            baseQuery: fetchBaseQuery(_this.baseQuery),
+            endpoints: () => ({})
+        });
+
+    _this.create = (routes) => {
+        const endpoints = (routes) ? routes : () => ({});
+        console.log('routes = ', routes);
+        const api = _this.baseApi.injectEndpoints((builder) => (routes));
+
+        return api;
+    }
+
+    return _this;
+}
+
+export default ApiFactory;

package/src/factories/state.js

@@ -0,0 +1,10 @@
+
+export const StateFactory = (namespace) => ({
+    [namespace]: {},
+    data: [],
+    loading: false,
+    success: false,
+    error: null
+});
+
+export default StateFactory;

package/src/factories/state.ts

@@ -0,0 +1,10 @@
+
+export const StateFactory = (namespace) => ({
+    [namespace]: {},
+    data: [],
+    loading: false,
+    success: false,
+    error: null
+});
+
+export default StateFactory;

package/src/factories/thunk.js

@@ -0,0 +1,53 @@
+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 = {
+
+  create: (entity, prefix) => { 
+
+    return (
+      createAsyncThunk(
+
+        `${entity}/${prefix}`,
+
+        async ( params, thunkApi ) => {
+          let url = `${entity}/${prefix}`;
+          console.log('params = ', params);
+          if ( prefix == 'one' ) url = `${entity}/${params.id}`
+
+          return API.get(url, (prefix == 'search') ? {params} : {})                           
+            
+            .then((response) => response.data.result )
+            
+            .catch((error) => thunkApi.rejectWithValue(error.message) )
+        }
+      )
+    )
+  },
+
+  post: (entity, prefix) => {
+    return ( 
+      createAsyncThunk(
+        
+        `${entity}/${prefix}`,
+
+        async ( data, thunkApi ) => {
+
+          return API.post(`${entity}/${prefix}`, data)
+            
+            .then((response) => {
+
+              return response.data.result;
+
+            })
+            
+            .catch((error) => thunkApi.rejectWithValue(error.message) )
+        }
+      )
+    )
+  }
+}
+
+export default ThunkFactory;

package/src/factories/thunk.ts

@@ -0,0 +1,53 @@
+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 = {
+
+  create: (entity, prefix) => { 
+
+    return (
+      createAsyncThunk(
+
+        `${entity}/${prefix}`,
+
+        async ( params, thunkApi ) => {
+          let url = `${entity}/${prefix}`;
+          console.log('params = ', params);
+          if ( prefix == 'one' ) url = `${entity}/${params.id}`
+
+          return API.get(url, (prefix == 'search') ? {params} : {})                           
+            
+            .then((response) => response.data.result )
+            
+            .catch((error) => thunkApi.rejectWithValue(error.message) )
+        }
+      )
+    )
+  },
+
+  post: (entity, prefix) => {
+    return ( 
+      createAsyncThunk(
+        
+        `${entity}/${prefix}`,
+
+        async ( data, thunkApi ) => {
+
+          return API.post(`${entity}/${prefix}`, data)
+            
+            .then((response) => {
+
+              return response.data.result;
+
+            })
+            
+            .catch((error) => thunkApi.rejectWithValue(error.message) )
+        }
+      )
+    )
+  }
+}
+
+export default ThunkFactory;

package/src/factory/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/factory/cache.js

@@ -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 != 'undefined' ? 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/index.js

@@ -0,0 +1,115 @@
+import { createSlice, createEntityAdapter, combineReducers } from '@reduxjs/toolkit';
+import ThunkFactory from './thunk';
+import StateFactory from "./state";
+//import ApiFactory from './service';
+
+
+export function FeatureFactory(entity, reducers = {}, endpoints = null) {
+
+    const _this = {
+        entity,
+        reducers,
+        //api: ApiFactory,
+        thunk: ThunkFactory,
+        state: StateFactory,
+        adapter: createEntityAdapter(),
+    
+    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,
+        };
+    },
+    inject: (source, dest) => {
+        for (var prop in source) {
+            if (source.hasOwnProperty(prop)) {
+                dest[prop] = source[prop];
+            }
+        }
+        return dest;
+    },
+    create: (options = { service: null, initialState: null }) => {
+        const { service, initialState } = options;
+        const sliceName = _this.entity;
+        const standard = {
+            fetch: _this.thunk.create(sliceName, 'all'),
+            fetchOne: _this.thunk.create(sliceName, 'one'),
+            search: _this.thunk.create(sliceName, 'search')
+        }
+
+        const factorySlice = createSlice({
+            name: sliceName,
+            initialState: StateFactory(sliceName),
+            reducers: _this.reducers,
+            extraReducers: (builder) => {
+                Object.keys(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 (key == 'fetchOne') {
+                                state[sliceName] = action.payload[0];
+                            }
+                        })
+                        .addCase(standard[key].rejected, (state, action) => {
+                            state.loading = false;
+                            state.success = false;
+                            state.error = action.error;
+                        });
+                })
+                if (service) {
+                    Object.keys(service).forEach(key => {
+                        if (service[key] != standard[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;
+                                state[sliceName] = action.payload[0]
+                            })
+                            .addCase(service[key].rejected, (state, action) => {
+                                state.loading = false;
+                                state.success = false;
+                                state.error = action.payload;
+                            });
+                        }
+                    }) 
+                }}
+            }
+        )
+    
+        const asyncActions = _this.inject(standard, (service) ? service : {});
+
+        return {
+            slice: factorySlice,
+            asyncActions
+        };
+    }}
+
+    return _this;
+}
+
+export default FeatureFactory;

package/src/factory/service.js

@@ -0,0 +1,28 @@
+// src/services/myApi.js
+import { createApi, fetchBaseQuery } from '@reduxjs/toolkit/query/react';
+const USERS_URL = "auth"
+
+const ApiFactory = ( sliceName ) => {
+    const _this = {};
+    _this.API_BASE_URL = _this.base_url || "http://localhost:4000/fear/api/";
+    _this.baseQuery = { baseUrl: _this.API_BASE_URL };
+        
+    _this.baseApi = createApi({
+            reducerPath: sliceName,
+            tagTypes: ["Product", "Order", "User", "Category"],
+            baseQuery: fetchBaseQuery(_this.baseQuery),
+            endpoints: () => ({})
+        });
+
+    _this.create = (routes) => {
+        const endpoints = (routes) ? routes : () => ({});
+        console.log('routes = ', routes);
+        const api = _this.baseApi.injectEndpoints((builder) => (routes));
+
+        return api;
+    }
+
+    return _this;
+}
+
+export default ApiFactory;

package/src/factory/state.js

@@ -0,0 +1,9 @@
+export const StateFactory = (namespace) => ({
+    [namespace]: {},
+    data: [],
+    loading: false,
+    success: false,
+    error: null
+});
+
+export default StateFactory;

package/src/factory/thunk.js

@@ -0,0 +1,53 @@
+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 = {
+
+  create: (entity, prefix) => { 
+
+    return (
+      createAsyncThunk(
+
+        `${entity}/${prefix}`,
+
+        async ( params, thunkApi ) => {
+          let url = `${entity}/${prefix}`;
+          console.log('params = ', params);
+          if ( prefix == 'one' ) url = `${entity}/${params.id}`
+
+          return API.get(url, (prefix == 'search') ? {params} : {})                           
+            
+            .then((response) => response.data.result )
+            
+            .catch((error) => thunkApi.rejectWithValue(error.message) )
+        }
+      )
+    )
+  },
+
+  post: (entity, prefix) => {
+    return ( 
+      createAsyncThunk(
+        
+        `${entity}/${prefix}`,
+
+        async ( data, thunkApi ) => {
+          console.log('params = ', data);
+          return API.post(`${entity}/${prefix}`, data)
+            
+            .then((response) => {
+
+              return response.data.result;
+
+            })
+            
+            .catch((error) => thunkApi.rejectWithValue(error.message) )
+        }
+      )
+    )
+  }
+}
+
+export default ThunkFactory;

package/src/index.js

@@ -1,5 +1,7 @@
+export { default as FeatureFactory } from "./factory/index.js";
 
-export { default as FeatureFactory } from "./factory/factory.js";
+export { default as ThunkFactory } from "./factory/thunk.js";
 
-export { default as InstanceFactory } from "./api/factory.js";
+export { default as ApiFactory } from "./factory/service.js";
 
+export { default as StateFactory } from "./factory/state.js";

package/src/index.ts

@@ -0,0 +1,7 @@
+export { default as FeatureFactory } from "./factories/factory.js";
+
+export { default as ThunkFactory } from "./factories/thunk.js";
+
+export { default as ApiFactory } from "./factories/service.js";
+
+export { default as StateFactory } from "./factories/state.js";

package/tsconfig.json

@@ -0,0 +1,11 @@
+    {
+      "compilerOptions": {
+        "target": "es2019",
+        "module": "commonjs",
+        "declaration": true,
+        "outDir": "./dist",
+        "strict": true,
+        //"allowImportingTsExtensions": true,
+      },
+      "include": ["src/**/*"]
+    }

package/tsup.config.ts

@@ -0,0 +1,9 @@
+    // tsup.config.ts
+    import { defineConfig } from 'tsup';
+
+    export default defineConfig({
+      entry: ['src/index.ts'],
+      format: ['cjs', 'esm'],
+      dts: true, // Generate declaration files
+      clean: true, // Clean the dist folder before building
+    });

package/src/api/factory.js

@@ -1,80 +0,0 @@
-import axios from "axios";
-import qs from "qs";
-import cache from "../cache/cache.js";
-
-
-
-
-function InstanceFactory ( options ) {
-    console.log('Instance Opts = ', options)
-    const API_BASE_URL = (options.API_BASE_URL)
-    ? options.API_BASE_URL
-    : "http://fear.master.com/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;