@faststore/core 3.66.0 → 3.68.0

package/src/sdk/deliveryPromise/index.ts

@@ -0,0 +1,22 @@
+export {
+  deliveryPromiseStore,
+  PICKUP_ALL_FACET_VALUE,
+  PICKUP_IN_POINT_FACET_VALUE,
+  PICKUP_POINT_FACET_KEY,
+  SHIPPING_FACET_KEY,
+  useDeliveryPromise,
+} from './useDeliveryPromise'
+export type { DeliveryPromiseStore, PickupPoint } from './useDeliveryPromise'
+
+export { getPickupPoints } from './queries'
+
+export {
+  deliveryPromiseReducer,
+  initializeDeliveryPromiseState,
+  initialPickupPointsSimulation,
+  type DeliveryPromiseReducerAction,
+  type DeliveryPromiseReducerState,
+  type PickupPointsSimulation,
+} from './reducer'
+
+export { DeliveryPromiseProvider, useDeliveryPromiseContext } from './provider'

package/src/sdk/deliveryPromise/provider.tsx

@@ -0,0 +1,119 @@
+import deepEquals from 'fast-deep-equal'
+import type { Dispatch, PropsWithChildren } from 'react'
+import {
+  createContext,
+  useContext,
+  useEffect,
+  useMemo,
+  useReducer,
+} from 'react'
+
+import { useSession } from 'src/sdk/session'
+
+import {
+  deliveryPromiseReducer,
+  deliveryPromiseStore,
+  getPickupPoints,
+  initialPickupPointsSimulation,
+  initializeDeliveryPromiseState,
+  type DeliveryPromiseReducerAction,
+  type DeliveryPromiseReducerState,
+} from '.'
+
+type Context = DeliveryPromiseReducerState & {
+  dispatchDeliveryPromiseAction: Dispatch<DeliveryPromiseReducerAction>
+}
+
+const DeliveryPromiseContext = createContext<Context | undefined>(undefined)
+
+export function DeliveryPromiseProvider({
+  children,
+}: PropsWithChildren<unknown>) {
+  const { postalCode, geoCoordinates } = useSession()
+  const [state, dispatch] = useReducer(
+    deliveryPromiseReducer,
+    undefined,
+    initializeDeliveryPromiseState
+  )
+
+  useEffect(() => {
+    if (!postalCode || !state.shouldUpdatePickupPoints) {
+      return
+    }
+
+    async function fetchPickupPoints() {
+      const newPickupPoints = await getPickupPoints({
+        geoCoordinates:
+          state.simulatePickupPoints &&
+          state.pickupPointsSimulation?.geoCoordinates
+            ? state.pickupPointsSimulation.geoCoordinates
+            : geoCoordinates,
+      })
+
+      // Pickup points simulation
+      if (state.simulatePickupPoints) {
+        deliveryPromiseStore.set({
+          pickupPointsSimulation: {
+            ...state.pickupPointsSimulation,
+            pickupPoints: newPickupPoints,
+          },
+          shouldUpdatePickupPoints: false,
+          simulatePickupPoints: false,
+        })
+
+        return
+      }
+
+      // Prevent reset store after reloading the page
+      if (
+        state.pickupPoints.length !== 0 &&
+        deepEquals(state.pickupPoints, newPickupPoints)
+      ) {
+        return
+      }
+
+      // Check if `changeGlobalPickupPoint` action was already triggered
+      // for cases where shopper is changing both postal code and global pickup point
+      const isGlobalPickupPointUpdated = newPickupPoints.some(
+        ({ id }) => id === state.globalPickupPoint?.id
+      )
+
+      deliveryPromiseStore.set({
+        globalPickupPoint: isGlobalPickupPointUpdated
+          ? state.globalPickupPoint
+          : null,
+        defaultPickupPoint: null,
+        pickupPoints: newPickupPoints,
+        pickupPointsSimulation: initialPickupPointsSimulation,
+        simulatePickupPoints: false,
+        shouldUpdatePickupPoints: false,
+      })
+    }
+
+    fetchPickupPoints()
+  }, [state.shouldUpdatePickupPoints, postalCode])
+
+  const value = useMemo(
+    () => ({
+      ...state,
+      dispatchDeliveryPromiseAction: dispatch,
+    }),
+    [state]
+  )
+
+  return (
+    <DeliveryPromiseContext.Provider value={value}>
+      {children}
+    </DeliveryPromiseContext.Provider>
+  )
+}
+
+export function useDeliveryPromiseContext() {
+  const context = useContext(DeliveryPromiseContext)
+
+  if (context === undefined) {
+    throw new Error('Missing Delivery Promise context on React tree')
+  }
+
+  return context
+}

package/src/sdk/deliveryPromise/queries.ts

@@ -0,0 +1,80 @@
+import { gql } from '@generated'
+import type {
+  ClientPickupPointsQueryQuery as ClientPickupPointsQuery,
+  ClientPickupPointsQueryQueryVariables as ClientPickupPointsQueryVariables,
+} from '@generated/graphql'
+
+import { deliveryPromise } from 'discovery.config'
+import { request } from 'src/sdk/graphql/request'
+
+const pickupPointsQuery = gql(`
+  query ClientPickupPointsQuery(
+    $geoCoordinates: IStoreGeoCoordinates
+  ) {
+    pickupPoints(geoCoordinates: $geoCoordinates) {
+      pickupPointDistances {
+        pickupId
+        distance
+        pickupName
+        isActive
+        address {
+          city
+          state
+          number
+          postalCode
+          street
+        }
+      }
+    }
+  }
+`)
+
+type GetPickupPointsProps = {
+  geoCoordinates: {
+    latitude: number
+    longitude: number
+  } | null
+}
+
+export const getPickupPoints = async ({
+  geoCoordinates,
+}: GetPickupPointsProps) => {
+  if (!deliveryPromise.enabled) {
+    return []
+  }
+
+  if (!geoCoordinates) {
+    return []
+  }
+
+  const variables = {
+    geoCoordinates: geoCoordinates ?? undefined,
+  }
+
+  const data = await request<
+    ClientPickupPointsQuery,
+    ClientPickupPointsQueryVariables
+  >(pickupPointsQuery, variables)
+
+  if (!data) {
+    return []
+  }
+
+  const pickupPoints = data.pickupPoints?.pickupPointDistances
+    ?.filter((pickupPoint) => pickupPoint.isActive)
+    .map((pickupPoint) => ({
+      id: pickupPoint?.pickupId,
+      name: pickupPoint?.pickupName,
+      totalItems: data.pickupPoints?.pickupPointDistances?.length ?? 0,
+      address: {
+        street: pickupPoint?.address?.street,
+        number: pickupPoint?.address?.number,
+        postalCode: pickupPoint?.address?.postalCode,
+        city: pickupPoint?.address?.city,
+        state: pickupPoint?.address?.state,
+      },
+      distance: pickupPoint?.distance,
+    }))
+
+  return pickupPoints
+}

package/src/sdk/deliveryPromise/reducer.ts

@@ -0,0 +1,137 @@
+import type { Session } from '@faststore/sdk'
+
+import type { PickupPoint } from '.'
+
+export type PickupPointsSimulation = {
+  pickupPoints?: PickupPoint[]
+  geoCoordinates: Session['geoCoordinates'] | null
+}
+
+export const initialPickupPointsSimulation: PickupPointsSimulation = {
+  pickupPoints: [],
+  geoCoordinates: null,
+}
+
+export type DeliveryPromiseReducerState = {
+  pickupPoints?: PickupPoint[]
+  defaultPickupPoint?: PickupPoint
+  globalPickupPoint?: PickupPoint
+  shouldUpdatePickupPoints?: boolean
+  simulatePickupPoints?: boolean
+  pickupPointsSimulation?: PickupPointsSimulation
+}
+
+export type DeliveryPromiseReducerAction =
+  | {
+      type: 'updatePickupPoints'
+      payload: DeliveryPromiseReducerState
+    }
+  | {
+      type: 'changePickupPoint'
+      payload: DeliveryPromiseReducerState['defaultPickupPoint']
+    }
+  | {
+      type: 'changeGlobalPickupPoint'
+      payload: DeliveryPromiseReducerState['globalPickupPoint']
+    }
+  | {
+      type: 'onPostalCodeChange'
+      payload?: {
+        simulatePickupPoints: DeliveryPromiseReducerState['simulatePickupPoints']
+        validatedSession: Partial<Session>
+      }
+    }
+  | {
+      type: 'updateDeliveryPromiseState'
+      payload: DeliveryPromiseReducerState
+    }
+  | {
+      type: 'clearPickupPointsSimulation'
+    }
+
+export const initializeDeliveryPromiseState =
+  (): DeliveryPromiseReducerState => ({
+    pickupPoints: [],
+    defaultPickupPoint: null,
+    globalPickupPoint: null,
+    shouldUpdatePickupPoints: false,
+    simulatePickupPoints: false,
+    pickupPointsSimulation: initialPickupPointsSimulation,
+  })
+
+export const deliveryPromiseReducer = (
+  state: DeliveryPromiseReducerState,
+  action: DeliveryPromiseReducerAction
+): DeliveryPromiseReducerState => {
+  const { type } = action
+
+  switch (type) {
+    case 'updatePickupPoints': {
+      const { payload } = action
+
+      return {
+        ...state,
+        defaultPickupPoint: null,
+        globalPickupPoint: null,
+        pickupPoints: payload.pickupPoints,
+        shouldUpdatePickupPoints: payload.shouldUpdatePickupPoints,
+      }
+    }
+
+    case 'onPostalCodeChange': {
+      if (action.payload) {
+        const {
+          payload: { simulatePickupPoints, validatedSession },
+        } = action
+
+        return {
+          ...state,
+          simulatePickupPoints,
+          pickupPointsSimulation: {
+            ...state.pickupPointsSimulation,
+            geoCoordinates: validatedSession.geoCoordinates,
+          },
+          shouldUpdatePickupPoints: true,
+        }
+      }
+
+      return {
+        ...state,
+        pickupPointsSimulation: initialPickupPointsSimulation,
+        shouldUpdatePickupPoints: true,
+      }
+    }
+
+    case 'changePickupPoint': {
+      const { payload } = action
+
+      return { ...state, defaultPickupPoint: payload }
+    }
+
+    case 'changeGlobalPickupPoint': {
+      const { payload } = action
+
+      return { ...state, globalPickupPoint: payload }
+    }
+
+    case 'updateDeliveryPromiseState': {
+      const { payload } = action
+
+      return {
+        ...state,
+        ...payload,
+      }
+    }
+
+    case 'clearPickupPointsSimulation': {
+      return {
+        ...state,
+        simulatePickupPoints: false,
+        pickupPointsSimulation: initialPickupPointsSimulation,
+      }
+    }
+
+    default:
+      throw new Error(`Action ${type} not implemented`)
+  }
+}