accounts-frontend/packages/app/components/accounts/reducer.ts

export type Account = {
  id: number;
  username: string;
  email: string;
  token: string;
  refreshToken: string | null;
};

export type State = {
  active: number | null;
  available: Account[];
};

export type AddAction = { type: 'accounts:add'; payload: Account };
export type RemoveAction = { type: 'accounts:remove'; payload: Account };
export type ActivateAction = { type: 'accounts:activate'; payload: Account };
export type UpdateTokenAction = {
  type: 'accounts:updateToken';
  payload: string;
};
export type ResetAction = { type: 'accounts:reset' };

type Action =
  | AddAction
  | RemoveAction
  | ActivateAction
  | UpdateTokenAction
  | ResetAction;

export function getActiveAccount(state: { accounts: State }): Account | null {
  const accountId = state.accounts.active;

  return (
    state.accounts.available.find(account => account.id === accountId) || null
  );
}

export function getAvailableAccounts(state: {
  accounts: State;
}): Array<Account> {
  return state.accounts.available;
}

export default function accounts(
  state: State = {
    active: null,
    available: [],
  },
  action: Action,
): State {
  switch (action.type) {
    case 'accounts:add': {
      if (!action.payload || !action.payload.id || !action.payload.token) {
        throw new Error('Invalid or empty payload passed for accounts.add');
      }

      const { payload } = action;

      state.available = state.available
        .filter(account => account.id !== payload.id)
        .concat(payload);

      state.available.sort((account1, account2) => {
        if (account1.username === account2.username) {
          return 0;
        }

        return account1.username > account2.username ? 1 : -1;
      });

      return state;
    }

    case 'accounts:activate': {
      if (!action.payload || !action.payload.id || !action.payload.token) {
        throw new Error('Invalid or empty payload passed for accounts.add');
      }

      const { payload } = action;

      return {
        available: state.available.map(account => {
          if (account.id === payload.id) {
            return { ...payload };
          }

          return { ...account };
        }),
        active: payload.id,
      };
    }

    case 'accounts:reset':
      return {
        active: null,
        available: [],
      };

    case 'accounts:remove': {
      if (!action.payload || !action.payload.id) {
        throw new Error('Invalid or empty payload passed for accounts.remove');
      }

      const { payload } = action;

      return {
        ...state,
        available: state.available.filter(account => account.id !== payload.id),
      };
    }

    case 'accounts:updateToken': {
      if (typeof action.payload !== 'string') {
        throw new Error('payload must be a jwt token');
      }

      const { payload } = action;

      return {
        ...state,
        available: state.available.map(account => {
          if (account.id === state.active) {
            return {
              ...account,
              token: payload,
            };
          }

          return { ...account };
        }),
      };
    }
  }

  return state;
}