@envive-ai/react-hooks 0.3.46 → 0.3.48

package/src/services/urlResolverWarmupService/__tests__/urlResolverWarmupService.test.ts

@@ -0,0 +1,85 @@
+import { createStore } from 'jotai';
+import { getAtomStore, setAtomStoreForTesting } from 'src/atoms/atomStore/atomStore';
+import { contextSourceAtom, envAtom, enviveConfigAtom } from 'src/atoms/envive/enviveConfig';
+import { featureFlagServiceAtom } from 'src/atoms/org/graphqlConfig';
+import { FeatureFlagService } from 'src/services/featureFlagService';
+import type { EnviveServiceConfig } from 'src/services/enviveConfigService';
+import { warmUrlResolver } from '../index';
+
+const { mockResolveUrl } = vi.hoisted(() => ({ mockResolveUrl: vi.fn() }));
+
+vi.mock('src/application/commerce-api', () => ({
+  default: { resolveUrl: mockResolveUrl },
+}));
+
+const enviveServiceConfig = {
+  org: { org: { short_name: 'test-org', id: 'org-1' } },
+} as EnviveServiceConfig;
+
+const baseParams = {
+  baseUrl: 'https://commerce-api.spiffy.ai',
+  apiKey: 'test-key',
+  enviveServiceConfig,
+  show: true,
+  enviveOn: false,
+};
+
+describe('warmUrlResolver', () => {
+  beforeEach(() => {
+    setAtomStoreForTesting(createStore());
+    window.sessionStorage.clear();
+    vi.clearAllMocks();
+    mockResolveUrl.mockResolvedValue({ ready: true });
+  });
+
+  it('seeds env, contextSource, and the feature flag service before resolving', async () => {
+    const featureFlagService = new FeatureFlagService([]);
+
+    let envAtCallTime: string | undefined;
+    let contextSourceAtCallTime: string | undefined;
+    let flagServiceAtCallTime: FeatureFlagService | undefined;
+    mockResolveUrl.mockImplementation(async () => {
+      const store = getAtomStore();
+      envAtCallTime = store.get(envAtom);
+      contextSourceAtCallTime = store.get(contextSourceAtom);
+      flagServiceAtCallTime = store.get(featureFlagServiceAtom)?.featureFlagService;
+      return { ready: true };
+    });
+
+    await warmUrlResolver({
+      ...baseParams,
+      env: 'prod',
+      contextSource: 'app',
+      featureFlagService,
+    });
+
+    expect(mockResolveUrl).toHaveBeenCalledTimes(1);
+    expect(envAtCallTime).toBe('prod');
+    expect(contextSourceAtCallTime).toBe('app');
+    expect(flagServiceAtCallTime).toBe(featureFlagService);
+  });
+
+  it('does not overwrite atoms a provider has already seeded', async () => {
+    const store = getAtomStore();
+    const existingFlagService = new FeatureFlagService([]);
+    store.set(enviveConfigAtom, { identifyingPrefix: 'test', env: 'dev' });
+    store.set(featureFlagServiceAtom, { featureFlagService: existingFlagService });
+
+    await warmUrlResolver({
+      ...baseParams,
+      env: 'prod',
+      contextSource: 'playground',
+      featureFlagService: new FeatureFlagService([]),
+    });
+
+    expect(store.get(envAtom)).toBe('dev');
+    expect(store.get(featureFlagServiceAtom)?.featureFlagService).toBe(existingFlagService);
+  });
+
+  it('leaves the feature flag service atom unset when none is provided', async () => {
+    await warmUrlResolver(baseParams);
+
+    expect(getAtomStore().get(featureFlagServiceAtom)).toBeUndefined();
+    expect(mockResolveUrl).toHaveBeenCalledTimes(1);
+  });
+});

package/src/services/urlResolverWarmupService/index.ts

@@ -0,0 +1,89 @@
+import CommerceApiClient from 'src/application/commerce-api';
+import Logger from 'src/application/logging/logger';
+import { UrlResolverResponse, urlResolverAtom } from 'src/atoms/app/variant';
+import { getAtomStore } from 'src/atoms/atomStore/atomStore';
+import { enviveConfigAtom } from 'src/atoms/envive/enviveConfig';
+import { resolvedBaseConfigVersionAtom } from 'src/atoms/envive/resolvedBaseConfigVersion';
+import { featureFlagServiceAtom } from 'src/atoms/org/graphqlConfig';
+import { EnviveServiceConfig } from 'src/services/enviveConfigService';
+import type { FeatureFlagService } from 'src/services/featureFlagService';
+
+const logger = new Logger('urlResolverWarmupService');
+
+export interface WarmUrlResolverParams {
+  baseUrl: string;
+  apiKey: string;
+  enviveServiceConfig: EnviveServiceConfig;
+  show?: boolean;
+  enviveOn?: boolean;
+  env?: string;
+  contextSource?: string;
+  featureFlagService?: FeatureFlagService;
+}
+
+/**
+ * Fires the /v1/url_resolving request as soon as the org config is available,
+ * instead of waiting for the React tree to mount and PageProvider's effect to
+ * run — that removes a full network round trip from the first-widget-paint
+ * critical path.
+ *
+ * Seeds the same atoms EnviveProvider/EnviveConfigProvider populate later
+ * (with identical values) so the request context matches the one
+ * PageProvider would send, then stores the response in the
+ * sessionStorage-backed urlResolverAtom that PageProvider consults before
+ * fetching. Concurrent calls for the same URL are deduped inside
+ * CommerceApiClient.resolveUrl.
+ */
+export const warmUrlResolver = async ({
+  baseUrl,
+  apiKey,
+  enviveServiceConfig,
+  show,
+  enviveOn,
+  env,
+  contextSource,
+  featureFlagService,
+}: WarmUrlResolverParams): Promise<void> => {
+  try {
+    const store = getAtomStore();
+    // Must match PageProvider's URL cleansing so the cache key lines up.
+    const cleansedUrl = window.location.href.toLowerCase().trim();
+    if (store.get(urlResolverAtom)[cleansedUrl]) {
+      return;
+    }
+
+    // The CommerceApiClient singleton captures baseUrl/apiKey at first
+    // instantiation, so these atoms must be seeded before any API call.
+    // Only seed when unset — providers own this atom once React mounts.
+    if (store.get(enviveConfigAtom) === undefined) {
+      store.set(enviveConfigAtom, {
+        baseUrl,
+        orgLevelApiKey: apiKey,
+        orgShortName: enviveServiceConfig.org.org.short_name,
+        orgId: enviveServiceConfig.org.org.id,
+        show,
+        enviveOn,
+        env,
+        contextSource,
+      });
+    }
+    // resolveUrl reads feature gates through featureFlagServiceAtom; without
+    // this seed the warm-up request is computed with feature_gates={} and
+    // that response is what gets cached for PageProvider.
+    if (featureFlagService && store.get(featureFlagServiceAtom) === undefined) {
+      store.set(featureFlagServiceAtom, { featureFlagService });
+    }
+    // Mirrors EnviveProvider: "deployed" is the no-pin sentinel.
+    const { baseVersion, baseVersionSource } = enviveServiceConfig.orgConfig?.resolution ?? {};
+    if (baseVersion && baseVersionSource && baseVersionSource !== 'deployed') {
+      store.set(resolvedBaseConfigVersionAtom, baseVersion);
+    }
+
+    const response = (await CommerceApiClient.resolveUrl(cleansedUrl)) as UrlResolverResponse;
+    store.set(urlResolverAtom, { url: cleansedUrl, response });
+  } catch (err) {
+    // Fail open: PageProvider issues its own resolveUrl call when the cache
+    // is empty, so a warm-up failure never blocks rendering.
+    logger.logDebug('URL resolver warm-up failed', err);
+  }
+};

package/src/types/enviveConfig.ts

@@ -2,8 +2,11 @@ import { FrontendConfigOverrides, VariantInfo } from 'src/application/models';
 import type { HardcopyResponse } from 'src/contexts/hardcopyContext/hardcopyContext';
 import type { WidgetTypeV3 } from 'src/contexts/typesV3';
 
+export type AddToCartCallback = (params: { product_id: string }) => void | Promise<void>;
+
 export interface EnviveConfig {
   publicKey?: string;
+  addToCart?: AddToCartCallback;
   userID?: string;
   env?: 'prod' | 'dev';
   clientID?: string;