@envive-ai/react-hooks 0.3.62 → 0.3.64

package/src/services/enviveConfigService/__tests__/fetchBootstrapConfig.test.ts

@@ -0,0 +1,271 @@
+import { type FetchBootstrapConfigParams, fetchBootstrapConfig } from '../fetchBootstrapConfig';
+
+const mockFetch = vi.fn();
+globalThis.fetch = mockFetch;
+
+// A representative /v1/session/bootstrap response (REST snake_case). products_config
+// is left empty so the shared transformV3ProductsConfig falls back to mock config —
+// its internals are covered by fetchGraphQLConfig.test.ts; here we only assert the
+// bootstrap-specific mapping (org/gates/assignments/resolution/url_resolving).
+function makeBootstrapResponse() {
+  mockFetch.mockResolvedValueOnce({
+    ok: true,
+    json: () =>
+      Promise.resolve({
+        org_config: {
+          org: {
+            org: {
+              id: 'org-boot',
+              short_name: 'boot-org',
+              display_name: 'Boot Org',
+              domain: 'boot.com',
+              status: 'active',
+              created_at: '2024-01-01T00:00:00.000Z',
+              updated_at: '2024-02-02T00:00:00.000Z',
+            },
+            settings: {},
+          },
+          gates: [
+            { name: 'use_unified_config', value: true, group_name: 'Treatment', rule_id: 'r1' },
+            { name: 'is_client_session_enabled', value: false, group_name: null, rule_id: null },
+          ],
+          // Decoy: org_config.experiment_assignments is server-gated on
+          // unified_config_active and must NOT be the source. If the mapper reads
+          // this, the assertion below fails.
+          experiment_assignments: [
+            {
+              layer_name: 'DECOY_org_config',
+              namespace: 'ml',
+              allocated_experiment_name: 'should_not_be_read',
+              group_name: 'X',
+            },
+          ],
+          resolution: { base_version: '1.0.0', base_version_source: 'merchant_layer' },
+        },
+        widget_config: {
+          products_config: {},
+          // The correct source — mirrors getWidgetConfig (ungated).
+          experiment_assignments: [
+            {
+              layer_name: 'ml',
+              namespace: 'ml',
+              allocated_experiment_name: 'exp_a',
+              group_name: 'A',
+            },
+          ],
+          resolution: { base_version: '1.0.0', base_version_source: 'merchant_layer' },
+        },
+        url_resolving: { variant_type: 'pdp', specific_details: {}, ready: true },
+      }),
+  });
+}
+
+const baseParams: FetchBootstrapConfigParams = {
+  baseUrl: 'https://commerce-api.spiffy.ai',
+  apiKey: 'test-key',
+  userId: 'user-1',
+  source: 'app',
+  namespace: 'spiffy-react-components',
+  gateNames: ['use_unified_config', 'is_client_session_enabled'],
+  url: 'https://shop.example.com/products/thing',
+  orgId: 'org-1',
+  orgShortName: 'test-org',
+  contextSource: 'app',
+  env: 'prod',
+  featureGates: { use_unified_config: true, is_empty_div_plp_enabled: true },
+};
+
+beforeEach(() => {
+  vi.clearAllMocks();
+  window.history.replaceState({}, '', '/');
+});
+
+describe('fetchBootstrapConfig', () => {
+  it('POSTs to /v1/session/bootstrap with the bearer key', async () => {
+    makeBootstrapResponse();
+
+    await fetchBootstrapConfig(baseParams);
+
+    const [url, options] = mockFetch.mock.calls[0];
+    expect(url).toBe('https://commerce-api.spiffy.ai/v1/session/bootstrap');
+    expect(options.method).toBe('POST');
+    expect(options.headers.Authorization).toBe('Bearer test-key');
+  });
+
+  it('maps org identity, gates (group_name→groupName), assignments, and resolution', async () => {
+    makeBootstrapResponse();
+
+    const { config } = await fetchBootstrapConfig(baseParams);
+
+    expect(config.org.org).toEqual({
+      id: 'org-boot',
+      short_name: 'boot-org',
+      display_name: 'Boot Org',
+      domain: 'boot.com',
+      status: 'active',
+      created_at: '2024-01-01T00:00:00.000Z',
+      updated_at: '2024-02-02T00:00:00.000Z',
+    });
+    // snake group_name → camel groupName; null → undefined.
+    expect(config.gates).toEqual([
+      { name: 'use_unified_config', value: true, groupName: 'Treatment' },
+      { name: 'is_client_session_enabled', value: false, groupName: undefined },
+    ]);
+    // experiment_assignments already snake — pass straight through.
+    expect(config.experiment_assignments).toEqual([
+      { layer_name: 'ml', namespace: 'ml', allocated_experiment_name: 'exp_a', group_name: 'A' },
+    ]);
+    // resolution snake → camel, attached to orgConfig.
+    expect(config.orgConfig?.resolution).toEqual({
+      baseVersion: '1.0.0',
+      baseVersionSource: 'merchant_layer',
+    });
+  });
+
+  it('reads experiment_assignments from widget_config, not the server-gated org_config', async () => {
+    makeBootstrapResponse();
+
+    const { config } = await fetchBootstrapConfig(baseParams);
+
+    // org_config carried a DECOY; the value must come from widget_config so it
+    // matches getWidgetConfig (which is ungated by use_unified_config). Reading
+    // org_config would drop assignments whenever the gate is off server-side.
+    expect(config.experiment_assignments).toEqual([
+      { layer_name: 'ml', namespace: 'ml', allocated_experiment_name: 'exp_a', group_name: 'A' },
+    ]);
+    expect(config.experiment_assignments?.some(a => a.layer_name === 'DECOY_org_config')).toBe(
+      false,
+    );
+  });
+
+  it('returns the url_resolving payload verbatim for the warm-up to seed', async () => {
+    makeBootstrapResponse();
+
+    const { urlResolving } = await fetchBootstrapConfig(baseParams);
+
+    expect(urlResolving).toEqual({ variant_type: 'pdp', specific_details: {}, ready: true });
+  });
+
+  it('returns urlResolving null when bootstrap omitted the branch', async () => {
+    mockFetch.mockResolvedValueOnce({
+      ok: true,
+      json: () =>
+        Promise.resolve({
+          org_config: {
+            org: { org: { id: 'o' } },
+            gates: [{ name: 'use_unified_config', value: true }],
+          },
+          widget_config: { products_config: {} },
+          url_resolving: null,
+        }),
+    });
+
+    const { urlResolving } = await fetchBootstrapConfig(baseParams);
+
+    expect(urlResolving).toBeNull();
+  });
+
+  it('builds the url_resolving context and version split from params', async () => {
+    makeBootstrapResponse();
+
+    await fetchBootstrapConfig({ ...baseParams, chatId: 'chat-9' });
+
+    const body = JSON.parse(mockFetch.mock.calls[0][1].body as string);
+    expect(body).toMatchObject({
+      user_id: 'user-1',
+      source: 'app',
+      // Scopes org_config.configs — must be sent or bootstrap dumps internal configs.
+      namespace: 'spiffy-react-components',
+      include_feature_gates: ['use_unified_config', 'is_client_session_enabled'],
+    });
+    expect(body.url_resolving).toMatchObject({
+      url: 'https://shop.example.com/products/thing',
+      // Override-aware gates forwarded so client overrides reach page-variant resolution.
+      feature_gates: { use_unified_config: true, is_empty_div_plp_enabled: true },
+    });
+    // No org_base_config_version — the version comes only from the URL query param
+    // (override_config_version), never from getWidgetConfig's resolution.
+    expect(body.url_resolving.org_base_config_version).toBeUndefined();
+    expect(body.url_resolving.context).toEqual({
+      user_id: 'user-1',
+      org_id: 'org-1',
+      org_short_name: 'test-org',
+      chat_id: 'chat-9',
+      source: 'app',
+      env: 'prod',
+    });
+  });
+
+  it('threads a config-version query param into version + override_config_version', async () => {
+    window.history.replaceState({}, '', '/?envive_config_version=9.9.9');
+    makeBootstrapResponse();
+
+    await fetchBootstrapConfig(baseParams);
+
+    const body = JSON.parse(mockFetch.mock.calls[0][1].body as string);
+    expect(body.version).toBe('9.9.9');
+    expect(body.url_resolving.override_config_version).toBe('9.9.9');
+  });
+
+  it('throws on a non-ok response so the caller can fall back', async () => {
+    mockFetch.mockResolvedValueOnce({ ok: false, statusText: 'Bad Gateway' });
+
+    await expect(fetchBootstrapConfig(baseParams)).rejects.toThrow(
+      'Bootstrap config request failed',
+    );
+  });
+
+  // Each case isolates ONE missing/degraded required section (the others valid).
+  const okGates = [{ name: 'use_unified_config', value: true }];
+  const okOrg = { org: { org: { id: 'o' } }, gates: okGates };
+  const okWidget = { products_config: {} };
+  it.each([
+    ['missing org_config', { org_config: undefined, widget_config: okWidget }],
+    [
+      'partial org_config (no org.org)',
+      { org_config: { org: {}, gates: okGates }, widget_config: okWidget },
+    ],
+    ['absent gates', { org_config: { org: { org: { id: 'o' } } }, widget_config: okWidget }],
+    [
+      'empty gates',
+      { org_config: { org: { org: { id: 'o' } }, gates: [] }, widget_config: okWidget },
+    ],
+    ['missing widget_config', { org_config: okOrg, widget_config: null }],
+  ])(
+    'throws on a 2xx with %s so the caller can fall back to getWidgetConfig',
+    async (_label, payload) => {
+      mockFetch.mockResolvedValueOnce({ ok: true, json: () => Promise.resolve(payload) });
+
+      await expect(fetchBootstrapConfig(baseParams)).rejects.toThrow('missing required sections');
+    },
+  );
+
+  it('passes an AbortSignal to fetch (timeout wiring)', async () => {
+    makeBootstrapResponse();
+
+    await fetchBootstrapConfig(baseParams);
+
+    const [, options] = mockFetch.mock.calls[0];
+    expect(options.signal).toBeInstanceOf(AbortSignal);
+  });
+
+  it('aborts and rejects when the request exceeds the timeout so the caller can fall back', async () => {
+    vi.useFakeTimers();
+    // Mimic real fetch: reject with an AbortError once its signal aborts.
+    mockFetch.mockImplementationOnce(
+      (_url: string, opts: { signal: AbortSignal }) =>
+        new Promise((_resolve, reject) => {
+          opts.signal.addEventListener('abort', () =>
+            reject(new DOMException('The operation was aborted', 'AbortError')),
+          );
+        }),
+    );
+
+    const promise = fetchBootstrapConfig(baseParams);
+    const rejection = expect(promise).rejects.toThrow();
+    await vi.advanceTimersByTimeAsync(5000);
+    await rejection;
+
+    vi.useRealTimers();
+  });
+});

package/src/services/enviveConfigService/enviveConfigService.ts

@@ -2,7 +2,15 @@ import { OrgConfigExperimentAssignment, OrgConfigFeatureGate } from 'src/applica
 import { FeatureGates } from 'src/application/models/featureGates';
 import type { GraphQlConfigValues } from 'src/contexts/graphqlContext';
 import { configVersionOverride } from 'src/types/config-versions';
+import { FeatureFlagService } from 'src/services/featureFlagService';
+import Logger from 'src/application/logging/logger';
+import type { UrlResolverResponse } from 'src/atoms/app/variant';
+import { getAtomStore } from 'src/atoms/atomStore/atomStore';
+import { chatIdAtom } from 'src/atoms/app';
 import { fetchUnifiedGraphQLConfig } from './fetchGraphQLConfig';
+import { fetchBootstrapConfig } from './fetchBootstrapConfig';
+
+const logger = new Logger('enviveConfigService');
 
 // Short-lived so config changes (gates, experiments) still propagate within
 // a session, while sparing every page navigation from re-fetching org
@@ -21,6 +29,12 @@ type EnviveConfigServiceProps = {
   userId: string;
   namespace: string;
   source: string;
+  // The url_resolving context bits the hooks layer can't derive itself, supplied
+  // by the injection bundle so getEnviveConfig can call /v1/session/bootstrap on
+  // the use_unified_config gate-ON path. Optional: when absent (mocks, non-bundle
+  // callers) the bootstrap branch is skipped and getWidgetConfig stands.
+  env?: string;
+  contextSource?: string;
 };
 
 export type EnviveServiceConfig = {
@@ -36,9 +50,10 @@ export type EnviveServiceConfig = {
     };
   };
   gates: OrgConfigFeatureGate[];
-  // Populated by the backend when the `use_unified_config` Statsig gate
-  // evaluates true. amplitudeService reads these to enrich events with
-  // `experiment.{ns}.*` properties.
+  // The user's Statsig experiment-layer assignments, from the widget config's
+  // resolved experiments — getWidgetConfig, or bootstrap's `widget_config`
+  // (both ungated by use_unified_config; empty only under a version pin).
+  // amplitudeService reads these to enrich events with `experiment.{ns}.*` props.
   experiment_assignments?: OrgConfigExperimentAssignment[];
   // orgConfig.resolution is populated only on the unified path (sourced from
   // getWidgetConfig.resolution, not /v1/org/config.resolution) so the version
@@ -51,8 +66,18 @@ export interface IEnviveConfigService {
   readonly baseUrl: string;
   readonly apiKey: string;
   getEnviveConfig(): Promise<EnviveServiceConfig>;
+  // NB: `takeBootstrapUrlResolving` is intentionally NOT on this interface. It's
+  // a bootstrap-only detail consumed solely by the injection bundle via the
+  // concrete EnviveConfigService; keeping it off the public DI contract avoids a
+  // breaking change for external consumers that supply their own config service
+  // (EnviveProvider only ever calls getEnviveConfig / baseUrl / apiKey).
 }
 
+// The bootstrap url_resolving payload plus the URL it was resolved for, so the
+// warm-up can verify the URL still matches before seeding (see F1: a SPA nav
+// during the bootstrap round trip must not cache URL A's result under URL B).
+type BootstrapUrlResolving = { url: string; response: UrlResolverResponse };
+
 export class EnviveConfigService implements IEnviveConfigService {
   public readonly baseUrl: string;
 
@@ -64,14 +89,40 @@ export class EnviveConfigService implements IEnviveConfigService {
 
   private readonly source: string;
 
+  private readonly env?: string;
+
+  private readonly contextSource?: string;
+
   private response: EnviveServiceConfig | null = null;
 
-  constructor({ baseUrl, apiKey, userId, namespace, source }: EnviveConfigServiceProps) {
+  private bootstrapUrlResolving: BootstrapUrlResolving | null = null;
+
+  constructor({
+    baseUrl,
+    apiKey,
+    userId,
+    namespace,
+    source,
+    env,
+    contextSource,
+  }: EnviveConfigServiceProps) {
     this.baseUrl = baseUrl;
     this.apiKey = apiKey;
     this.userId = userId;
     this.namespace = namespace;
     this.source = source;
+    this.env = env;
+    this.contextSource = contextSource;
+  }
+
+  // Hands off (once) the url_resolving payload that /v1/session/bootstrap
+  // returned alongside the config — paired with the URL it was resolved for — so
+  // the warm-up seeds urlResolverAtom with it instead of firing a separate
+  // /v1/url_resolving. null on the getWidgetConfig / cached path.
+  takeBootstrapUrlResolving(): BootstrapUrlResolving | null {
+    const value = this.bootstrapUrlResolving;
+    this.bootstrapUrlResolving = null;
+    return value;
   }
 
   private getCacheKey(): string {
@@ -132,16 +183,84 @@ export class EnviveConfigService implements IEnviveConfigService {
     // list of gates the app checks, so the resolver evaluates and returns them.
     const gateNames = Object.values(FeatureGates).map(featureGate => featureGate.toString());
 
-    this.response = await fetchUnifiedGraphQLConfig(
+    const widgetConfig = await fetchUnifiedGraphQLConfig(
       this.baseUrl,
       this.apiKey,
       this.userId,
       gateNames,
       this.source,
     );
+
+    this.response = await this.maybeUpgradeToBootstrap(widgetConfig, gateNames);
     this.writeCachedConfig(this.response);
     return this.response;
   }
+
+  // The unified-config ramp (`use_unified_config` Statsig gate). When the gate
+  // is ON for this user, swap the getWidgetConfig result for Matt's
+  // /v1/session/bootstrap — the same config PLUS the initial url_resolving in
+  // ONE round trip (the consolidation this migration is about). The gate is read
+  // off the getWidgetConfig response just fetched, because the FE has no Statsig
+  // SDK: pymono evaluates the gate server-side and returns it. `FeatureFlagService`
+  // also honors a `?use_unified_config=true` override, so the bootstrap path is
+  // testable before the gate ramps.
+  //
+  // Only runs on the cache-miss path (bootstrap's config is then cached like any
+  // other), so a cached load never re-fetches. Needs env + contextSource for the
+  // url_resolving context — absent for mocks / non-bundle callers, where the
+  // branch is skipped. A bootstrap failure falls back to the getWidgetConfig
+  // config already in hand: a bootstrap problem degrades to the proven path
+  // instead of aborting injection. At 100% the getWidgetConfig call above is
+  // dropped and bootstrap becomes the sole config call (step 8).
+  private async maybeUpgradeToBootstrap(
+    widgetConfig: EnviveServiceConfig,
+    gateNames: string[],
+  ): Promise<EnviveServiceConfig> {
+    if (this.env === undefined || this.contextSource === undefined) {
+      return widgetConfig;
+    }
+    // Built once: reads the gate (override-aware) AND supplies the override-aware
+    // gate map bootstrap's url_resolving needs (matches the legacy resolveUrl path).
+    const featureFlagService = new FeatureFlagService(widgetConfig.gates);
+    if (!featureFlagService.isFeatureGateEnabled(FeatureGates.UseUnifiedConfig)) {
+      return widgetConfig;
+    }
+
+    // Captured once and reused for both the bootstrap request and the stash, so
+    // the URL carried to the warm-up is provably the one bootstrap resolved. The
+    // warm-up only seeds it if this still matches the current URL (a SPA nav
+    // during the round trip would otherwise cache this result under a later URL).
+    // Same cleansing as warmUrlResolver so the urlResolverAtom key lines up.
+    const cleansedUrl = window.location.href.toLowerCase().trim();
+    try {
+      const { config, urlResolving } = await fetchBootstrapConfig({
+        baseUrl: this.baseUrl,
+        apiKey: this.apiKey,
+        userId: this.userId,
+        source: this.source,
+        // Scope org_config.configs to this namespace so bootstrap doesn't return
+        // internal-only org configs to the browser (matches the legacy /v1/org/config).
+        namespace: this.namespace,
+        gateNames,
+        url: cleansedUrl,
+        orgId: widgetConfig.org.org.id,
+        orgShortName: widgetConfig.org.org.short_name,
+        contextSource: this.contextSource,
+        env: this.env,
+        featureGates: featureFlagService.getFeatureFlags(),
+        // The persistent chat session id (same source resolveUrl reads) so
+        // bootstrap's url_resolving carries it instead of an empty string.
+        chatId: getAtomStore().get(chatIdAtom),
+      });
+      this.bootstrapUrlResolving = urlResolving
+        ? { url: cleansedUrl, response: urlResolving }
+        : null;
+      return config;
+    } catch (err) {
+      logger.logError('getEnviveConfig | bootstrap upgrade failed, using getWidgetConfig', err);
+      return widgetConfig;
+    }
+  }
 }
 
 /**