@uappi/public-sdk 1.0.0

package/modules/Tracking/endpoints/SearchComposable.ts

@@ -0,0 +1,32 @@
+import publicApi from '../../Api';
+
+import type { TrackingProductFields } from './types';
+
+import { viewItemList } from '../events/views/viewItemList';
+
+import type {
+  ApiParams,
+  ProductConditionFields,
+  ProductFields,
+  ProductSortFields,
+} from '../../Api/types';
+
+export function getSearch(
+  term: string,
+  options?: Pick<
+    ApiParams<TrackingProductFields, ProductSortFields, ProductConditionFields>,
+    'condition' | 'fields' | 'limit' | 'meta' | 'offset' | 'order'
+  >,
+) {
+  let fields: Array<ProductFields> = ['price', 'brand', 'variation'];
+
+  if (options?.fields) fields = [...options.fields, ...fields];
+
+  return publicApi.product
+    .getSearch(term, { ...options, fields })
+    .then(data => {
+      viewItemList(data);
+
+      return data;
+    });
+}

package/modules/Tracking/endpoints/ShowcaseComposable.ts

@@ -0,0 +1,54 @@
+import publicApi from '../../Api';
+
+import type { TrackingProductFields } from './types';
+
+import { viewItemList } from '../events/views/viewItemList';
+
+import type {
+  ApiParams,
+  ProductFields,
+  Showcase,
+} from '../../Api/types';
+
+export function listShowcase(
+  codes: string,
+  options?: Pick<
+    ApiParams<TrackingProductFields>,
+    'condition' | 'fields' | 'meta' | 'order'
+  >,
+): Promise<Showcase>;
+
+export function listShowcase(
+  codes: Array<string>,
+  options?: Pick<
+    ApiParams<TrackingProductFields>,
+    'condition' | 'fields' | 'meta' | 'order'
+  >,
+): Promise<Array<Showcase>>;
+
+export function listShowcase(
+  codes: Array<string> | string,
+  options?: Pick<
+    ApiParams<TrackingProductFields>,
+    'condition' | 'fields' | 'meta' | 'order'
+  >,
+) {
+  let fields: Array<ProductFields> = ['price', 'brand', 'variation'];
+
+  if (options?.fields) fields = [...options.fields, ...fields];
+
+  if (Array.isArray(codes))
+    return publicApi.customization
+      .listShowcase(codes, { ...options, fields })
+      .then(data => {
+        viewItemList(data);
+        return data;
+      });
+
+  return publicApi.customization
+    .listShowcase(codes, { ...options, fields })
+    .then(data => {
+      viewItemList([data]);
+      return data;
+    });
+}

package/modules/Tracking/endpoints/UrlComposable.ts

@@ -0,0 +1,41 @@
+import publicApi from '../../Api';
+
+import type { TrackingProductFields } from './types';
+
+import { viewItem } from '../events/views/viewItem';
+import { viewItemList } from '../events/views/viewItemList';
+
+import type {
+  ApiParams,
+  ProductConditionFields,
+  ProductFields,
+  ProductSortFields,
+  UrlBrand,
+  UrlListing,
+  UrlPage,
+  UrlProduct,
+} from '../../Api/types';
+
+export function getUrl<UrlType>(
+  path: string,
+  options?: Pick<
+    ApiParams<TrackingProductFields, ProductSortFields, ProductConditionFields>,
+    'condition' | 'fields' | 'limit' | 'offset' | 'meta' | 'order'
+  >,
+) {
+  let fields: Array<ProductFields> = ['price', 'brand', 'variation'];
+
+  if (options?.fields) fields = [...options.fields, ...fields];
+
+  return publicApi.product
+    .getUrl<UrlType>(path, { ...options, fields })
+    .then(data => {
+      const pageData = data as UrlProduct | UrlPage | UrlBrand | UrlListing;
+
+      if (pageData.type === 'product') viewItem(pageData.content);
+      if (pageData.type === 'brand' || pageData.type === 'category')
+        viewItemList(pageData);
+
+      return data;
+    });
+}

package/modules/Tracking/endpoints/types.ts

@@ -0,0 +1,11 @@
+import type { CustomerFields, ProductFields } from '../../Api/types';
+
+export type TrackingCustomerFields = Exclude<
+  CustomerFields,
+  'addresses' | 'documents'
+>;
+
+export type TrackingProductFields = Exclude<
+  ProductFields,
+  'price' | 'variation' | 'mainCategory' | 'brand'
+>;

package/modules/Tracking/events/actions/addPaymentInfo.ts

@@ -0,0 +1,31 @@
+import { getAddedCartItems, getVariant, totalValue } from '../../utils/cart';
+import { pushDatalayer } from '../../utils/pushDatalayer';
+
+import type { CartResponse } from '../../api/types';
+
+export function addPaymentInfoAction(
+  paymentMethod: string,
+  cartPayload: CartResponse,
+) {
+  pushDatalayer({
+    event: 'add_payment_info',
+    ecommerce: {
+      currency: 'BRL',
+      value: totalValue(cartPayload),
+      coupon: cartPayload.discountMap.coupon?.discountMainCode || '',
+      payment_type: paymentMethod,
+      items: getAddedCartItems(cartPayload).map(item => {
+        return {
+          item_category: '',
+          coupon: cartPayload.discountMap.coupon?.discountMainCode || '',
+          item_brand: `${item.product.brandId}`,
+          item_id: item.product.productId,
+          item_name: item.product.name,
+          item_variant: getVariant(item),
+          price: item.unitValue,
+          quantity: item.quantity,
+        };
+      }),
+    },
+  });
+}

package/modules/Tracking/events/actions/addShippingInfo.ts

@@ -0,0 +1,27 @@
+import { getAddedCartItems, getVariant, totalValue } from '../../utils/cart';
+import { pushDatalayer } from '../../utils/pushDatalayer';
+
+import type { CartResponse } from '../../api/types';
+
+export function addShippingInfoAction(cartPayload: CartResponse) {
+  pushDatalayer({
+    event: 'add_shipping_info',
+    ecommerce: {
+      currency: 'BRL',
+      value: totalValue(cartPayload),
+      coupon: cartPayload.discountMap.coupon?.discountMainCode || '',
+      items: getAddedCartItems(cartPayload).map(item => {
+        return {
+          item_category: '',
+          coupon: cartPayload.discountMap.coupon?.discountMainCode || '',
+          item_brand: `${item.product.brandId}`,
+          item_id: item.product.productId,
+          item_name: item.product.name,
+          item_variant: getVariant(item),
+          price: item.unitValue,
+          quantity: item.quantity,
+        };
+      }),
+    },
+  });
+}

package/modules/Tracking/events/actions/addToCart.ts

@@ -0,0 +1,35 @@
+import { getAddedCartItems, getVariant, totalValue } from '../../utils/cart';
+import { pushDatalayer } from '../../utils/pushDatalayer';
+
+import type { UpsertTrackingCartRequest } from '../../types';
+import type { CartResponse } from '../../api/types';
+
+export function addToCartAction(
+  upsertPayload: UpsertTrackingCartRequest,
+  cartPayload: CartResponse,
+) {
+  if (!getAddedCartItems(cartPayload, upsertPayload).length) return;
+
+  pushDatalayer({
+    event: 'add_to_cart',
+    ecommerce: {
+      currency: 'BRL',
+      value: totalValue(cartPayload, upsertPayload),
+      items: getAddedCartItems(cartPayload, upsertPayload).map(item => {
+        return {
+          item_category: '',
+          coupon: cartPayload.discountMap.coupon?.discountMainCode || '',
+          item_brand: `${item.product.brandId}`,
+          item_id: item.product.productId,
+          item_name: item.product.name,
+          item_variant: getVariant(item),
+          price: item.unitValue,
+          quantity:
+            item.quantity > item.oldQuantity!
+              ? item.quantity - item.oldQuantity!
+              : item.oldQuantity! - item.quantity,
+        };
+      }),
+    },
+  });
+}

package/modules/Tracking/events/actions/beginCheckout.ts

@@ -0,0 +1,28 @@
+import { getAddedCartItems, getVariant, totalValue } from '../../utils/cart';
+import { pushDatalayer } from '../../utils/pushDatalayer';
+
+import type { CartResponse } from '../../api/types';
+
+export function beginCheckoutAction(cartPayload: CartResponse) {
+  pushDatalayer({
+    event: 'begin_checkout',
+    ecommerce: {
+      currency: 'BRL',
+      value: totalValue(cartPayload),
+      shipping_tier: 'Ground',
+      coupon: cartPayload.discountMap.coupon?.discountMainCode || '',
+      items: getAddedCartItems(cartPayload).map(item => {
+        return {
+          item_category: '',
+          coupon: cartPayload.discountMap.coupon?.discountMainCode || '',
+          item_brand: `${item.product.brandId}`,
+          item_id: item.product.productId,
+          item_name: item.product.name,
+          item_variant: getVariant(item),
+          price: item.unitValue,
+          quantity: item.quantity,
+        };
+      }),
+    },
+  });
+}

package/modules/Tracking/events/actions/customerProfile.ts

@@ -0,0 +1,36 @@
+import { pushDatalayer } from '../../utils/pushDatalayer';
+
+import type { CustomerResponse } from '../../api/types';
+
+export function customerProfileAction(payload?: CustomerResponse) {
+  if (!payload) {
+    pushDatalayer({
+      event: 'customer_profile',
+      customer: {
+        id: 0,
+        birthdate: '',
+        email: '',
+        name: 'Visitante',
+        gender: 'undefined',
+        flags: null,
+        address: null,
+        loginStatus: false,
+      },
+    });
+    return;
+  }
+
+  pushDatalayer({
+    event: 'customer_profile',
+    customer: {
+      id: payload.id,
+      birthdate: payload.birthdate,
+      email: payload.email,
+      name: payload.nameCorporateName,
+      gender: payload.gender,
+      flags: payload.flags,
+      address: payload.addresses,
+      loginStatus: true,
+    },
+  });
+}

package/modules/Tracking/events/actions/generateLead.ts

@@ -0,0 +1,12 @@
+import { pushDatalayer } from '../../utils/pushDatalayer';
+
+import type { CustomerLead } from '../../types';
+
+export function generateLead(customer: CustomerLead) {
+  pushDatalayer({
+    event: 'generate_lead',
+    name: customer.name,
+    email: customer.email,
+    phone: customer.phone,
+  });
+}

package/modules/Tracking/events/actions/login.ts

@@ -0,0 +1,8 @@
+import { pushDatalayer } from '../../utils/pushDatalayer';
+
+export function loginAction() {
+  pushDatalayer({
+    event: 'login',
+    method: 'Internal',
+  });
+}

package/modules/Tracking/events/actions/purchase.ts

@@ -0,0 +1,42 @@
+import { getAddedCartItems, getVariant, totalValue } from '../../utils/cart';
+import { pushDatalayer } from '../../utils/pushDatalayer';
+
+import type { CartResponse } from '../../api/types';
+
+export function purchaseAction(
+  paymentMethod: string,
+  cartPayload: CartResponse,
+) {
+  pushDatalayer({
+    event: 'purchase',
+    ecommerce: {
+      currency: 'BRL',
+      affiliation: 'Loja Virtual',
+
+      payment_status: 'em aberto',
+      payment_type: paymentMethod,
+
+      shipping: cartPayload.shippingValue,
+      shipping_tier: cartPayload.orders[0].shippingOptions.find(
+        shippingOption => shippingOption.selected,
+      )!.label,
+      tax: 0,
+      transaction_id: '',
+
+      value: totalValue(cartPayload),
+      coupon: cartPayload.discountMap.coupon?.discountMainCode || '',
+      items: getAddedCartItems(cartPayload).map(item => {
+        return {
+          item_category: '',
+          coupon: cartPayload.discountMap.coupon?.discountMainCode || '',
+          item_brand: `${item.product.brandId}`,
+          item_id: item.product.productId,
+          item_name: item.product.name,
+          item_variant: getVariant(item),
+          price: item.unitValue,
+          quantity: item.quantity,
+        };
+      }),
+    },
+  });
+}

package/modules/Tracking/events/actions/removeFromCart.ts

@@ -0,0 +1,52 @@
+import { getAddedCartItems, getVariant, totalValue } from '../../utils/cart';
+import { pushDatalayer } from '../../utils/pushDatalayer';
+
+import type { CartResponse, DeleteCartRequest } from '../../api/types';
+
+export function removeFromCartAction(
+  deletePayload: DeleteCartRequest,
+  cartPayload: CartResponse,
+  oldCartResponse?: CartResponse,
+) {
+  if (!cartPayload.orders.length) {
+    pushDatalayer({
+      event: 'remove_from_cart',
+      ecommerce: {
+        currency: 'BRL',
+        value: 0,
+        items: [
+          {
+            coupon: cartPayload.discountMap.coupon?.discountMainCode || '',
+            item_category: '',
+            item_brand: `${oldCartResponse!.orders[0].items[0].product.brandId}`,
+            item_id: oldCartResponse!.orders[0].items[0].product.productId,
+            item_name: oldCartResponse!.orders[0].items[0].product.name,
+            item_variant: getVariant(oldCartResponse!.orders[0].items[0]),
+            price: oldCartResponse!.orders[0].items[0].unitValue,
+            quantity: 1,
+          },
+        ],
+      },
+    });
+    return;
+  }
+  pushDatalayer({
+    event: 'remove_from_cart',
+    ecommerce: {
+      currency: 'BRL',
+      value: totalValue(cartPayload, deletePayload),
+      items: getAddedCartItems(cartPayload, deletePayload).map(item => {
+        return {
+          coupon: cartPayload.discountMap.coupon?.discountMainCode || '',
+          item_category: '',
+          item_brand: `${item.product.brandId}`,
+          item_id: item.product.productId,
+          item_name: item.product.name,
+          item_variant: getVariant(item),
+          price: item.unitValue,
+          quantity: item.quantity,
+        };
+      }),
+    },
+  });
+}

package/modules/Tracking/events/actions/search.ts

@@ -0,0 +1,8 @@
+import { pushDatalayer } from '../../utils/pushDatalayer';
+
+export function searchAction(term: string) {
+  pushDatalayer({
+    event: 'search',
+    search_term: term,
+  });
+}

package/modules/Tracking/events/actions/selectItem.ts

@@ -0,0 +1,64 @@
+import { getVariant } from '../../utils/cart';
+import { pushDatalayer } from '../../utils/pushDatalayer';
+
+import type {
+  Search,
+  Showcase,
+  UrlBrand,
+  UrlListing,
+} from '../../api/types';
+
+export function selectItemAction(
+  page: UrlBrand | UrlListing | Showcase | Search,
+  productIndex: number,
+) {
+  if ('type' in page) {
+    const product = page.content.registers[productIndex];
+    pushDatalayer({
+      event: 'select_item',
+      ecommerce: {
+        item_list_id: page.type === 'search' ? 'Search' : page.entity.name,
+        item_list_name: page.type === 'search' ? 'Search' : page.entity.name,
+        currency: 'BRL',
+        items: [
+          {
+            item_id: product.id,
+            item_name: product.name,
+            item_list_id: page.type === 'search' ? 'Search' : page.entity.name,
+            item_list_name:
+              page.type === 'search' ? 'Search' : page.entity.name,
+            item_brand: product.brand?.name || '',
+            item_variant: getVariant(product),
+            item_category: product.mainCategory?.name || '',
+            price: product.price?.salePrice || 0,
+            index: productIndex + 1,
+          },
+        ],
+      },
+    });
+    return;
+  }
+
+  const product = page.products[productIndex];
+  pushDatalayer({
+    event: 'select_item',
+    ecommerce: {
+      item_list_id: page.name,
+      item_list_name: page.name,
+      currency: 'BRL',
+      items: [
+        {
+          item_id: product.id,
+          item_name: product.name,
+          item_list_id: page.name,
+          item_list_name: page.name,
+          item_brand: product.brand?.name || '',
+          item_variant: getVariant(product),
+          item_category: product.mainCategory?.name || '',
+          price: product.price?.salePrice || 0,
+          index: productIndex + 1,
+        },
+      ],
+    },
+  });
+}

package/modules/Tracking/events/actions/selectPromotion.ts

@@ -0,0 +1,24 @@
+import { pushDatalayer } from '../../utils/pushDatalayer';
+
+import type { BannerItem } from '../../types';
+import type { Banner } from '../../api/types';
+
+export function selectPromotionAction<AdditionalParameters>(
+  banner: Banner<AdditionalParameters>,
+  index: number,
+) {
+  pushDatalayer({
+    event: 'select_promotion',
+    ecommerce: {
+      items: [
+        {
+          promotion_id: banner.id,
+          promotion_name: 'Banners' as BannerItem['promotion_name'],
+          creative_name: `${banner.scheduling?.startDate.slice(0, 10)}-${banner.name.replaceAll(' ', '-')}`,
+          creative_slot: index + 1,
+          index: index + 1,
+        },
+      ],
+    },
+  });
+}

package/modules/Tracking/events/actions/shippingCalculation.ts

@@ -0,0 +1,7 @@
+import { pushDatalayer } from '../../utils/pushDatalayer';
+
+export function shippingCalculationAction() {
+  pushDatalayer({
+    event: 'item_view_shipping_calculation',
+  });
+}

package/modules/Tracking/events/actions/signup.ts

@@ -0,0 +1,8 @@
+import { pushDatalayer } from '../../utils/pushDatalayer';
+
+export function signupAction() {
+  pushDatalayer({
+    event: 'sign_up',
+    method: 'Internal',
+  });
+}

package/modules/Tracking/events/actions/upsertToCart.ts

@@ -0,0 +1,62 @@
+import { getAddedCartItems, getVariant, totalValue } from '../../utils/cart';
+import { pushDatalayer } from '../../utils/pushDatalayer';
+
+import type { UpsertTrackingCartRequest } from '../../types';
+import type { CartResponse } from '../../api/types';
+
+export function upsertToCartAction(
+  upsertPayload: UpsertTrackingCartRequest,
+  cartPayload: CartResponse,
+) {
+  if (!getAddedCartItems(cartPayload, upsertPayload).length) return;
+
+  if (
+    upsertPayload.items.some(item => (item.oldQuantity || 0) > item.quantity!)
+  ) {
+    pushDatalayer({
+      event: 'remove_from_cart',
+      ecommerce: {
+        currency: 'BRL',
+        value: totalValue(cartPayload, upsertPayload),
+        items: getAddedCartItems(cartPayload, upsertPayload).map(item => {
+          return {
+            item_category: '',
+            item_list_name: '',
+            item_brand: `${item.product.brandId}`,
+            item_id: item.product.productId,
+            coupon: cartPayload.discountMap.coupon?.discountMainCode || '',
+            item_name: item.product.name,
+            item_variant: getVariant(item),
+            price: item.unitValue,
+            quantity: item.oldQuantity! - item.quantity,
+          };
+        }),
+      },
+    });
+
+    return;
+  }
+
+  pushDatalayer({
+    event: 'add_to_cart',
+    ecommerce: {
+      currency: 'BRL',
+      value: totalValue(cartPayload, upsertPayload),
+      items: getAddedCartItems(cartPayload, upsertPayload).map(item => {
+        return {
+          item_category: '',
+          item_list_name: '',
+          item_brand: `${item.product.brandId}`,
+          item_id: item.product.productId,
+          coupon: cartPayload.discountMap.coupon?.discountMainCode || '',
+          item_name: item.product.name,
+          item_variant: getVariant(item),
+          price: item.unitValue,
+          quantity: item.oldQuantity
+            ? item.quantity - item.oldQuantity
+            : item.quantity,
+        };
+      }),
+    },
+  });
+}

package/modules/Tracking/events/views/viewCart.ts

@@ -0,0 +1,28 @@
+import { getAddedCartItems, getVariant, totalValue } from '../../utils/cart';
+import { pushDatalayer } from '../../utils/pushDatalayer';
+
+import type { CartResponse } from '../../api/types';
+
+export function viewCart(cartPayload: CartResponse) {
+  pushDatalayer({
+    event: 'view_cart',
+    ecommerce: {
+      currency: 'BRL',
+      value: totalValue(cartPayload),
+      coupon: cartPayload.discountMap.coupon?.discountMainCode || '',
+      items: getAddedCartItems(cartPayload).map(item => {
+        return {
+          coupon: cartPayload.discountMap.coupon?.discountMainCode || '',
+          item_category: '',
+          item_list_name: '',
+          item_brand: `${item.product.brandId}`,
+          item_id: item.product.productId,
+          item_name: item.product.name,
+          item_variant: getVariant(item),
+          price: item.unitValue,
+          quantity: item.quantity,
+        };
+      }),
+    },
+  });
+}

package/modules/Tracking/events/views/viewHome.ts

@@ -0,0 +1,5 @@
+import { pushDatalayer } from '../../utils/pushDatalayer';
+
+export function viewHome() {
+  pushDatalayer({ event: 'view_home' });
+}

package/modules/Tracking/events/views/viewItem.ts

@@ -0,0 +1,31 @@
+import { getVariant } from '../../utils/cart';
+import { pushDatalayer } from '../../utils/pushDatalayer';
+
+import type { Product } from '../../api/types';
+
+export function viewItem(product: Product) {
+  pushDatalayer({
+    event: 'view_item',
+    google_tag_params: {
+      ecomm_category: '',
+      ecomm_prodid: product.id,
+      ecomm_pagetype: 'product',
+      ecomm_totalvalue: product.price?.salePrice || 0,
+    },
+    ecommerce: {
+      currency: 'BRL',
+      items: [
+        {
+          coupon: '',
+          item_brand: product.brand?.name || '',
+          item_category: product.mainCategory?.name || '',
+          item_id: product.id,
+          item_name: product.name,
+          item_variant: getVariant(product),
+          price: product.price?.salePrice || 0,
+          quantity: 1,
+        },
+      ],
+    },
+  });
+}