feat: create redux slice for featureFlags

app/core/redux/slices/featureFlags/index.ts

@@ -0,0 +1,65 @@
+import { PayloadAction, createSlice } from '@reduxjs/toolkit';
+
+export interface FeatureFlagsState {
+  featureFlags: object[] | null;
+  loading: boolean;
+  error: string | null;
+}
+
+export const initialState: FeatureFlagsState = {
+  featureFlags: null,
+  loading: false,
+  error: null,
+};
+
+const name = 'featureFlags';
+
+const slice = createSlice({
+  name,
+  initialState,
+  reducers: {
+    /**
+     * Initiates the fetching of feature flags.
+     * @param state - The current state of the featureFlags slice.
+     */
+    getFeatureFlags: (state: FeatureFlagsState) => {
+      state.loading = true;
+      state.error = null;
+    },
+    /**
+     * Handles the successful fetching of feature flags.
+     * @param state - The current state of the featureFlags slice.
+     * @param action - An action with the fetched feature flags as payload.
+     */
+    getFeatureFlagsSuccess: (
+      state: FeatureFlagsState,
+      action: PayloadAction<object>,
+    ) => {
+      state.featureFlags = action.payload;
+      state.loading = false;
+      state.error = null;
+    },
+    /**
+     * Handles errors that occur during the fetching of feature flags.
+     * @param state - The current state of the featureFlags slice.
+     * @param action - An action with the error message as payload.
+     */
+    getFeatureFlagsError: (
+      state: FeatureFlagsState,
+      action: PayloadAction<string>,
+    ) => {
+      state.loading = false;
+      state.error = action.payload;
+    },
+  },
+});
+
+const { actions, reducer } = slice;
+
+export default reducer;
+
+export const { getFeatureFlags, getFeatureFlagsSuccess, getFeatureFlagsError } =
+  actions;
+
+export const FETCH_FEATURE_FLAGS = 'getFeatureFlags';
+export type FETCH_FEATURE_FLAGS = typeof FETCH_FEATURE_FLAGS;

app/reducers/index.ts

@@ -1,6 +1,7 @@
 import bookmarksReducer from './bookmarks';
 import browserReducer from './browser';
 import engineReducer from '../core/redux/slices/engine';
+import featureFlagsReducer from '../core/redux/slices/featureFlags';
 import privacyReducer from './privacy';
 import modalsReducer from './modals';
 import settingsReducer from './settings';
@@ -56,6 +57,9 @@ export interface RootState {
   engine: { backgroundState: EngineState };
   // TODO: Replace "any" with type
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  featureFlags: any;
+  // TODO: Replace "any" with type
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
   privacy: any;
   // TODO: Replace "any" with type
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -132,6 +136,7 @@ const rootReducer = combineReducers<RootState, any>({
   // TODO: Replace "any" with type
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
   engine: engineReducer as any,
+  featureFlags: featureFlagsReducer,
   privacy: privacyReducer,
   bookmarks: bookmarksReducer,
   browser: browserReducer,

app/store/index.ts

@@ -66,6 +66,9 @@ const createStoreAndPersistor = async () => {
       basicFunctionalityEnabled:
         store.getState().settings.basicFunctionalityEnabled,
     });
+    store.dispatch({
+      type: 'FETCH_FEATURE_FLAGS',
+    });
     EngineService.initalizeEngine(store);
     Authentication.init(store);
     LockManagerService.init(store);

app/store/sagas/index.ts

@@ -16,6 +16,10 @@ import Logger from '../../util/Logger';
 import LockManagerService from '../../core/LockManagerService';
 import AppConstants from '../../../app/core/AppConstants';
 import { XMLHttpRequest as _XMLHttpRequest } from 'xhr2';
+import {
+  getFeatureFlagsSuccess,
+  getFeatureFlagsError,
+} from '../../core/redux/slices/featureFlags';
 
 if (typeof global.XMLHttpRequest === 'undefined') {
   global.XMLHttpRequest = _XMLHttpRequest;
@@ -24,6 +28,18 @@ if (typeof global.XMLHttpRequest === 'undefined') {
 const originalSend = XMLHttpRequest.prototype.send;
 const originalOpen = XMLHttpRequest.prototype.open;
 
+interface GenericObject {
+  [key: string]: unknown;
+}
+
+type DataArray<T extends GenericObject> = T[];
+
+interface FeatureFlagResponse {
+  status: string;
+  data: DataArray<GenericObject>;
+  message?: string;
+}
+
 export function* appLockStateMachine() {
   let biometricsListenerTask: Task<void> | undefined;
   while (true) {
@@ -166,8 +182,30 @@ export function* basicFunctionalityToggle() {
   }
 }
 
+function* fetchFeatureFlags(): Generator {
+  try {
+    let response: FeatureFlagResponse = {
+      status: '',
+      data: [],
+    };
+    yield fetch('http://localhost:3000/launch-darkly')
+      .then((res) => res.json())
+      .then((res) => (response = res));
+
+    if (response.status !== 'ok') {
+      yield put(getFeatureFlagsError(response.message));
+      return;
+    }
+    yield put(getFeatureFlagsSuccess(response.data));
+  } catch (error) {
+    console.error(error);
+    yield put(getFeatureFlagsError(error));
+  }
+}
+
 // Main generator function that initializes other sagas in parallel.
 export function* rootSaga() {
   yield fork(authStateMachine);
   yield fork(basicFunctionalityToggle);
+  yield fork(fetchFeatureFlags);
 }