@envive-ai/react-hooks 0.1.0 → 0.1.2

package/src/application/service/pageVariantService.ts

@@ -1,9 +1,9 @@
-import { v4 as uuid } from 'uuid';
-import { createVisitUserEvent } from 'src/hooks/utils';
-import CommerceApiClient from 'src/adapters/spiffy/commerce/api';
-import Logger from 'src/application/logging/logger';
-import { getAtomStore } from 'src/atoms/atomStore';
-import { featureFlagServiceAtom } from 'src/atoms/org/org';
+import { v4 as uuid } from "uuid";
+import { createVisitUserEvent } from "src/hooks/utils";
+import CommerceApiClient from "src/adapters/spiffy/commerce/api";
+import Logger from "src/application/logging/logger";
+import { getAtomStore } from "src/atoms/atomStore/atomStore";
+import { featureFlagServiceAtom } from "src/atoms/org/org";
 import {
   CategoryExtractor,
   CategoryExtractorType,
@@ -12,26 +12,31 @@ import {
   PageVariantConfig,
   PageVariantTest,
   PageVariantTestType,
-} from 'src/contexts/types';
-import { ShopifyUrlService } from 'src/application/service/shopifyUrlService';
-import { Message, MessageRole, MessageType, VariantInfo } from 'src/application/models';
-import { FeatureGates } from 'src/application/models/featureGates';
-import { appDetailsAtom } from 'src/atoms/app';
+} from "src/contexts/types";
+import { ShopifyUrlService } from "src/application/service/shopifyUrlService";
+import {
+  Message,
+  MessageRole,
+  MessageType,
+  VariantInfo,
+} from "src/application/models";
+import { FeatureGates } from "src/application/models/featureGates";
+import { appDetailsAtom } from "src/atoms/app";
 
 import {
   PageVisitCategory,
   type SupportedEventProductCategory,
-} from '@spiffy-ai/commerce-api-client';
+} from "@spiffy-ai/commerce-api-client";
 import {
   SupportedEvent,
   urlResolverAtom,
   UrlResolverResponse,
   UrlResolvingPDPConfig,
   UrlResolvingPLPConfig,
-} from 'src/atoms/app/variant';
-import { tellExtensionAboutInjectionError } from 'src/extension';
-import { chatAtom, lastAssistantMessageAtom } from 'src/atoms/chat';
-import { StringUtils } from '../utils/stringUtils';
+} from "src/atoms/app/variant";
+import { tellExtensionAboutInjectionError } from "src/extension";
+import { chatAtom, lastAssistantMessageAtom } from "src/atoms/chat";
+import { StringUtils } from "../utils/stringUtils";
 
 /**
  * This class is used to resolve the PageVariants for the Spiffy App.
@@ -49,13 +54,16 @@ class PageVariantService {
       responseStreaming: boolean;
       messages: Message[][];
       lastAssistantMessage?: Message[] | null | undefined;
-    },
+    }
   ): Promise<boolean> => {
     switch (test.testType) {
       case PageVariantTestType.UrlResolver: {
         const url = window._spiffy.variantUrlOverride ?? window.location.href;
         const response = await PageVariantService.getCachedUrlResolver(url);
-        return response.ready && response.variant_type === pageVariantConfig.variantType;
+        return (
+          response.ready &&
+          response.variant_type === pageVariantConfig.variantType
+        );
       }
       case PageVariantTestType.ShopifyPDP:
         return ShopifyUrlService.isOnPdpPage();
@@ -83,23 +91,43 @@ class PageVariantService {
         // The 'fallback' testType will always evaluate to true
         return true;
       case PageVariantTestType.CatalogCategory:
-        return PageVariantService.checkCatalogCategory(test.category, pageVariantConfig);
+        return PageVariantService.checkCatalogCategory(
+          test.category,
+          pageVariantConfig
+        );
       case PageVariantTestType.TopCatalogCategory:
-        return PageVariantService.checkInTopCategory(test.topCategory, pageVariantConfig);
+        return PageVariantService.checkInTopCategory(
+          test.topCategory,
+          pageVariantConfig
+        );
       case PageVariantTestType.HasReviews:
-        return PageVariantService.checkHasReviews(pageVariantConfig, test.reviewMinimum);
+        return PageVariantService.checkHasReviews(
+          pageVariantConfig,
+          test.reviewMinimum
+        );
       case PageVariantTestType.InCollection:
-        return PageVariantService.checkInCollection(test.collections, pageVariantConfig);
+        return PageVariantService.checkInCollection(
+          test.collections,
+          pageVariantConfig
+        );
       case PageVariantTestType.HasMerchantTag:
-        return PageVariantService.checkHasMerchantTag(test.merchantTags, pageVariantConfig);
+        return PageVariantService.checkHasMerchantTag(
+          test.merchantTags,
+          pageVariantConfig
+        );
       case PageVariantTestType.UserHasInteracted:
         return PageVariantService.userHasInteracted(atomValues?.messages);
       case PageVariantTestType.UserHasNotInteracted:
         return PageVariantService.userHasNotInteracted(atomValues?.messages);
       case PageVariantTestType.isLoading:
-        return PageVariantService.isLoading(atomValues?.messages, atomValues?.responseStreaming);
+        return PageVariantService.isLoading(
+          atomValues?.messages,
+          atomValues?.responseStreaming
+        );
       case PageVariantTestType.isProductComparison:
-        return PageVariantService.isProductComparison(atomValues?.lastAssistantMessage);
+        return PageVariantService.isProductComparison(
+          atomValues?.lastAssistantMessage
+        );
       default:
         // If there is a testType that we do not cover - default to false
         Logger.logInfo(`[Spiffy] pageTest - ${test} not supported`);
@@ -117,7 +145,9 @@ class PageVariantService {
       return cachedUrlResolver;
     }
 
-    const response = (await CommerceApiClient.resolveUrl(url)) as UrlResolverResponse;
+    const response = (await CommerceApiClient.resolveUrl(
+      url
+    )) as UrlResolverResponse;
 
     // Store in atom cache for this URL (will be persisted to sessionStorage automatically)
     atomStore.set(urlResolverAtom, { url, response });
@@ -135,9 +165,11 @@ class PageVariantService {
    */
   private static readonly checkCatalogCategory = async (
     category: SupportedEventProductCategory | string,
-    pageVariantConfig: PageVariantConfig,
+    pageVariantConfig: PageVariantConfig
   ): Promise<boolean> => {
-    const supportedEventResponse = await PageVariantService.checkSupportedEvent(pageVariantConfig);
+    const supportedEventResponse = await PageVariantService.checkSupportedEvent(
+      pageVariantConfig
+    );
     if (supportedEventResponse && supportedEventResponse.category) {
       return supportedEventResponse?.category === category;
     }
@@ -147,9 +179,11 @@ class PageVariantService {
 
   private static readonly checkInTopCategory = async (
     topCategory: string[],
-    pageVariantConfig: PageVariantConfig,
+    pageVariantConfig: PageVariantConfig
   ): Promise<boolean> => {
-    const supportedEventResponse = await PageVariantService.checkSupportedEvent(pageVariantConfig);
+    const supportedEventResponse = await PageVariantService.checkSupportedEvent(
+      pageVariantConfig
+    );
     if (supportedEventResponse && supportedEventResponse?.top_category) {
       return topCategory.includes(supportedEventResponse?.top_category);
     }
@@ -159,9 +193,11 @@ class PageVariantService {
 
   private static readonly checkHasReviews = async (
     pageVariantConfig: PageVariantConfig,
-    reviewMinimum: number = 0,
+    reviewMinimum: number = 0
   ): Promise<boolean> => {
-    const supportedEventResponse = await PageVariantService.checkSupportedEvent(pageVariantConfig);
+    const supportedEventResponse = await PageVariantService.checkSupportedEvent(
+      pageVariantConfig
+    );
     if (supportedEventResponse?.numberOfReviews) {
       return supportedEventResponse.numberOfReviews >= reviewMinimum;
     }
@@ -170,12 +206,14 @@ class PageVariantService {
 
   private static readonly checkInCollection = async (
     collections: string[],
-    pageVariantConfig: PageVariantConfig,
+    pageVariantConfig: PageVariantConfig
   ): Promise<boolean> => {
-    const supportedEventResponse = await PageVariantService.checkSupportedEvent(pageVariantConfig);
+    const supportedEventResponse = await PageVariantService.checkSupportedEvent(
+      pageVariantConfig
+    );
     if (supportedEventResponse?.collections) {
       return supportedEventResponse.collections.some((collection) =>
-        collections.includes(collection),
+        collections.includes(collection)
       );
     }
     return false;
@@ -183,12 +221,16 @@ class PageVariantService {
 
   private static readonly checkHasMerchantTag = async (
     merchantTags: string[],
-    pageVariantConfig: PageVariantConfig,
+    pageVariantConfig: PageVariantConfig
   ): Promise<boolean> => {
-    const supportedEventResponse = await PageVariantService.checkSupportedEvent(pageVariantConfig);
+    const supportedEventResponse = await PageVariantService.checkSupportedEvent(
+      pageVariantConfig
+    );
 
     if (supportedEventResponse?.merchant_tags) {
-      return supportedEventResponse.merchant_tags.some((tag) => merchantTags.includes(tag));
+      return supportedEventResponse.merchant_tags.some((tag) =>
+        merchantTags.includes(tag)
+      );
     }
 
     return false;
@@ -204,17 +246,24 @@ class PageVariantService {
     return messages.some((m) => m.some((msg) => msg.role === MessageRole.User));
   };
 
-  private static readonly userHasNotInteracted = (msgs?: Message[][]): boolean => {
+  private static readonly userHasNotInteracted = (
+    msgs?: Message[][]
+  ): boolean => {
     if (msgs) {
       return !msgs.some((m) => m.some((msg) => msg.role === MessageRole.User));
     }
 
     const atomStore = getAtomStore();
     const chat = atomStore.get(chatAtom);
-    return !chat.messages.some((m) => m.some((msg) => msg.role === MessageRole.User));
+    return !chat.messages.some((m) =>
+      m.some((msg) => msg.role === MessageRole.User)
+    );
   };
 
-  private static readonly isLoading = (msgs?: Message[][], responseStream?: boolean): boolean => {
+  private static readonly isLoading = (
+    msgs?: Message[][],
+    responseStream?: boolean
+  ): boolean => {
     if (msgs) {
       return responseStream || (!responseStream && msgs.length === 0);
     }
@@ -225,15 +274,20 @@ class PageVariantService {
   };
 
   private static readonly isProductComparison = (
-    lastMsg: Message[] | null | undefined,
+    lastMsg: Message[] | null | undefined
   ): boolean => {
     if (lastMsg) {
-      return lastMsg?.filter((msg) => msg.type === MessageType.Product).length === 2;
+      return (
+        lastMsg?.filter((msg) => msg.type === MessageType.Product).length === 2
+      );
     }
 
     const atomStore = getAtomStore();
     const lastAssistantMessage = atomStore.get(lastAssistantMessageAtom);
-    return lastAssistantMessage?.filter((msg) => msg.type === MessageType.Product).length === 2;
+    return (
+      lastAssistantMessage?.filter((msg) => msg.type === MessageType.Product)
+        .length === 2
+    );
   };
 
   private static readonly checkPlpIds = async ({
@@ -244,12 +298,12 @@ class PageVariantService {
     plpIdExtractor: IdExtractor;
   }): Promise<boolean> => {
     let currentPlpId: string | null;
-    if (plpIdExtractor === 'url-resolver-plp-id') {
-      currentPlpId = await PageVariantService.getIdFromUrlResolver('plpId');
+    if (plpIdExtractor === "url-resolver-plp-id") {
+      currentPlpId = await PageVariantService.getIdFromUrlResolver("plpId");
     } else {
       currentPlpId = await PageVariantService.getId(plpIdExtractor);
     }
-    const result = plpIds.includes(currentPlpId ?? '');
+    const result = plpIds.includes(currentPlpId ?? "");
     return result;
   };
 
@@ -270,12 +324,14 @@ class PageVariantService {
     productIdExtractor: IdExtractor;
   }): Promise<boolean> => {
     let currentProductId: string | null;
-    if (productIdExtractor === 'url-resolver-product-id') {
-      currentProductId = await PageVariantService.getIdFromUrlResolver('productId');
+    if (productIdExtractor === "url-resolver-product-id") {
+      currentProductId = await PageVariantService.getIdFromUrlResolver(
+        "productId"
+      );
     } else {
       currentProductId = await PageVariantService.getId(productIdExtractor);
     }
-    const result = productIds.includes(currentProductId ?? '');
+    const result = productIds.includes(currentProductId ?? "");
     return result;
   };
 
@@ -295,7 +351,10 @@ class PageVariantService {
       const urlMap = Object.entries(extractor.map);
 
       const matched = urlMap.find(([, urls]) => {
-        const hostMatched = StringUtils.findMatchingPattern(urls, window.location);
+        const hostMatched = StringUtils.findMatchingPattern(
+          urls,
+          window.location
+        );
         if (hostMatched) {
           return hostMatched;
         }
@@ -312,53 +371,58 @@ class PageVariantService {
 
     Logger.logError(
       `[spiffy-ai] PageVariantService.getCategory error - extractor=${extractor} not supported`,
-      undefined,
+      undefined
     );
     return null;
   }
 
   static async getId(extractor?: IdExtractor): Promise<string | null> {
-    if (!extractor || extractor === 'null') {
+    if (!extractor || extractor === "null") {
       Logger.logDebug(
-        `[spiffy-ai] PageVariantService.getId - extractor=${extractor} is null or not supported`,
+        `[spiffy-ai] PageVariantService.getId - extractor=${extractor} is null or not supported`
       );
       return null;
     }
 
     // Handle URL resolver extractors
-    if (extractor === 'url-resolver-product-id') {
-      return PageVariantService.getIdFromUrlResolver('productId');
+    if (extractor === "url-resolver-product-id") {
+      return PageVariantService.getIdFromUrlResolver("productId");
     }
 
-    if (extractor === 'url-resolver-plp-id') {
-      return PageVariantService.getIdFromUrlResolver('plpId');
+    if (extractor === "url-resolver-plp-id") {
+      return PageVariantService.getIdFromUrlResolver("plpId");
     }
 
     // Handle regular extractors
     return ShopifyUrlService.getPlpOrPdpId(extractor);
   }
 
-  private static readonly getIdFromUrlResolver = async (field: 'productId' | 'plpId') => {
+  private static readonly getIdFromUrlResolver = async (
+    field: "productId" | "plpId"
+  ) => {
     const url = window._spiffy.variantUrlOverride ?? window.location.href;
     const response = await this.getCachedUrlResolver(url);
     // PDP
-    if (field === 'productId' && response.variant_type === 'pdp') {
+    if (field === "productId" && response.variant_type === "pdp") {
       let productId: string | undefined;
-      if (response.user_event?.attributes && 'product_id' in response.user_event.attributes) {
+      if (
+        response.user_event?.attributes &&
+        "product_id" in response.user_event.attributes
+      ) {
         productId = response.user_event.attributes.product_id;
       }
       return productId ?? null;
     }
 
     // PLP
-    if (field === 'plpId' && response.variant_type === 'plp') {
+    if (field === "plpId" && response.variant_type === "plp") {
       let plpId: string | undefined;
       if (
-        response.user_event?.category === 'plp_visit' &&
+        response.user_event?.category === "plp_visit" &&
         response.user_event.attributes &&
-        'attributes' in response.user_event.attributes &&
+        "attributes" in response.user_event.attributes &&
         response.user_event.attributes.attributes &&
-        'id' in response.user_event.attributes.attributes
+        "id" in response.user_event.attributes.attributes
       ) {
         plpId = response.user_event.attributes.attributes.id;
       }
@@ -500,24 +564,29 @@ class PageVariantService {
    * return any matches.
    */
   static readonly getVariantInfoWithPageConfig = async (
-    orgPageConfig: OrgPageConfig,
+    orgPageConfig: OrgPageConfig
   ): Promise<[VariantInfo, PageVariantConfig] | undefined> => {
     // First check if there is a variant override set
     if (window?._spiffy?.variantInfoOverride) {
-      Logger.logDebug('[spiffy-ai] Found variantInfoOverride', window._spiffy.variantInfoOverride);
+      Logger.logDebug(
+        "[spiffy-ai] Found variantInfoOverride",
+        window._spiffy.variantInfoOverride
+      );
       const matchingPageVariantConfig = orgPageConfig.pageVariants.find(
-        (pageVariant) => pageVariant.variantId === window._spiffy.variantInfoOverride?.variantId,
+        (pageVariant) =>
+          pageVariant.variantId ===
+          window._spiffy.variantInfoOverride?.variantId
       );
       if (matchingPageVariantConfig) {
         Logger.logInfo(
-          '[spiffy-ai] Returning overriden variantInfo',
-          window._spiffy.variantInfoOverride,
+          "[spiffy-ai] Returning overriden variantInfo",
+          window._spiffy.variantInfoOverride
         );
         return [window._spiffy.variantInfoOverride, matchingPageVariantConfig];
       }
       Logger.logWarn(
-        '[spiffy-ai] Found variantInfoOverride but no matching pageVariantConfig',
-        window._spiffy.variantInfoOverride,
+        "[spiffy-ai] Found variantInfoOverride but no matching pageVariantConfig",
+        window._spiffy.variantInfoOverride
       );
     }
 
@@ -562,7 +631,9 @@ class PageVariantService {
     // return the first variant that passes all of its tests
     for await (const pageVariant of [...orgPageConfig.pageVariants]) {
       const testResults = await Promise.all(
-        pageVariant.variantTests.map((test) => PageVariantService.pageTest(test, pageVariant)),
+        pageVariant.variantTests.map((test) =>
+          PageVariantService.pageTest(test, pageVariant)
+        )
       );
 
       if (testResults.every((result) => result)) {
@@ -579,11 +650,13 @@ class PageVariantService {
     }
 
     Logger.logWarn(
-      '[spiffy-ai] no pageVariantConfig matched',
+      "[spiffy-ai] no pageVariantConfig matched",
       undefined,
-      orgPageConfig.pageVariants,
+      orgPageConfig.pageVariants
+    );
+    await tellExtensionAboutInjectionError(
+      new Error("No pagevariantConfig matched")
     );
-    await tellExtensionAboutInjectionError(new Error('No pagevariantConfig matched'));
 
     return undefined;
   };
@@ -598,23 +671,23 @@ class PageVariantService {
    * @returns The supported event response from the backend, or undefined if the page is not supported.
    */
   static readonly checkSupportedEvent = async (
-    pageVariantConfig: PageVariantConfig,
+    pageVariantConfig: PageVariantConfig
   ): Promise<SupportedEvent | undefined> => {
     try {
       const variantInfo = await this.parsePageVariantConfig(
         pageVariantConfig,
-        window.location.href,
+        window.location.href
       );
 
       const usesURLResolver = pageVariantConfig.variantTests.some(
-        (test) => test.testType === PageVariantTestType.UrlResolver,
+        (test) => test.testType === PageVariantTestType.UrlResolver
       );
 
       if (
         !variantInfo ||
-        (variantInfo.variant === 'plp' && !variantInfo.plpId) ||
-        (variantInfo.variant === 'pdp' && !variantInfo.productId) ||
-        (variantInfo.variant === 'page_visit' && !variantInfo.url)
+        (variantInfo.variant === "plp" && !variantInfo.plpId) ||
+        (variantInfo.variant === "pdp" && !variantInfo.productId) ||
+        (variantInfo.variant === "page_visit" && !variantInfo.url)
       ) {
         return undefined;
       }
@@ -625,7 +698,7 @@ class PageVariantService {
       const visitEvent = createVisitUserEvent({ variantInfo });
 
       if (!visitEvent) {
-        Logger.logWarn('spiffy-ai] no visitEvent found', variantInfo);
+        Logger.logWarn("spiffy-ai] no visitEvent found", variantInfo);
         return undefined;
       }
 
@@ -648,15 +721,16 @@ class PageVariantService {
         numberOfReviews: 0,
       } as SupportedEvent;
 
-      if (variantInfo.variant === 'plp') {
-        const { top_category } = response.specific_details as UrlResolvingPLPConfig;
+      if (variantInfo.variant === "plp") {
+        const { top_category } =
+          response.specific_details as UrlResolvingPLPConfig;
         return {
           ...basicResponse,
           top_category,
         };
       }
 
-      if (variantInfo.variant === 'pdp') {
+      if (variantInfo.variant === "pdp") {
         const { collections, number_of_reviews, merchant_tags } =
           response.specific_details as UrlResolvingPDPConfig;
         return {
@@ -669,7 +743,9 @@ class PageVariantService {
 
       return basicResponse;
     } catch (error) {
-      Logger.logError('spiffy-ai] error checking supported event', error, { pageVariantConfig });
+      Logger.logError("spiffy-ai] error checking supported event", error, {
+        pageVariantConfig,
+      });
       return undefined;
     }
   };
@@ -684,21 +760,27 @@ class PageVariantService {
    */
   private static readonly parsePageVariantConfig = async (
     pageVariantConfig: PageVariantConfig,
-    url: string,
+    url: string
   ): Promise<VariantInfo | undefined> => {
     if (window?._spiffy?.variantInfoOverride) {
       return window._spiffy.variantInfoOverride;
     }
 
-    if (pageVariantConfig.variantType === 'pdp') {
-      let productId: string = '';
-      if (pageVariantConfig.productIdExtractor === 'url-resolver-product-id') {
-        productId = (await PageVariantService.getIdFromUrlResolver('productId')) ?? '';
+    if (pageVariantConfig.variantType === "pdp") {
+      let productId: string = "";
+      if (pageVariantConfig.productIdExtractor === "url-resolver-product-id") {
+        productId =
+          (await PageVariantService.getIdFromUrlResolver("productId")) ?? "";
       } else {
-        productId = (await PageVariantService.getId(pageVariantConfig.productIdExtractor)) ?? '';
+        productId =
+          (await PageVariantService.getId(
+            pageVariantConfig.productIdExtractor
+          )) ?? "";
       }
       const parentProductId =
-        (await PageVariantService.getId(pageVariantConfig.parentProductIdExtractor)) ?? '';
+        (await PageVariantService.getId(
+          pageVariantConfig.parentProductIdExtractor
+        )) ?? "";
       return {
         variantId: pageVariantConfig.variantId,
         variant: pageVariantConfig.variantType,
@@ -708,12 +790,14 @@ class PageVariantService {
       };
     }
 
-    if (pageVariantConfig.variantType === 'plp') {
-      let plpId: string = '';
-      if (pageVariantConfig.plpIdExtractor === 'url-resolver-plp-id') {
-        plpId = (await PageVariantService.getIdFromUrlResolver('plpId')) ?? '';
+    if (pageVariantConfig.variantType === "plp") {
+      let plpId: string = "";
+      if (pageVariantConfig.plpIdExtractor === "url-resolver-plp-id") {
+        plpId = (await PageVariantService.getIdFromUrlResolver("plpId")) ?? "";
       } else {
-        plpId = (await PageVariantService.getId(pageVariantConfig.plpIdExtractor)) ?? '';
+        plpId =
+          (await PageVariantService.getId(pageVariantConfig.plpIdExtractor)) ??
+          "";
       }
       return {
         variantId: pageVariantConfig.variantId,
@@ -723,18 +807,21 @@ class PageVariantService {
       };
     }
 
-    if (pageVariantConfig.variantType === 'page_visit') {
-      const pageVisitCategory = pageVariantConfig.variantTests.reduce<PageVisitCategory | null>(
-        (acc, currentTest) =>
-          currentTest.testType === PageVariantTestType.PageCategory
-            ? PageVariantService.getCategory(currentTest.extractor)
-            : acc,
-        null,
-      );
+    if (pageVariantConfig.variantType === "page_visit") {
+      const pageVisitCategory =
+        pageVariantConfig.variantTests.reduce<PageVisitCategory | null>(
+          (acc, currentTest) =>
+            currentTest.testType === PageVariantTestType.PageCategory
+              ? PageVariantService.getCategory(currentTest.extractor)
+              : acc,
+          null
+        );
 
       // This *should* only be the result of invalid config. Should we throw an error here or handle it with a default value?
       if (pageVisitCategory === null) {
-        throw new Error('[spiffy-ai] - Invalid variant config produced invalid pageVisitCategory');
+        throw new Error(
+          "[spiffy-ai] - Invalid variant config produced invalid pageVisitCategory"
+        );
       }
 
       return {
@@ -745,28 +832,28 @@ class PageVariantService {
       };
     }
 
-    if (pageVariantConfig.variantType === 'homepage') {
+    if (pageVariantConfig.variantType === "homepage") {
       return {
         variantId: pageVariantConfig.variantId,
-        variant: 'page_visit',
+        variant: "page_visit",
         pageVisitCategory: PageVisitCategory.Homepage,
         url,
       };
     }
 
-    if (pageVariantConfig.variantType === 'search') {
+    if (pageVariantConfig.variantType === "search") {
       return {
         variantId: pageVariantConfig.variantId,
-        variant: 'page_visit',
+        variant: "page_visit",
         pageVisitCategory: PageVisitCategory.Search,
         url,
       };
     }
 
-    if (pageVariantConfig.variantType === 'other') {
+    if (pageVariantConfig.variantType === "other") {
       return {
         variantId: pageVariantConfig.variantId,
-        variant: 'page_visit',
+        variant: "page_visit",
         pageVisitCategory: PageVisitCategory.Other,
         url,
       };

package/src/application/service/searchService.ts

@@ -4,7 +4,7 @@ import {
   ResponseError,
   SearchApi,
 } from "@spiffy-ai/commerce-api-client";
-import { getAtomStore } from "src/atoms/atomStore";
+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";