@envive-ai/react-hooks 0.1.5 → 0.1.6

package/src/atoms/chat/replies.ts

@@ -1,51 +1,59 @@
-import { atom } from 'jotai';
-import { Message, MessageType } from 'src/application/models';
+import { atom } from "jotai";
+import { Message, MessageType } from "src/application/models";
 import {
   userHasRepliedAtom,
   messagesAtom,
   userQueryAtom,
   replyEventCategoryAtom,
-} from 'src/atoms/chat';
-import { UserEventCategory } from '@spiffy-ai/commerce-api-client';
-import { AmplitudeAdapter, SpiffyMetricsEventName } from 'src/adapters/amplitude';
-import { queueUserEventAtom } from './messageQueue';
+} from "src/atoms/chat";
+import { UserEventCategory } from "@spiffy-ai/commerce-api-client";
+import { queueUserEventAtom } from "./messageQueue";
+import { SpiffyMetricsEventName } from "src/contexts/amplitudeContext";
+import { amplitudeTrackEventAtom } from "src/atoms/amplitude/amplitudeTrackEventAtom";
 
 type HandleReplyParams = {
   message: Message;
   userTyped: boolean;
 };
 
-export const handleReplyAtom = atom(null, (get, set, { message, userTyped }: HandleReplyParams) => {
-  if (message.type !== MessageType.QueryTyped) {
-    return;
-  }
+export const handleReplyAtom = atom(
+  null,
+  (get, set, { message, userTyped }: HandleReplyParams) => {
+    if (message.type !== MessageType.QueryTyped) {
+      return;
+    }
 
-  const queryTyped = message.metadata.content;
+    const trackEvent = get(amplitudeTrackEventAtom);
+    const queryTyped = message.metadata.content;
 
-  set(replyEventCategoryAtom, UserEventCategory.QueryTyped);
-  set(userQueryAtom, queryTyped);
-  set(messagesAtom, [...get(messagesAtom), [message]]);
-  set(userHasRepliedAtom, true);
-  set(queueUserEventAtom, {
-    eventId: message.id,
-    createdAt: message.createdAt,
-    category: UserEventCategory.QueryTyped,
-    attributes: {
-      query: queryTyped,
-    },
-  });
-  AmplitudeAdapter.trackEvent({
-    eventName: SpiffyMetricsEventName.ChatUserMessageInput,
-    eventProps: {
-      message_id: message.id,
-      message_role: message.role,
-      message_type: message.type,
-      message_metadata: {
-        content: AmplitudeAdapter.amplitudeSafeString(message?.metadata?.content),
-        created_at: message.createdAt,
-        user_typed: userTyped,
+    set(replyEventCategoryAtom, UserEventCategory.QueryTyped);
+    set(userQueryAtom, queryTyped);
+    set(messagesAtom, [...get(messagesAtom), [message]]);
+    set(userHasRepliedAtom, true);
+    set(queueUserEventAtom, {
+      eventId: message.id,
+      createdAt: message.createdAt,
+      category: UserEventCategory.QueryTyped,
+      attributes: {
+        query: queryTyped,
       },
-    },
-    alsoSendToGoogleAnalytics: true,
-  });
-});
+    });
+
+    if (trackEvent) {
+      trackEvent({
+        eventName: SpiffyMetricsEventName.ChatUserMessageInput,
+        eventProps: {
+          message_id: message.id,
+          message_role: message.role,
+          message_type: message.type,
+          message_metadata: {
+            content: message?.metadata?.content, // Removed amplitudeSafeString
+            created_at: message.createdAt,
+            user_typed: userTyped,
+          },
+        },
+        alsoSendToGoogleAnalytics: true,
+      });
+    }
+  }
+);

package/src/atoms/envive/enviveConfig.ts

@@ -2,7 +2,7 @@ import Logger from "src/application/logging/logger";
 import { atom } from "jotai";
 import { EnviveConfig } from "src/contexts/types";
 import { ContextSourceEnum } from "@spiffy-ai/commerce-api-client";
-import { LocalStorageService } from "src/application/service";
+import { LocalStorageKeys } from "src/contexts/localStorageContext";
 
 const internalEnviveConfigAtom = atom<EnviveConfig | undefined>(undefined);
 
@@ -48,15 +48,13 @@ export const cdnUrlAtom = atom((get) => {
 export const contextSourceAtom = atom((get) => {
   const config = get(enviveConfigAtom);
 
-  if (window.IS_STORYBOOK) {
-    return ContextSourceEnum.Test;
-  }
-
   if (config?.contextSource) {
     return config.contextSource as ContextSourceEnum;
   }
 
-  const spiffyOnFeatureFlagSet = LocalStorageService.getSpiffyOnFeatureFlag();
+  const spiffyOnFeatureFlagSet = window.localStorage.getItem(
+    LocalStorageKeys.SpiffyOnOverride
+  );
   if (spiffyOnFeatureFlagSet === "true") {
     return ContextSourceEnum.Playground;
   }
@@ -79,3 +77,9 @@ export const identifyingPrefixAtom = atom((get) => {
   Logger.logDebug("enviveConfig.ts: Accessing identifyingPrefix", config);
   return config?.identifyingPrefix || "spiffy";
 });
+
+export const publicKeyAtom = atom((get) => {
+  const config = get(enviveConfigAtom);
+  Logger.logDebug("enviveConfig.ts: Accessing publicKey", config);
+  return config?.publicKey;
+});

package/src/atoms/org/graphqlConfig.ts

@@ -2,7 +2,8 @@ import { atom } from "jotai";
 import { ColorMapping } from "src/application/models/colorsConfig";
 import { FrontendConfig } from "src/application/models/frontendConfig";
 import { getOrgInfo } from "src/application/models/supportedOrgs";
-import { orgShortNameAtom } from "src/atoms/org/org";
+import { orgShortNameAtom } from "../envive/enviveConfig";
+import { FeatureFlagContextType } from "src/contexts/featureFlagServiceContext"; // Import FeatureFlagContextType from new context
 
 export const internalGraphQLColorsConfigAtom = atom<ColorMapping | undefined>(
   undefined
@@ -11,6 +12,11 @@ const internalGraphQLFrontendConfigAtom = atom<FrontendConfig | undefined>(
   undefined
 );
 
+export const orgIdAtom = atom<string | undefined>(undefined); // New atom for orgId
+export const featureFlagServiceAtom = atom<FeatureFlagContextType | undefined>(
+  undefined
+); // New atom for FeatureFlagService
+
 export const colorsConfigAtom = atom(
   async (get) => {
     const colors = get(internalGraphQLColorsConfigAtom);

package/src/atoms/org/index.ts

@@ -1,7 +1,7 @@
 export * from "./customerService";
 export * from "./graphqlConfig";
-export * from "./merchantCss";
-export * from "./org";
+// export * from "./org";
 export * from "./orgAnalyticsConfig";
 export * from "./orgPageConfig";
-export * from "./orgUIConfig";
+export * from "./newOrgConfigAtom";
+// export * from "./orgUIConfig";

package/src/atoms/org/newOrgConfigAtom.ts

@@ -0,0 +1,8 @@
+import { atom } from "jotai";
+import { BasicOrgInfoType } from "src/application/models";
+import { GraphQlConfigValues } from "src/contexts";
+import { NewOrgConfigContextType } from "src/contexts/newOrgConfigContext";
+
+export const newOrgConfigAtom = atom<
+  (GraphQlConfigValues & BasicOrgInfoType) | null
+>(null);

package/src/atoms/org/orgPageConfig.ts

@@ -1,18 +1,19 @@
 import { atom } from "jotai";
 import { getOrgInfo } from "src/application/models";
 import { frontendConfigAtom } from "src/atoms/org/graphqlConfig";
-import { orgConfigAtom } from "src/atoms/org/org";
+import { enviveConfigAtom } from "src/atoms/envive/enviveConfig";
 import { PageVariantConfig } from "src/contexts/types";
 
 const internalInjectedPageVariantsAtom = atom<PageVariantConfig[]>([]);
 
 export const orgPageConfigAtom = atom(
   async (get) => {
-    const orgConfig = get(orgConfigAtom);
-    if (!orgConfig) {
-      throw new Error("orgConfig is not available");
+    const enviveConfig = get(enviveConfigAtom);
+    const orgShortName = enviveConfig?.orgShortName;
+    if (!orgShortName) {
+      throw new Error("orgShortName is not available from enviveConfig");
     }
-    const orgInfo = await getOrgInfo(orgConfig.org.org.shortName);
+    const orgInfo = await getOrgInfo(orgShortName);
     const frontendConfig = get(frontendConfigAtom);
     const injectedPageVariants = get(internalInjectedPageVariantsAtom);
     const localOrgPageConfig = orgInfo.orgPageConfig();

package/src/atoms/search/chatSearch.ts

@@ -14,7 +14,7 @@ import {
   userQueryAtom,
 } from "src/atoms/chat";
 import { queueUserEventAtom } from "../chat/messageQueue";
-import { orgUIConfigAtom } from "../org";
+import { newOrgConfigAtom } from "../org";
 import { ProductFilters } from "./productFilters";
 import { ProductSorter } from "./productSorter";
 import { ChatSearchStateType, ProductSorting } from "./types";
@@ -75,8 +75,11 @@ const buildChatSearchTurn = (
 };
 
 const chatSearchFilterConfigAtom = atom((get) => {
-  const orgUIConfig = get(orgUIConfigAtom);
-  return orgUIConfig?.searchConfig?.searchFilterConfig || [];
+  const newOrgConfig = get(newOrgConfigAtom);
+  return (
+    newOrgConfig?.frontendConfig?.uiConfigs?.searchConfig?.searchFilterConfig ||
+    []
+  );
 });
 
 const searchMapAtom = atom((get) => {
@@ -107,8 +110,11 @@ export const selectedFilterOptionsAtom = atom<SelectedChatSearchFilterOption[]>(
 );
 
 export const additiveDynamicFiltersAtom = atom((get) => {
-  const orgUIConfig = get(orgUIConfigAtom);
-  return orgUIConfig?.searchConfig?.additiveDynamicFilters ?? false;
+  const newOrgConfig = get(newOrgConfigAtom);
+  return (
+    newOrgConfig?.frontendConfig?.uiConfigs?.searchConfig
+      ?.additiveDynamicFilters ?? false
+  );
 });
 
 export const createChatSearchFilterOption = (

package/src/atoms/search/searchAPI.ts

@@ -1,10 +1,10 @@
 import { atom } from "jotai";
 import { SearchResult, SearchParams } from "src/application/models/api/search";
-import SearchService from "src/application/service/searchService";
 import { ProductSorting } from "./types";
 import { ProductFilters } from "./productFilters";
 import { ProductSorter } from "./productSorter";
-import { orgUIConfigAtom } from "../org";
+import { newOrgConfigAtom } from "../org";
+import { getSearchServiceFunction } from "./searchServiceAdapter";
 
 export type SelectedFilterOption = {
   id: string; // "filterId:filterItemId" - maintains backward compatibility for comparisons
@@ -91,15 +91,19 @@ export const filteredSearchProductsAtom = atom((get) => {
   const searchData = get(searchAtom).data;
   const sorting = get(searchProductSortingAtom);
   const selectedFilters = get(searchSelectedFiltersAtom);
-  const orgConfig = get(orgUIConfigAtom);
+  const newOrgConfig = get(newOrgConfigAtom);
 
-  if (!searchData?.products || !orgConfig?.searchConfig) return [];
+  if (
+    !searchData?.products ||
+    !newOrgConfig?.frontendConfig?.uiConfigs?.searchConfig
+  )
+    return [];
 
   const filteredProducts = ProductFilters.filterProducts(
     searchData.products,
-    orgConfig.searchConfig.searchFilterConfig,
+    newOrgConfig.frontendConfig.uiConfigs.searchConfig.searchFilterConfig,
     selectedFilters,
-    orgConfig.searchConfig.additiveDynamicFilters
+    newOrgConfig.frontendConfig.uiConfigs.searchConfig.additiveDynamicFilters
   );
 
   return ProductSorter.sort(filteredProducts, sorting);
@@ -108,13 +112,17 @@ export const filteredSearchProductsAtom = atom((get) => {
 export const searchFiltersAtom = atom((get) => {
   const searchData = get(searchAtom).data;
   const selectedFilters = get(searchSelectedFiltersAtom);
-  const orgConfig = get(orgUIConfigAtom);
+  const newOrgConfig = get(newOrgConfigAtom);
 
-  if (!searchData?.products || !orgConfig?.searchConfig) return [];
+  if (
+    !searchData?.products ||
+    !newOrgConfig?.frontendConfig?.uiConfigs?.searchConfig
+  )
+    return [];
 
   return ProductFilters.getFiltersForProducts(
     searchData.products,
-    orgConfig.searchConfig.searchFilterConfig,
+    newOrgConfig.frontendConfig.uiConfigs.searchConfig.searchFilterConfig,
     selectedFilters
   );
 });
@@ -148,9 +156,10 @@ export const performSearchAtom = atom(
   null,
   async (get, set, params: SearchParams, allowRedirect = false) => {
     const currentState = get(searchAtom);
-    const orgUIConfig = get(orgUIConfigAtom);
+    const newOrgConfig = get(newOrgConfigAtom);
     const redirectSearchResultsUrl =
-      orgUIConfig?.searchConfig?.redirectSearchResultsUrl;
+      newOrgConfig?.frontendConfig?.uiConfigs?.searchConfig
+        ?.redirectSearchResultsUrl;
 
     if (allowRedirect && redirectSearchResultsUrl) {
       const redirectUrl = new URL(redirectSearchResultsUrl);
@@ -183,7 +192,8 @@ export const performSearchAtom = atom(
       lastQuery: params.query,
     });
     try {
-      const result = await SearchService.searchProducts(params);
+      const searchServiceFunction = getSearchServiceFunction();
+      const result = await searchServiceFunction(params);
       set(searchAtom, {
         data: result,
         loading: false,

package/src/atoms/search/searchServiceAdapter.ts

@@ -0,0 +1,25 @@
+import { SearchResult, SearchParams } from "src/application/models/api/search";
+
+// This will be set by the SearchProvider when it initializes
+let searchServiceFunction:
+  | ((params: SearchParams) => Promise<SearchResult>)
+  | null = null;
+
+export const setSearchServiceFunction = (
+  fn: (params: SearchParams) => Promise<SearchResult>
+) => {
+  searchServiceFunction = fn;
+};
+
+export const getSearchServiceFunction = () => {
+  if (!searchServiceFunction) {
+    throw new Error(
+      "Search service function not initialized. Make sure SearchProvider is mounted."
+    );
+  }
+  return searchServiceFunction;
+};
+
+export const clearSearchServiceFunction = () => {
+  searchServiceFunction = null;
+};