@faststore/api 2.1.9 → 2.1.24

package/dist/platforms/vtex/clients/commerce/index.d.ts

@@ -38,18 +38,12 @@ export declare const VtexCommerce: ({ account, environment, incrementAddress }:
     checkout: {
         simulation: (args: SimulationArgs, { salesChannel }?: SimulationOptions) => Promise<Simulation>;
         incrementAddress: (country: string, postalCode: string) => Promise<IncrementedAddress>;
-        getDeliveryWindows: ({ id, index, deliveryMode, body, }: {
-            id: string;
-            index: number;
-            deliveryMode?: DeliveryMode | null | undefined;
-            body: ShippingDataBody;
-        }, incrementedAddress?: IncrementedAddress | undefined) => Promise<OrderForm>;
         shippingData: ({ id, index, deliveryMode, body, }: {
             id: string;
             index: number;
             deliveryMode?: DeliveryMode | null | undefined;
             body: ShippingDataBody;
-        }, incrementedAddress?: IncrementedAddress | undefined) => Promise<OrderForm>;
+        }, incrementedAddress?: IncrementedAddress | undefined, setDeliveryWindow?: boolean | undefined) => Promise<OrderForm>;
         orderForm: ({ id, refreshOutdatedData, channel, }: {
             id: string;
             refreshOutdatedData?: boolean | undefined;

package/dist/platforms/vtex/clients/commerce/types/OrderForm.d.ts

@@ -271,7 +271,7 @@ export interface SLA {
     shippingEstimateDate: string | null;
     lockTTL: string | null;
     availableDeliveryWindows: AvailableDeliveryWindows[];
-    deliveryWindow: string | null;
+    deliveryWindow: DeliveryWindow | null;
     price: number;
     listPrice: number;
     tax: number;
@@ -287,6 +287,10 @@ export interface SLA {
     polygonName: string | null;
     transitTime: string | null;
 }
+export interface DeliveryWindow {
+    startDateUtc: string;
+    endDateUtc: string;
+}
 export interface AvailableDeliveryWindows {
     startDateUtc: string;
     endDateUtc: string;

package/dist/platforms/vtex/clients/index.d.ts

@@ -30,18 +30,12 @@ export declare const getClients: (options: Options, ctx: Context) => {
         checkout: {
             simulation: (args: import("./commerce/types/Simulation").SimulationArgs, { salesChannel }?: import("./commerce/types/Simulation").SimulationOptions) => Promise<import("./commerce/types/Simulation").Simulation>;
             incrementAddress: (country: string, postalCode: string) => Promise<import("./commerce/types/IncrementedAddress").IncrementedAddress>;
-            getDeliveryWindows: ({ id, index, deliveryMode, body, }: {
-                id: string;
-                index: number;
-                deliveryMode?: import("./commerce/types/ShippingData").DeliveryMode | null | undefined;
-                body: import("./commerce/types/ShippingData").ShippingDataBody;
-            }, incrementedAddress?: import("./commerce/types/IncrementedAddress").IncrementedAddress | undefined) => Promise<import("./commerce/types/OrderForm").OrderForm>;
             shippingData: ({ id, index, deliveryMode, body, }: {
                 id: string;
                 index: number;
                 deliveryMode?: import("./commerce/types/ShippingData").DeliveryMode | null | undefined;
                 body: import("./commerce/types/ShippingData").ShippingDataBody;
-            }, incrementedAddress?: import("./commerce/types/IncrementedAddress").IncrementedAddress | undefined) => Promise<import("./commerce/types/OrderForm").OrderForm>;
+            }, incrementedAddress?: import("./commerce/types/IncrementedAddress").IncrementedAddress | undefined, setDeliveryWindow?: boolean | undefined) => Promise<import("./commerce/types/OrderForm").OrderForm>;
             orderForm: ({ id, refreshOutdatedData, channel, }: {
                 id: string;
                 refreshOutdatedData?: boolean | undefined;

package/dist/platforms/vtex/utils/shouldUpdateShippingData.d.ts

@@ -0,0 +1,3 @@
+import { IStoreSession } from '../../../__generated__/schema';
+import { OrderForm } from '../clients/commerce/types/OrderForm';
+export declare const shouldUpdateShippingData: (orderForm: OrderForm, session: IStoreSession) => boolean;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@faststore/api",
-  "version": "2.1.9",
+  "version": "2.1.24",
   "license": "MIT",
   "main": "dist/index.js",
   "typings": "dist/index.d.ts",
@@ -56,5 +56,5 @@
     "@envelop/core": "^1 || ^2",
     "graphql": "^15.6.0"
   },
-  "gitHead": "e8c0051ff4e990fcf9375bc8a22f76570967e1af"
+  "gitHead": "38bb4d96f41615c87fe93b6b88e6b0e8d034b97e"
 }

package/src/platforms/vtex/clients/commerce/index.ts

@@ -113,7 +113,7 @@ export const VtexCommerce = (
           : Promise.resolve(undefined)
       },
 
-      getDeliveryWindows: (
+      shippingData: (
         {
           id,
           index,
@@ -125,76 +125,47 @@ export const VtexCommerce = (
           deliveryMode?: DeliveryMode | null
           body: ShippingDataBody
         },
-        incrementedAddress?: IncrementedAddress
+        incrementedAddress?: IncrementedAddress,
+        setDeliveryWindow?: boolean
       ): Promise<OrderForm> => {
-        const mappedBody = {
-          logisticsInfo: Array.from({ length: index }, (_, itemIndex) => ({
-            itemIndex,
-            selectedDeliveryChannel: deliveryMode?.deliveryChannel || null,
-            selectedSla: deliveryMode?.deliveryMethod || null,
-          })),
-          selectedAddresses: body?.selectedAddresses?.map((address) => {
-            const selectedAddress: SelectedAddress = {
-              addressType: address.addressType || null,
-              receiverName: address.receiverName || null,
-              postalCode:
-                address.postalCode || incrementedAddress?.postalCode || null,
-              city: incrementedAddress?.city || null,
-              state: incrementedAddress?.state || null,
-              country: address.country || incrementedAddress?.country || null,
-              street: incrementedAddress?.street || null,
-              number: incrementedAddress?.number || null,
-              neighborhood: incrementedAddress?.neighborhood || null,
-              complement: incrementedAddress?.complement || null,
-              reference: incrementedAddress?.reference || null,
-              geoCoordinates: [], // Initialize with default value
-            }
-
-            const longitude =
-              address?.geoCoordinates instanceof Array
-                ? null
-                : address?.geoCoordinates?.longitude || null
+        const addressSession = body?.selectedAddresses?.map((address) => {
+          const addressSession: SelectedAddress = {
+            addressType: address.addressType || null,
+            receiverName: address.receiverName || null,
+            postalCode:
+              address.postalCode || incrementedAddress?.postalCode || null,
+            city: incrementedAddress?.city || null,
+            state: incrementedAddress?.state || null,
+            country: address.country || incrementedAddress?.country || null,
+            street: incrementedAddress?.street || null,
+            number: incrementedAddress?.number || null,
+            neighborhood: incrementedAddress?.neighborhood || null,
+            complement: incrementedAddress?.complement || null,
+            reference: incrementedAddress?.reference || null,
+            geoCoordinates: [], // Initialize with default value
+          }
 
+          const geoCoordinates = address?.geoCoordinates
+          if (geoCoordinates) {
             const latitude =
-              address?.geoCoordinates instanceof Array
-                ? null
-                : address?.geoCoordinates?.latitude || null
+              typeof geoCoordinates === 'object' && 'latitude' in geoCoordinates
+                ? geoCoordinates.latitude
+                : null
+            const longitude =
+              typeof geoCoordinates === 'object' &&
+              'longitude' in geoCoordinates
+                ? geoCoordinates.longitude
+                : null
 
-            selectedAddress.geoCoordinates =
-              longitude && latitude
-                ? { longitude, latitude }
+            addressSession.geoCoordinates =
+              latitude !== null && longitude !== null
+                ? [longitude, latitude]
                 : incrementedAddress?.geoCoordinates || []
-
-            return selectedAddress
-          }),
-        }
-
-        return fetchAPI(
-          `${base}/api/checkout/pub/orderForm/${id}/attachments/shippingData`,
-          {
-            ...BASE_INIT,
-            body: JSON.stringify(mappedBody),
           }
-        )
-      },
-
-      shippingData: (
-        {
-          id,
-          index,
-          deliveryMode,
-          body,
-        }: {
-          id: string
-          index: number
-          deliveryMode?: DeliveryMode | null
-          body: ShippingDataBody
-        },
-        incrementedAddress?: IncrementedAddress
-      ): Promise<OrderForm> => {
-        const hasDeliveryWindow = deliveryMode?.deliveryWindow ? true : false
+          return addressSession
+        })
 
-        const deliveryWindow = hasDeliveryWindow
+        const deliveryWindow = setDeliveryWindow
           ? {
               startDateUtc: deliveryMode?.deliveryWindow?.startDate,
               endDateUtc: deliveryMode?.deliveryWindow?.endDate,
@@ -208,40 +179,8 @@ export const VtexCommerce = (
             selectedSla: deliveryMode?.deliveryMethod || null,
             deliveryWindow: deliveryWindow,
           })),
-          selectedAddresses: body?.selectedAddresses?.map((address) => {
-            const selectedAddress: SelectedAddress = {
-              addressType: address.addressType || null,
-              receiverName: address.receiverName || null,
-              postalCode:
-                address.postalCode || incrementedAddress?.postalCode || null,
-              city: incrementedAddress?.city || null,
-              state: incrementedAddress?.state || null,
-              country: address.country || incrementedAddress?.country || null,
-              street: incrementedAddress?.street || null,
-              number: incrementedAddress?.number || null,
-              neighborhood: incrementedAddress?.neighborhood || null,
-              complement: incrementedAddress?.complement || null,
-              reference: incrementedAddress?.reference || null,
-              geoCoordinates: [], // Initialize with default value
-            }
-
-            const longitude =
-              address?.geoCoordinates instanceof Array
-                ? null
-                : address?.geoCoordinates?.longitude || null
-
-            const latitude =
-              address?.geoCoordinates instanceof Array
-                ? null
-                : address?.geoCoordinates?.latitude || null
-
-            selectedAddress.geoCoordinates =
-              longitude && latitude
-                ? [longitude, latitude]
-                : incrementedAddress?.geoCoordinates || []
-
-            return selectedAddress
-          }),
+          selectedAddresses: addressSession,
+          address: addressSession,
         }
 
         return fetchAPI(

package/src/platforms/vtex/clients/commerce/types/OrderForm.ts

@@ -288,7 +288,7 @@ export interface SLA {
   shippingEstimateDate: string | null
   lockTTL: string | null
   availableDeliveryWindows: AvailableDeliveryWindows[]
-  deliveryWindow: string | null
+  deliveryWindow: DeliveryWindow  | null
   price: number
   listPrice: number
   tax: number
@@ -305,6 +305,11 @@ export interface SLA {
   transitTime: string | null
 }
 
+export interface DeliveryWindow {
+  startDateUtc: string
+  endDateUtc: string
+}
+
 export interface AvailableDeliveryWindows {
   startDateUtc: string,
   endDateUtc: string,

package/src/platforms/vtex/resolvers/validateCart.ts

@@ -24,6 +24,7 @@ import type {
   OrderFormItem,
 } from '../clients/commerce/types/OrderForm'
 import { IncrementedAddress } from '../clients/commerce/types/IncrementedAddress'
+import { shouldUpdateShippingData } from '../utils/shouldUpdateShippingData'
 
 type Indexed<T> = T & { index?: number }
 
@@ -234,21 +235,11 @@ const getOrderForm = async (
     return orderForm
   }
 
-  const shouldUpdateShippingData =
-    orderForm.items.length > 0 &&
-    (typeof session.postalCode === 'string' &&
-      orderForm.shippingData?.address?.postalCode !== session.postalCode) ||
-    (typeof session.geoCoordinates === 'object' &&
-      typeof session.geoCoordinates?.latitude === 'number' &&
-      typeof session.geoCoordinates.longitude === 'number' &&
-      (orderForm.shippingData?.address?.geoCoordinates[0] !==
-        session.geoCoordinates.longitude ||
-        orderForm.shippingData?.address?.geoCoordinates[1] !==
-          session.geoCoordinates.latitude)) 
-
-  if (shouldUpdateShippingData) {
+  const updateShipping = shouldUpdateShippingData(orderForm, session)
+
+  if (updateShipping) {
     let incrementedAddress: IncrementedAddress | undefined
-    
+
     if (session.postalCode) {
       incrementedAddress = await commerce.checkout.incrementAddress(
         session.country,
@@ -261,7 +252,7 @@ const getOrderForm = async (
 
     if (hasDeliveryWindow) {
       // if you have a Delivery Window you have to first get the delivery window to set the desired after
-      await commerce.checkout.getDeliveryWindows(
+      await commerce.checkout.shippingData(
         {
           id: orderForm.orderFormId,
           index: orderForm.items.length,
@@ -270,10 +261,11 @@ const getOrderForm = async (
             selectedAddresses: [session],
           },
         },
-        incrementedAddress
+        incrementedAddress,
+        false
       )
     }
-    
+
     return commerce.checkout.shippingData(
       {
         id: orderForm.orderFormId,
@@ -283,7 +275,8 @@ const getOrderForm = async (
           selectedAddresses: [session],
         },
       },
-      incrementedAddress
+      incrementedAddress,
+      true
     )
   }
 
@@ -340,7 +333,16 @@ export const validateCart = async (
   // Step1: Get OrderForm from VTEX Commerce
   const orderForm = await getOrderForm(orderNumber, session, ctx)
 
-  // Step1.5: Check if another system changed the orderForm with this orderNumber
+  // Step1.1: Checks if the orderForm id has changed. There are three cases for this:
+  // Social Selling: the vtex_session cookie contains a new orderForm id with Social Selling data
+  // My Orders: the customer clicks on reordering through generating a new cart and when returning to the faststore, this information needs to be returned by vtex_session cookie.
+  // New session: a new user enters the website and has no orderForm attributed to it (has no relation to the vtex_session cookie).
+  // In all cases, the origin orderForm should replace the copy that's in the browser
+  if (orderForm.orderFormId != orderNumberFromCart) {
+    return orderFormToCart(orderForm, skuLoader)
+  }
+
+  // Step1.2: Check if another system changed the orderForm with this orderNumber
   // If so, this means the user interacted with this cart elsewhere and expects
   // to see this new cart state instead of what's stored on the user's browser.
   const isStale = isOrderFormStale(orderForm)

package/src/platforms/vtex/utils/shouldUpdateShippingData.ts

@@ -0,0 +1,155 @@
+import {
+  IStoreGeoCoordinates,
+  IStoreSession,
+} from '../../../__generated__/schema'
+import {
+  CheckoutAddress,
+  OrderForm,
+  LogisticsInfo,
+} from '../clients/commerce/types/OrderForm'
+
+export const shouldUpdateShippingData = (
+  orderForm: OrderForm,
+  session: IStoreSession
+) => {
+  if (!hasSessionPostalCodeOrGeoCoordinates(session)) {
+    return false
+  }
+
+  const { address } = orderForm.shippingData ?? { address: null }
+
+  if (checkPostalCode(address, session.postalCode)) {
+    return true
+  }
+
+  if (checkGeoCoordinates(address, session.geoCoordinates)) {
+    return true
+  }
+
+  if (!hasItems(orderForm)) {
+    return false
+  }
+
+  // The logisticsInfo will always exist if there´s at least one item inside the cart
+  const { logisticsInfo } = orderForm.shippingData!
+
+  if (shouldUpdateDeliveryChannel(logisticsInfo, session)) {
+    return true
+  }
+
+  if (shouldUpdateDeliveryMethod(logisticsInfo, session)) {
+    return true
+  }
+
+  if (shouldUpdateDeliveryWindow(logisticsInfo, session)) {
+    return true
+  }
+  return false
+}
+
+// Validate if theres any postal Code or GeoCoordinates set at the session
+const hasSessionPostalCodeOrGeoCoordinates = (session: IStoreSession) => {
+  return (
+    !!session.postalCode ||
+    (session.geoCoordinates &&
+      session.geoCoordinates.latitude &&
+      session.geoCoordinates.longitude)
+  )
+}
+
+// Validate if theres a difference between the session postal code and orderForm postal code
+const checkPostalCode = (
+  address: CheckoutAddress | null | undefined,
+  postalCode: string | null | undefined
+) => {
+  return typeof postalCode === 'string' && address?.postalCode !== postalCode
+}
+
+// Validate if theres a difference between the session geoCoords and orderForm geoCoords
+const checkGeoCoordinates = (
+  address: CheckoutAddress | null | undefined,
+  geoCoordinates: IStoreGeoCoordinates | null | undefined
+) => {
+  return (
+    typeof geoCoordinates?.latitude === 'number' &&
+    typeof geoCoordinates?.longitude === 'number' &&
+    (address?.geoCoordinates[0] !== geoCoordinates?.longitude ||
+      address?.geoCoordinates[1] !== geoCoordinates?.latitude)
+  )
+}
+
+// Validate if theres any item inside the orderForm
+const hasItems = (orderForm: OrderForm) => {
+  return orderForm.items.length !== 0
+}
+
+// Validate if the deliveryChannel from the session is different from the selected delivery channel
+// and if so needs to validate if the deliveryChannel for the session is available inside the slas for the item
+const shouldUpdateDeliveryChannel = (
+  logisticsInfo: LogisticsInfo[],
+  session: IStoreSession | null | undefined
+) => {
+  if (!session?.deliveryMode?.deliveryChannel) {
+    return false
+  }
+  const { deliveryChannel } = session.deliveryMode
+  for (const item of logisticsInfo) {
+    if (item.selectedDeliveryChannel !== deliveryChannel) {
+      const matchingSla = item.slas.find(
+        (sla) => sla.deliveryChannel === deliveryChannel
+      )
+      if (matchingSla) {
+        return true
+      }
+    }
+  }
+  return false
+}
+
+// Validate if the deliveryMethod from the session is different from the selectedSLA
+// and if so needs to validate if the deliveryMethod for the session is available inside the slas for the item
+const shouldUpdateDeliveryMethod = (
+  logisticsInfo: LogisticsInfo[],
+  session: IStoreSession
+) => {
+  if (!session?.deliveryMode?.deliveryMethod) {
+    return false
+  }
+  const { deliveryMethod } = session.deliveryMode
+  for (const item of logisticsInfo) {
+    if (item.selectedSla !== deliveryMethod) {
+      const matchingSla = item.slas.find((sla) => sla.id === deliveryMethod)
+      if (matchingSla) {
+        return true
+      }
+    }
+  }
+  return false
+}
+
+// Validate if the deliveryWindow from the session is different from the deliveryWindow of the SLA
+// and if so needs to validate if the deliveryWindow for the session is available inside the availableDeliveryWindows for the item
+const shouldUpdateDeliveryWindow = (
+  logisticsInfo: LogisticsInfo[],
+  session: IStoreSession
+) => {
+  if (
+    !session?.deliveryMode?.deliveryWindow?.startDate ||
+    !session?.deliveryMode?.deliveryWindow?.endDate
+  ) {
+    return false
+  }
+  const { startDate, endDate } = session.deliveryMode.deliveryWindow
+  for (const item of logisticsInfo) {
+    for (const sla of item.slas) {
+      const matchingWindow = sla.availableDeliveryWindows?.some(
+        (window) =>
+          window.startDateUtc === startDate && window.endDateUtc === endDate
+      )
+      if (matchingWindow) {
+        return true
+      }
+    }
+  }
+  return false
+}