@envive-ai/react-hooks 0.1.0

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

@@ -0,0 +1,37 @@
+import { OrganizationConfig } from 'src/application/models/api/organizationConfig';
+import { isApiOrganizationConfig } from 'src/application/models/guards/api/isApiOrganizationConfig';
+
+export const validateOrganizationConfig = (data: unknown): OrganizationConfig | undefined => {
+  if (!isApiOrganizationConfig(data)) {
+    return undefined;
+  }
+
+  return {
+    id: data.id,
+    createdAt: data.created_at.toISOString(),
+    namespace: data.namespace,
+    organizationId: data.organization_id,
+    isLatest: data.is_latest,
+    version: data.version,
+    updatedAt: data.updated_at.toISOString(),
+    config: {
+      amplitude: data.config.amplitude
+        ? {
+            sessionReplayEnabled: data.config.amplitude.session_replay_enabled,
+            sessionReplaySampleRate: data.config.amplitude.session_replay_sample_rate,
+            trackingEnabled: data.config.amplitude.tracking_enabled,
+          }
+        : undefined,
+      customerService: data.config.customer_service
+        ? {
+            provider: data.config.customer_service.provider,
+          }
+        : undefined,
+      googleAnalytics: data.config.google_analytics
+        ? {
+            measurementId: data.config.google_analytics.measurement_id,
+          }
+        : undefined,
+    },
+  };
+};

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

@@ -0,0 +1,187 @@
+import { ResponseCategory } from '@spiffy-ai/commerce-api-client';
+import { Response, ReviewRichInformation } from 'src/application/models/index';
+import { ApiReviewRichInformation } from 'src/application/models/api/responseGenerics';
+import { isApiPageResponseAttributes } from 'src/application/models/guards/api/isApiPageResponseAttributes';
+import { isApiProductResponseAttributes } from 'src/application/models/guards/api/isApiProductResponseAttributes';
+import { isApiResponse } from 'src/application/models/guards/api/isApiResponse';
+import { isApiReviewResponseAttributes } from 'src/application/models/guards/api/isApiReviewResponseAttributes';
+import { isApiTextResponseAttributes } from 'src/application/models/guards/api/isApiTextResponseAttributes';
+import { isApiProductSearchResponseAttributes } from 'src/application/models/guards/api/isApiProductSearchAttributes';
+import { isApiFormResponseAttributes } from 'src/application/models/guards/api/isApiFormResponse';
+import { isApiOrderResponseAttributes } from 'src/application/models/guards/api/isApiOrderResponseAttributes';
+import { stringToFulfillmentDisplayStatusEnumValue } from 'src/application/models/utils/stringToFulfillmentDisplayStatusEnumValue';
+import { isApiProductSearchFilterResponseAttributes } from 'src/application/models/guards/api/isApiProductSearchFilterAttributes';
+
+const richInformationFromCommerceRichInformation = (
+  data: ApiReviewRichInformation,
+): ReviewRichInformation => ({
+  cons: data.cons,
+  pros: data.pros,
+  reviewDate: data.review_date,
+  reviewerTitle: data.reviewer_title,
+  productFamiliarity: data.product_familiarity,
+});
+
+export const validateResponse = (data: unknown): Response | undefined => {
+  if (!isApiResponse(data)) {
+    return undefined;
+  }
+
+  if (data.category === ResponseCategory.Text && isApiTextResponseAttributes(data.attributes)) {
+    return {
+      id: data.id,
+      createdAt: data.created_at,
+      category: ResponseCategory.Text,
+      attributes: {
+        content: data.attributes.content,
+      },
+    };
+  }
+
+  if (
+    data.category === ResponseCategory.Product &&
+    isApiProductResponseAttributes(data.attributes)
+  ) {
+    return {
+      id: data.id,
+      createdAt: data.created_at,
+      category: ResponseCategory.Product,
+      attributes: {
+        id: data.attributes.id,
+        description: data.attributes.description,
+        imageUrl: data.attributes.image_url,
+        imageUrls: data.attributes.image_urls,
+        title: data.attributes.title,
+        url: data.attributes.url,
+        originalPrice: data.attributes.original_price,
+        salePrice: data.attributes.sale_price,
+        averageRating: data.attributes.average_rating,
+        numberReviews: data.attributes.number_reviews,
+        metadata: data.attributes.metadata,
+        isForGrid: data.attributes.is_for_grid,
+        colors: data.attributes.colors,
+        sizes: data.attributes.sizes,
+        filters: data.attributes.filters,
+      },
+    };
+  }
+
+  if (data.category === ResponseCategory.Review && isApiReviewResponseAttributes(data.attributes)) {
+    return {
+      id: data.id,
+      createdAt: data.created_at,
+      category: ResponseCategory.Review,
+      attributes: {
+        id: data.attributes.id,
+        productId: data.attributes.product_id,
+        title: data.attributes.title,
+        reviewer: data.attributes.reviewer,
+        review: data.attributes.review,
+        stars: data.attributes.stars,
+        richInformation: data.attributes.rich_information
+          ? richInformationFromCommerceRichInformation(data.attributes.rich_information)
+          : undefined,
+      },
+    };
+  }
+
+  if (data.category === ResponseCategory.Separator) {
+    return {
+      id: data.id,
+      createdAt: data.created_at,
+      category: ResponseCategory.Separator,
+    };
+  }
+
+  if (data.category === ResponseCategory.Page && isApiPageResponseAttributes(data.attributes)) {
+    return {
+      id: data.id,
+      createdAt: data.created_at,
+      category: ResponseCategory.Page,
+      attributes: {
+        id: data.attributes.id,
+        title: data.attributes.title,
+        description: data.attributes.description,
+        url: data.attributes.url,
+      },
+    };
+  }
+
+  if (data.category === ResponseCategory.Form && isApiFormResponseAttributes(data.attributes)) {
+    return {
+      id: data.id,
+      createdAt: data.created_at,
+      category: ResponseCategory.Form,
+      attributes: {
+        formCategory: data.attributes.form_category
+          ? {
+              formType: data.attributes.form_category.form_type,
+            }
+          : undefined,
+        schema: {
+          properties: data.attributes.schema.properties,
+          required: data.attributes.schema.required.map(String),
+        },
+      },
+    };
+  }
+
+  if (
+    data.category === ResponseCategory.ProductSearch &&
+    isApiProductSearchResponseAttributes(data.attributes)
+  ) {
+    return {
+      id: data.id,
+      createdAt: data.created_at,
+      category: ResponseCategory.ProductSearch,
+      attributes: {
+        generatedQuery: data.attributes.generated_query,
+        productCount: data.attributes.product_count,
+      },
+    };
+  }
+
+  if (
+    data.category === ResponseCategory.ProductSearchFilter &&
+    isApiProductSearchFilterResponseAttributes(data.attributes)
+  ) {
+    return {
+      id: data.id,
+      createdAt: data.created_at,
+      category: ResponseCategory.ProductSearchFilter,
+      attributes: {
+        filterName: data.attributes.filter_name,
+      },
+    };
+  }
+
+  if (data.category === ResponseCategory.Order && isApiOrderResponseAttributes(data.attributes)) {
+    return {
+      id: data.id,
+      createdAt: data.created_at,
+      category: ResponseCategory.Order,
+      attributes: {
+        orderId: data.attributes.order_id,
+        orderNumber: data.attributes.order_number,
+        createdAt: data.attributes.created_at,
+        latestEventDate: data.attributes.latest_event_date,
+        lineItems: data.attributes.line_items.map((item) => ({
+          itemTitle: item.item_title,
+          itemPrice: item.item_price,
+          itemQuantity: item.item_quantity,
+          orderItemId: item.order_item_id,
+          image: item.image ?? undefined,
+          inTransitAt: item.in_transit_at ?? undefined,
+          deliveredAt: item.delivered_at ?? undefined,
+          estimatedDeliveryAt: item.estimated_delivery_at ?? undefined,
+          fulfillmentDisplayStatus: item.fulfillment_display_status
+            ? stringToFulfillmentDisplayStatusEnumValue(item.fulfillment_display_status)
+            : undefined,
+          trackingUrl: item.tracking_url ?? undefined,
+        })),
+      },
+    };
+  }
+
+  return undefined;
+};

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

@@ -0,0 +1,16 @@
+import { isSuggestion } from '../guards/api/isApiSuggestion';
+import { Suggestion } from '../api/suggestion';
+
+export const validateSuggestion = (data: unknown): Suggestion | undefined => {
+  if (!isSuggestion(data)) {
+    return undefined;
+  }
+
+  return {
+    id: data.id,
+    category: data.category,
+    content: data.content,
+    createdAt: data.created_at,
+    isAnswer: data.is_answer,
+  };
+};

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

@@ -0,0 +1,110 @@
+import { UserEventCategory } from '@spiffy-ai/commerce-api-client';
+import { isApiUserEvent } from 'src/application/models/guards/api/isApiUserEvent';
+import { UserEvent } from 'src/application/models/index';
+import { isApiPDPAttributes } from 'src/application/models/guards/api/isApiPDPEventAttributes';
+import { isApiQueryTypedAttributes } from 'src/application/models/guards/api/isApiQueryTypedEventAttributes';
+import { isApiSearchAttributes } from 'src/application/models/guards/api/isApiSearchEventAttributes';
+import { isApiSuggestionClickedAttributes } from 'src/application/models/guards/api/isApiSuggestionClickedEventAttributes';
+import {
+  isApiPLPEventAttributes,
+  isApiPLPIdAttribute,
+} from 'src/application/models/guards/api/isApiPLPEventAttributes';
+import { isApiFormSubmittedResponseAttributes } from 'src/application/models/guards/api/isApiFormSubmittedResponseAttributes';
+
+export const validateUserEvent = (data: unknown): UserEvent | undefined => {
+  if (!isApiUserEvent(data)) {
+    return undefined;
+  }
+
+  if (data.category === UserEventCategory.PdpVisit && isApiPDPAttributes(data.attributes)) {
+    return {
+      eventId: data.event_id,
+      createdAt: data.created_at,
+      category: UserEventCategory.PdpVisit,
+      attributes: {
+        productId: data.attributes.product_id,
+        parentProductId: data.attributes.parent_product_id,
+        url: data.attributes.url,
+      },
+    };
+  }
+
+  if (
+    data.category === UserEventCategory.QueryTyped &&
+    isApiQueryTypedAttributes(data.attributes)
+  ) {
+    return {
+      eventId: data.event_id,
+      createdAt: data.created_at,
+      category: UserEventCategory.QueryTyped,
+      attributes: {
+        query: data.attributes.query,
+      },
+    };
+  }
+
+  if (data.category === UserEventCategory.Search && isApiSearchAttributes(data.attributes)) {
+    return {
+      eventId: data.event_id,
+      createdAt: data.created_at,
+      category: UserEventCategory.Search,
+      attributes: {
+        searchTerm: data.attributes.search_term,
+        selectedFilters: data.attributes.selected_filters,
+      },
+    };
+  }
+
+  if (
+    data.category === UserEventCategory.SuggestionClicked &&
+    isApiSuggestionClickedAttributes(data.attributes)
+  ) {
+    return {
+      eventId: data.event_id,
+      createdAt: data.created_at,
+      category: UserEventCategory.SuggestionClicked,
+      attributes: {
+        suggestionId: data.attributes.suggestion_id,
+      },
+    };
+  }
+
+  if (data.category === UserEventCategory.PlpVisit && isApiPLPEventAttributes(data.attributes)) {
+    if (isApiPLPIdAttribute(data.attributes)) {
+      return {
+        eventId: data.event_id,
+        createdAt: data.created_at,
+        category: UserEventCategory.PlpVisit,
+        attributes: {
+          category: data.attributes.category,
+          attributes: {
+            id: data.attributes.id,
+          },
+        },
+      };
+    }
+  }
+
+  if (
+    data.category === UserEventCategory.FormSubmitted &&
+    isApiFormSubmittedResponseAttributes(data.attributes)
+  ) {
+    return {
+      eventId: data.event_id,
+      createdAt: data.created_at,
+      category: UserEventCategory.FormSubmitted,
+      attributes: {
+        filledSchema: { ...data.attributes.filled_schema },
+        formResponseId: data.attributes.form_response_id,
+        formType: data.attributes.form_type,
+      },
+    };
+  }
+
+  // we're not using app_unloaded at the moment so return the app_loaded event as default
+  return {
+    eventId: data.event_id,
+    createdAt: data.created_at,
+    category: UserEventCategory.AppLoaded,
+  };
+};

package/src/application/models/variantInfo/index.ts

@@ -0,0 +1 @@
+export * from './variantInfo';

package/src/application/models/variantInfo/pageVisitInfo.ts

@@ -0,0 +1,6 @@
+import { PageVisitCategory } from '@spiffy-ai/commerce-api-client';
+
+export interface PageVisitInfo {
+  url: string;
+  pageVisitCategory: PageVisitCategory;
+}

package/src/application/models/variantInfo/plpInfo.ts

@@ -0,0 +1,3 @@
+export interface PLPInfo {
+  plpId: string;
+}

package/src/application/models/variantInfo/productInfo.ts

@@ -0,0 +1,5 @@
+export interface ProductInfo {
+  productId: string;
+  parentProductId?: string;
+  url?: string;
+}

package/src/application/models/variantInfo/variantInfo.ts

@@ -0,0 +1,23 @@
+import { PLPInfo } from './plpInfo';
+import { PageVisitInfo } from './pageVisitInfo';
+import { ProductInfo } from './productInfo';
+
+export type VariantType = 'pdp' | 'plp' | 'page_visit';
+
+export type VariantInfo = PDPVariantInfo | PLPVariantInfo | PageVisitVariantInfo;
+
+export type PDPVariantInfo = {
+  variantId: string;
+  variant: 'pdp';
+} & ProductInfo;
+
+export type PLPVariantInfo = {
+  variantId: string;
+  variant: 'plp';
+  url?: string;
+} & PLPInfo;
+
+export type PageVisitVariantInfo = {
+  variantId: string;
+  variant: 'page_visit';
+} & PageVisitInfo;

package/src/application/service/cachingService.ts

@@ -0,0 +1,84 @@
+import { CachedValue } from '../models/cachedValue';
+import Logger from '../logging/logger';
+
+const CACHE_VERSION = 1.2;
+const CACHE_ENABLED = true;
+
+function cacheableAsync<T extends (...args: never[]) => Promise<unknown>>(func: T, expiry: number) {
+  return async function (...args: Parameters<T>): Promise<ReturnType<T>> {
+    const cacheKey = `spiffy:${CACHE_VERSION}:${JSON.stringify(args)}`;
+
+    // Check if the value is cached in local storage
+    const cachedValueString: string | null = localStorage.getItem(cacheKey);
+    if (cachedValueString !== null) {
+      // Return cached value, parsed as appropriate type
+      const cachedValue: CachedValue = JSON.parse(cachedValueString);
+      if (CACHE_ENABLED && cachedValue.expiry > Date.now() && cachedValue.value !== null) {
+        // Logger.logDebug(
+        //   `[cache-hit] Returning cached value for ${cacheKey}`,
+        //   cachedValue.value,
+        //   cachedValue.expiry,
+        //   Date.now(),
+        // );
+        // @ts-expect-error unknown return type
+        return cachedValue.value;
+      }
+    }
+
+    // Call the original function
+    // @ts-expect-error unknown return type
+    return func(...args)
+      .then((result) => {
+        if (result) {
+          // Cache the result in local storage
+          const cachedValue: CachedValue = {
+            value: result,
+            expiry: Date.now() + expiry,
+          };
+          localStorage.setItem(cacheKey, JSON.stringify(cachedValue));
+          // Logger.logDebug(`[cache-miss] Returning cached value for ${cacheKey}`, cachedValue.value);
+        }
+        return result;
+      })
+      .catch((error) => {
+        Logger.logError(`[cache-error] Error invoking cacheable underlying func`, error);
+        throw error;
+      });
+  };
+}
+
+function cacheable<T extends (...args: unknown[]) => unknown>(func: T, expiry: number) {
+  return function (...args: Parameters<T>): ReturnType<T> {
+    const cacheKey = `spiffy:${CACHE_VERSION}:${JSON.stringify(args)}`;
+
+    // Check if the value is cached in local storage
+    const cachedValueString: string | null = localStorage.getItem(cacheKey);
+    if (cachedValueString !== null) {
+      // Return cached value, parsed as appropriate type
+      const cachedValue: CachedValue = JSON.parse(cachedValueString);
+      if (CACHE_ENABLED && cachedValue.expiry > Date.now() && cachedValue.value !== null) {
+        Logger.logDebug(`[cache-hit] Returning cached value for ${cacheKey}`, cachedValue.value);
+        // @ts-expect-error unknown return type
+        return cachedValue.value;
+      }
+    }
+
+    // Call the original function
+    const result = func(...args);
+
+    // Cache the result in local storage
+    if (result) {
+      const cachedValue: CachedValue = {
+        value: result,
+        expiry: Date.now() + expiry,
+      };
+      localStorage.setItem(cacheKey, JSON.stringify(cachedValue));
+      // Logger.logDebug(`[cache-miss] Returning cached value for ${cacheKey}`, cachedValue.value);
+    }
+
+    // @ts-expect-error unknown return type
+    return result;
+  };
+}
+
+export { cacheable, cacheableAsync };

package/src/application/service/cdnService.ts

@@ -0,0 +1,18 @@
+import { useEnviveConfig } from "src/contexts/enviveConfigContext";
+
+class CdnService {
+  static get CDN_URL() {
+    const { cdnUrl } = useEnviveConfig();
+    return cdnUrl || "https://cdn.spiffy.ai/other";
+  }
+
+  static getCndBasePath() {
+    return CdnService.CDN_URL;
+  }
+
+  static getAssetURL(assetName: string, orgShortName: string) {
+    return `${CdnService.getCndBasePath()}/assets/${orgShortName}/${assetName}`;
+  }
+}
+
+export { CdnService };

package/src/application/service/customerService/index.ts

@@ -0,0 +1,8 @@
+import { UnsupportedCustomerService } from "./providers/UnsupportedCustomerService";
+import { CustomerServiceIntegration, CustomerServiceType } from "./types";
+
+export const findCustomerServiceImpl = (
+  _provider: CustomerServiceType | undefined
+): CustomerServiceIntegration => {
+  return UnsupportedCustomerService;
+};

package/src/application/service/customerService/providers/UnsupportedCustomerService.ts

@@ -0,0 +1,15 @@
+import { CustomerServiceProvider } from '@spiffy-ai/commerce-api-client';
+import Logger from 'src/application/logging/logger';
+
+import { CustomerServiceIntegration } from '../types';
+
+export const UnsupportedCustomerService: CustomerServiceIntegration = ({
+  provider: CustomerServiceProvider.Unsupported,
+  supportedIntegrationModes: [],
+  isEnabled: () => false,
+
+  onSwitchToAgent: () => {
+    Logger.logInfo('Spiffy: Switch to Agent - Unsupported');
+  },
+  isBusinessHours: () => Promise.resolve(false)
+})

package/src/application/service/customerService/types.ts

@@ -0,0 +1,31 @@
+import { CustomerServiceProvider } from "@spiffy-ai/commerce-api-client";
+
+export enum CustomerServiceType {
+  shopify = "shopify",
+  gorgias = "gorgias",
+  kustomer = "kustomer",
+  groove = "groove",
+  tidio = "tidio",
+  zowie = "zowie",
+  redo = "redo",
+  gladly = "gladly",
+  richpanel = "richpanel",
+  zendesk = "zendesk",
+  unsupported = "unsupported",
+}
+export enum CustomerServiceIntegrationMode {
+  none = "none",
+  simple = "simple",
+  full = "full",
+}
+
+export interface CustomerServiceIntegration {
+  provider: CustomerServiceProvider;
+  supportedIntegrationModes: CustomerServiceIntegrationMode[];
+  allowFileUpload?: boolean;
+  maxfileUploadSize?: number;
+  // TODO: Remove this method when migrating other providers to the new unified CX button.
+  onSwitchToAgent: () => void;
+  isEnabled: () => boolean;
+  isBusinessHours: (apiKey?: string, apiEndpoint?: string) => Promise<boolean>;
+}