@envive-ai/react-hooks 0.1.5 → 0.1.6

package/src/application/service/searchService.ts

@@ -1,147 +0,0 @@
-import {
-  Configuration,
-  ResponseCategory,
-  ResponseError,
-  SearchApi,
-} from "@spiffy-ai/commerce-api-client";
-import { getAtomStore } from "src/atoms/atomStore/atomStore";
-import { apiKeyAtom } from "src/atoms/org/org";
-import { appDetailsAtom } from "src/atoms/app";
-import Logger from "src/application/logging/logger";
-import { SessionRestartRequired } from "src/adapters/spiffy/commerce/exceptions/sessionExceptions";
-import { UnsupportedProductException } from "src/adapters/spiffy/commerce/exceptions/unsupportedProductExceptions";
-import { SearchResult, SearchParams } from "../models/api/search";
-import { baseUrlAtom } from "src/atoms/envive/enviveConfig";
-
-const transformProductResponses = (products: SearchResult["products"]) =>
-  products.map((data) => ({
-    id: data.id,
-    responseId: data.response_id,
-    category: ResponseCategory.Product,
-    description: data.description,
-    imageUrl: data.image_url,
-    imageUrls: data.image_urls,
-    title: data.title,
-    url: data.url,
-    originalPrice: data.original_price,
-    salePrice: data.sale_price,
-    averageRating: data.average_rating,
-    numberReviews: data.number_reviews,
-    metadata: data.metadata,
-    isForGrid: data.is_for_grid,
-    colors: data.colors,
-    sizes: data.sizes,
-    filters: data.filters,
-  }));
-
-async function errorResponseBody(error: ResponseError) {
-  try {
-    return await error.response.json();
-  } catch {
-    return {};
-  }
-}
-
-async function throwSessionRestartRequiredIf(errorMsg: string, error: unknown) {
-  if (!(error instanceof ResponseError)) {
-    Logger.logInfo(errorMsg, error);
-    throw error;
-  }
-
-  const errorResponse = await errorResponseBody(error);
-  if (
-    errorResponse?.message?.toLowerCase() === "unsupported product" ||
-    errorResponse?.app_code?.toUpperCase() === "PRODUCT_NOT_FOUND"
-  ) {
-    throw new UnsupportedProductException();
-  } else if (
-    errorResponse?.app_code?.toUpperCase() === "RESTART_SESSION" ||
-    errorResponse?.sub_code?.toUpperCase() === "NOT_FOUND"
-  ) {
-    Logger.logInfo(
-      "Session does not exist. Re-start session",
-      error,
-      error.response,
-      errorResponse
-    );
-    throw new SessionRestartRequired();
-  }
-
-  Logger.logInfo(errorMsg, error);
-  throw error;
-}
-
-class SearchService {
-  private readonly searchApi: SearchApi;
-
-  private static instance: SearchService | undefined;
-
-  private static getInstance = (): SearchService => {
-    if (!SearchService.instance) {
-      const atomStore = getAtomStore();
-      const apiKey = atomStore.get(apiKeyAtom);
-      if (!apiKey) {
-        throw new Error(
-          "[spiffy-ai] SearchService requires apiKey to be available"
-        );
-      }
-      SearchService.instance = new SearchService(apiKey);
-    }
-    return SearchService.instance;
-  };
-
-  private constructor(apiKey: string, basePath?: string) {
-    const atomStore = getAtomStore();
-
-    const baseUrl = atomStore.get(baseUrlAtom);
-    const path = basePath || baseUrl;
-    const config: Configuration = new Configuration({
-      accessToken: apiKey,
-      basePath: path,
-      headers: {
-        "Content-Type": "application/json",
-        Accept: "application/json",
-      },
-    });
-    this.searchApi = new SearchApi(config);
-  }
-
-  private async _searchProducts(params: SearchParams): Promise<SearchResult> {
-    const atomStore = getAtomStore();
-    const appDetails = atomStore.get(appDetailsAtom);
-    try {
-      const response = await this.searchApi.v1SearchQueryGet({
-        query: params.query,
-        limit: params.limit,
-        org_id: appDetails.orgId,
-        user_id: appDetails.userId,
-      });
-      const {
-        products,
-        filters,
-        search_response_id: searchResponseId,
-      } = response;
-
-      return {
-        products: transformProductResponses(products) || [],
-        filters: filters || [],
-        totalProductCount: products?.length || 0,
-        searchResponseId: searchResponseId || "",
-      };
-    } catch (error) {
-      await throwSessionRestartRequiredIf("Failed to search products", error);
-      // This part will not be reached if an exception is thrown, but it's required for type safety
-      return {
-        products: [],
-        filters: [],
-        totalProductCount: 0,
-        searchResponseId: "",
-      };
-    }
-  }
-
-  static searchProducts = (params: SearchParams): Promise<SearchResult> =>
-    SearchService.getInstance()._searchProducts(params);
-}
-
-export default SearchService;

package/src/application/service/sessionStorageService.ts

@@ -1,27 +0,0 @@
-import Logger from '../logging/logger';
-
-class SessionStorageService {
-  static setItem(key: string, value: string): void {
-    sessionStorage.setItem(key, value);
-    window.dispatchEvent(
-      new StorageEvent('storage', {
-        key,
-        newValue: value,
-      }),
-    );
-  }
-
-  static getItem(key: string): string | null {
-    return sessionStorage.getItem(key);
-  }
-
-  static getSessionStorage() {
-    const ls = window?.sessionStorage;
-    if (!ls) {
-      Logger.logError('sessionStorage is not available', undefined);
-    }
-    return ls;
-  }
-}
-
-export { SessionStorageService };

package/src/application/service/shopifyUrlService.ts

@@ -1,63 +0,0 @@
-import { IdExtractor } from 'src/contexts/types';
-import { parseHref } from 'src/application/utils/urlsParser';
-
-class ShopifyUrlService {
-  static getTrimmedPathName(): string | null {
-    let { pathname } = window.location;
-    // strip out the proxy path so local dev still works
-    pathname = pathname.replace('/proxy', '');
-    // remove trailing hash if it exists
-    pathname = pathname.replace(/#.*$/, '');
-    // remove trailing /, ie. some URLs can end with '/' like /collections/cast-iron/
-    pathname = pathname.replace(/\/$/, '');
-
-    if (pathname === undefined || pathname === null || pathname.length === 0) {
-      return null;
-    }
-
-    return pathname;
-  }
-
-  /**
-   * Parses the URL to determine the PLP or PDP ID.
-   *
-   * @param extractor the type of extractor to parse segments of the page URL
-   *
-   * @returns the PLP or PDP ID if found, otherwise null
-   */
-  static getPlpOrPdpId(extractor: IdExtractor): string | null {
-    if (extractor === 'shopify-product-variant-id') {
-      const parsedHref = parseHref(window.location.href);
-      // TODO: this extractor is unique to Spanx who uses the "variant" query param to identify the product.
-      // variant. It should be flexible enough to support params defined in the page config
-      const variantId = parsedHref?.urlSearchParams?.get('variant');
-      // Allow the "shopify-product-variant-id" extractor to fallback to the "shopify-product-id" extractor
-      if (!variantId) {
-        return ShopifyUrlService.getPlpOrPdpId('shopify-product-id');
-      }
-      return variantId;
-    }
-
-    const pathSegment = extractor === 'shopify-product-id' ? 'products' : 'collections';
-    const tokens = ShopifyUrlService.getTrimmedPathName()?.split('/');
-    const idIndex = tokens?.findIndex((token) => token === pathSegment);
-    if (idIndex !== undefined && idIndex >= 0 && tokens) {
-      return decodeURIComponent(tokens[idIndex + 1]);
-    }
-    return null;
-  }
-
-  static isOnPdpPage(): boolean {
-    return ShopifyUrlService.getTrimmedPathName()?.includes('/products') ?? false;
-  }
-
-  static isOnPlpPage(): boolean {
-    return (
-      (ShopifyUrlService.getTrimmedPathName()?.includes('/collections') &&
-        !ShopifyUrlService.getTrimmedPathName()?.includes('/products')) ??
-      false
-    );
-  }
-}
-
-export { ShopifyUrlService };

package/src/application/service/userIdentityService.ts

@@ -1,114 +0,0 @@
-import UAParser from 'ua-parser-js';
-import Logger from 'src/application/logging/logger';
-import CommerceApiClient from 'src/adapters/spiffy/commerce/api';
-import { v4 as uuid } from 'uuid';
-import { ClientDetails } from 'src/application/models/clientDetails';
-import { LocalStorageService } from 'src/application/service/localStorageService';
-import { WindowDataLayerService } from 'src/application/service/windowDataLayerService';
-
-const getUserAgentDetails = (): ClientDetails => {
-  const uaParser = new UAParser();
-  const result = uaParser.getResult();
-
-  return {
-    os: result?.os?.name, // Operating system name (e.g., "Windows", "iOS")
-    osVersion: result?.os?.version, // Operating system version (e.g., "10", "14.1")
-    deviceBrand: result?.device?.vendor, // Device brand (e.g., "Apple", "Samsung")
-    deviceManufacturer: result?.device?.vendor, // Device manufacturer (e.g., "Apple", "Samsung")
-    deviceModel: result?.device?.model, // Device model (e.g., "iPhone", "Galaxy S10")
-    browser: result?.browser?.name, // Browser name (e.g., "Chrome", "Safari")
-    browserVersion: result?.browser?.version, // Browser version
-    userAgent: result?.ua, // User agent string
-  };
-};
-
-class UserIdentityService {
-  static USER_ID_OVERRIDE_KEY = 'v1-spiffy-user-id-override';
-
-  static USER_ID_DEFAULT_KEY = 'v1-spiffy-user-id-default';
-
-  static async identifyUser(): Promise<void> {
-    try {
-      const cdpUserId = WindowDataLayerService.getGoogleAnalyticsClientId();
-      const userId = UserIdentityService.getUserIdOrDefault();
-      const userAgentDetails = getUserAgentDetails();
-
-      if (!cdpUserId) {
-        Logger.logWarn('[spiffy-ai] No GA Client ID found, skipping identifyUser', undefined);
-        return;
-      }
-
-      await CommerceApiClient.identifyUser(userId, cdpUserId, userAgentDetails);
-    } catch (error) {
-      Logger.logError('[spiffy-ai] Error identifying user', error);
-    }
-  }
-
-  static getUserIdOrDefault(): string {
-    const userIdOverride = UserIdentityService.getUserIdOverrideFromLocalStorage();
-    if (userIdOverride) {
-      return userIdOverride;
-    }
-
-    const defaultUserId = UserIdentityService.getUserIdDefaultFromLocalStorage();
-    if (defaultUserId) {
-      return defaultUserId;
-    }
-
-    return this.setUserIdDefaultInLocalStorage(`spiffy-user-id-${uuid()}`);
-  }
-
-  static getUserIdOverrideFromLocalStorage(): string | undefined {
-    return (
-      LocalStorageService.getLocalStorage()?.getItem(UserIdentityService.USER_ID_OVERRIDE_KEY) ??
-      undefined
-    );
-  }
-
-  static getUserIdDefaultFromLocalStorage(): string | undefined {
-    return (
-      LocalStorageService.getLocalStorage()?.getItem(UserIdentityService.USER_ID_DEFAULT_KEY) ??
-      undefined
-    );
-  }
-
-  static setUserIdDefaultInLocalStorage(userId: string): string {
-    Logger.logInfo(`setUserIdDefaultInLocalStorage - Setting user_id=${userId}`);
-    LocalStorageService.getLocalStorage()?.setItem(UserIdentityService.USER_ID_DEFAULT_KEY, userId);
-    window.dispatchEvent(
-      new StorageEvent('storage', {
-        key: UserIdentityService.USER_ID_DEFAULT_KEY,
-        newValue: userId,
-      }),
-    );
-    return userId;
-  }
-
-  static setUserIdOverrideInLocalStorage(userId: string): string {
-    Logger.logInfo(`setUserIdOverrideInLocalStorage - Setting user_id=${userId}`);
-    LocalStorageService.getLocalStorage()?.setItem(
-      UserIdentityService.USER_ID_OVERRIDE_KEY,
-      userId,
-    );
-    window.dispatchEvent(
-      new StorageEvent('storage', {
-        key: UserIdentityService.USER_ID_OVERRIDE_KEY,
-        newValue: userId,
-      }),
-    );
-    return userId;
-  }
-
-  static clearUserIdOverrideInLocalStorage() {
-    Logger.logInfo(`clearUserIdOverrideInLocalStorage - Clearing user_id`);
-    LocalStorageService.getLocalStorage()?.removeItem(UserIdentityService.USER_ID_OVERRIDE_KEY);
-    window.dispatchEvent(
-      new StorageEvent('storage', {
-        key: UserIdentityService.USER_ID_OVERRIDE_KEY,
-        newValue: undefined,
-      }),
-    );
-  }
-}
-
-export { UserIdentityService };

package/src/application/service/windowChatToggleService.ts

@@ -1,80 +0,0 @@
-import { useSetAtom } from "jotai";
-import { useEffect, useRef } from "react";
-import { Message, MessageRole, MessageType } from "src/application/models";
-import { handleReplyAtom } from "src/atoms/chat";
-import { useChatToggle } from "src/hooks";
-import { v4 as uuid } from "uuid";
-import Logger from "../logging/logger";
-import { ChatElementDisplayLocation } from "../models/chatElementDisplayLocation";
-import { getAtomStore } from "src/atoms/atomStore";
-import { identifyingPrefixAtom } from "src/atoms/envive/enviveConfig";
-
-let hasAttachedEnviveChatToggle = false;
-
-export const WindowChatToggleBinder = () => {
-  const triggerLocation = ChatElementDisplayLocation.WINDOW_API_CALL;
-  const hook = useChatToggle();
-  const setReply = useSetAtom(handleReplyAtom);
-
-  // Refs to hold latest implementations
-  const openChatRef = useRef<(triggerId?: string) => void>();
-  const closeChatRef = useRef<(triggerId?: string) => void>();
-  const toggleChatRef = useRef<(triggerId?: string) => void>();
-  const isOpenRef = useRef<boolean>(hook.isOpen);
-  const openChatWithPromptRef =
-    useRef<(prompt: string, triggerId?: string) => void>();
-
-  // Keep refs up to date with latest hook/state
-  useEffect(() => {
-    openChatRef.current = (triggerId?: string) =>
-      hook.openChat(triggerLocation, triggerId);
-    closeChatRef.current = (triggerId?: string) =>
-      hook.closeChat(triggerLocation, triggerId);
-    toggleChatRef.current = (triggerId?: string) =>
-      hook.toggle(triggerLocation, triggerId);
-    isOpenRef.current = hook.isOpen;
-    openChatWithPromptRef.current = (prompt: string, triggerId?: string) => {
-      const message: Message = {
-        id: uuid(),
-        createdAt: new Date().toISOString(),
-        role: MessageRole.User,
-        type: MessageType.QueryTyped,
-        metadata: {
-          content: prompt,
-        },
-      };
-      setReply({ message, userTyped: false });
-      hook.openChat(triggerLocation, triggerId);
-    };
-  }, [hook, setReply, triggerLocation, hook.isOpen]);
-
-  // Attach once; wrapper functions call through to refs
-  useEffect(() => {
-    if (hasAttachedEnviveChatToggle) return;
-    const atomStore = getAtomStore();
-    const identifyingPrefix = atomStore.get(identifyingPrefixAtom);
-    try {
-      if (!window[identifyingPrefix]) {
-        window[identifyingPrefix] = {} as Window[typeof identifyingPrefix];
-      }
-      window[identifyingPrefix].openChat = (triggerId?: string) =>
-        openChatRef.current?.(triggerId);
-      window[identifyingPrefix].closeChat = (triggerId?: string) =>
-        closeChatRef.current?.(triggerId);
-      window[identifyingPrefix].toggleChat = (triggerId?: string) =>
-        toggleChatRef.current?.(triggerId);
-      window[identifyingPrefix].getChatIsOpen = () => !!isOpenRef.current;
-      window[identifyingPrefix].openChatWithPrompt = (
-        prompt: string,
-        triggerId?: string
-      ) => openChatWithPromptRef.current?.(prompt, triggerId);
-
-      Logger.logDebug("[spiffy-ai] Chat toggle functions attached");
-      hasAttachedEnviveChatToggle = true;
-    } catch (e) {
-      Logger.logError("[spiffy-ai] Failed to attach Chat toggle functions", e);
-    }
-  }, []);
-
-  return null;
-};

package/src/application/service/windowDataLayerService.ts

@@ -1,181 +0,0 @@
-import Logger from 'src/application/logging/logger';
-import { OrgAnalyticsGoogleAnalyticsConfig } from 'src/application/models/api/orgAnalyticsConfig';
-
-declare global {
-  interface Window {
-    dataLayer: any;
-  }
-}
-
-class WindowDataLayerService {
-  private readonly dataLayer: any;
-
-  private readonly originalDataLayerPush: any;
-
-  private static instance: WindowDataLayerService | undefined;
-
-  private readonly merchantGoogleMeasurementId: string;
-
-  private constructor(private readonly gaConfig: OrgAnalyticsGoogleAnalyticsConfig) {
-    this.dataLayer = window.dataLayer;
-    this.originalDataLayerPush = this.dataLayer?.push;
-    this.merchantGoogleMeasurementId = this.gaConfig.measurementId || 'default';
-  }
-
-  /**
-   * Pushes data to the dataLayer
-   * @param data
-   *  data has the shape: { event: 'event_name', ... }
-   *  Example:
-   *  {
-   *         "event": "add_to_cart",
-   *         "currency": "USD",
-   *         "value": 30.03,
-   *         "items": [
-   *           {
-   *             "item_id": "SKU_12345",
-   *             "item_name": "Stan and Friends Tee",
-   *             "affiliation": "Google Merchandise Store",
-   *             "coupon": "SUMMER_FUN",
-   *             "discount": 2.22,
-   *             "index": 0,
-   *             "item_brand": "Google",
-   *             "item_category": "Apparel",
-   *             "item_category2": "Adult",
-   *             "item_category3": "Shirts",
-   *             "item_category4": "Crew",
-   *             "item_category5": "Short sleeve",
-   *             "item_list_id": "related_products",
-   *             "item_list_name": "Related Products",
-   *             "item_variant": "green",
-   *             "location_id": "ChIJIQBpAG2ahYAR_6128GcTUEo",
-   *             "price": 10.01,
-   *             "quantity": 3
-   *           }
-   *         ]
-   * }
-   */
-  push(data: any) {
-    this.dataLayer?.push(data);
-  }
-
-  static isDataLayerAvailable(): boolean {
-    const windowDataLayer = window.dataLayer;
-    if (windowDataLayer && windowDataLayer.push) {
-      return true;
-    }
-    Logger.logDebug('[spiffy-ai] DataLayerEventsListener dataLayer not available');
-    return false;
-  }
-
-  static tryFlattenArguments(args: any): any {
-    function isArguments(obj: any) {
-      return obj !== undefined && Object.prototype.toString.call(obj) === '[object Arguments]';
-    }
-
-    try {
-      const all_arguments = [];
-      if (args.length > 0) {
-        for (let i = 0; i < args.length; i++) {
-          const arg = args[i];
-          if (isArguments(arg)) {
-            const flattened = WindowDataLayerService.tryFlattenArguments(arg);
-            all_arguments.push(...flattened);
-          } else {
-            all_arguments.push(arguments[i]);
-          }
-        }
-      }
-      return all_arguments;
-    } catch {
-      return args;
-    }
-  }
-
-  wrapWithProxyMethod(methodName: string, callback: Function) {
-    if (!this.dataLayer) {
-      Logger.logWarn('DataLayerEventsListener dataLayer not available', undefined);
-      return;
-    }
-
-    const originalMethod = this.dataLayer[methodName];
-    this.dataLayer[methodName] = function () {
-      try {
-        callback.apply(this, arguments);
-      } catch (e) {
-        Logger.logError(`Error in dataLayer.${methodName}: `, e);
-      } finally {
-        originalMethod.apply(this, arguments);
-      }
-    };
-  }
-
-  static getSingletonInstanceOf(
-    gaConfig: OrgAnalyticsGoogleAnalyticsConfig,
-  ): WindowDataLayerService {
-    if (!WindowDataLayerService.instance) {
-      WindowDataLayerService.instance = new WindowDataLayerService(gaConfig);
-    }
-
-    return WindowDataLayerService.instance;
-  }
-
-  sendToGoogleAnalyticsCircularEventsSafe(
-    eventName: string,
-    eventProps: Record<string, unknown> | undefined,
-  ) {
-    // To avoid circular events, we need only send the event to Google Analytics if it is not already in the dataLayer!
-    // Example of a circular event:
-    // 1. User clicks add to cart button
-    // 2. dataLayer is updated with the add to cart event
-    // 3. DataLayerEventsListener intercepts the add to cart event and sends it to Amplitude via MetricsService/MetricsContext
-    // 4. MetricsService/MetricsContext calls this method to send the event to Google Analytics! <--- Circular event!!!
-
-    const This = this;
-
-    function doesEventExistInDataLayer(eventName: string) {
-      return This.dataLayer?.find((event: any) => event.event === eventName);
-    }
-
-    if (doesEventExistInDataLayer(eventName)) {
-      Logger.logDebug(
-        `[spiffy-ai] Event ${eventName} already exists in dataLayer. Skipping Google Analytics event.`,
-      );
-      return;
-    }
-
-    function gtag() {
-      if (This.originalDataLayerPush) {
-        This.originalDataLayerPush(arguments);
-      } else {
-        Logger.logDebug('No originalDataLayerPush found - no metrics being logged');
-      }
-    }
-
-    // @ts-ignore
-    gtag('event', eventName, {
-      event: eventName,
-      send_to: this.merchantGoogleMeasurementId,
-      ...eventProps,
-    });
-  }
-
-  static getGoogleAnalyticsClientId = (): string | undefined => {
-    try {
-      // ga cookie has the format _ga=GA1.1.xxxxxxxxxx.yyyyyyyyyy
-      const gaCookie = document.cookie.split(';').find((c) => c.trim().startsWith('_ga='));
-
-      if (!gaCookie) {
-        Logger.logWarn('[spiffy-ai] No GA cookie found', undefined);
-        return undefined;
-      }
-
-      return gaCookie.split('.').slice(2).join('.');
-    } catch (error) {
-      Logger.logError('Error getting GA client ID:', error);
-      return undefined;
-    }
-  };
-}
-
-export { WindowDataLayerService };