Refactor configNodesSelected

common/features/config/nodes/selected/actions.ts

@@ -1,49 +1,44 @@
-import {
-  ChangeNodeRequestedAction,
-  ChangeNodeSucceededAction,
-  ChangeNodeFailedAction,
-  ChangeNodeRequestedOneTimeAction,
-  ChangeNodeForceAction,
-  CONFIG_NODES_SELECTED
-} from './types';
+import * as types from './types';
 
 export type TChangeNodeRequested = typeof changeNodeRequested;
-export function changeNodeRequested(payload: string): ChangeNodeRequestedAction {
+export function changeNodeRequested(payload: string): types.ChangeNodeRequestedAction {
   return {
-    type: CONFIG_NODES_SELECTED.CHANGE_REQUESTED,
+    type: types.ConfigNodesSelectedActions.CHANGE_REQUESTED,
     payload
   };
 }
 
 export type TChangeNodeSucceeded = typeof changeNodeSucceeded;
 export function changeNodeSucceeded(
-  payload: ChangeNodeSucceededAction['payload']
-): ChangeNodeSucceededAction {
+  payload: types.ChangeNodeSucceededAction['payload']
+): types.ChangeNodeSucceededAction {
   return {
-    type: CONFIG_NODES_SELECTED.CHANGE_SUCCEEDED,
+    type: types.ConfigNodesSelectedActions.CHANGE_SUCCEEDED,
     payload
   };
 }
 
 export type TChangeNodeFailed = typeof changeNodeFailed;
-export function changeNodeFailed(): ChangeNodeFailedAction {
+export function changeNodeFailed(): types.ChangeNodeFailedAction {
   return {
-    type: CONFIG_NODES_SELECTED.CHANGE_FAILED
+    type: types.ConfigNodesSelectedActions.CHANGE_FAILED
   };
 }
 
 export type TChangeNodeRequestedOneTime = typeof changeNodeRequestedOneTime;
-export function changeNodeRequestedOneTime(payload: string): ChangeNodeRequestedOneTimeAction {
+export function changeNodeRequestedOneTime(
+  payload: string
+): types.ChangeNodeRequestedOneTimeAction {
   return {
-    type: CONFIG_NODES_SELECTED.CHANGE_REQUESTED_ONETIME,
+    type: types.ConfigNodesSelectedActions.CHANGE_REQUESTED_ONETIME,
     payload
   };
 }
 
 export type TChangeNodeForce = typeof changeNodeForce;
-export function changeNodeForce(payload: string): ChangeNodeForceAction {
+export function changeNodeForce(payload: string): types.ChangeNodeForceAction {
   return {
-    type: CONFIG_NODES_SELECTED.CHANGE_FORCE,
+    type: types.ConfigNodesSelectedActions.CHANGE_FORCE,
     payload
   };
 }

common/features/config/nodes/selected/index.ts

@@ -1,4 +1,11 @@
-export * from './types';
-export * from './actions';
-export * from './reducer';
-export * from './selectors';
+import * as configNodesSelectedTypes from './types';
+import * as configNodesSelectedActions from './actions';
+import * as configNodesSelectedReducer from './reducer';
+import * as configNodesSelectedSelectors from './selectors';
+
+export {
+  configNodesSelectedTypes,
+  configNodesSelectedActions,
+  configNodesSelectedReducer,
+  configNodesSelectedSelectors
+};

common/features/config/nodes/selected/reducer.spec.ts

@@ -1,5 +1,5 @@
-import { SelectedNodeState } from './types';
-import { changeNodeRequested, changeNodeSucceeded } from './actions';
+import * as types from './types';
+import * as actions from './actions';
 import { selectedNodeReducer } from './reducer';
 
 export const expectedState = {
@@ -8,20 +8,25 @@ export const expectedState = {
   nodeChangeIntent: { nodeId: 'eth_mycrypto', prevNode: 'eth_mycrypto', pending: true }
 };
 
-export const actions = {
-  changeNode: changeNodeSucceeded({ nodeId: 'nodeToChangeTo', networkId: 'networkToChangeTo' }),
-  changeNodeRequested: changeNodeRequested('eth_mycrypto')
+export const actionsToDispatch = {
+  changeNode: actions.changeNodeSucceeded({
+    nodeId: 'nodeToChangeTo',
+    networkId: 'networkToChangeTo'
+  }),
+  changeNodeRequested: actions.changeNodeRequested('eth_mycrypto')
 };
 
 describe('selected node reducer', () => {
   it('should handle a node change', () =>
-    expect(selectedNodeReducer(undefined, actions.changeNode)).toEqual(expectedState.nodeChange));
+    expect(selectedNodeReducer(undefined, actionsToDispatch.changeNode)).toEqual(
+      expectedState.nodeChange
+    ));
 
   it('should handle the intent to change a node', () =>
     expect(
       selectedNodeReducer(
-        expectedState.initialState as SelectedNodeState,
-        actions.changeNodeRequested
+        expectedState.initialState as types.ConfigNodesSelectedState,
+        actionsToDispatch.changeNodeRequested
       )
     ).toEqual(expectedState.nodeChangeIntent));
 });

common/features/config/nodes/selected/reducer.ts

@@ -1,45 +1,47 @@
 import { makeAutoNodeName } from 'libs/nodes';
-import {
-  CONFIG_NODES_SELECTED,
-  SelectedNodeState as State,
-  SelectedNodeAction,
-  ChangeNodeRequestedAction,
-  ChangeNodeSucceededAction
-} from './types';
+import * as types from './types';
 
-export const SELECTED_NODE_INITIAL_STATE: State = {
+export const SELECTED_NODE_INITIAL_STATE: types.ConfigNodesSelectedState = {
   nodeId: makeAutoNodeName('ETH'),
   prevNode: makeAutoNodeName('ETH'),
   pending: false
 };
 
-const changeNodeRequested = (state: State, _: ChangeNodeRequestedAction): State => ({
+const changeNodeRequested = (
+  state: types.ConfigNodesSelectedState,
+  _: types.ChangeNodeRequestedAction
+): types.ConfigNodesSelectedState => ({
   ...state,
   pending: true
 });
 
-const changeNodeSucceeded = (state: State, { payload }: ChangeNodeSucceededAction): State => ({
+const changeNodeSucceeded = (
+  state: types.ConfigNodesSelectedState,
+  { payload }: types.ChangeNodeSucceededAction
+): types.ConfigNodesSelectedState => ({
   nodeId: payload.nodeId,
   // make sure we dont accidentally switch back to a web3 node
   prevNode: state.nodeId === 'web3' ? state.prevNode : state.nodeId,
   pending: false
 });
 
-const changeNodeFailed = (state: State): State => ({
+const changeNodeFailed = (
+  state: types.ConfigNodesSelectedState
+): types.ConfigNodesSelectedState => ({
   ...state,
   pending: false
 });
 
 export const selectedNodeReducer = (
-  state: State = SELECTED_NODE_INITIAL_STATE,
-  action: SelectedNodeAction
+  state: types.ConfigNodesSelectedState = SELECTED_NODE_INITIAL_STATE,
+  action: types.SelectedNodeAction
 ) => {
   switch (action.type) {
-    case CONFIG_NODES_SELECTED.CHANGE_SUCCEEDED:
+    case types.ConfigNodesSelectedActions.CHANGE_SUCCEEDED:
       return changeNodeSucceeded(state, action);
-    case CONFIG_NODES_SELECTED.CHANGE_REQUESTED:
+    case types.ConfigNodesSelectedActions.CHANGE_REQUESTED:
       return changeNodeRequested(state, action);
-    case CONFIG_NODES_SELECTED.CHANGE_FAILED:
+    case types.ConfigNodesSelectedActions.CHANGE_FAILED:
       return changeNodeFailed(state);
     default:
       return state;

common/features/config/nodes/selected/types.ts

@@ -1,4 +1,4 @@
-export enum CONFIG_NODES_SELECTED {
+export enum ConfigNodesSelectedActions {
   CHANGE_REQUESTED = 'CONFIG_NODES_SELECTED_CHANGE_REQUESTED',
   CHANGE_SUCCEEDED = 'CONFIG_NODES_SELECTED_CHANGE_SUCCEEDED',
   CHANGE_FAILED = 'CONFIG_NODES_SELECTED_CHANGE_FAILED',
@@ -7,12 +7,12 @@ export enum CONFIG_NODES_SELECTED {
 }
 
 export interface ChangeNodeRequestedAction {
-  type: CONFIG_NODES_SELECTED.CHANGE_REQUESTED;
+  type: ConfigNodesSelectedActions.CHANGE_REQUESTED;
   payload: string;
 }
 
 export interface ChangeNodeSucceededAction {
-  type: CONFIG_NODES_SELECTED.CHANGE_SUCCEEDED;
+  type: ConfigNodesSelectedActions.CHANGE_SUCCEEDED;
   payload: {
     nodeId: string;
     networkId: string;
@@ -20,16 +20,16 @@ export interface ChangeNodeSucceededAction {
 }
 
 export interface ChangeNodeFailedAction {
-  type: CONFIG_NODES_SELECTED.CHANGE_FAILED;
+  type: ConfigNodesSelectedActions.CHANGE_FAILED;
 }
 
 export interface ChangeNodeRequestedOneTimeAction {
-  type: CONFIG_NODES_SELECTED.CHANGE_REQUESTED_ONETIME;
+  type: ConfigNodesSelectedActions.CHANGE_REQUESTED_ONETIME;
   payload: string;
 }
 
 export interface ChangeNodeForceAction {
-  type: CONFIG_NODES_SELECTED.CHANGE_FORCE;
+  type: ConfigNodesSelectedActions.CHANGE_FORCE;
   payload: string;
 }
 
@@ -52,4 +52,4 @@ export interface NodeChangePending {
   nodeId: string;
 }
 
-export type SelectedNodeState = NodeLoaded | NodeChangePending;
+export type ConfigNodesSelectedState = NodeLoaded | NodeChangePending;