@faststore/api 2.0.156-alpha.0 → 2.0.157-alpha.0

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

@@ -13,8 +13,9 @@ import type { SalesChannel } from './types/SalesChannel';
 import { MasterDataResponse } from './types/Newsletter';
 import type { Address, AddressInput } from './types/Address';
 import { ShippingDataBody } from './types/ShippingData';
+import { IncrementedAddress } from './types/IncrementedAddress';
 declare type ValueOf<T> = T extends Record<string, infer K> ? K : never;
-export declare const VtexCommerce: ({ account, environment }: Options, ctx: Context) => {
+export declare const VtexCommerce: ({ account, environment, incrementAddress }: Options, ctx: Context) => {
     catalog: {
         salesChannel: (sc: string) => Promise<SalesChannel>;
         brand: {
@@ -36,10 +37,11 @@ export declare const VtexCommerce: ({ account, environment }: Options, ctx: Cont
     };
     checkout: {
         simulation: (args: SimulationArgs, { salesChannel }?: SimulationOptions) => Promise<Simulation>;
+        incrementAddress: (country: string, postalCode: string) => Promise<IncrementedAddress>;
         shippingData: ({ id, body, }: {
             id: string;
             body: ShippingDataBody;
-        }) => Promise<OrderForm>;
+        }, incrementedAddress?: IncrementedAddress | undefined) => Promise<OrderForm>;
         orderForm: ({ id, refreshOutdatedData, channel, }: {
             id: string;
             refreshOutdatedData?: boolean | undefined;

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

@@ -0,0 +1,16 @@
+export interface IncrementedAddress {
+    postalCode?: string | null;
+    city?: string | null;
+    state?: string | null;
+    country?: string | null;
+    street?: string | null;
+    number?: string | null;
+    neighborhood?: string | null;
+    complement?: string | null;
+    reference?: string | null;
+    geoCoordinates?: GeoCoordinates | null | [];
+}
+export interface GeoCoordinates {
+    latitude: GLfloat;
+    longitude: GLfloat;
+}

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

@@ -29,10 +29,11 @@ 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>;
             shippingData: ({ id, body, }: {
                 id: string;
                 body: import("./commerce/types/ShippingData").ShippingDataBody;
-            }) => Promise<import("./commerce/types/OrderForm").OrderForm>;
+            }, incrementedAddress?: import("./commerce/types/IncrementedAddress").IncrementedAddress | undefined) => Promise<import("./commerce/types/OrderForm").OrderForm>;
             orderForm: ({ id, refreshOutdatedData, channel, }: {
                 id: string;
                 refreshOutdatedData?: boolean | undefined;

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

@@ -9,6 +9,7 @@ export interface Options {
     channel: string;
     locale: string;
     hideUnavailableItems: boolean;
+    incrementAddress: boolean;
     flags?: FeatureFlags;
 }
 interface FeatureFlags {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@faststore/api",
-  "version": "2.0.156-alpha.0",
+  "version": "2.0.157-alpha.0",
   "license": "MIT",
   "main": "dist/index.js",
   "typings": "dist/index.d.ts",
@@ -49,5 +49,5 @@
   "peerDependencies": {
     "graphql": "^15.6.0"
   },
-  "gitHead": "d24d06c4907a19c8f33cae1812175e393f223340"
+  "gitHead": "2fe3d9c5452955ce2444486eefb015a9b9921ccf"
 }

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

@@ -20,6 +20,7 @@ import type { SalesChannel } from './types/SalesChannel'
 import { MasterDataResponse } from './types/Newsletter'
 import type { Address, AddressInput } from './types/Address'
 import { ShippingDataBody } from './types/ShippingData'
+import { IncrementedAddress } from './types/IncrementedAddress'
 
 
 type ValueOf<T> = T extends Record<string, infer K> ? K : never
@@ -32,7 +33,7 @@ const BASE_INIT = {
 }
 
 export const VtexCommerce = (
-  { account, environment }: Options,
+  { account, environment, incrementAddress }: Options,
   ctx: Context
 ) => {
   const base = `https://${account}.${environment}.com.br`
@@ -91,28 +92,48 @@ export const VtexCommerce = (
           }
         )
       },
+
+      incrementAddress: (
+        country: string,
+        postalCode: string
+      ): Promise<IncrementedAddress> => {
+
+        return incrementAddress
+          ? fetchAPI(`${base}/api/checkout/pub/postal-code/${country}/${postalCode}`, {
+            method: 'GET',
+            headers: {
+              'content-type': 'application/json'
+            },
+          })
+          : Promise.resolve(undefined);
+      },
+
       shippingData: ({
+
         id,
         body,
       }: {
         id: string
         body: ShippingDataBody
-      }): Promise<OrderForm> => {
+      },
+        incrementedAddress?: IncrementedAddress): Promise<OrderForm> => {
+
 
         const mappedBody = {
           "selectedAddresses": body?.selectedAddresses?.map(address => ({
             "addressType": address.addressType || null,
             "receiverName": address.receiverName || null,
-            "postalCode": address.postalCode || null,
-            "city": address.city || null,
-            "state": address.state || null,
-            "country": address.country || null,
-            "street": address.street || null,
-            "number": address.number || null,
-            "neighborhood": address.neighborhood || null,
-            "complement": address.complement || null,
-            "reference": address.reference || null,
-            "geoCoordinates": address.geoCoordinates || []
+            "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": address.geoCoordinates || incrementedAddress?.geoCoordinates || []
+
           }))
         };
 

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

@@ -0,0 +1,17 @@
+export interface IncrementedAddress {
+    postalCode?: string | null;
+    city?: string | null;
+    state?: string | null;
+    country?: string | null;
+    street?: string | null;
+    number?: string | null;
+    neighborhood?: string | null;
+    complement?: string | null;
+    reference?: string | null;
+    geoCoordinates?: GeoCoordinates | null | [];
+}
+
+export interface GeoCoordinates {
+    latitude: GLfloat;
+    longitude: GLfloat;
+}

package/src/platforms/vtex/index.ts

@@ -35,6 +35,7 @@ export interface Options {
   channel: string
   locale: string
   hideUnavailableItems: boolean
+  incrementAddress: boolean,
   flags?: FeatureFlags
 }
 
@@ -91,16 +92,16 @@ const Resolvers = {
 
 export const getContextFactory =
   (options: Options) =>
-  (ctx: any): Context => {
-    ctx.storage = {
-      channel: ChannelMarshal.parse(options.channel),
-      flags: options.flags ?? {},
-      locale: options.locale,
-    }
-    ctx.clients = getClients(options, ctx)
-    ctx.loaders = getLoaders(options, ctx)
+    (ctx: any): Context => {
+      ctx.storage = {
+        channel: ChannelMarshal.parse(options.channel),
+        flags: options.flags ?? {},
+        locale: options.locale,
+      }
+      ctx.clients = getClients(options, ctx)
+      ctx.loaders = getLoaders(options, ctx)
 
-    return ctx
-  }
+      return ctx
+    }
 
 export const getResolvers = (_: Options) => Resolvers

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

@@ -21,6 +21,7 @@ import type {
   OrderFormInputItem,
   OrderFormItem
 } from '../clients/commerce/types/OrderForm'
+import { IncrementedAddress } from '../clients/commerce/types/IncrementedAddress'
 
 type Indexed<T> = T & { index?: number }
 
@@ -210,14 +211,14 @@ async function getOrderNumberFromSession(
     const { namespaces } = await commerce.getSessionOrder()
     return namespaces.checkout?.orderFormId?.value
   }
-  return ;
+  return;
 }
 
 // Returns the regionalized orderForm
 const getOrderForm = async (
   id: string,
   session: Maybe<IStoreSession> | undefined,
-  { clients: { commerce } }: Context
+  { clients: { commerce } }: Context,
 ) => {
   const orderForm = await commerce.checkout.orderForm({
     id,
@@ -234,15 +235,27 @@ const getOrderForm = async (
 
   const shouldUpdateShippingData =
     typeof session.postalCode === 'string' &&
-    orderForm.shippingData?.address?.postalCode != session.postalCode
+    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) {
+    let incrementedAddress: IncrementedAddress | undefined;
+    if (session.postalCode) {
+      incrementedAddress = await commerce.checkout.incrementAddress(session.country, session.postalCode)
+      
+    }
     return commerce.checkout.shippingData({
       id: orderForm.orderFormId,
       body: {
         selectedAddresses: [session],
       },
-    })
+    }, incrementedAddress)
   }
 
   return orderForm
@@ -298,11 +311,11 @@ export const validateCart = async (
   // 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)
-  
+
   if (isStale && orderNumber) {
     const newOrderForm = await setOrderFormEtag(orderForm, commerce).then(
       joinItems
-      )
+    )
     return orderFormToCart(newOrderForm, skuLoader)
   }