sgpl/bundles/auth.js

import { clearAllCached, createSelector } from 'redux-bundler'
import tryIt from 'tryit'
import { FIREBASE_TOKEN_FAILED } from './firebase'
const actions = {
  CLEAR_LOGIN_STATE: 'CLEAR_LOGIN_STATE',
  DO_LOGIN_START: 'DO_LOGIN_START',
  DO_LOGIN_SUCCESS: 'DO_LOGIN_SUCCESS',
  DO_LOGIN_ERROR: 'DO_LOGIN_ERROR',
  DO_LOGOUT: 'DO_LOGOUT',
  TOKEN_RECEIVED: 'TOKEN_RECEIVED',
  TOKEN_EXPIRED: 'TOKEN_EXPIRED',
  FETCH_FB_TOKEN: 'FETCH_FB_TOKEN'
}

const doLogin = (email, superUser = false) => ({ dispatch, gqlFetch }) => {
  dispatch({ type: actions.DO_LOGIN_START, payload: { email, attemptType: 'login' } })
  gqlFetch(`mutation {
    triggerLogin(email:"${email}", url:"${window.location.href}", claimSuperUser:${superUser}) {
      email
      token
      signInUrl
    }
  }`)
  .then(
    (result) => {
      const triggeredLogin = result.data.triggerLogin
      if (triggeredLogin) {
        dispatch({ type: actions.DO_LOGIN_SUCCESS, payload: triggeredLogin })
      }
    },
    (error) => {
      if (error.length && error[0].message === 'UserNotFound') {
        dispatch({ type: actions.DO_LOGIN_ERROR, error: new Error('UserNotFound') })
      } else {
        dispatch({ type: actions.DO_LOGIN_ERROR, error })
      }
    }
  )
}

const doSignUp = email => ({ dispatch, gqlFetch }) => {
  dispatch({ type: actions.DO_LOGIN_START, payload: { email, attemptType: 'signup' } })
  gqlFetch(`mutation {
    triggerSignUp(email:"${email}", url:"${window.location.href}") {
      email
      token
      signInUrl
    }
  }`)
  .then(
    (result) => {
      const triggeredLogin = result.data.triggerSignUp
      if (triggeredLogin) {
        dispatch({ type: actions.DO_LOGIN_SUCCESS, payload: triggeredLogin })
      }
    },
    (error) => {
      dispatch({ type: actions.DO_LOGIN_ERROR, error })
    }
  )
}

const doLogout = (broadcast = true) => ({ dispatch }) => {
  dispatch({ type: actions.DO_LOGOUT })
  tryIt(() => {
    // trigger storage event to log out other tabs
    if (broadcast) {
      window.localStorage.logout = true
    }
    const { debug } = window.localStorage
    window.localStorage.clear()
    if (debug) {
      window.localStorage.debug = true
    }
  })
  clearAllCached().then(() => {
    window.location = '/'
  })
}

const readTokens = () => {
  const res = {}
  tryIt(() => {
    res.token = window.localStorage.token
    res.fbToken = window.localStorage.fbToken
  })
  return res
}

const writeTokens = (token, fbToken) => {
  tryIt(() => {
    if (token) {
      window.localStorage.token = token
    }
    if (fbToken) {
      window.localStorage.fbToken = fbToken
    }
  })
}

const doReceiveToken = (tokenObject) => ({ dispatch }) => {
  const { token, fbToken } = tokenObject
  dispatch({ type: actions.TOKEN_RECEIVED, payload: tokenObject })
  writeTokens(token, fbToken)
}

const selectAuthToken = state => state.auth.token
const selectFirebaseToken = state => state.auth.fbToken

const doFetchFirebaseToken = () => ({gqlFetch, dispatch}) => {
  dispatch({type: actions.FETCH_FB_TOKEN})
  gqlFetch('{firebaseToken}')
    .then(({data}) => {
      const fbToken = data.firebaseToken
      if (fbToken) {
        dispatch(doReceiveToken({fbToken}))
      } else {
        throw Error('could not fetch FB token')
      }
    })
}

const selectIsLoggedIn = createSelector(
  selectAuthToken,
  token => !!token
)

const init = (store) => {
  const hashObject = store.selectHashObject()
  if (hashObject.token || hashObject.fbToken) {
    store.doReceiveToken(hashObject)
    store.doUpdateHash('', {replace: true})
  }
  window.addEventListener('storage', (event) => {
    // receive logout hint
    if (event.key === 'logout') {
      // don't broadcast since we're the
      // receiver
      store.doLogout(false)
    }
    if (event.key === 'token') {
      store.doReceiveToken({token: event.newValue})
    }
    if (event.key === 'fbToken') {
      store.doReceiveToken({fbToken: event.newValue})
    }
  })
}

export default {
  name: 'auth',
  init,
  getReducer: () => {
    const { token, fbToken } = readTokens() || {token: null, fbToken: null}
    const initialState = {
      token,
      fbToken,
      error: false,
      loading: false,
      email: null,
      tokenExpired: false,
      loggingOut: false,
      attemptType: null,
      fetchingFbToken: false,
      userFound: true,
      success: false
    }

    return (state = initialState, {type, payload, error}) => {
      if (type === actions.DO_LOGIN_START) {
        return Object.assign({}, state, {
          success: false,
          error: false,
          loading: true
        }, payload)
      }
      if (type === actions.DO_LOGIN_ERROR) {
        return Object.assign({}, state, {
          success: false,
          loading: false,
          error: true,
          failedLogin: Boolean(payload && payload.failedLogin),
          userFound: error.message !== 'UserNotFound'
        })
      }
      if (type === actions.DO_LOGIN_SUCCESS) {
        return Object.assign({}, state, {
          success: true,
          loading: false,
          error: false,
          signInUrl: payload.signInUrl,
          userFound: true
        })
      }
      if (type === actions.CLEAR_LOGIN_STATE) {
        return Object.assign({}, state, {
          success: false,
          loading: false,
          error: false,
          email: null,
          signInUrl: '',
          userFound: true,
          attemptType: null
        })
      }
      if (type === actions.TOKEN_RECEIVED) {
        const extraChanges = {}
        if (payload.fbToken) {
          extraChanges.fetchingFbToken = false
        }
        return Object.assign({}, state, payload, extraChanges)
      }
      if (type === actions.TOKEN_EXPIRED) {
        return Object.assign({}, state, {
          tokenExpired: true
        })
      }
      if (type === actions.FETCH_FB_TOKEN) {
        return Object.assign({}, state, {
          fetchingFbToken: true
        })
      }
      if (type === FIREBASE_TOKEN_FAILED) {
        return Object.assign({}, state, {
          fbToken: ''
        })
      }
      if (type === actions.DO_LOGOUT) {
        return Object.assign({}, state, {
          loggingOut: true
        })
      }
      return state
    }
  },
  selectAuthToken,
  selectFirebaseToken,
  selectIsLoggedIn,
  selectAuthState: (state) => state.auth,
  selectAuthEmail: createSelector(
    'selectAuthState',
    state => state.email
  ),
  selectAuthSignInUrl: createSelector(
    'selectAuthState',
    state => state.signInUrl
  ),
  selectAuthStatus: createSelector(
    'selectAuthState',
    (state) => {
      if (state.loading) {
        return 'sending'
      } else if (state.userFound === false) {
        return 'not found'
      } else if (state.error) {
        return 'error'
      } else if (state.success) {
        return 'success'
      }
      return ''
    }
  ),
  reactShouldTriggerLogout: createSelector(
    'selectAuthState',
    auth => {
      if (auth.tokenExpired && !auth.loggingOut) {
        return doLogout()
      }
    }
  ),
  doLogout,
  doLogin,
  doSignUp,
  doReceiveToken,
  doFetchFirebaseToken,
  doClearLoginState: () => ({type: actions.CLEAR_LOGIN_STATE}),
  reactShouldFetchFirebaseToken: createSelector(
    'selectAuthState',
    'selectIsOnline',
    (auth, online) => {
      if (online && auth.token && !auth.fbToken && !auth.fetchingFbToken) {
        return {actionCreator: 'doFetchFirebaseToken'}
      }
    }
  )
}