refactor: remove immutable from status and auth (#4727)

packages/netlify-cms-core/src/reducers/__tests__/auth.spec.ts

@@ -1,32 +1,38 @@
-import { fromJS } from 'immutable';
 import { authenticating, authenticate, authError, logout } from '../../actions/auth';
 import auth, { defaultState } from '../auth';
 
 describe('auth', () => {
   it('should handle an empty state', () => {
     // eslint-disable-next-line @typescript-eslint/ban-ts-ignore
-    // @ts-ignore
+    // @ts-ignore auth reducer doesn't accept empty action
     expect(auth(undefined, {})).toEqual(defaultState);
   });
 
   it('should handle an authentication request', () => {
-    expect(auth(undefined, authenticating())).toEqual(defaultState.set('isFetching', true));
+    expect(auth(undefined, authenticating())).toEqual({
+      ...defaultState,
+      isFetching: true,
+    });
   });
 
   it('should handle authentication', () => {
     const user = { name: 'joe', token: 'token' };
-    expect(auth(undefined, authenticate(user))).toEqual(defaultState.set('user', fromJS(user)));
+    expect(auth(undefined, authenticate(user))).toEqual({
+      ...defaultState,
+      user,
+    });
   });
 
   it('should handle an authentication error', () => {
-    expect(auth(undefined, authError(new Error('Bad credentials')))).toEqual(
-      defaultState.set('error', 'Error: Bad credentials'),
-    );
+    expect(auth(undefined, authError(new Error('Bad credentials')))).toEqual({
+      ...defaultState,
+      error: 'Error: Bad credentials',
+    });
   });
 
   it('should handle logout', () => {
     const user = { name: 'joe', token: 'token' };
-    const newState = auth(defaultState.set('user', fromJS(user)), logout());
-    expect(newState.get('user')).toBeUndefined();
+    const newState = auth({ ...defaultState, user }, logout());
+    expect(newState.user).toBeUndefined();
   });
 });

packages/netlify-cms-core/src/reducers/auth.ts

@@ -1,4 +1,4 @@
-import { fromJS } from 'immutable';
+import { produce } from 'immer';
 import { User } from 'netlify-cms-lib-util';
 import {
   AUTH_REQUEST,
@@ -8,35 +8,37 @@ import {
   LOGOUT,
   AuthAction,
 } from '../actions/auth';
-import { StaticallyTypedRecord } from '../types/immutable';
 
-export type Auth = StaticallyTypedRecord<{
+export type Auth = {
   isFetching: boolean;
-  user: StaticallyTypedRecord<User> | undefined;
+  user: User | undefined;
   error: string | undefined;
-}>;
+};
 
-export const defaultState = fromJS({
+export const defaultState: Auth = {
   isFetching: false,
   user: undefined,
   error: undefined,
-}) as Auth;
-
-const auth = (state = defaultState, action: AuthAction) => {
-  switch (action.type) {
-    case AUTH_REQUEST:
-      return state.set('isFetching', true);
-    case AUTH_SUCCESS:
-      return state.set('user', fromJS(action.payload));
-    case AUTH_FAILURE:
-      return state.set('error', action.payload && action.payload.toString());
-    case AUTH_REQUEST_DONE:
-      return state.set('isFetching', false);
-    case LOGOUT:
-      return state.set('user', undefined).set('isFetching', false);
-    default:
-      return state;
-  }
 };
 
+const auth = produce((state: Auth, action: AuthAction) => {
+  switch (action.type) {
+    case AUTH_REQUEST:
+      state.isFetching = true;
+      break;
+    case AUTH_SUCCESS:
+      state.user = action.payload;
+      break;
+    case AUTH_FAILURE:
+      state.error = action.payload && action.payload.toString();
+      break;
+    case AUTH_REQUEST_DONE:
+      state.isFetching = false;
+      break;
+    case LOGOUT:
+      state.user = undefined;
+      state.isFetching = false;
+  }
+}, defaultState);
+
 export default auth;

packages/netlify-cms-core/src/reducers/status.ts

@@ -1,46 +1,37 @@
-import { fromJS } from 'immutable';
+import { produce } from 'immer';
 import { STATUS_REQUEST, STATUS_SUCCESS, STATUS_FAILURE, StatusAction } from '../actions/status';
-import { StaticallyTypedRecord } from '../types/immutable';
 
-export type Status = StaticallyTypedRecord<{
+export type Status = {
   isFetching: boolean;
-  status: StaticallyTypedRecord<{
-    auth: StaticallyTypedRecord<{ status: boolean }>;
-    api: StaticallyTypedRecord<{ status: boolean; statusPage: string }>;
-  }>;
+  status: {
+    auth: { status: boolean };
+    api: { status: boolean; statusPage: string };
+  };
   error: Error | undefined;
-}>;
+};
 
-const defaultState = fromJS({
+const defaultState: Status = {
   isFetching: false,
   status: {
     auth: { status: true },
     api: { status: true, statusPage: '' },
   },
   error: undefined,
-}) as Status;
+};
 
-const status = (state = defaultState, action: StatusAction) => {
+const status = produce((state: Status, action: StatusAction) => {
   switch (action.type) {
     case STATUS_REQUEST:
-      return state.set('isFetching', true);
+      state.isFetching = true;
+      break;
     case STATUS_SUCCESS:
-      return state.withMutations(map => {
-        map.set('isFetching', false);
-        map.set('status', fromJS(action.payload.status));
-      });
+      state.isFetching = false;
+      state.status = action.payload.status;
+      break;
     case STATUS_FAILURE:
-      return state.withMutations(map => {
-        map.set('isFetching', false);
-        map.set('error', action.payload.error);
-      });
-    default:
-      return state;
+      state.isFetching = false;
+      state.error = action.payload.error;
   }
-};
-
-export const selectStatus = (status: Status) => {
-  return status.get('status').toJS();
-};
+}, defaultState);
 
 export default status;