fix: infer domain from client for useContextMutator setContext (#1317)

## This PR

As identified when chatting in
#1303 (comment),
if you pass a `Client` into `<OpenFeatureProvider/>`, then
`useContextMutator#setContext` will always see `domain` as `undefined`
and so will always mutate the default domain even if the client is not
for that domain -- instead, we should rely on the domain that the client
tells us it is for!

I've also updated the tests generally for `useContextMutator` slightly,
as they were sometimes reusing contexts set by other tests, leading to
unexpected failures when I added this new test.

### Notes

This, and the provider hook, were the only two things relying on the
`domain` property being exposed in the internal context, so I've removed
it to hopefully prevent any future logic from running into this same
trap.

Open question that I've left as a TODO, should the hook throw an error
if someone tries to use the hook outside of `<OpenFeatureProvider/>` (if
they've not set `defaultContext: true`)? Though I fear that would make
this a breaking change (though arguably it is still a fix as being able
to use this outside a hook today feels like a bug, not an intentional
design decision)?

---------

Signed-off-by: MattIPv4 <me@mattcowley.co.uk>

Author: MattIPv4

packages/react/src/context/use-context-mutator.ts

@@ -1,12 +1,12 @@
-import { useCallback, useContext } from 'react';
+import { useCallback, useContext, useEffect, useState } from 'react';
 import type { EvaluationContext } from '@openfeature/web-sdk';
 import { OpenFeature } from '@openfeature/web-sdk';
 import { Context } from '../internal';
 
 export type ContextMutationOptions = {
   /**
    * Mutate the default context instead of the domain scoped context applied at the `<OpenFeatureProvider/>`.
-   * Note, if the `<OpenFeatureProvider/>` has no domain specified, the default is used.
+   * By default, will use the domain set on `<OpenFeatureProvider/>` (or the domain associated with the client set on `<OpenFeatureProvider/>`).
    * See the {@link https://openfeature.dev/docs/reference/technologies/client/web/#manage-evaluation-context-for-domains|documentation} for more information.
    * @default false
    */
@@ -33,7 +33,28 @@ export type ContextMutation = {
  * @returns {ContextMutation} context-aware function(s) to mutate evaluation context
  */
 export function useContextMutator(options: ContextMutationOptions = { defaultContext: false }): ContextMutation {
-  const { domain } = useContext(Context) || {};
+  const { client } = useContext(Context) || {};
+  const domain = client?.metadata.domain;
+
+  // TODO: Replace this warning with a thrown error in a future major release,
+  //       to match the behavior of `useOpenFeatureProvider` + `useOpenFeatureClient`,
+  //       when `defaultContext` isn't explicitly set to true.
+  const [warned, setWarned] = useState(false);
+  useEffect(() => {
+    if (options.defaultContext || domain) {
+      if (warned) {
+        setWarned(false);
+      }
+      return;
+    }
+
+    if (!warned) {
+      console.warn(
+        '[useContextMutator] No domain available from OpenFeature context; are you using <OpenFeatureProvider/>? setContext will mutate the default context, as if `defaultContext: true` were set. This may result in a thrown error in the future.',
+      );
+      setWarned(true);
+    }
+  }, [warned]);
 
   const setContext = useCallback(
     async (

packages/react/src/internal/context.ts

@@ -9,9 +9,9 @@ import { normalizeOptions } from '.';
  * **DO NOT EXPORT PUBLICLY**
  * @internal
  */
-export const Context = React.createContext<
-  { client: Client; domain?: string; options: ReactFlagEvaluationOptions } | undefined
->(undefined);
+export const Context = React.createContext<{ client: Client; options: ReactFlagEvaluationOptions } | undefined>(
+  undefined,
+);
 
 /**
  * Get a normalized copy of the options used for this OpenFeatureProvider, see {@link normalizeOptions}.

packages/react/src/provider/provider.tsx

@@ -34,5 +34,5 @@ type ProviderProps = {
 export function OpenFeatureProvider({ client, domain, children, ...options }: ProviderProps) {
   const stableClient = React.useMemo(() => client || OpenFeature.getClient(domain), [client, domain]);
 
-  return <Context.Provider value={{ client: stableClient, options, domain }}>{children}</Context.Provider>;
+  return <Context.Provider value={{ client: stableClient, options }}>{children}</Context.Provider>;
 }

packages/react/src/provider/use-open-feature-provider.ts

@@ -17,5 +17,5 @@ export function useOpenFeatureProvider(): Provider {
     throw new MissingContextError('No OpenFeature context available');
   }
 
-  return OpenFeature.getProvider(openFeatureContext.domain);
+  return OpenFeature.getProvider(openFeatureContext.client.metadata.domain);
 }

packages/react/test/provider.spec.tsx

@@ -51,6 +51,10 @@ describe('OpenFeatureProvider', () => {
     ); // delay init by 100ms
   };
 
+  beforeEach(async () => {
+    await OpenFeature.clearContexts();
+  });
+
   describe('useOpenFeatureClient', () => {
     const DOMAIN = 'useOpenFeatureClient';
 
@@ -230,6 +234,43 @@ describe('OpenFeatureProvider', () => {
       expect(screen.getByText('Will says aloha')).toBeInTheDocument();
     });
 
+    it('should update context when a client is set', async () => {
+      const DOMAIN = 'mutate-context-client';
+      OpenFeature.setProvider(DOMAIN, suspendingProvider(), {});
+
+      const client = OpenFeature.getClient(DOMAIN);
+
+      const changed = jest.fn();
+      client.addHandler(ProviderEvents.ContextChanged, changed);
+
+      render(
+        <OpenFeatureProvider client={client}>
+          <React.Suspense fallback={<div>{FALLBACK}</div>}>
+            <TestComponent name="Will" />
+          </React.Suspense>
+        </OpenFeatureProvider>,
+      );
+
+      await waitFor(() => {
+        expect(screen.getByText('Will says hi')).toBeInTheDocument();
+      });
+
+      act(() => {
+        fireEvent.click(screen.getByText('Update Context'));
+      });
+      expect(screen.getByText('Updating context...')).toBeInTheDocument();
+
+      await waitFor(
+        () => {
+          expect(screen.getByText('Update Context')).toBeInTheDocument();
+        },
+        { timeout: DELAY * 2 },
+      );
+      expect(changed).toHaveBeenCalledTimes(1);
+
+      expect(screen.getByText('Will says aloha')).toBeInTheDocument();
+    });
+
     it('should update nested contexts', async () => {
       const DOMAIN1 = 'Wills Domain';
       const DOMAIN2 = 'Todds Domain';