@envive-ai/react-hooks 0.2.4 → 0.2.6-alpha

package/dist/src/contexts/featureFlagServiceContext/featureFlagServiceContext.js

@@ -0,0 +1,47 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { createContext, useContext, useMemo } from "react";
+import { FeatureGates } from "@envive-ai/types";
+import Logger from "src/application/logging/logger";
+// This is the class that was previously implicitly used or defined elsewhere
+export class FeatureFlagService {
+    constructor(featureGates) {
+        this.isFeatureGateEnabled = (featureGate) => {
+            const gateValue = this.featureGates.find((gate) => gate.name === featureGate);
+            // TODO: Add logic for overrides (query params, window, stored) if needed, similar to the old FeatureFlagContext.tsx
+            // For now, direct value from config is used.
+            if (gateValue == null || gateValue.value == null) {
+                Logger.logDebug(`[spiffy-ai] isFeatureGateEnabled featureGate:${featureGate} value is undefined - returning false`);
+                return false;
+            }
+            return gateValue.value;
+        };
+        this.isClientSessionEnabled = () => {
+            const isEnabled = this.featureGates.filter((gate) => gate.name === FeatureGates.IsClientSessionEnabled &&
+                gate.value === true).length > 0;
+            return isEnabled;
+        };
+        this.getFeatureFlags = () => {
+            return Object.fromEntries(Object.values(FeatureGates).map((featureGate) => [
+                featureGate,
+                this.isFeatureGateEnabled(featureGate),
+            ]));
+        };
+        this.featureGates = featureGates;
+    }
+}
+const FeatureFlagServiceContext = createContext(undefined);
+export const FeatureFlagServiceProvider = ({ featureGates, children }) => {
+    const featureFlagService = useMemo(() => new FeatureFlagService(featureGates), [featureGates]);
+    const contextValue = useMemo(() => ({
+        featureFlagService,
+        isFeatureGateEnabled: featureFlagService.isFeatureGateEnabled,
+    }), [featureFlagService]);
+    return (_jsx(FeatureFlagServiceContext.Provider, { value: contextValue, children: children }));
+};
+export const useFeatureFlagService = () => {
+    const context = useContext(FeatureFlagServiceContext);
+    if (context === undefined) {
+        throw new Error("useFeatureFlagService must be used within a FeatureFlagServiceProvider");
+    }
+    return context;
+};

package/dist/src/contexts/featureFlagServiceContext/index.js

@@ -0,0 +1 @@
+export * from "./featureFlagServiceContext";

package/dist/src/contexts/graphqlContext/graphqlContext.js

@@ -0,0 +1,87 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { createContext, useContext, useCallback, useMemo } from 'react';
+import { useAtomValue } from 'jotai';
+import { baseUrlAtom, orgLevelApiKeyAtom } from '../../atoms/envive/enviveConfig';
+import { getMerchantOrgIdQuery } from '../../application/models/graphql/queries/getMerchantOrgIdQuery';
+import { validateGraphQLOrgId } from '../../application/models/validators/validateGraphQLOrgId';
+import Logger from '../../application/logging/logger';
+import { transformSnakeToCamel } from '../../application/models';
+import { configVersion } from '../../util/configVersion';
+const GraphQLContext = createContext(null);
+const colorsAndFrontendConfigQuery = () => `
+  query ($version: String = "${configVersion()}") {
+    me {
+      getProductsConfigByVersion(version: $version) {
+        frontend { values }
+        colors { values }
+      }
+    }
+  }
+`;
+export const GraphQLProvider = ({ children }) => {
+    const apiKey = useAtomValue(orgLevelApiKeyAtom);
+    const baseUrl = useAtomValue(baseUrlAtom);
+    const isReady = Boolean(apiKey && baseUrl);
+    const executeQuery = useCallback(async (query, variables) => {
+        if (!isReady) {
+            throw new Error('GraphQL client not ready - missing apiKey or baseUrl');
+        }
+        const response = await fetch(`${baseUrl}/v1/graphql`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                Authorization: `Bearer ${apiKey}`,
+            },
+            body: JSON.stringify({ query, variables }),
+        });
+        if (!response.ok) {
+            throw new Error(`GraphQL request failed: ${response.statusText}`);
+        }
+        const result = await response.json();
+        if (result.errors) {
+            throw new Error(`GraphQL errors: ${JSON.stringify(result.errors)}`);
+        }
+        return result.data;
+    }, [apiKey, baseUrl, isReady]);
+    const getOrgId = useCallback(async () => {
+        var _a;
+        const response = await executeQuery(getMerchantOrgIdQuery);
+        return validateGraphQLOrgId((_a = response.me.org) === null || _a === void 0 ? void 0 : _a.id);
+    }, [executeQuery]);
+    const getColorsAndFrontendConfig = useCallback(async () => {
+        var _a, _b, _c, _d;
+        try {
+            const query = await colorsAndFrontendConfigQuery();
+            if (!query) {
+                throw new Error('Colors and frontend config query is not defined');
+            }
+            const response = await executeQuery(query);
+            const colorsConfig = (_b = (_a = response.me.getProductsConfigByVersion) === null || _a === void 0 ? void 0 : _a.colors) === null || _b === void 0 ? void 0 : _b.values;
+            const frontendConfig = (_d = (_c = response.me.getProductsConfigByVersion) === null || _c === void 0 ? void 0 : _c.frontend) === null || _d === void 0 ? void 0 : _d.values;
+            const transformedColorConfig = transformSnakeToCamel(colorsConfig);
+            const transformedFrontendConfig = transformSnakeToCamel(frontendConfig);
+            return {
+                colorsConfig: transformedColorConfig,
+                frontendConfig: transformedFrontendConfig,
+            };
+        }
+        catch (err) {
+            Logger.logError('Error fetching graphql colors and frontend config', err);
+            return { colorsConfig: undefined, frontendConfig: undefined };
+        }
+    }, [executeQuery]);
+    const value = useMemo(() => ({
+        executeQuery,
+        getOrgId,
+        getColorsAndFrontendConfig,
+        isReady,
+    }), [executeQuery, getOrgId, getColorsAndFrontendConfig, isReady]);
+    return _jsx(GraphQLContext.Provider, { value: value, children: children });
+};
+export const useGraphQLClient = () => {
+    const context = useContext(GraphQLContext);
+    if (!context) {
+        throw new Error('useGraphQLClient must be used within a GraphQLProvider');
+    }
+    return context;
+};

package/dist/src/contexts/graphqlContext/index.js

@@ -0,0 +1 @@
+export * from "./graphqlContext";

package/dist/src/contexts/localStorageContext/index.js

@@ -0,0 +1 @@
+export * from "./localStorageContext";

package/dist/src/contexts/localStorageContext/localStorageContext.js

@@ -0,0 +1,95 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { createContext, useContext, useCallback, useMemo, useEffect } from 'react';
+import Logger from '../../application/logging/logger';
+import { LocalStorageKeys, } from '@envive-ai/types';
+const LocalStorageContext = createContext(null);
+export const LocalStorageProvider = ({ children }) => {
+    const isAvailable = useMemo(() => {
+        try {
+            return typeof window !== 'undefined' && !!window.localStorage;
+        }
+        catch {
+            return false;
+        }
+    }, []);
+    useEffect(() => {
+        if (!isAvailable) {
+            Logger.logError('localStorage is not available', undefined);
+        }
+    }, [isAvailable]);
+    const setItem = useCallback((key, value) => {
+        if (!isAvailable)
+            return;
+        localStorage.setItem(key, value);
+        window.dispatchEvent(new StorageEvent('storage', { key, newValue: value }));
+    }, [isAvailable]);
+    const getItem = useCallback((key) => {
+        if (!isAvailable)
+            return null;
+        return localStorage.getItem(key);
+    }, [isAvailable]);
+    const setSpiffyOnFeatureFlag = useCallback((value) => {
+        if (!isAvailable)
+            return;
+        if (value === true) {
+            localStorage.setItem(LocalStorageKeys.SpiffyOnOverride, 'true');
+        }
+        else if (value === false) {
+            localStorage.setItem(LocalStorageKeys.SpiffyOnOverride, 'false');
+        }
+    }, [isAvailable]);
+    const getSpiffyOnFeatureFlag = useCallback(() => {
+        if (!isAvailable)
+            return null;
+        return localStorage.getItem(LocalStorageKeys.SpiffyOnOverride);
+    }, [isAvailable]);
+    const listenersCache = useMemo(() => new Map(), []);
+    const listenerForKey = useCallback((listener) => {
+        if (!listenersCache.has(listener.storageKey)) {
+            const handler = (event) => {
+                if (event.key !== listener.storageKey) {
+                    return;
+                }
+                Logger.logDebug(`[spiffy-ai] Storage event key=${event.key}, value=`, event.newValue);
+                listener.listener(event);
+            };
+            listenersCache.set(listener.storageKey, handler);
+        }
+        return listenersCache.get(listener.storageKey);
+    }, [listenersCache]);
+    const attachListener = useCallback((listener) => {
+        if (!isAvailable)
+            return;
+        window.addEventListener('storage', listenerForKey(listener));
+    }, [isAvailable, listenerForKey]);
+    const detachListener = useCallback((listener) => {
+        if (!isAvailable)
+            return;
+        window.removeEventListener('storage', listenerForKey(listener));
+    }, [isAvailable, listenerForKey]);
+    const value = useMemo(() => ({
+        setItem,
+        getItem,
+        setSpiffyOnFeatureFlag,
+        getSpiffyOnFeatureFlag,
+        attachListener,
+        detachListener,
+        isAvailable,
+    }), [
+        setItem,
+        getItem,
+        setSpiffyOnFeatureFlag,
+        getSpiffyOnFeatureFlag,
+        attachListener,
+        detachListener,
+        isAvailable,
+    ]);
+    return _jsx(LocalStorageContext.Provider, { value: value, children: children });
+};
+export const useLocalStorage = () => {
+    const context = useContext(LocalStorageContext);
+    if (!context) {
+        throw new Error('useLocalStorage must be used within a LocalStorageProvider');
+    }
+    return context;
+};

package/dist/src/contexts/newOrgConfigContext/index.js

@@ -0,0 +1 @@
+export * from "./newOrgConfigContext";

package/dist/src/contexts/newOrgConfigContext/newOrgConfigContext.js

@@ -0,0 +1,33 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { createContext, useContext, useMemo } from 'react';
+import { useAtomValue, useSetAtom } from 'jotai';
+import { useColorsAndFrontendConfig } from 'src/hooks/GraphQLConfig/useGraphQLConfig';
+import { orgShortNameAtom } from 'src/atoms/envive/enviveConfig';
+import { newOrgConfigAtom } from 'src/atoms/org/newOrgConfigAtom';
+import { FeatureFlagServiceProvider } from '../featureFlagServiceContext';
+const NewOrgConfigContext = createContext(undefined);
+export const NewOrgConfigProvider = ({ children }) => {
+    const orgShortName = useAtomValue(orgShortNameAtom);
+    const setNewOrgConfig = useSetAtom(newOrgConfigAtom);
+    const { data: newConfig, loading, error } = useColorsAndFrontendConfig();
+    const contextValue = useMemo(() => {
+        if (!orgShortName || loading) {
+            return { ...newConfig, loading: true, error: null };
+        }
+        if (error) {
+            return { ...newConfig, loading: false, error };
+        }
+        setNewOrgConfig(newConfig);
+        return { ...newConfig, loading: false, error: null };
+    }, [orgShortName, loading, error]);
+    // TODO: Provide actual featureGates when available in combinedConfig
+    const featureGates = [];
+    return (_jsx(NewOrgConfigContext.Provider, { value: contextValue, children: _jsx(FeatureFlagServiceProvider, { featureGates: featureGates, children: children }) }));
+};
+export const useNewOrgConfigContext = () => {
+    const context = useContext(NewOrgConfigContext);
+    if (context === undefined) {
+        throw new Error('useNewOrgConfigContext must be used within a NewOrgConfigProvider');
+    }
+    return context;
+};

package/dist/src/contexts/searchContext/index.js

@@ -0,0 +1 @@
+export * from "./searchContext";

package/dist/src/contexts/searchContext/searchContext.js

@@ -0,0 +1,131 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { createContext, useContext, useCallback, useMemo, useEffect } from 'react';
+import { useAtomValue } from 'jotai';
+import { Configuration, ResponseCategory, ResponseError, SearchApi, } from '@spiffy-ai/commerce-api-client';
+import { baseUrlAtom } from '../../atoms/envive/enviveConfig';
+import Logger from '../../application/logging/logger';
+import { SessionRestartRequired, UnsupportedProductException } from '../../exceptions';
+import { useAppDetails } from '../../hooks/AppDetails/useAppDetails';
+import { useEnviveConfig } from '../../contexts/enviveConfigContext/enviveConfigContext';
+import { clearSearchServiceFunction, setSearchServiceFunction, } from '../../atoms/search/searchServiceAdapter';
+const transformProductResponses = (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) {
+    try {
+        return await error.response.json();
+    }
+    catch {
+        return {};
+    }
+}
+async function throwSessionRestartRequiredIf(errorMsg, error) {
+    var _a, _b, _c, _d;
+    if (!(error instanceof ResponseError)) {
+        Logger.logInfo(errorMsg, error);
+        throw error;
+    }
+    const errorResponse = await errorResponseBody(error);
+    if (((_a = errorResponse === null || errorResponse === void 0 ? void 0 : errorResponse.message) === null || _a === void 0 ? void 0 : _a.toLowerCase()) === 'unsupported product' ||
+        ((_b = errorResponse === null || errorResponse === void 0 ? void 0 : errorResponse.app_code) === null || _b === void 0 ? void 0 : _b.toUpperCase()) === 'PRODUCT_NOT_FOUND') {
+        throw new UnsupportedProductException();
+    }
+    else if (((_c = errorResponse === null || errorResponse === void 0 ? void 0 : errorResponse.app_code) === null || _c === void 0 ? void 0 : _c.toUpperCase()) === 'RESTART_SESSION' ||
+        ((_d = errorResponse === null || errorResponse === void 0 ? void 0 : errorResponse.sub_code) === null || _d === void 0 ? void 0 : _d.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;
+}
+const SearchContext = createContext(undefined);
+export const SearchProvider = ({ children }) => {
+    const { orgLevelApiKey, publicKey } = useEnviveConfig();
+    const apiKey = orgLevelApiKey || publicKey; // Replicate apiKeyAtom logic
+    const appDetails = useAppDetails();
+    const baseUrl = useAtomValue(baseUrlAtom);
+    const isReady = Boolean(apiKey && appDetails && baseUrl);
+    const searchApi = useMemo(() => {
+        if (!isReady)
+            return null;
+        const config = new Configuration({
+            accessToken: apiKey,
+            basePath: baseUrl,
+            headers: {
+                'Content-Type': 'application/json',
+                Accept: 'application/json',
+            },
+        });
+        return new SearchApi(config);
+    }, [apiKey, baseUrl, isReady]);
+    const searchProducts = useCallback(async (params) => {
+        if (!isReady || !searchApi) {
+            throw new Error('SearchService not ready - missing dependencies');
+        }
+        try {
+            const response = await 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 === null || products === void 0 ? void 0 : 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: '',
+            };
+        }
+    }, [searchApi, isReady, appDetails]);
+    // Register the search function with the adapter for use in atoms
+    useEffect(() => {
+        if (isReady) {
+            setSearchServiceFunction(searchProducts);
+        }
+        else {
+            clearSearchServiceFunction();
+        }
+        return () => {
+            clearSearchServiceFunction();
+        };
+    }, [searchProducts, isReady]);
+    const value = useMemo(() => ({
+        searchProducts,
+        isReady,
+    }), [searchProducts, isReady]);
+    return _jsx(SearchContext.Provider, { value: value, children: children });
+};
+export const useSearchService = () => {
+    const context = useContext(SearchContext);
+    if (!context) {
+        throw new Error('useSearchService must be used within a SearchProvider');
+    }
+    return context;
+};

package/dist/src/contexts/sessionStorageContext/index.js

@@ -0,0 +1 @@
+export * from "./sessionStorageContext";

package/dist/src/contexts/sessionStorageContext/sessionStorageContext.js

@@ -0,0 +1,43 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { createContext, useContext, useCallback, useMemo, useEffect } from 'react';
+import Logger from '../../application/logging/logger';
+const SessionStorageContext = createContext(null);
+export const SessionStorageProvider = ({ children }) => {
+    const isAvailable = useMemo(() => {
+        try {
+            return typeof window !== 'undefined' && !!window.sessionStorage;
+        }
+        catch {
+            return false;
+        }
+    }, []);
+    useEffect(() => {
+        if (!isAvailable) {
+            Logger.logError('sessionStorage is not available', undefined);
+        }
+    }, [isAvailable]);
+    const setItem = useCallback((key, value) => {
+        if (!isAvailable)
+            return;
+        sessionStorage.setItem(key, value);
+        window.dispatchEvent(new StorageEvent('storage', { key, newValue: value }));
+    }, [isAvailable]);
+    const getItem = useCallback((key) => {
+        if (!isAvailable)
+            return null;
+        return sessionStorage.getItem(key);
+    }, [isAvailable]);
+    const value = useMemo(() => ({
+        setItem,
+        getItem,
+        isAvailable,
+    }), [setItem, getItem, isAvailable]);
+    return _jsx(SessionStorageContext.Provider, { value: value, children: children });
+};
+export const useSessionStorage = () => {
+    const context = useContext(SessionStorageContext);
+    if (!context) {
+        throw new Error('useSessionStorage must be used within a SessionStorageProvider');
+    }
+    return context;
+};

package/dist/src/contexts/shopifyUrlContext/index.js

@@ -0,0 +1 @@
+export * from "./shopifyUrlContext";

package/dist/src/contexts/shopifyUrlContext/shopifyUrlContext.js

@@ -0,0 +1,62 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { createContext, useCallback, useContext, useMemo } from 'react';
+import { parseHref } from '../../application/utils/urlsParser';
+const ShopifyUrlContext = createContext(undefined);
+export const ShopifyUrlProvider = ({ children }) => {
+    const isReady = true; // No external dependencies, so always ready
+    const getTrimmedPathName = useCallback(() => {
+        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;
+    }, []);
+    const getPlpOrPdpId = useCallback((extractor) => {
+        var _a, _b;
+        if (extractor === 'shopify-product-variant-id') {
+            const parsedHref = parseHref(window.location.href);
+            const variantId = (_a = parsedHref === null || parsedHref === void 0 ? void 0 : parsedHref.urlSearchParams) === null || _a === void 0 ? void 0 : _a.get('variant');
+            if (!variantId) {
+                return getPlpOrPdpId('shopify-product-id');
+            }
+            return variantId;
+        }
+        const pathSegment = extractor === 'shopify-product-id' ? 'products' : 'collections';
+        const tokens = (_b = getTrimmedPathName()) === null || _b === void 0 ? void 0 : _b.split('/');
+        const idIndex = tokens === null || tokens === void 0 ? void 0 : tokens.findIndex((token) => token === pathSegment);
+        if (idIndex !== undefined && idIndex >= 0 && tokens) {
+            return decodeURIComponent(tokens[idIndex + 1]);
+        }
+        return null;
+    }, [getTrimmedPathName]);
+    const isOnPdpPage = useCallback(() => {
+        var _a, _b;
+        return (_b = (_a = getTrimmedPathName()) === null || _a === void 0 ? void 0 : _a.includes('/products')) !== null && _b !== void 0 ? _b : false;
+    }, [getTrimmedPathName]);
+    const isOnPlpPage = useCallback(() => {
+        var _a, _b, _c;
+        return ((_c = (((_a = getTrimmedPathName()) === null || _a === void 0 ? void 0 : _a.includes('/collections')) &&
+            !((_b = getTrimmedPathName()) === null || _b === void 0 ? void 0 : _b.includes('/products')))) !== null && _c !== void 0 ? _c : false);
+    }, [getTrimmedPathName]);
+    const value = useMemo(() => ({
+        getTrimmedPathName,
+        getPlpOrPdpId,
+        isOnPdpPage,
+        isOnPlpPage,
+        isReady,
+    }), [getTrimmedPathName, getPlpOrPdpId, isOnPdpPage, isOnPlpPage, isReady]);
+    return _jsx(ShopifyUrlContext.Provider, { value: value, children: children });
+};
+export const useShopifyUrl = () => {
+    const context = useContext(ShopifyUrlContext);
+    if (!context) {
+        throw new Error('useShopifyUrl must be used within a ShopifyUrlProvider');
+    }
+    return context;
+};

package/dist/src/contexts/systemSettingsContext/index.js

@@ -0,0 +1 @@
+export * from "./systemSettingsContext";

package/dist/src/contexts/systemSettingsContext/systemSettingsContext.js

@@ -0,0 +1,29 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useAtomValue } from 'jotai';
+import { createContext, useMemo, useState } from 'react';
+import { baseUrlAtom } from 'src/atoms/envive/enviveConfig';
+// TODO: Refactor this to a common service that handles query params (and spiffy variables all together)
+const getChatModelName = () => {
+    const urlObj = new URL(window.location.href);
+    const params = new URLSearchParams(urlObj.search);
+    const paramsObj = Object.fromEntries(params.entries());
+    return paramsObj.llm_model_name;
+};
+const defaultGenerationParams = {
+    stream: true,
+    numSuggestions: 3,
+    model: getChatModelName(),
+};
+const SystemSettingsContext = createContext(undefined);
+const SystemSettingsContextProvider = ({ children, generationParams, showDebugBar, }) => {
+    const [params, setParams] = useState(() => generationParams !== null && generationParams !== void 0 ? generationParams : defaultGenerationParams);
+    const endpointURL = useAtomValue(baseUrlAtom);
+    const settingsContextValues = useMemo(() => ({
+        generationParams: params,
+        showDebugBar,
+        setGenerationParams: setParams,
+        endpointURL,
+    }), [generationParams, endpointURL, showDebugBar]);
+    return (_jsx(SystemSettingsContext.Provider, { value: settingsContextValues, children: children }));
+};
+export { SystemSettingsContextProvider, SystemSettingsContext, defaultGenerationParams };

package/dist/src/contexts/userIdentityContext/index.js

@@ -0,0 +1 @@
+export * from "./userIdentityContext";