@envive-ai/react-hooks 0.3.61 → 0.3.63

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

@@ -30,6 +30,76 @@ function makeOkConfigFetch() {
   });
 }
 
+// getWidgetConfig response with the use_unified_config gate ON (plus a real
+// version pin) — the trigger for the /v1/session/bootstrap upgrade.
+function makeGateOnConfigFetch() {
+  mockFetch.mockResolvedValueOnce({
+    ok: true,
+    json: () =>
+      Promise.resolve({
+        data: {
+          me: {
+            org: {
+              id: 'org-1',
+              shortName: 'test-org',
+              displayName: 'Test Org',
+              domain: 'test.com',
+              createdAt: '2024-01-01T00:00:00.000Z',
+              updatedAt: '2024-01-01T00:00:00.000Z',
+            },
+            getWidgetConfig: {
+              productsConfig: {},
+              gates: [{ name: 'use_unified_config', value: true }],
+              experimentAssignments: [],
+              resolution: { baseVersion: '1.0.0', baseVersionSource: 'merchant_layer' },
+            },
+          },
+        },
+      }),
+  });
+}
+
+// /v1/session/bootstrap response (REST snake_case). Distinct org id so tests can
+// assert the config actually came from bootstrap, not the getWidgetConfig call.
+function makeBootstrapFetch() {
+  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-01-01T00:00:00.000Z',
+            },
+            settings: {},
+          },
+          gates: [{ name: 'use_unified_config', value: true, group_name: 'Treatment' }],
+          resolution: { base_version: '1.0.0', base_version_source: 'merchant_layer' },
+        },
+        widget_config: {
+          products_config: {},
+          // Assignments come from widget_config (matches 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 },
+      }),
+  });
+}
+
 function makeService(
   overrides: Partial<ConstructorParameters<typeof EnviveConfigService>[0]> = {},
 ) {
@@ -182,3 +252,159 @@ describe('EnviveConfigService caching', () => {
     expect(result.org.org.id).toBe('org-1');
   });
 });
+
+describe('EnviveConfigService bootstrap upgrade (use_unified_config)', () => {
+  // The injection bundle supplies env + contextSource; without them the branch
+  // is skipped entirely (see the "non-bundle caller" case below).
+  const bootstrapService = () => makeService({ env: 'dev', contextSource: 'app' });
+
+  it('stays on getWidgetConfig (no bootstrap) when the gate is off', async () => {
+    makeOkConfigFetch(); // gates: []
+
+    const service = bootstrapService();
+    const result = await service.getEnviveConfig();
+
+    expect(mockFetch).toHaveBeenCalledTimes(1);
+    expect(mockFetch.mock.calls[0][0]).toContain('/v1/graphql');
+    expect(result.org.org.id).toBe('org-1');
+    expect(service.takeBootstrapUrlResolving()).toBeNull();
+  });
+
+  it('calls /v1/session/bootstrap and uses ITS config when the gate is on', async () => {
+    makeGateOnConfigFetch();
+    makeBootstrapFetch();
+
+    const service = bootstrapService();
+    const result = await service.getEnviveConfig();
+
+    expect(mockFetch).toHaveBeenCalledTimes(2);
+    expect(mockFetch.mock.calls[1][0]).toContain('/v1/session/bootstrap');
+    // config is bootstrap's, not the getWidgetConfig call used to read the gate.
+    expect(result.org.org.id).toBe('org-boot');
+    expect(result.org.org.short_name).toBe('boot-org');
+    // gates: snake group_name mapped to camel groupName.
+    expect(result.gates).toContainEqual({
+      name: 'use_unified_config',
+      value: true,
+      groupName: 'Treatment',
+    });
+    // experiment_assignments pass through (already snake).
+    expect(result.experiment_assignments).toEqual([
+      { layer_name: 'ml', namespace: 'ml', allocated_experiment_name: 'exp_a', group_name: 'A' },
+    ]);
+    // resolution mapped snake -> camel.
+    expect(result.orgConfig?.resolution).toEqual({
+      baseVersion: '1.0.0',
+      baseVersionSource: 'merchant_layer',
+    });
+  });
+
+  it('stashes bootstrap url_resolving (paired with its URL) for the warm-up to consume once', async () => {
+    makeGateOnConfigFetch();
+    makeBootstrapFetch();
+
+    const service = bootstrapService();
+    await service.getEnviveConfig();
+
+    const taken = service.takeBootstrapUrlResolving();
+    expect(taken?.response).toEqual({ variant_type: 'pdp', specific_details: {}, ready: true });
+    // paired with the URL bootstrap resolved (the current, cleansed href) so the
+    // warm-up can guard against a SPA nav before seeding.
+    expect(taken?.url).toBe(window.location.href.toLowerCase().trim());
+    // handed off exactly once.
+    expect(service.takeBootstrapUrlResolving()).toBeNull();
+  });
+
+  it('sends url_resolving context + gate names + version pin in the bootstrap body', async () => {
+    makeGateOnConfigFetch();
+    makeBootstrapFetch();
+
+    await bootstrapService().getEnviveConfig();
+
+    const [, options] = mockFetch.mock.calls[1];
+    const body = JSON.parse(options.body as string);
+    expect(body.include_feature_gates).toContain('use_unified_config');
+    // Scopes org_config.configs so bootstrap doesn't dump internal configs to the browser.
+    expect(body.namespace).toBe('spiffy-react-components');
+    expect(body.url_resolving.context).toMatchObject({
+      org_id: 'org-1',
+      org_short_name: 'test-org',
+      source: 'app',
+      env: 'dev',
+    });
+    // The version comes ONLY from the URL query param (none set here) — never from
+    // getWidgetConfig's resolution, so bootstrap doesn't depend on the discarded
+    // getWidgetConfig response.
+    expect(body.url_resolving.org_base_config_version).toBeUndefined();
+    expect(body.url_resolving.override_config_version).toBeUndefined();
+    // override-aware gates (FeatureFlagService.getFeatureFlags()) forwarded so
+    // client gate overrides reach page-variant resolution.
+    expect(body.url_resolving.feature_gates.use_unified_config).toBe(true);
+    // the persistent chat session id is threaded (not an empty string).
+    expect(body.url_resolving.context.chat_id).toBeTruthy();
+  });
+
+  it('reflects a ?<gate>=true override in the bootstrap feature_gates it sends', async () => {
+    // Force a page-variant gate the server did NOT return — it must still reach
+    // bootstrap's url_resolving via getFeatureFlags()'s override precedence.
+    window.history.replaceState({}, '', '/?use_unified_config=true&is_empty_div_plp_enabled=true');
+    makeOkConfigFetch(); // gates: [] — the ?use_unified_config=true override drives the bootstrap path
+    makeBootstrapFetch();
+
+    await bootstrapService().getEnviveConfig();
+
+    const body = JSON.parse(mockFetch.mock.calls[1][1].body as string);
+    expect(body.url_resolving.feature_gates.is_empty_div_plp_enabled).toBe(true);
+  });
+
+  it('skips bootstrap for non-bundle callers (no env/contextSource) even when the gate is on', async () => {
+    makeGateOnConfigFetch();
+
+    const result = await makeService().getEnviveConfig(); // no env/contextSource
+
+    expect(mockFetch).toHaveBeenCalledTimes(1);
+    expect(result.org.org.id).toBe('org-1');
+  });
+
+  it('falls back to the getWidgetConfig config when bootstrap fails', async () => {
+    makeGateOnConfigFetch();
+    mockFetch.mockResolvedValueOnce({ ok: false, statusText: 'Bad Gateway' });
+
+    const service = bootstrapService();
+    const result = await service.getEnviveConfig();
+
+    expect(mockFetch).toHaveBeenCalledTimes(2);
+    // degraded to the proven path rather than aborting.
+    expect(result.org.org.id).toBe('org-1');
+    expect(service.takeBootstrapUrlResolving()).toBeNull();
+  });
+
+  it('falls back to getWidgetConfig config when bootstrap returns a malformed 2xx payload', async () => {
+    makeGateOnConfigFetch();
+    // 2xx but missing required sections — must NOT replace the known-good config
+    // with empty gates / mock products (which would disable the client session).
+    mockFetch.mockResolvedValueOnce({
+      ok: true,
+      json: () => Promise.resolve({ org_config: {}, widget_config: null }),
+    });
+
+    const service = bootstrapService();
+    const result = await service.getEnviveConfig();
+
+    expect(mockFetch).toHaveBeenCalledTimes(2);
+    expect(result.org.org.id).toBe('org-1'); // getWidgetConfig's, not bootstrap's empty payload
+    expect(service.takeBootstrapUrlResolving()).toBeNull();
+  });
+
+  it('honors a ?use_unified_config=true override when the gate itself is off', async () => {
+    window.history.replaceState({}, '', '/?use_unified_config=true');
+    makeOkConfigFetch(); // gates: [] — the override, not the gate, forces bootstrap
+    makeBootstrapFetch();
+
+    const result = await bootstrapService().getEnviveConfig();
+
+    expect(mockFetch).toHaveBeenCalledTimes(2);
+    expect(mockFetch.mock.calls[1][0]).toContain('/v1/session/bootstrap');
+    expect(result.org.org.id).toBe('org-boot');
+  });
+});

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();
+  });
+});