@envive-ai/react-hooks 0.1.5 → 0.1.7

package/src/application/models/validators/validateGraphQLFrontendConfig.ts

@@ -6,8 +6,8 @@ import {
   PageVariantTestType,
   WidgetMountingConfig,
 } from 'src/contexts/types';
-import { DOMInsertionType } from 'src/application/service/domMutations/domInsertionService';
-import { GridInsertionType } from 'src/application/service/domMutations/GridInsertionService';
+import { DOMInsertionType } from 'src/merchants/domInsertion';
+import { GridInsertionType } from 'src/merchants/gridInsertion';
 import Logger from 'src/application/logging/logger';
 
 // Helper function to validate and transform PageVariantQueryData to PageVariantConfig

package/src/application/utils/analyticsUtils.ts

@@ -1,13 +1,19 @@
-import Logger from 'src/application/logging/logger';
-import { AmplitudeAdapter, SpiffyMetricsEventName } from 'src/adapters/amplitude';
+import Logger from "src/application/logging/logger";
 import {
   isLegacyUAEcommerceEvent,
   isGA4EcommerceEvent,
   isBaseEcommerceEvent,
   BaseEcommerceEvent,
-} from 'src/application/models';
+} from "src/application/models";
+import { SpiffyMetricsEventName } from "src/contexts/amplitudeContext/amplitudeContext";
 
-const NORMALIZED_ADD_TO_CART_EVENT_NAMES = ['addtocart', 'addedtocart'];
+declare global {
+  interface Window {
+    dataLayer: any[];
+  }
+}
+
+const NORMALIZED_ADD_TO_CART_EVENT_NAMES = ["addtocart", "addedtocart"];
 const CHECK_DATA_LAYER_INTERVAL_MS = 500;
 const CHECK_DATA_LAYER_MAX_ATTEMPTS = 10;
 
@@ -19,8 +25,10 @@ const CHECK_DATA_LAYER_MAX_ATTEMPTS = 10;
  * @returns True if the event is an add_to_cart event, false otherwise.
  */
 const isAddToCartEvent = (event: string): boolean => {
-  const normalizedEvent = event.replace(/[-_]/g, '').toLowerCase();
-  return NORMALIZED_ADD_TO_CART_EVENT_NAMES.some((name) => normalizedEvent.includes(name));
+  const normalizedEvent = event.replace(/[-_]/g, "").toLowerCase();
+  return NORMALIZED_ADD_TO_CART_EVENT_NAMES.some((name) =>
+    normalizedEvent.includes(name)
+  );
 };
 
 /**
@@ -28,7 +36,13 @@ const isAddToCartEvent = (event: string): boolean => {
  *
  * @param event The event to track.
  */
-const handleAddToCartEvent = (event: BaseEcommerceEvent) => {
+const handleAddToCartEvent = (
+  event: BaseEcommerceEvent,
+  track: (
+    eventName: SpiffyMetricsEventName,
+    eventProps?: Record<string, unknown>
+  ) => void
+) => {
   let eventProps: Record<string, unknown>;
 
   if (isLegacyUAEcommerceEvent(event)) {
@@ -40,7 +54,7 @@ const handleAddToCartEvent = (event: BaseEcommerceEvent) => {
         quantity: product.quantity,
       })),
       currency: event.ecommerce.add.currencyCode,
-      event_format_version: 'legacy_universal_analytics',
+      event_format_version: "legacy_universal_analytics",
     };
   } else if (isGA4EcommerceEvent(event)) {
     eventProps = {
@@ -51,17 +65,16 @@ const handleAddToCartEvent = (event: BaseEcommerceEvent) => {
         quantity: item.quantity,
       })),
       currency: event.ecommerce.currency,
-      event_format_version: 'google_analytics_4',
+      event_format_version: "google_analytics_4",
     };
   } else {
     eventProps = {
       event_properties: { ...event },
-      event_format_version: 'unknown',
+      event_format_version: "unknown",
     };
   }
 
-  AmplitudeAdapter.trackEvent({
-    eventName: SpiffyMetricsEventName.AddToCartClicked,
+  track(SpiffyMetricsEventName.AddToCartClicked, {
     eventProps,
   });
 };
@@ -70,18 +83,23 @@ const handleAddToCartEvent = (event: BaseEcommerceEvent) => {
  * Wraps the window.dataLayer.push method to intercept add_to_cart events and send them to Amplitude.
  * This function runs on an interval until the dataLayer is available.
  */
-export const initDataLayerWrapper = () => {
+export const initDataLayerWrapper = (
+  track: (
+    eventName: SpiffyMetricsEventName,
+    eventProps?: Record<string, unknown>
+  ) => void
+) => {
   let attempts = 0;
 
   // currently, our bundle is always loaded after GTM has initialized GA/dataLayer
   // we'll need this check here if/when we load spiffy before/outside of GTM
   const checkAndInitialize = () => {
-    if (!window.dataLayer || !window.dataLayer.push) {
+    if (!window.dataLayer || !(window.dataLayer as any).push) {
       attempts += 1;
 
       if (attempts >= CHECK_DATA_LAYER_MAX_ATTEMPTS) {
         Logger.logDebug(
-          `[spiffy-ai] dataLayer not available after ${CHECK_DATA_LAYER_MAX_ATTEMPTS} attempts`,
+          `[spiffy-ai] dataLayer not available after ${CHECK_DATA_LAYER_MAX_ATTEMPTS} attempts`
         );
         return;
       }
@@ -90,21 +108,34 @@ export const initDataLayerWrapper = () => {
       return;
     }
 
-    Logger.logDebug('[spiffy-ai] dataLayer is available, wrapping push function...');
+    Logger.logDebug(
+      "[spiffy-ai] dataLayer is available, wrapping push function..."
+    );
     const originalPush = window.dataLayer.push;
-    window.dataLayer.push = (args: unknown) => {
-      if (isBaseEcommerceEvent(args) && isAddToCartEvent(args.event)) {
-        handleAddToCartEvent(args);
+    window.dataLayer.push = (...args: unknown[]) => {
+      if (
+        isBaseEcommerceEvent(args[0]) &&
+        isAddToCartEvent((args[0] as any).event)
+      ) {
+        handleAddToCartEvent(args[0] as BaseEcommerceEvent, track);
       }
 
       // IMPORTANT: call the original push method so that the event is still logged to GA
-      originalPush.apply(window.dataLayer, [args]);
+      return originalPush.apply(window.dataLayer, args);
     };
   };
 
   checkAndInitialize();
 };
 
-export const initAmplitude = () => {
-  AmplitudeAdapter.getSingletonInstanceOf();
+export const initAmplitude = (
+  track: (
+    eventName: SpiffyMetricsEventName,
+    eventProps?: Record<string, unknown>
+  ) => void
+) => {
+  // This function might not be needed anymore if Amplitude is initialized via context.
+  // For now, we'll keep it and pass the track function.
+  // If it's truly redundant, it can be removed later.
+  track(SpiffyMetricsEventName.BundleLoaded); // Example usage, adjust as needed
 };

package/src/application/utils/cdnUtils.ts

@@ -0,0 +1,11 @@
+import { getAtomStore } from "src/atoms/atomStore/atomStore";
+import { cdnUrlAtom } from "src/atoms/envive/enviveConfig";
+
+export const getCdnAssetURL = (
+  assetName: string,
+  orgShortName: string
+): string => {
+  const atomStore = getAtomStore();
+  const cdnUrl = atomStore.get(cdnUrlAtom) || "https://cdn.spiffy.ai/other";
+  return `${cdnUrl}/assets/${orgShortName}/${assetName}`;
+};

package/src/atoms/amplitude/amplitudeTrackEventAtom.ts

@@ -0,0 +1,15 @@
+import { atom } from "jotai";
+import { SpiffyMetricsEventName } from "src/contexts/amplitudeContext/amplitudeContext";
+
+interface TrackEventParams {
+  eventName: SpiffyMetricsEventName;
+  eventProps?: Record<string, unknown>;
+  eventGroups?: Record<string, unknown>;
+  alsoSendToGoogleAnalytics?: boolean;
+}
+
+// This atom will hold the trackEvent function from the Amplitude context.
+// It needs to be initialized by a React component that has access to the useAmplitude hook.
+export const amplitudeTrackEventAtom = atom<
+  ((params: TrackEventParams) => Promise<void>) | null
+>(null);

package/src/atoms/app/index.ts

@@ -5,9 +5,8 @@ import {
 import { atom } from "jotai";
 import { atomWithStorage } from "jotai/utils";
 import { VariantInfo } from "src/application/models";
-import { UserIdentityService } from "src/application/service/userIdentityService";
+import { UserIdentityContextType } from "src/contexts/userIdentityContext/userIdentityContext";
 import { variantInfoAtom } from "src/atoms/app/variant";
-import { orgIdAtom, orgShortNameAtom } from "src/atoms/org/org";
 import { v4 as uuid } from "uuid";
 import { contextSourceAtom } from "../envive/enviveConfig";
 
@@ -33,16 +32,20 @@ export const userIdAtom = atom(
       return maybeUserId;
     }
 
-    return UserIdentityService.getUserIdOrDefault();
+    return get(userIdentityAtom)?.getUserIdOrDefault() ?? "";
   },
   (_, set, value: string | undefined) => {
     set(internalUserIdAtom, value);
   }
 );
+
+export const userIdentityAtom = atom<UserIdentityContextType | undefined>(
+  undefined
+);
+
 export const appSourceAtom = atom<ContextSourceEnum>(
   (get): ContextSourceEnum => get(contextSourceAtom) ?? ContextSourceEnum.App
 );
-export const envAtom = atom<ContextEnvEnum>(ContextEnvEnum.Dev);
 export const chatIdAtom = atomWithStorage<string>(
   "v1-spiffy-chat-session-id",
   uuid(),
@@ -51,16 +54,3 @@ export const chatIdAtom = atomWithStorage<string>(
     getOnInit: true,
   }
 );
-
-export const appDetailsAtom = atom(
-  (get): AppDetails => ({
-    orgId: get(orgIdAtom) ?? "",
-    // TODO: orgShortName should be available when this atom is created
-    orgShortName: get(orgShortNameAtom) ?? "spiffy-ai",
-    chatId: get(chatIdAtom),
-    userId: get(userIdAtom),
-    source: get(appSourceAtom),
-    env: get(envAtom),
-    variantInfo: get(variantInfoAtom),
-  })
-);

package/src/atoms/app/variant.ts

@@ -14,7 +14,7 @@ import {
   OrgShortName,
 } from "src/application/models";
 import { sessionStorageUtil } from "src/atoms/atomStore/atomStore";
-import { featureFlagServiceAtom, orgShortNameAtom } from "src/atoms/org/org";
+import { enviveConfigAtom } from "src/atoms/envive/enviveConfig";
 
 export interface SupportedEvent
   extends Pick<
@@ -149,6 +149,14 @@ const internalStorageSupportedEventAtom = atomWithStorage<string | undefined>(
 );
 const internalSupportedEventAtom = atom<SupportedEvent | undefined>(undefined);
 
+const featureFlagServiceAtom = atom((get) => {
+  const config = get(enviveConfigAtom);
+  const featureOverrides = config?.featureOverrides;
+  return {
+    isFeatureGateEnabled: (gate: string) => featureOverrides?.[gate] || false,
+  };
+});
+
 export const supportedEventAtom = atom(
   (get): SupportedEvent | undefined => {
     const maybeSupportedEvent = get(internalStorageSupportedEventAtom);
@@ -170,7 +178,8 @@ export const supportedEventAtom = atom(
     const featureFlagService = get(featureFlagServiceAtom);
     const maybeSupportedEvent = get(internalSupportedEventAtom);
     const variantCategory = maybeSupportedEvent?.category;
-    const shortName = get(orgShortNameAtom);
+    const config = get(enviveConfigAtom);
+    const orgShortName = config?.orgShortName;
 
     // TODO: clean up this logic & the feature gate when we've fully rolled out
     if (
@@ -180,8 +189,8 @@ export const supportedEventAtom = atom(
       ) &&
       variantCategory &&
       variantCategory !== SupportedEventProductCategory.Shapewear &&
-      (shortName === OrgShortName.Spanx ||
-        shortName === OrgShortName.SpanxStaging)
+      (orgShortName === OrgShortName.Spanx ||
+        orgShortName === OrgShortName.SpanxStaging)
     ) {
       const modifiedSupportedEvent = {
         supported: false,

package/src/atoms/chat/chatState.ts

@@ -1,12 +1,19 @@
-import { UserEventCategory } from '@spiffy-ai/commerce-api-client/dist/models/UserEventCategory';
-import { atom } from 'jotai';
-import { AmplitudeAdapter, SpiffyMetricsEventName } from 'src/adapters/amplitude';
-import { FormSubmittedAttributes, Message, Suggestion, UserEvent } from 'src/application/models';
-import { ChatElementDisplayLocation } from 'src/application/models/chatElementDisplayLocation';
-import { SpiffyEventName } from 'src/application/models/events';
+import { UserEventCategory } from "@spiffy-ai/commerce-api-client/dist/models/UserEventCategory";
+import { atom } from "jotai";
+import { SpiffyMetricsEventName } from "src/contexts/amplitudeContext/amplitudeContext";
+import {
+  FormSubmittedAttributes,
+  Message,
+  Suggestion,
+  UserEvent,
+} from "src/application/models";
+import { ChatElementDisplayLocation } from "src/application/models/chatElementDisplayLocation";
+import { SpiffyEventName } from "src/application/models/events";
 
 export const userHasRepliedAtom = atom<boolean>(false);
-export const replyEventCategoryAtom = atom<UserEventCategory>(UserEventCategory.AppLoaded);
+export const replyEventCategoryAtom = atom<UserEventCategory>(
+  UserEventCategory.AppLoaded
+);
 export const userQueryAtom = atom<string>();
 export const suggestionAtom = atom<Suggestion | undefined>(undefined);
 export const askQuestionBtnClickedAtom = atom<boolean>(false);
@@ -20,25 +27,28 @@ export const requestFailureAtom = atom<boolean>(false);
 export const formSubmitAtom = atom<FormSubmittedAttributes>();
 export const chatOnToggleAtom = atom(
   null,
-  (get, set, triggerLocation?: ChatElementDisplayLocation) => {
+  (
+    get,
+    set,
+    triggerLocation?: ChatElementDisplayLocation,
+    track?: (
+      eventName: SpiffyMetricsEventName,
+      eventProps?: Record<string, unknown>
+    ) => void
+  ) => {
     const isOpen = get(chatIsOpenAtom);
     set(chatIsOpenAtom, !isOpen);
 
     if (!isOpen) {
       window.dispatchEvent(new CustomEvent(SpiffyEventName.WidgetOpen));
-      AmplitudeAdapter.trackEvent({
-        eventName: SpiffyMetricsEventName.ChatComponentExpanded,
-        eventProps: {
-          message_metadata: {
-            trigger_location: triggerLocation,
-          },
+      track?.(SpiffyMetricsEventName.ChatComponentExpanded, {
+        message_metadata: {
+          trigger_location: triggerLocation,
         },
       });
     } else {
       window.dispatchEvent(new CustomEvent(SpiffyEventName.WidgetClose));
-      AmplitudeAdapter.trackEvent({
-        eventName: SpiffyMetricsEventName.ChatComponentCollapsed,
-      });
+      track?.(SpiffyMetricsEventName.ChatComponentCollapsed);
     }
-  },
+  }
 );

package/src/atoms/chat/messageQueue.ts

@@ -6,8 +6,13 @@ import {
   UserEvent,
 } from "src/application/models";
 import { getAtomStore } from "src/atoms/atomStore/atomStore";
-import { appDetailsAtom } from "src/atoms/app";
-import { featureFlagServiceAtom } from "src/atoms/org/org";
+import { userIdAtom, chatIdAtom } from "src/atoms/app";
+import {
+  orgShortNameAtom,
+  contextSourceAtom,
+  envAtom,
+} from "src/atoms/envive/enviveConfig";
+import { orgIdAtom, featureFlagServiceAtom } from "src/atoms/org/graphqlConfig";
 
 const internalUserEventQueueAtom = atom<UserEvent[]>([]);
 
@@ -61,6 +66,12 @@ export const userQueueEventCountAtom = atom(
   (get) => get(userEventQueueAtom).length
 );
 
+import {
+  ContextSourceEnum,
+  ContextEnvEnum,
+} from "@spiffy-ai/commerce-api-client"; // Import necessary enums
+// import type { Context } from "@spiffy-ai/commerce-api-client/dist/models/Context"; // Import Context type
+
 export const createResponsePayload = ({
   userEvents,
   generationParams,
@@ -69,14 +80,34 @@ export const createResponsePayload = ({
   generationParams?: GenerationParams;
 }): NextMessageRequest => {
   const atomStore = getAtomStore();
-  const context = atomStore.get(appDetailsAtom);
+  const orgShortName = atomStore.get(orgShortNameAtom);
+  const orgId = atomStore.get(orgIdAtom);
+  const userId = atomStore.get(userIdAtom);
+  const chatId = atomStore.get(chatIdAtom);
+  const source = atomStore.get(contextSourceAtom);
+  const env = atomStore.get(envAtom);
+
   const featureFlagService = atomStore.get(featureFlagServiceAtom);
-  const featureFlags = featureFlagService?.getFeatureFlags() || {};
+
+  const context = {
+    userId: userId ?? "",
+    org_id: orgId ?? "",
+    org_short_name: orgShortName ?? "",
+    chat_id: chatId ?? "",
+    source: source ?? ContextSourceEnum.App,
+    env: (env as ContextEnvEnum) ?? ContextEnvEnum.Dev,
+  };
+
+  const featureFlags =
+    featureFlagService?.featureFlagService?.getFeatureFlags() || {};
+
   return {
     id: uuid(),
     context,
     userEvents,
-    featureFlags,
+    featureFlags: Object.fromEntries(
+      Object.entries(featureFlags).filter(([, isEnabled]) => isEnabled)
+    ), // Convert back to Record<string, boolean>
     generationParams,
   };
 };

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/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

@@ -1,8 +1,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/featureFlagServiceContext"; // Import FeatureFlagContextType from new context
 
 export const internalGraphQLColorsConfigAtom = atom<ColorMapping | undefined>(
   undefined
@@ -11,42 +11,10 @@ const internalGraphQLFrontendConfigAtom = atom<FrontendConfig | undefined>(
   undefined
 );
 
-export const colorsConfigAtom = atom(
-  async (get) => {
-    const colors = get(internalGraphQLColorsConfigAtom);
-    const orgShortName = get(orgShortNameAtom);
-    if (!orgShortName) {
-      return colors;
-    }
-    const orgInfo = await getOrgInfo(orgShortName);
-    const orgUIConfigColors = orgInfo.orgColors();
-
-    // If we have GraphQL colors, merge them with org colors (GraphQL takes priority)
-    if (
-      colors &&
-      orgUIConfigColors &&
-      Object.keys(orgUIConfigColors).length > 0
-    ) {
-      return { ...orgUIConfigColors, ...colors } as ColorMapping;
-    }
-
-    // If we have GraphQL colors but no org colors, return GraphQL colors
-    if (colors) {
-      return colors;
-    }
-
-    // If we have org colors but no GraphQL colors, return org colors
-    if (orgUIConfigColors && Object.keys(orgUIConfigColors).length > 0) {
-      return orgUIConfigColors as ColorMapping;
-    }
-
-    // Fallback to undefined if neither are available
-    return undefined;
-  },
-  (_, set, value: ColorMapping | undefined) => {
-    set(internalGraphQLColorsConfigAtom, value);
-  }
-);
+export const orgIdAtom = atom<string | undefined>(undefined); // New atom for orgId
+export const featureFlagServiceAtom = atom<FeatureFlagContextType | undefined>(
+  undefined
+); // New atom for FeatureFlagService
 
 export const frontendConfigAtom = atom(
   (get) => get(internalGraphQLFrontendConfigAtom),

package/src/atoms/org/index.ts

@@ -1,7 +1,6 @@
 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,4 @@
+import { atom } from "jotai";
+import { GraphQlConfigValues } from "src/contexts/graphqlContext";
+
+export const newOrgConfigAtom = atom<GraphQlConfigValues | null>(null);

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 = (