import type { FC } from 'react' import React, { useCallback, useMemo, useRef, useEffect } from 'react' import * as uuid from 'uuid' import type { useOrderQueue as useOrderQueueType, useQueueStatus as useQueueStatusType, OrderQueueContext, OrderFormContext, } from '@vtex/order-manager' import { TASK_CANCELLED_CODE } from '@vtex/order-manager' import type { AddItemFn, RemoveItemFn, SetManualPriceFn, UpdateQuantityFn, Context as OrderItemsContextType, AddItemItemParam, AddItemsFn, } from './OrderItemsContext' import { OrderItemsContext } from './OrderItemsContext' import { getLocalOrderQueue, popLocalOrderQueue, pushLocalOrderQueue, } from './localOrderQueue' import { adjustForItemInput, isSameItem, mapToOrderFormItem } from '../utils' import type { Item, OrderForm, Totalizer, UpdateQuantityInput, UpdateQuantityMutationVariables, } from '../typings' import type { CreateAddItemsParams } from './createUseAddItems' import { createUseAddItems } from './createUseAddItems' import type { CreateUseSetManualPriceParams } from './createUseSetManualPrice' import { createUseSetManualPrice } from './createUseSetManualPrice' import type { CreateUseUpdateQuantityParams } from './createUseUpdateQuantity' import { createUseUpdateQuantity } from './createUseUpdateQuantity' import { updateTotalizersAndValue } from './updateTotalizersAndValue' import type { UseLogger } from './logger' const noop = async () => {} interface Task { execute: () => Promise rollback?: () => void id?: string } const useEnqueueTask = ({ useOrderForm, useLogger, useOrderQueue, useQueueStatus, }: { useOrderForm: () => OrderFormContext useLogger: UseLogger useOrderQueue: () => OrderQueueContext useQueueStatus: typeof useQueueStatusType }) => { const { log } = useLogger() const { enqueue } = useOrderQueue() const queueStatusRef = useQueueStatus() const { setOrderForm } = useOrderForm() const enqueueTask = useCallback<(task: Task) => PromiseLike>( (task) => enqueue(task.execute, task.id).then( (orderForm) => { popLocalOrderQueue(0, log) if (queueStatusRef.current === 'Fulfilled') { setOrderForm(orderForm) } else { setOrderForm((prevOrderForm: OrderForm) => ({ ...prevOrderForm, messages: { ...orderForm.messages, generalMessages: orderForm.messages?.generalMessages, }, })) } }, (error: any) => { if (error && error.code === TASK_CANCELLED_CODE) { popLocalOrderQueue(error.index, log) return } popLocalOrderQueue(0, log) log({ type: 'Error', level: 'Critical', event: error, workflowType: 'OrderItems', workflowInstance: 'enqueue-task-error', }) throw error } ), [enqueue, queueStatusRef, setOrderForm, log] ) return enqueueTask } interface FakeUniqueIdMap { [fakeUniqueId: string]: string } function useFakeUniqueIdMap({ useOrderQueue, }: { useOrderQueue: typeof useOrderQueueType }) { const fakeUniqueIdMapRef = useRef({}) const { listen } = useOrderQueue() useEffect( () => listen('Fulfilled', () => { // avoid leaking "fake" `uniqueId`. // this works because everytime we fulfill the queue, we know // for sure that we won't have any locally generated uniqueId's // left to map to a real uniqueId. fakeUniqueIdMapRef.current = {} }), [listen] ) return fakeUniqueIdMapRef } export interface OrderItemsProviderProps extends CreateUseSetManualPriceParams, CreateUseUpdateQuantityParams, CreateAddItemsParams { useOrderForm: () => OrderFormContext useLogger: UseLogger useOrderQueue: typeof useOrderQueueType useQueueStatus: typeof useQueueStatusType } export function createOrderItemsProvider({ useMutateAddItems, useMutateUpdateQuantity, useMutateSetManualPrice, useOrderForm, useLogger, useOrderQueue, useQueueStatus, }: OrderItemsProviderProps) { const useAddItem = createUseAddItems({ useMutateAddItems, useOrderForm }) const useSetManualPrice = createUseSetManualPrice({ useMutateSetManualPrice, }) const useUpdateQuantity = createUseUpdateQuantity({ useMutateUpdateQuantity, useOrderForm, }) const OrderItemsProvider: FC = ({ children }) => { const { orderForm, setOrderForm } = useOrderForm() const { log } = useLogger() const fakeUniqueIdMapRef = useFakeUniqueIdMap({ useOrderQueue }) const enqueueTask = useEnqueueTask({ useOrderForm, useLogger, useOrderQueue, useQueueStatus, }) const addItemsTask = useAddItem(fakeUniqueIdMapRef) const updateItemsTask = useUpdateQuantity(fakeUniqueIdMapRef) const setManualPriceTask = useSetManualPrice() const orderFormItemsRef = useRef(orderForm.items) useEffect(() => { orderFormItemsRef.current = orderForm.items }, [orderForm.items]) const updateQuantity = useCallback( async (input, options) => { let index: number let uniqueId = '' const currentOrderFormItems = orderFormItemsRef.current if (input.id) { index = currentOrderFormItems.findIndex((orderItem) => isSameItem(input, orderItem, currentOrderFormItems) ) } else if (input.uniqueId) { uniqueId = input.uniqueId index = currentOrderFormItems.findIndex( (orderItem) => orderItem.uniqueId === input.uniqueId ) } else { index = input?.index ?? -1 } if (index < 0 || index >= currentOrderFormItems.length) { throw new Error(`Item ${input.id ?? input.uniqueId} not found`) } if (!uniqueId) { uniqueId = currentOrderFormItems[index].uniqueId } const quantity = input.quantity ?? 1 setOrderForm((prevOrderForm) => { const updatedItems = prevOrderForm.items.slice() const oldItem = updatedItems[index] const newItem = { ...oldItem, quantity, } if (quantity > 0) { updatedItems[index] = newItem } else { updatedItems.splice(index, 1) } return { ...prevOrderForm, ...updateTotalizersAndValue({ totalizers: prevOrderForm.totalizers as Totalizer[], currentValue: prevOrderForm.value, newItem, oldItem, }), items: updatedItems, } }) let mutationVariables: UpdateQuantityMutationVariables let id = uuid.v4() if (quantity > 0) { const localQueue = getLocalOrderQueue(log).queue let previousTaskIndex = -1 const originalId = id // Skip the first element in the queue (which is currently being executed) // because we can't cancel an in-progress task. for (let i = 1; i < localQueue.length; i++) { const task = localQueue[i] if ( task.type === 'update_mutation' && task.variables.orderItems.every( (itemInput) => itemInput.quantity > 0 ) ) { // If we find an update-only mutation (without removed items) // we will re-use it's id so we minimize the number of updates // to send to the API previousTaskIndex = i id = task.id! } else { // If we find any other kind of request we need to reset our // `previousTaskIndex` and `id` because we can't rely on the indexes // of the operations done before this task. For example, assume the // following cart: // // [{ id: 1, quantity: 2 }, { id: 2, quantity: 3 }, { id: 3, quantity: 1 }] // // If we update the second item's quantity to 1, then remove the first // item and update the third item quantity to 2, we can't "join" the first // and last updates, because the indexes will have been shifted due to // the second item being removed (and the API rely on the index of the items, // even though we send the unique id). The same could happen if we add one // item and the cart isn't using the default "add_time" sort algorithm. previousTaskIndex = -1 id = originalId } } const previousTask = previousTaskIndex === -1 ? undefined : localQueue[previousTaskIndex] const previousTaskItems = previousTask?.type === 'update_mutation' ? previousTask.variables.orderItems : [] const itemIndexInPreviousTask = previousTaskItems.findIndex( (prevInput) => 'uniqueId' in prevInput ? prevInput.uniqueId === uniqueId : prevInput.index === index ) let itemInput: UpdateQuantityInput = { uniqueId, quantity } if ('index' in input) { itemInput = { index, quantity } } mutationVariables = { allowedOutdatedData: options?.allowedOutdatedData, splitItem: options?.splitItem, orderItems: itemIndexInPreviousTask > -1 ? previousTaskItems.map((prevInput, prevInputIndex) => prevInputIndex === itemIndexInPreviousTask ? itemInput : prevInput ) : previousTaskItems.concat([itemInput]), } } else { mutationVariables = { allowedOutdatedData: options?.allowedOutdatedData, splitItem: options?.splitItem, orderItems: [{ uniqueId, quantity }], } } pushLocalOrderQueue( { id, type: 'update_mutation', variables: mutationVariables, orderFormItems: currentOrderFormItems, }, log ) return enqueueTask( updateItemsTask({ items: mutationVariables.orderItems, orderFormItems: currentOrderFormItems, id, allowedOutdatedData: options?.allowedOutdatedData, splitItem: options?.splitItem, }) ) }, [enqueueTask, log, setOrderForm, updateItemsTask] ) /** * Add the items to the order form. * In case of an item already in the cart, it increments its quantity. */ const addItems = useCallback( async (items, options) => { const { salesChannel, marketingData, allowedOutdatedData, splitItem } = options ?? {} const { newItems, updatedItems } = items.reduce< Record >( (acc, item) => { const { newItems: newList, updatedItems: updateList } = acc // assembly items are always different const isAssemblyItem = item.options && item.options.length > 0 const existingItem = isAssemblyItem ? undefined : orderFormItemsRef.current.find((i) => isSameItem(item, i, items) ) if (existingItem == null) { newList.push(item) } else { updateList.push({ ...item, quantity: (item.quantity ?? 1) + existingItem!.quantity, }) } return acc }, { newItems: [], updatedItems: [] } ) const updatedItemsPromises: Array> = [] if (updatedItems.length) { updatedItems.forEach((item) => { const updatedItemPromise = updateQuantity(item, { allowedOutdatedData, splitItem, }) updatedItemsPromises.push(updatedItemPromise) }) } if (newItems.length === 0) { return Promise.all(updatedItemsPromises).then(noop) } const mutationInputItems = newItems.map(adjustForItemInput) const orderFormItems = newItems.map((cartItem, index) => mapToOrderFormItem(mutationInputItems[index], cartItem) ) setOrderForm((prevOrderForm) => { return { ...prevOrderForm, items: [...orderFormItemsRef.current, ...orderFormItems], totalizers: orderFormItems.reduce( (totalizers: Totalizer[], item: Item): Totalizer[] => { return updateTotalizersAndValue({ totalizers, newItem: item }) .totalizers }, (prevOrderForm.totalizers as Totalizer[]) ?? [] ), marketingData: marketingData ?? prevOrderForm.marketingData, value: prevOrderForm.value + orderFormItems.reduce( (total, item) => total + item.sellingPrice! * item.quantity, 0 ), } }) pushLocalOrderQueue( { type: 'add_mutation', variables: { items: mutationInputItems, marketingData, salesChannel, allowedOutdatedData, }, orderFormItems, }, log ) const addedItemsPromise = enqueueTask( addItemsTask({ mutationInputItems, mutationInputMarketingData: marketingData, orderFormItems, salesChannel, allowedOutdatedData: options?.allowedOutdatedData, }) ) return Promise.all([...updatedItemsPromises, addedItemsPromise]).then( noop ) }, [addItemsTask, enqueueTask, log, setOrderForm, updateQuantity] ) const addItem = useCallback( (items, marketingData, salesChannel) => { return addItems(items, { marketingData, salesChannel }) }, [addItems] ) const setManualPrice = useCallback( (price, itemIndex) => { const task = setManualPriceTask(price, itemIndex) if (!task) return enqueueTask(task) }, [enqueueTask, setManualPriceTask] ) const removeItem = useCallback( (input, options) => updateQuantity({ ...input, quantity: 0 }, options), [updateQuantity] ) const value = useMemo( () => ({ addItem, addItems, updateQuantity, removeItem, setManualPrice }), [addItem, addItems, updateQuantity, removeItem, setManualPrice] ) useEffect(() => { const localOrderQueue = getLocalOrderQueue(log) localOrderQueue.queue.forEach((task) => { if (task.type === 'add_mutation') { enqueueTask( addItemsTask({ mutationInputItems: task.variables.items, mutationInputMarketingData: task.variables.marketingData, orderFormItems: task.orderFormItems, salesChannel: task.variables.salesChannel, allowedOutdatedData: task.variables.allowedOutdatedData, }) ) } else if (task.type === 'update_mutation') { enqueueTask( updateItemsTask({ items: task.variables.orderItems, orderFormItems: task.orderFormItems, allowedOutdatedData: task.variables.allowedOutdatedData, splitItem: task.variables.splitItem, id: task.id!, }) ) } }) }, [addItemsTask, enqueueTask, log, updateItemsTask]) return ( {children} ) } return { OrderItemsProvider } }