@app-brew/brewery 1.0.0

package/src/state/src/lib/user.ts

@@ -0,0 +1,1721 @@
+import {
+  Address,
+  CreateCustomerInput,
+  Customer,
+  MailingAddressInput,
+  Order,
+} from '@gauntlet/shopify-types'
+import { LocalStorage } from '@gauntlet/local-storage'
+import { StoreSlice } from './types'
+import { ConfigSlice } from './config'
+import { ModuleSlice } from './modules'
+import {
+  AsyncData,
+  CheckUserExistsRequest,
+  CreateUserRequestForOtpSignIn,
+  GenerateOtpRequest,
+  ErrorCodes,
+  ICheckoutProvider,
+  IShopifyAuthProvider,
+  LoginCredentialsResponse,
+  Rewards,
+  SHOPIFY_CUSTOMER_AUTH_TOKEN,
+  SocialSigninRequest,
+  VerifyOtpApiResponseData,
+  VerifyOtpRequest,
+} from '@gauntlet/types'
+import { add } from 'date-fns'
+
+import { Platform } from 'react-native'
+import { AnalyticsEvent } from '@gauntlet/types'
+import { getAnalyticsProvider } from './integrations/analytics'
+import Toast from 'react-native-toast-message'
+import { JsonObject } from 'type-fest'
+import { AddressSlice } from './address'
+import { CartSlice } from './cart'
+import EnvConfig from 'react-native-config'
+import { CookieManager } from '@gauntlet/cookie-manager'
+import { SubscriptionSlice } from './subscriptions'
+import { WishlistSlice } from './wishlist'
+import deviceInfoModule from 'react-native-device-info'
+import { googleSignin } from './google-signin'
+import { RouteSlice } from './route'
+import { ProductSlice } from './products'
+import { CollectionSlice } from './collections'
+import { MetafieldSlice } from './metafield'
+import { EVENTS, EventEmitter } from '@gauntlet/event-emitter'
+import { LocalizationSlice } from './localization'
+import { updateUserAddressByCountry } from './hooks'
+
+export interface Form<T> {
+  valid: boolean
+  data: T
+}
+export interface SignInData {
+  email: string | undefined
+  password: string | undefined
+}
+export interface SignUpData {
+  firstName: string | undefined
+  lastName: string | undefined
+  phone: string | undefined
+  email: string | undefined
+  password: string | undefined
+  acceptsMarketing: boolean | undefined
+}
+export interface RecoverEmailData {
+  email: string | undefined
+}
+export interface ChangePasswordData {
+  password: string | undefined
+}
+
+export interface ResetPasswordData {
+  password: string | undefined
+}
+interface OtpVerificationData {
+  otp: string
+  isVerifyButtonDisabled: boolean
+}
+export interface CustomerAccessToken {
+  accessToken: string
+  expiresAt: string
+}
+
+export interface CheckUserExistsApiResponseData {
+  customerExists: boolean
+}
+
+export interface ErrorToastMessage {
+  error: string
+  errors?: any
+  errorCode?: string | number
+}
+export interface SuccessToastMessage {
+  success: string
+  data?: any
+}
+
+export interface CustomerAccountsToken {
+  access_token: string
+  expires_in: number
+  id_token: string
+  refresh_token: string
+  timestamp: string
+}
+
+export type FulfillmentLog = {
+  events: Array<{
+    status: string
+    message: string
+    happenedAt: string
+    estimatedDeliveryDate: string
+    city: string
+    province: string
+    zipcode: string
+    country: string
+    fulfilmentId: string
+    awb?: string
+  }>
+  awb?: string
+  status: string
+  estimatedDeliveryDate: string
+  id: string
+}
+
+export type Fulfillments = Record<string, FulfillmentLog>
+
+export type SignInForm = Form<SignInData>
+export type SignUpForm = Form<SignUpData>
+export type RecoverEmailForm = Form<RecoverEmailData>
+export type ChangePasswordForm = Form<ChangePasswordData>
+export type ResetPasswordForm = Form<ResetPasswordData>
+type OtpVerificationForm = Form<OtpVerificationData>
+export interface UserData {
+  customerAccessToken: AsyncData<CustomerAccessToken>
+  shippingAddress: AsyncData<Partial<Address>>
+  userDetails: AsyncData<Partial<Customer>>
+  customerCompanyId: AsyncData<{ companyLocationId: string }>
+}
+export interface UserForms {
+  signin: SignInForm
+  signup: SignUpForm
+  'recover-email': RecoverEmailForm
+  'change-password': ChangePasswordForm
+  'otp-verification': OtpVerificationForm
+  'reset-password': ResetPasswordForm
+}
+export type UserFormType = keyof UserForms
+export type UserState = {
+  forms: UserForms
+  data: UserData
+}
+export interface UserSlice {
+  user: UserState & UserActions
+}
+
+const initialFormState: UserForms = {
+  signin: { valid: false, data: { email: undefined, password: undefined } },
+  signup: {
+    valid: false,
+    data: {
+      email: undefined,
+      password: undefined,
+      firstName: undefined,
+      lastName: undefined,
+      phone: undefined,
+      acceptsMarketing: undefined,
+    },
+  },
+  'recover-email': { valid: false, data: { email: undefined } },
+  'change-password': { valid: false, data: { password: undefined } },
+  'otp-verification': {
+    valid: false,
+    data: { otp: '', isVerifyButtonDisabled: false },
+  },
+  'reset-password': { valid: false, data: { password: undefined } },
+}
+
+const initialUserState: UserState = {
+  forms: initialFormState,
+  data: {
+    customerAccessToken: { status: 'init' },
+    shippingAddress: { status: 'init' },
+    userDetails: { status: 'init' },
+    customerCompanyId: { status: 'init' },
+  },
+}
+export interface UserActions {
+  signin: () => Promise<ErrorToastMessage | SuccessToastMessage>
+  signout: () => Promise<void>
+  signUp: () => Promise<ErrorToastMessage | SuccessToastMessage>
+  resetUser: () => void
+  socialSignin: (
+    request: SocialSigninRequest
+  ) => Promise<ErrorToastMessage | SuccessToastMessage>
+  recoverCustomer: () => Promise<ErrorToastMessage | SuccessToastMessage>
+  getCustomerAccessToken: () => string | undefined
+  getCustomerAccountsAccessToken: () => string | undefined
+  getCustomerCompanyId: () => string | undefined
+  getUserDetails: () => Promise<
+    | {
+        success: string
+        customerDetails: Partial<Customer>
+      }
+    | { error: unknown }
+  >
+  updateUserDetails: (
+    customer: Partial<CreateCustomerInput>
+  ) => Promise<ErrorToastMessage | SuccessToastMessage>
+  updateProfile: (
+    payload: Record<string, string | Record<string, string> | undefined>
+  ) => Promise<ErrorToastMessage | SuccessToastMessage>
+  updateDefaultAddress: (
+    id: Address['id']
+  ) => Promise<ErrorToastMessage | SuccessToastMessage>
+  createUserAddress: (
+    address: MailingAddressInput
+  ) => Promise<ErrorToastMessage | SuccessToastMessage>
+  deleteUserAddress: (
+    id: Address['id']
+  ) => Promise<ErrorToastMessage | SuccessToastMessage>
+  updateUserAddress: (
+    address: MailingAddressInput,
+    id: Address['id']
+  ) => Promise<ErrorToastMessage | SuccessToastMessage>
+  getFormData: (formType: UserFormType) => UserForms[UserFormType]['data']
+  getFormValidity: (formType: UserFormType) => UserForms[UserFormType]['valid']
+  updateFormData: (
+    formType: UserFormType,
+    data: UserForms[UserFormType]['data']
+  ) => void
+  updateFormValidity: (formType: UserFormType, flag: boolean) => void
+  getLastOrder: () => Promise<AsyncData<Order>>
+  changePassword: () => Promise<ErrorToastMessage | SuccessToastMessage>
+  isUserAuthenticated: () => boolean
+  getCustomerAddresses: () => Promise<ErrorToastMessage | SuccessToastMessage>
+  generateOtp: (request: GenerateOtpRequest) => Promise<
+    | ErrorToastMessage
+    | {
+        success?: string
+        requestId?: string
+      }
+  >
+  verifyOtp: (
+    request: VerifyOtpRequest
+  ) => Promise<
+    SuccessToastMessage | ErrorToastMessage | VerifyOtpApiResponseData
+  >
+  checkUserExists: (
+    request: CheckUserExistsRequest
+  ) => Promise<ErrorToastMessage | CheckUserExistsApiResponseData>
+  otpSignUp: (
+    request: CreateUserRequestForOtpSignIn
+  ) => Promise<SuccessToastMessage | ErrorToastMessage | void>
+  updateOrderStatus: (orderId: string, status: string) => void
+  signinWithMultipass: (multipassToken: string) => Promise<void>
+  initiateSigninForVerifiedUser: ({
+    multipassToken,
+    email,
+    passKey,
+    activationUrl,
+    provider,
+    customerProps,
+  }: {
+    multipassToken?: string
+    email?: string
+    passKey?: string
+    provider?: string
+    activationUrl?: string
+    customerProps?: {
+      link_existing_account?: boolean
+      new_customer?: boolean
+    }
+  }) => Promise<ErrorToastMessage | void>
+  resetPasswordByUrl: (resetUrl: any) => Promise<void>
+  updateUserDummyData: () => void
+  refreshCustomerAccountToken: () => Promise<void>
+  signOutFromShopifyCustomerAccounts: () => Promise<void>
+  fetchCustomerAccountsAccessToken: (
+    code: string,
+    verifier: string
+  ) => Promise<AsyncData<CustomerAccountsToken>>
+  fetchCustomerAccountsCompanyId: (
+    token: string
+  ) => Promise<AsyncData<{ companyLocationId: string }>>
+  fetchCustomerAccountsCompanyId: (
+    token: string
+  ) => Promise<AsyncData<{ companyLocationId: string }>>
+  getLoginCredentialsFromToken: (
+    token: CustomerAccountsToken['access_token']
+  ) => Promise<AsyncData<LoginCredentialsResponse>>
+  signInUsingCustomerAccountToken: (
+    token: CustomerAccountsToken['access_token']
+  ) => Promise<AsyncData<ErrorToastMessage | SuccessToastMessage>>
+}
+const localStorage = LocalStorage.getInstance()
+
+export const createUserSlice: StoreSlice<
+  UserSlice,
+  UserSlice &
+    ConfigSlice &
+    ModuleSlice &
+    AddressSlice &
+    CartSlice &
+    SubscriptionSlice &
+    WishlistSlice &
+    RouteSlice &
+    ProductSlice &
+    CollectionSlice &
+    MetafieldSlice &
+    LocalizationSlice
+> = (set, get) => ({
+  user: {
+    ...initialUserState,
+    getCustomerAccessToken: () => {
+      const res = localStorage.getJson(
+        'customerAccessToken'
+      ) as unknown as CustomerAccessToken
+      if (res && res.accessToken) return res.accessToken
+      return
+    },
+    getCustomerAccountsAccessToken: () => {
+      const res = localStorage.getJson(
+        SHOPIFY_CUSTOMER_AUTH_TOKEN
+      ) as unknown as CustomerAccountsToken
+      if (res && res.access_token) return res.access_token
+      return
+    },
+    getCustomerCompanyId: () => {
+      const companyLocationId = get().user.data.customerCompanyId
+      if (companyLocationId?.status === 'idle' && companyLocationId?.data) {
+        return companyLocationId.data.companyLocationId
+      } else {
+        const id = localStorage.getJson('customerCompanyId') as {
+          companyLocationId: string
+        }
+        if (id) {
+          set((store) => {
+            store.user.data.customerCompanyId = {
+              status: 'idle',
+              data: { companyLocationId: id.companyLocationId },
+            }
+          })
+          return id.companyLocationId
+        }
+      }
+      return undefined
+    },
+    isUserAuthenticated: () => {
+      return Boolean(get().user.getCustomerAccessToken())
+    },
+    getFormData: (formType: UserFormType) => {
+      const formData = get().user.forms[formType].data
+      return formData
+    },
+    getFormValidity: () => {
+      const { email, password } = get().user.forms['signin'].data
+      const emailPattern = /^\w+@[a-zA-Z_]+?\.[a-zA-Z]{2,3}$/
+      const isEmailValid = email?.match(emailPattern)
+      return Boolean(isEmailValid && Boolean(password))
+    },
+    updateFormData: (
+      formType: UserFormType,
+      data:
+        | SignInData
+        | SignUpData
+        | RecoverEmailData
+        | ChangePasswordData
+        | ResetPasswordData
+    ) => {
+      set((store) => {
+        store.user.forms[formType].data = data
+      })
+    },
+    updateFormValidity: (formType: UserFormType, valid: boolean) => {
+      set((store) => {
+        store.user.forms[formType].valid = valid
+      })
+    },
+    signin: async () => {
+      const authModule = get().modules.getModule<IShopifyAuthProvider>('auth')
+      const email = get().user.forms['signin'].data.email
+      const password = get().user.forms['signin'].data.password
+      if (!email || !password)
+        return { error: 'Login credentials are undefined' }
+
+      const response = await authModule.createCustomerAccessToken({
+        email,
+        password,
+      })
+      if (response.status === 'error') {
+        return (
+          response.error ?? {
+            error:
+              'Some error occured while shigning in. Response is undefined',
+          }
+        )
+      }
+      const { data } = response
+      if (!data.customerAccessTokenCreate)
+        return {
+          error:
+            'Login API response structure mismach, customerAccessTokenCreate is undefined',
+        }
+      const { customerUserErrors, customerAccessToken } =
+        data.customerAccessTokenCreate
+      return await onSignInSuccess(
+        customerUserErrors,
+        customerAccessToken,
+        set,
+        get,
+        'email-password'
+      )
+    },
+    socialSignin: async (request: SocialSigninRequest) => {
+      const authModule = get().modules.getModule<IShopifyAuthProvider>('auth')
+      const { multipassToken, passKey, email } = await fetch(
+        `${EnvConfig['APP_SERVICE_URL']}/integrations/social-signin/signin`,
+        {
+          method: 'post',
+          body: JSON.stringify(request),
+          headers: {
+            'Content-Type': 'application/json',
+          },
+        }
+      )
+        .then((res: any) => res.json())
+        .catch((err) => {
+          Toast.show({
+            type: 'error',
+            text1: 'Something went wrong',
+          })
+        })
+
+      if (multipassToken) {
+        return await onSigninWithMultipass(
+          multipassToken,
+          authModule,
+          get,
+          set,
+          request.provider
+        )
+      } else {
+        return await onSigninWithoutMultipass(
+          email,
+          passKey,
+          authModule,
+          get,
+          set,
+          request.provider
+        )
+      }
+    },
+    signout: async () => {
+      const authModule = get().modules.getModule<IShopifyAuthProvider>('auth')
+      const accessToken = get().user.getCustomerAccessToken()
+      const webClientId =
+        get().config.data?.integrations?.socialSignin?.googleWebClientId
+      if (!accessToken)
+        return { status: 'error', error: 'access token not defined' }
+      get().user.resetUser()
+      get().cart.resetCart()
+      get().subscriptions.resetSubscriptions()
+      if (webClientId) {
+        await googleSignin.signOut()
+      }
+      const { status, data, error } =
+        await authModule.deleteCustomerAccessToken(accessToken)
+      await get().user.signOutFromShopifyCustomerAccounts()
+
+      // we should always reset the user irrespective of the response
+      if (status !== 'success') {
+        return error ?? { error: 'Logout failed!!' }
+      }
+      const analytics = getAnalyticsProvider(get)
+      analytics.sendEvent(AnalyticsEvent.LOGOUT, {})
+      const eventEmitter = EventEmitter.getInstance()
+      eventEmitter.publish(EVENTS.SIGNOUT_SUCCESS, {})
+      return {
+        success: 'Logout successful!',
+      }
+    },
+    resetUser: () => {
+      localStorage.set('customerAccessToken', {})
+      localStorage.delete('bearerToken')
+      localStorage.delete('addressForm')
+      CookieManager.clearAll() // we are deliberately not going to wait for the promise
+      set((userSlice) => {
+        userSlice.address.updateFormData({})
+        userSlice.user.forms = initialFormState
+        userSlice.user.data = {
+          customerAccessToken: { status: 'init' },
+          shippingAddress: { status: 'init' },
+          userDetails: { status: 'init' },
+          customerCompanyId: { status: 'init' },
+        }
+      })
+      get().wishlist.clear()
+      get().userNotifications.resetSlice()
+
+      // Clear session data for gokwik
+      try {
+        if (get().modules.isModuleDefined('checkout')) {
+          get().modules.getModule<ICheckoutProvider>('checkout').onSignOut()
+        }
+      } catch (error) {
+        console.error('Error in checkout provider onSignOut function', error)
+      }
+    },
+    signUp: async () => {
+      const authModule = get().modules.getModule<IShopifyAuthProvider>('auth')
+      const formData = { ...get().user.forms['signup'].data }
+      const { firstName, lastName, email, phone, password, acceptsMarketing } =
+        formData
+
+      if (!firstName || !lastName || !email || !password)
+        return { error: 'signup form data empty for some fields' }
+
+      const { data, status, error } = await authModule.createCustomer({
+        acceptsMarketing: acceptsMarketing ?? false,
+        email,
+        password,
+        firstName,
+        lastName,
+        phone: phone || null,
+      })
+
+      if (status !== 'success') {
+        return (
+          { error: error } ?? {
+            error: 'Signup for user failed.',
+          }
+        )
+      }
+      if (!data.customerCreate)
+        return { error: 'Response is not proper, customerCreate is undefined.' }
+      const { customerUserErrors, customer } = data.customerCreate
+      if (customerUserErrors && customerUserErrors.length > 0) {
+        const errorCode = customerUserErrors[0].code
+          ?.toUpperCase()
+          ?.replace(/\s+/g, '_')
+        const customErrorMessage =
+          get().config.data?.settings?.messages?.[`AUTH_ERROR_${errorCode}`]
+        return { error: customErrorMessage ?? customerUserErrors[0].message }
+      }
+      const analytics = getAnalyticsProvider(get)
+      analytics.sendEvent(AnalyticsEvent.SIGNUP, {
+        method: 'email-password',
+      })
+      set((userSlice) => {
+        userSlice.user.data.userDetails = customer
+        userSlice.user.forms.signin.data.email = email
+        userSlice.user.forms.signin.data.password = password
+      })
+
+      const res = await get().user.signin()
+      if (res.error) return res
+      return { success: 'Account created successfully' }
+    },
+    updateUserDetails: async (user: Partial<CreateCustomerInput>) => {
+      const authModule = get().modules.getModule<IShopifyAuthProvider>('auth')
+      const accessToken = get().user.getCustomerAccessToken()
+      if (!accessToken)
+        return { status: 'error', error: 'access token not defined' }
+      const { data, status, error } = await authModule.updateCustomer(
+        accessToken,
+        user
+      )
+      if (status !== 'success') {
+        return (
+          error ?? {
+            status: 'error',
+            error: 'update user details network call failed.',
+          }
+        )
+      }
+      if (!data.customerUpdate)
+        return (
+          error ?? {
+            status: 'error',
+            error:
+              'data.customerUpdate.customer is undefined in updateuserDetails.',
+          }
+        )
+      const { customer: userDetails } = data.customerUpdate
+      set((userSlice) => {
+        if (userDetails?.firstName)
+          userSlice.user.data.userDetails.data.firstName = userDetails.firstName
+        if (userDetails?.lastName)
+          userSlice.user.data.userDetails.data.lastName = userDetails.lastName
+        if (userDetails?.phone)
+          userSlice.user.data.userDetails.data.phone = userDetails.phone
+      })
+      return {
+        status: 'success',
+        success: 'User details updated successfully',
+      }
+    },
+    updateProfile: async (
+      payload: Record<string, string | Record<string, string> | undefined>
+    ): Promise<ErrorToastMessage | SuccessToastMessage> => {
+      const accessToken = get().user.getCustomerAccessToken()
+      const userDetails = get().user.data.userDetails as {
+        data?: { id?: string }
+      }
+      const customerId = userDetails?.data?.id
+      if (!accessToken) return { error: 'access token not defined' }
+      if (!customerId) return { error: 'customer id not found' }
+      try {
+        const response = await fetch(
+          `${EnvConfig['APP_SERVICE_URL']}/integrations/shopify/customers`,
+          {
+            method: 'PATCH',
+            body: JSON.stringify(payload),
+            headers: {
+              'x-customer-access-token': accessToken,
+              'x-app-id': EnvConfig['APP_ID'],
+              'Content-Type': 'application/json',
+            },
+          }
+        )
+        const data = await response.json()
+        if (!response.ok) {
+          const { message, errors, errorCode } = data
+          if (errorCode == ErrorCodes.VALIDATION_ERROR) {
+            if (Array.isArray(errors) && errors.length > 0) {
+              return { error: 'Some fields are invalid', errors }
+            }
+            return { error: message ?? 'Some fields are invalid' }
+          }
+          return {
+            error: message ?? 'Failed to update profile',
+          }
+        }
+        await get().user.getUserDetails()
+        return { success: 'Profile updated successfully' }
+      } catch (err) {
+        return {
+          error:
+            err instanceof Error ? err.message : 'Failed to update profile',
+        }
+      }
+    },
+    getUserDetails: async () => {
+      const authModule = get().modules.getModule<IShopifyAuthProvider>('auth')
+      let accessToken = get().user.getCustomerAccessToken()
+      function onGetUserDetailsError(error: any) {
+        set((store) => {
+          store.user.data.userDetails.status = 'error'
+        })
+        get().user.resetUser()
+        return { error }
+      }
+      if (!accessToken) {
+        return { error: 'Access token is not defined, cannot get user details' }
+      }
+
+      set((store) => {
+        store.user.data.userDetails.status = 'loading'
+      })
+
+      const profileFields = (get().config?.data?.integrations?.[
+        'customer-rich-profile'
+      ]?.profileFields ?? []) as Array<{ key: string; hidden?: boolean }>
+      const visibleProfileFields = profileFields.filter(
+        (f) => f.hidden !== true
+      )
+      const metafieldIdentifiers = visibleProfileFields.map((f) => ({
+        namespace: 'custom' as const,
+        key: f.key,
+      }))
+
+      const { status, data, error } = await authModule.getCustomerDetails(
+        accessToken,
+        metafieldIdentifiers
+      )
+      if (status !== 'success') {
+        return onGetUserDetailsError(
+          error ? { error } : { error: 'Fetching user details failed' }
+        )
+      }
+      if (!data.customer) {
+        return onGetUserDetailsError(
+          'Customer details not found, data.customer is undefined'
+        )
+      }
+
+      const { customer: customerDetails } = data
+      const { defaultAddress } = customerDetails
+
+      set((userSlice) => {
+        const address = customerDetails.addresses.edges[0]
+        userSlice.address.updateFormData({
+          email: customerDetails.email,
+          firstName: customerDetails.firstName,
+          lastName: customerDetails.lastName,
+          phone: customerDetails.phone,
+          zip: address?.zip,
+          city: address?.city,
+          country: address?.country,
+          province: address?.province,
+          address1: address?.address1,
+          address2: address?.address2,
+        })
+        userSlice.user.data.userDetails.status = 'idle'
+        userSlice.user.data.userDetails.data = {
+          ...customerDetails,
+          orders: mapUserOrders(customerDetails),
+        }
+      })
+      if (defaultAddress) {
+        const {
+          country,
+          zip,
+          province,
+          city,
+          address1,
+          address2,
+          phone,
+          countryCodeV2,
+        } = defaultAddress
+        localStorage.set('addressForm', {
+          country: { countryName: country, countryCode: countryCodeV2 },
+          zip,
+          province,
+          city,
+          address1,
+          address2,
+          email: customerDetails?.email,
+          firstName: customerDetails?.firstName,
+          lastName: customerDetails?.lastName,
+          phone: phone ?? customerDetails?.phone,
+        })
+        set((userSlice) => {
+          userSlice.user.data.shippingAddress.status = 'idle'
+          userSlice.user.data.shippingAddress.data = defaultAddress
+        })
+      }
+      const {
+        status: tokenStatus,
+        data: tokenData,
+        error: tokenError,
+      } = await authModule.renewCustomerAccessToken(accessToken)
+      if (tokenStatus === 'success') {
+        accessToken =
+          tokenData.customerAccessTokenRenew?.customerAccessToken?.accessToken
+        if (accessToken)
+          localStorage.set(
+            'customerAccessToken',
+            tokenData.customerAccessTokenRenew.customerAccessToken
+          )
+      }
+      if (tokenStatus !== 'success') {
+        return onGetUserDetailsError(
+          tokenError
+            ? { error: tokenError }
+            : { error: 'Refresh Token could not be renewed' }
+        )
+      }
+      return { success: 'User details fetched and updated', customerDetails }
+    },
+    createUserAddress: async (address: MailingAddressInput) => {
+      const authModule = get().modules.getModule<IShopifyAuthProvider>('auth')
+      const accessToken = get().user.getCustomerAccessToken()
+      if (!accessToken) {
+        return { status: 'error', error: 'access token not defined' }
+      }
+      const { countryCodeV2, ...rest } = address
+      const { status, data, error } = await authModule.createCustomerAddress(
+        rest,
+        accessToken
+      )
+      if (status !== 'success')
+        return {
+          status: 'error',
+          error: error ?? 'createUserAddress network request failed',
+        }
+      if (
+        data.customerAddressCreate &&
+        data.customerAddressCreate.customerUserErrors.length !== 0
+      ) {
+        return {
+          status: 'error',
+          error:
+            data.customerAddressCreate.customerUserErrors[0]?.message ??
+            'Field error',
+        }
+      }
+      await get().user.getCustomerAddresses()
+
+      get().address.createAddress(address)
+      const isMultiCurrencyEnabled =
+        get().config.data?.settings?.['global']?.enableMultiCurrencyV4
+      const localizationCountryName =
+        get().localization.data.selectedCountry?.name
+
+      if (
+        isMultiCurrencyEnabled &&
+        address.country === localizationCountryName
+      ) {
+        get().cart.updateShippingAddress()
+        // if we allow user to update address with country that is different than the localization country, new cart will show prices in the address country currency rather than the localization country currency. So we are not allowing user to select address with different country
+      }
+
+      return {
+        success: 'Address is added successfully.',
+        id: data.customerAddressCreate?.customerAddress?.id,
+      }
+    },
+    getCustomerAddresses: async () => {
+      const authModule = get().modules.getModule<IShopifyAuthProvider>('auth')
+      const accessToken = get().user.getCustomerAccessToken()
+      if (!accessToken)
+        return {
+          status: 'error',
+          error: 'access token not defined in getCustomerAddresses',
+        }
+      const { status, data, error } = await authModule.getCustomerAddresses(
+        accessToken
+      )
+      if (status !== 'success')
+        return error ?? { error: 'getCustomerAddresses network request failed' }
+      const addresses = data?.customer?.addresses?.edges
+      set((userSlice) => {
+        userSlice.user.data.userDetails.data.addresses.edges = addresses
+      })
+      return { success: 'Address list is updated successfully.' }
+    },
+    deleteUserAddress: async (addressId: string) => {
+      const authModule = get().modules.getModule<IShopifyAuthProvider>('auth')
+      const accessToken = get().user.getCustomerAccessToken()
+      if (!accessToken)
+        return {
+          status: 'error',
+          error: 'access token not defined in deleteUserAddress',
+        }
+      const { status, data, error } = await authModule.deleteCustomerAddress(
+        accessToken,
+        addressId
+      )
+      if (status !== 'success')
+        return error ?? { error: 'deleteUserAddress network request failed' }
+      if (
+        data.customerAddressDelete &&
+        data.customerAddressDelete.customerUserErrors.length !== 0
+      ) {
+        return {
+          status: 'error',
+          error:
+            data.customerAddressDelete.customerUserErrors[0]?.message ??
+            'Field error',
+        }
+      }
+      await get().user.getCustomerAddresses()
+      return {
+        success: 'Address is deleted successfully.',
+        id: data.customerAddressDelete?.deletedCustomerAddressId,
+      }
+    },
+    updateUserAddress: async (
+      address: MailingAddressInput,
+      addressId: string
+    ) => {
+      const authModule = get().modules.getModule<IShopifyAuthProvider>('auth')
+      const accessToken = get().user.getCustomerAccessToken()
+      if (!accessToken)
+        return {
+          status: 'error',
+          error: 'access token not defined in deleteUserAddress',
+        }
+      const { countryCodeV2, ...rest } = address
+      const { status, data, error } = await authModule.updateCustomerAddress(
+        rest,
+        accessToken,
+        addressId
+      )
+      if (status !== 'success') {
+        return {
+          error: 'updateUserAddress network request failed',
+        }
+      }
+
+      if (
+        data.customerAddressUpdate &&
+        data.customerAddressUpdate.customerUserErrors?.length !== 0
+      ) {
+        return {
+          status: 'error',
+          error:
+            data.customerAddressUpdate.customerUserErrors[0]?.message ??
+            'Field error',
+        }
+      }
+
+      await get().user.getCustomerAddresses()
+      return { success: 'Address is updated successfully.' }
+    },
+    updateDefaultAddress: async (addressId: string) => {
+      const authModule = get().modules.getModule<IShopifyAuthProvider>('auth')
+      const accessToken = get().user.getCustomerAccessToken()
+      if (!accessToken)
+        return {
+          status: 'error',
+          error: 'access token not defined in deleteUserAddress',
+        }
+
+      const { status, data, error } = await authModule.updateDefaultAddress(
+        accessToken,
+        addressId
+      )
+      if (status !== 'success')
+        return (
+          error ?? {
+            status: 'error',
+            error: 'updateUserAddress network request failed',
+          }
+        )
+    },
+    async getLastOrder() {
+      const module = get().modules.getModule<IShopifyAuthProvider>('auth')
+      const token = get().user.getCustomerAccessToken()
+      if (!token)
+        return {
+          status: 'error',
+          error: {
+            message: 'User not signed in',
+            code: 'UNIDENTIFIED_USER',
+            rootCause:
+              'Tried to fetch orders when customerAccessToken was not defined ',
+          },
+        }
+      const res = await module.getLastOrder(token)
+      if (res.error)
+        return {
+          status: 'error',
+          error: {
+            message: "Couldn't fetch order details",
+            code: res.error.name,
+            rootCause: res.error.message,
+          },
+        }
+      if (res.data) {
+        return { status: 'idle', data: mapUserOrders(res.data.customer)[0] }
+      }
+      return {
+        status: 'error',
+        error: {
+          message: 'Something wrong happened',
+          code: 'UNKOWN_ERROR',
+          rootCause: 'Both data and error were undefined',
+        },
+      }
+    },
+    recoverCustomer: async () => {
+      const authModule = get().modules.getModule<IShopifyAuthProvider>('auth')
+      const recoverEmail = get().user.forms['recover-email'].data.email
+      if (!recoverEmail) return { status: 'error', error: 'Invalid Email' }
+
+      const { data, status, error } = await authModule.recoverCustomer(
+        recoverEmail
+      )
+      if (status !== 'success') {
+        return {
+          status: 'error',
+          error: error ?? 'Unable to send email, recover email failed.',
+        }
+      }
+      if (!data.customerRecover)
+        return {
+          status: 'error',
+          error:
+            'Unable to send email, recover email failed. customerRecover is undefined',
+        }
+      const { customerUserErrors } = data.customerRecover
+      if (customerUserErrors && customerUserErrors.length > 0) {
+        return { error: customerUserErrors[0].message }
+      }
+      return { success: 'We have sent a reset link to your email address.' }
+    },
+    changePassword: async () => {
+      const authModule = get().modules.getModule<IShopifyAuthProvider>('auth')
+      const newPassword = get().user.forms['change-password'].data.password
+      const token = get().user.getCustomerAccessToken()
+      if (!token)
+        return {
+          status: 'error',
+          error: {
+            message: 'User not signed in',
+            code: 'UNIDENTIFIED_USER',
+            rootCause:
+              'Tried to update password when customerAccessToken was not defined ',
+          },
+        }
+
+      const { data, status, error } = await authModule.updateCustomer(token, {
+        password: newPassword,
+      })
+      if (status !== 'success') {
+        return (
+          error ?? {
+            status: 'error',
+            error: 'changePassword network request failed',
+          }
+        )
+      }
+      if (!data.customerUpdate || !data.customerUpdate.customer) {
+        get().user.resetUser()
+        return {
+          status: 'error',
+          error:
+            'changePassword network request failed, customerUpdate or customer is undefined',
+        }
+      }
+
+      const { customerUserErrors, customer, customerAccessToken } =
+        data.customerUpdate
+      if (customerUserErrors && customerUserErrors.length > 0)
+        return { error: customerUserErrors[0].message }
+
+      set((userSlice) => {
+        userSlice.user.data.customerAccessToken = customerAccessToken
+      })
+      localStorage.set('customerAccessToken', customerAccessToken)
+      return { success: 'Password changed successfully' }
+    },
+    generateOtp: async (request: GenerateOtpRequest) => {
+      try {
+        const response = await fetch(
+          `${EnvConfig['APP_SERVICE_URL']}/integrations/otp-signin/generate-otp`,
+          {
+            method: 'POST',
+            body: JSON.stringify(request),
+            headers: {
+              'x-app-id': EnvConfig['APP_ID'],
+              'x-app-version': deviceInfoModule.getVersion(),
+              'x-app-platform': Platform.OS,
+              'Content-Type': 'application/json',
+            },
+          }
+        )
+
+        const responseData = await response.json()
+        if (!response.ok) {
+          const { message, errorCode } = responseData
+          return {
+            error: message,
+            errorCode,
+          }
+        }
+        const { isSuccess, message, requestId } = responseData
+        if (isSuccess) {
+          return {
+            success: message,
+            requestId,
+          }
+        }
+        return responseData
+      } catch (err) {
+        console.error(err)
+        return { error: 'Unable to connect to server!' }
+      }
+    },
+    verifyOtp: async (request: VerifyOtpRequest) => {
+      try {
+        const response = await fetch(
+          `${EnvConfig['APP_SERVICE_URL']}/integrations/otp-signin/verify-otp`,
+          {
+            method: 'POST',
+            body: JSON.stringify(request),
+            headers: {
+              'x-app-id': EnvConfig['APP_ID'],
+              'x-app-version': deviceInfoModule.getVersion(),
+              'x-app-platform': Platform.OS,
+              'Content-Type': 'application/json',
+            },
+          }
+        )
+
+        const responseData = await response.json()
+        if (!response.ok) {
+          const { message, errorCode } = responseData
+          return {
+            error: message,
+            errorCode,
+          }
+        }
+        try {
+          if (get().modules.isModuleDefined('checkout')) {
+            get()
+              .modules.getModule<ICheckoutProvider>('checkout')
+              .onOtpVerify?.(responseData)
+          }
+        } catch (err) {
+          console.error('Error in checkout onOtpVerify function', err)
+        }
+        return responseData
+      } catch (err) {
+        console.error(err)
+        return { error: 'Unable to connect to server!' }
+      }
+    },
+    checkUserExists: async (request: CheckUserExistsRequest) => {
+      try {
+        const response = await fetch(
+          `${EnvConfig['APP_SERVICE_URL']}/integrations/otp-signin/check-user-exists`,
+          {
+            method: 'POST',
+            body: JSON.stringify(request),
+            headers: {
+              'x-app-id': EnvConfig['APP_ID'],
+              'x-app-version': deviceInfoModule.getVersion(),
+              'x-app-platform': Platform.OS,
+              'Content-Type': 'application/json',
+            },
+          }
+        )
+        const responseData = await response.json()
+        if (!response.ok) {
+          const { message, errorCode } = responseData
+          return {
+            error: message,
+            errorCode,
+          }
+        }
+        return responseData
+      } catch (err) {
+        console.error(err)
+        return { error: 'Unable to connect to server!' }
+      }
+    },
+    otpSignUp: async (request: CreateUserRequestForOtpSignIn) => {
+      try {
+        const response = await fetch(
+          `${EnvConfig['APP_SERVICE_URL']}/integrations/otp-signin/create-user`,
+          {
+            method: 'POST',
+            body: JSON.stringify(request),
+            headers: {
+              'x-app-id': EnvConfig['APP_ID'],
+              'x-app-version': deviceInfoModule.getVersion(),
+              'x-app-platform': Platform.OS,
+              'Content-Type': 'application/json',
+            },
+          }
+        )
+
+        const responseData = await response.json()
+        if (!response.ok) {
+          const { message, errorCode } = responseData
+          return {
+            error: message,
+            errorCode,
+          }
+        }
+        const { multipassToken, email, passKey, activationUrl } = responseData
+        return get().user.initiateSigninForVerifiedUser({
+          email,
+          multipassToken,
+          passKey,
+          activationUrl,
+          provider: 'otp-signin',
+          customerProps: { new_customer: true },
+        })
+      } catch (err) {
+        console.error(err)
+        return { error: 'Unable to connect to server!' }
+      }
+    },
+    updateOrderStatus: (orderId: string, status: string) => {
+      set((store) => {
+        const userDetails = store.user.data.userDetails
+        if (userDetails.status !== 'idle') return
+        const user = userDetails.data
+        const order = user.orders?.find((order) => order.id === orderId)
+        if (order) {
+          order.fulfillmentStatus = status as any
+        }
+      })
+    },
+    signinWithMultipass: async (multipassToken: string) => {
+      if (multipassToken) {
+        const authModule = get().modules.getModule<IShopifyAuthProvider>('auth')
+        const { data, status, error } =
+          await authModule.createCustomerAccessTokenUsingMultipass(
+            multipassToken
+          )
+        if (status === 'error' && error) {
+          return error
+        }
+        const { customerUserErrors, customerAccessToken } =
+          data.customerAccessTokenCreateWithMultipass
+        return await onSignInSuccess(
+          customerUserErrors,
+          customerAccessToken,
+          set,
+          get
+        )
+      }
+    },
+    initiateSigninForVerifiedUser: async ({
+      multipassToken,
+      email,
+      passKey,
+      activationUrl,
+      provider,
+      customerProps,
+    }: {
+      multipassToken?: string
+      email?: string
+      passKey?: string
+      activationUrl?: string
+      provider?: string
+      customerProps?: {
+        link_existing_account?: boolean
+        new_customer?: boolean
+      }
+    }) => {
+      if (multipassToken) {
+        return await onSigninWithMultipass(
+          multipassToken,
+          get().modules.getModule<IShopifyAuthProvider>('auth'),
+          get,
+          set,
+          provider,
+          customerProps
+        )
+      }
+      if (activationUrl && passKey) {
+        return await onSigninWithActivationUrl(
+          activationUrl,
+          passKey,
+          get().modules.getModule<IShopifyAuthProvider>('auth'),
+          get,
+          set,
+          provider,
+          customerProps
+        )
+      }
+      if (email && passKey) {
+        return await onSigninWithoutMultipass(
+          email,
+          passKey,
+          get().modules.getModule<IShopifyAuthProvider>('auth'),
+          get,
+          set,
+          provider,
+          customerProps
+        )
+      }
+      return { error: 'No credentials provided for sign in.' }
+    },
+    resetPasswordByUrl: async (resetUrl: any) => {
+      const newPassword = get().user.forms['reset-password'].data.password
+      const authModule = get().modules.getModule<IShopifyAuthProvider>('auth')
+      const { data, status, error } = await authModule.resetPasswordByUrl(
+        newPassword,
+        resetUrl
+      )
+      if (status === 'error' && error) {
+        return error
+      }
+      if (!data.customerResetByUrl) {
+        return error ?? { error: 'Reset password failed' }
+      }
+
+      return { success: 'Sign in using new password' }
+    },
+    updateUserDummyData: () => {
+      localStorage.set('customerAccessToken', {
+        accessToken: '1234567',
+        expiresAt: add(new Date(), { days: 1 }),
+      })
+      set((userSlice) => {
+        userSlice.address.updateFormData({
+          email: 'John.Doe@yahoo.com',
+          firstName: 'John',
+          lastName: 'Doe',
+          phone: '415-555-8976',
+          zip: '94105',
+          city: 'San Francisco',
+          country: {
+            countryCallingCode: '1',
+            countryName: 'United States',
+            countryCode: 'US',
+          },
+          province: 'California',
+          address1: '123 Market Street',
+          address2: 'Suite 400',
+        })
+        userSlice.user.data.userDetails.status = 'idle'
+        userSlice.user.data.userDetails.data = {
+          firstName: 'John',
+          lastName: 'Doe',
+          email: 'John.Doe@yahoo.co',
+          displayName: 'John Doe',
+          phone: '9667122352',
+        }
+      })
+    },
+    //customer accounts actions
+    refreshCustomerAccountToken: async () => {
+      const customerAccountsToken = localStorage.getJson(
+        SHOPIFY_CUSTOMER_AUTH_TOKEN
+      ) as CustomerAccountsToken
+      if (!customerAccountsToken) return
+      const authModule = get().modules.getModule<IShopifyAuthProvider>('auth')
+      const res = await authModule.refreshCustomerAccountToken()
+      if (res.status === 'error') {
+        console.error('Error refreshing customer account token', res.error)
+        return
+      }
+      if (res?.status !== 'idle') {
+        console.error(
+          'Error refreshing customer account token status',
+          res.status
+        )
+        return
+      }
+      const { access_token, expires_in, refresh_token } = res.data
+      localStorage.set(
+        SHOPIFY_CUSTOMER_AUTH_TOKEN,
+        JSON.stringify({
+          access_token,
+          expires_in,
+          refresh_token,
+          timestamp: Date.now(),
+        })
+      )
+      console.debug('Token refreshed successfully')
+    },
+    signOutFromShopifyCustomerAccounts: async () => {
+      if (!get().user.getCustomerAccountsAccessToken()) return
+      const authModule = get().modules.getModule<IShopifyAuthProvider>('auth')
+      localStorage.delete(SHOPIFY_CUSTOMER_AUTH_TOKEN)
+      localStorage.delete('customerCompanyId')
+      await authModule.signOutFromShopifyCustomerAccounts()
+      await get().config.resetStore()
+    },
+    fetchCustomerAccountsAccessToken: async (code, verifier) => {
+      const authModule = get().modules.getModule<IShopifyAuthProvider>('auth')
+      const res = await authModule.fetchCustomerAccountsAccessToken(
+        code,
+        verifier
+      )
+      if (res.status === 'error') {
+        return {
+          status: 'error',
+          error: {
+            message: 'Failed to fetch customer accounts access token',
+            code: `${res.error}`,
+            rootCause: 'Fetch customer accounts access token API failed.',
+          },
+        }
+      }
+      if (res.status !== 'idle') {
+        return {
+          status: 'error',
+          error: {
+            message: 'Unknown error occurred',
+            code: 'UNKNOWN_ERROR',
+            rootCause: `Fetch customer accounts access token API failed.- ${res.status}`,
+          },
+        }
+      }
+      const tokenData = res.data
+      setCustomerAccountsAccessToken(tokenData)
+      await get().user.fetchCustomerAccountsCompanyId(tokenData.access_token)
+      return {
+        status: 'idle',
+        success: 'Customer accounts access token obtained successfully',
+        data: tokenData,
+      }
+    },
+    fetchCustomerAccountsCompanyId: async (token: string) => {
+      const authModule = get().modules.getModule<IShopifyAuthProvider>('auth')
+      const { status, data } = await authModule.getCompanyLocationId(token)
+      if (!data) {
+        return {
+          status: 'error',
+          error: {
+            message: 'Failed to obtain company location id',
+            code: `${status}`,
+            rootCause: 'Obtain company location id API failed.',
+          },
+        }
+      }
+      const companyLocationId =
+        data?.customer?.companyContacts?.edges?.[0]?.node?.company?.locations
+          ?.edges?.[0]?.node?.id
+      if (!companyLocationId) {
+        return {
+          status: 'error',
+          error: {
+            message: 'Failed to fetch company location id',
+            code: `${status}`,
+            rootCause: 'Obtain company location id response incorect.',
+          },
+        }
+      }
+      set((userSlice) => {
+        userSlice.user.data.customerCompanyId = {
+          status: 'idle',
+          data: { companyLocationId },
+        }
+      })
+      localStorage.set('customerCompanyId', {
+        companyLocationId,
+      })
+      await get().config.resetStore()
+      return {
+        status: 'idle',
+        success: 'Company location id obtained successfully',
+        data: { companyLocationId },
+      }
+    },
+    getLoginCredentialsFromToken: async (token) => {
+      const authModule = get().modules.getModule<IShopifyAuthProvider>('auth')
+      const res = await authModule.getLoginCredentialsFromToken(token)
+      if (res.status === 'error') {
+        return {
+          status: 'error',
+          error: {
+            message: 'Failed to fetch login credentials',
+            code: `${res.error}`,
+            rootCause: 'Fetch login credentials API failed.',
+          },
+        }
+      }
+      if (res.status !== 'idle') {
+        return {
+          status: 'error',
+          error: {
+            message: 'Unknown error occurred',
+            code: 'UNKNOWN_ERROR',
+            rootCause: `Fetch login credentials API failed.- ${res.status}`,
+          },
+        }
+      }
+      return { status: 'idle', data: res.data }
+    },
+    signInUsingCustomerAccountToken: async (token) => {
+      if (!token) {
+        return {
+          status: 'error',
+          error: {
+            message: 'Token is not defined',
+            code: 'TOKEN_UNDEFINED',
+          },
+        }
+      }
+      const loginCredentialsRes = await get().user.getLoginCredentialsFromToken(
+        token
+      )
+
+      if (loginCredentialsRes.status === 'error') {
+        return {
+          status: 'error',
+          error: {
+            message: loginCredentialsRes.error?.message || 'Invalid token',
+            code: 'INVALID_TOKEN',
+          },
+        }
+      }
+
+      if (loginCredentialsRes.status !== 'idle') {
+        return {
+          status: 'error',
+          error: {
+            message:
+              'Unknown error occurred during sign in using customer account',
+            code: 'UNKNOWN_ERROR',
+          },
+        }
+      }
+      const loginCredentials = loginCredentialsRes.data
+      const isSignedIn = await get().user.initiateSigninForVerifiedUser({
+        email: loginCredentials?.email,
+        passKey: loginCredentials?.passKey,
+        multipassToken: loginCredentials?.multipassToken,
+        activationUrl: loginCredentials?.activationUrl,
+      })
+
+      if (isSignedIn?.error) {
+        return {
+          status: 'error',
+          error: {
+            message:
+              typeof isSignedIn.error === 'string'
+                ? isSignedIn.error
+                : 'Sign in failed',
+            code: 'SIGN_IN_FAILED',
+          },
+        }
+      }
+      return {
+        status: 'idle',
+        data: {
+          success: 'Sign in successful',
+        },
+      }
+    },
+  },
+})
+
+async function onSignInSuccess(
+  customerUserErrors: Array<any>,
+  customerAccessToken: CustomerAccessToken,
+  set: any,
+  get: any,
+  provider?: string,
+  customerProps?: {
+    link_existing_account?: boolean
+    new_customer?: boolean
+  }
+) {
+  if (customerUserErrors.length > 0) {
+    const errorCode = customerUserErrors[0].code
+      ?.toUpperCase()
+      ?.replace(/\s+/g, '_')
+    const customErrorMessage =
+      get().config.data?.settings?.messages?.[`AUTH_ERROR_${errorCode}`]
+    return { error: customErrorMessage ?? customerUserErrors[0].message }
+  }
+
+  if (!customerAccessToken || !customerAccessToken.accessToken)
+    return {
+      error: 'Access token is undefined',
+    }
+
+  try {
+    if (get()?.modules?.isModuleDefined('checkout')) {
+      get()?.modules?.getModule('checkout')?.onSignIn()
+    }
+  } catch (err) {
+    console.error('Error in checkout onSignIn function', err)
+  }
+
+  localStorage.set(
+    'customerAccessToken',
+    customerAccessToken as unknown as JsonObject
+  )
+  set((userSlice: any) => {
+    userSlice.user.data.customerAccessToken = {
+      status: 'idle',
+      data: customerAccessToken,
+    }
+  })
+  const { customerDetails } = await get().user.getUserDetails()
+
+  await updateUserAddressByCountry({ userDetails: customerDetails })
+  const analytics = getAnalyticsProvider(get)
+  try {
+    const rewards = get().modules.getModule<Rewards>('rewards')
+    rewards &&
+      rewards.onSignin &&
+      rewards.onSignin(customerAccessToken.accessToken, customerDetails.email)
+  } catch (err) {
+    console.error(err)
+  }
+
+  const analyticsPayload: any = { method: provider }
+  if (customerProps?.new_customer) {
+    analyticsPayload['new_customer'] = 'true'
+    analytics.sendEvent(AnalyticsEvent.SIGNUP, analyticsPayload)
+  }
+  if (customerProps?.link_existing_account) {
+    analyticsPayload['link_existing_account'] = 'true'
+  }
+  analytics.sendEvent(AnalyticsEvent.LOGIN, analyticsPayload)
+
+  const eventEmitter = EventEmitter.getInstance()
+  eventEmitter.publish(EVENTS.SIGNIN_SUCCESS, {
+    customerDetails: customerDetails,
+    customerAccessToken: customerAccessToken.accessToken,
+    acceptsMarketing: customerDetails.acceptsMarketing,
+  })
+
+  return { success: 'Sign in successfully' }
+}
+
+async function onSigninWithMultipass(
+  multipassToken: string,
+  authModule: IShopifyAuthProvider,
+  get: any,
+  set: any,
+  provider?: string,
+  customerProps?: {
+    link_existing_account?: boolean
+    new_customer?: boolean
+  }
+) {
+  const { data, status, error } =
+    await authModule.createCustomerAccessTokenUsingMultipass(multipassToken)
+  if (status === 'error' && error) {
+    return error
+  }
+  const { customerUserErrors, customerAccessToken } =
+    data.customerAccessTokenCreateWithMultipass
+  return await onSignInSuccess(
+    customerUserErrors,
+    customerAccessToken,
+    set,
+    get,
+    provider,
+    customerProps
+  )
+}
+
+async function onSigninWithoutMultipass(
+  email: string,
+  passKey: string,
+  authModule: IShopifyAuthProvider,
+  get: any,
+  set: any,
+  provider?: string,
+  customerProps?: {
+    link_existing_account?: boolean
+    new_customer?: boolean
+  }
+) {
+  const { data, status, error } = await authModule.createCustomerAccessToken({
+    email,
+    password: passKey,
+  })
+  if (status === 'error' && error) {
+    return error
+  }
+  const { customerUserErrors, customerAccessToken } =
+    data.customerAccessTokenCreate
+  return await onSignInSuccess(
+    customerUserErrors,
+    customerAccessToken,
+    set,
+    get,
+    provider,
+    customerProps
+  )
+}
+
+async function onSigninWithActivationUrl(
+  activationUrl: string,
+  passKey: string,
+  authModule: IShopifyAuthProvider,
+  get: any,
+  set: any,
+  provider?: string,
+  customerProps?: {
+    link_existing_account?: boolean
+    new_customer?: boolean
+  }
+) {
+  const { data, status, error } =
+    await authModule.createCustomerAccessTokenUsingActivationUrl(
+      activationUrl,
+      passKey
+    )
+  if (status === 'error' && error) {
+    return error
+  }
+  const { customerUserErrors, customerAccessToken } = data.customerActivateByUrl
+  return await onSignInSuccess(
+    customerUserErrors,
+    customerAccessToken,
+    set,
+    get,
+    provider,
+    customerProps
+  )
+}
+
+function mapUserOrders(customer: any): Order[] {
+  if (!customer.orders?.edges) return []
+  return (
+    customer.orders?.edges?.map((order: any) => {
+      return {
+        id: order.node.id,
+        number: order.node.orderNumber,
+        name: order.node.name,
+        currency: order.node.currencyCode,
+        subTotal: order.node.currentSubtotalPrice.amount,
+        total: order.node.totalPrice.amount,
+        fulfillments: null,
+        fulfillmentStatus: order.node.fulfillmentStatus,
+        refundedAmount: order.node?.totalRefunded?.amount,
+        cancelReason: order.node.cancelReason,
+        canceledAt: order.node.canceledAt,
+        lineItems:
+          order.node.lineItems.edges.map((item: any) => {
+            if (!item.node.variant)
+              return {
+                productId: null,
+                quantity: item.node.currentQuantity,
+                orderedQuantity: item.node.quantity,
+                price: item.node.discountedTotalPrice.amount,
+                title: `${item.node.title}`,
+                originalPrice: item.node.originalTotalPrice.amount,
+              }
+            return {
+              id: item.node.variant.id,
+              productId: item?.node?.variant?.product?.id ?? null,
+              variantId: item.node.variant.title,
+              quantity: item.node.currentQuantity,
+              orderedQuantity: item.node.quantity,
+              price: item.node.discountedTotalPrice.amount,
+              title: `${item.node.title} - ${item.node.variant.title}`,
+              image: item.node.variant.image?.src, // figure out
+              originalPrice: item.node.originalTotalPrice.amount,
+              productHandle: item?.node?.variant?.product?.handle ?? null,
+            }
+          }) || [],
+      }
+    }) || []
+  )
+}
+
+function setCustomerAccountsAccessToken(token: CustomerAccountsToken) {
+  localStorage.set(
+    SHOPIFY_CUSTOMER_AUTH_TOKEN,
+    JSON.stringify({ ...token, timestamp: Date.now() })
+  )
+}