fix: open-feature-client context management

When accumulating the context in the OpenFeature client in the before
hooks, the context was being re-assigned instead of merged. This change
ensures that the context is merged correctly, preserving object
reference.

Signed-off-by: Mike Kitzman <[email protected]>

Author: mdkitzman

packages/server/src/client/internal/open-feature-client.ts

@@ -332,7 +332,7 @@ export class OpenFeatureClient implements Client {
     mergedContext: EvaluationContext,
     options: FlagEvaluationOptions,
   ) {
-    let accumulatedContext = mergedContext;
+    const accumulatedContext = mergedContext;
 
     for (const [index, hook] of hooks.entries()) {
       const hookContextIndex = hooks.length - 1 - index; // reverse index for before hooks
@@ -343,10 +343,7 @@ export class OpenFeatureClient implements Client {
 
       const hookResult = await hook?.before?.(hookContext, Object.freeze(options.hookHints));
       if (hookResult) {
-        accumulatedContext = {
-          ...accumulatedContext,
-          ...hookResult,
-        };
+        Object.assign(accumulatedContext, hookResult);
 
         for (let i = 0; i < hooks.length; i++) {
           Object.assign(hookContexts[hookContextIndex].context, accumulatedContext);

packages/server/src/provider/multi-provider/multi-provider.ts

@@ -30,7 +30,8 @@ export class MultiProvider implements Provider {
 
   public readonly events = new OpenFeatureEventEmitter();
 
-  private hookContents: Array<[HookContext, HookHints]> = [];
+  private hookContexts: WeakMap<EvaluationContext, HookContext> = new WeakMap<EvaluationContext, HookContext>();
+  private hookHints: WeakMap<EvaluationContext, HookHints> = new WeakMap<EvaluationContext, HookHints>();
 
   metadata: ProviderMetadata;
 
@@ -139,7 +140,8 @@ export class MultiProvider implements Provider {
     defaultValue: T,
     context: EvaluationContext,
   ): Promise<ResolutionDetails<T>> {
-    const [hookContext, hookHints] = this.hookContents.shift() ?? [];
+    const hookContext = this.hookContexts.get(context);
+    const hookHints = this.hookHints.get(context);
 
     if (!hookContext || !hookHints) {
       throw new GeneralError('Hook context not available for evaluation');
@@ -297,7 +299,8 @@ export class MultiProvider implements Provider {
     return [
       {
         before: async (hookContext: BeforeHookContext, hints: HookHints): Promise<EvaluationContext> => {
-          this.hookContents.push([hookContext, hints ?? {}]);
+          this.hookContexts.set(hookContext.context, hookContext);
+          this.hookHints.set(hookContext.context, hints ?? {});
           return hookContext.context;
         },
       },

packages/server/test/client.spec.ts

@@ -811,6 +811,40 @@ describe('OpenFeatureClient', () => {
         client.setContext({ [KEY]: VAL });
         expect(client.getContext()[KEY]).toEqual(VAL);
       });
+
+      it('context object is reference stable between hook and evaluation calls', async () => {
+        let hookContextRef;
+        const contextMap = new WeakMap<EvaluationContext, HookContext>();
+        const contextStabilityProvider = {
+          metadata: {
+            name: 'evaluation-context',
+          },
+          hooks: [
+            {
+              before: jest.fn((hookContext: HookContext) => {
+                contextMap.set(hookContext.context, hookContext);
+                return hookContext.context;
+              })
+            }
+          ],
+          resolveBooleanEvaluation: jest.fn((_flagKey, _defaultValue, context): Promise<ResolutionDetails<boolean>> => {
+            // We expect that the context object reference is the same as that captured in the hook
+            hookContextRef = contextMap.get(context);
+            return Promise.resolve({
+              value: true,
+            });
+          }),
+        } as unknown as Provider;
+
+        await OpenFeature.setProviderAndWait(contextStabilityProvider);
+        const client = OpenFeature.getClient();
+        
+        const context = { data: 1, value: '2' };
+        await client.getBooleanValue('some-other-flag', false, context);
+        expect(contextStabilityProvider.resolveBooleanEvaluation).toHaveBeenCalled();
+        expect(contextStabilityProvider.hooks?.[0].before).toHaveBeenCalled();
+        expect(hookContextRef).toBeDefined();
+      });
     });
   });