feat: add HookContext decorator

Signed-off-by: Simon Schrottner <[email protected]>

Author: aepfli

src/main/java/dev/openfeature/sdk/HookContext.java

@@ -1,38 +1,14 @@
 package dev.openfeature.sdk;
 
-import lombok.Builder;
-import lombok.NonNull;
-import lombok.Value;
-import lombok.With;
+import dev.openfeature.sdk.HookContextWithoutData.HookContextWithoutDataBuilder;
 
 /**
- * A data class to hold immutable context that {@link Hook} instances use.
+ * A interface to hold immutable context that {@link Hook} instances use.
  *
- * @param <T> the type for the flag being evaluated
  */
-@Value
-@Builder(toBuilder = true)
-@With
-public class HookContext<T> {
-    @NonNull String flagKey;
-
-    @NonNull FlagValueType type;
-
-    @NonNull T defaultValue;
-
-    @NonNull EvaluationContext ctx;
-
-    ClientMetadata clientMetadata;
-    Metadata providerMetadata;
-
+public interface HookContext<T> {
     /**
-     * Hook data provides a way for hooks to maintain state across their execution stages.
-     * Each hook instance gets its own isolated data store.
-     */
-    HookData hookData;
-
-    /**
-     * Builds a {@link HookContext} instances from request data.
+     * Builds a {@link HookContextWithoutData} instances from request data.
      *
      * @param key              feature flag key
      * @param type             flag value type
@@ -43,14 +19,14 @@ public class HookContext<T> {
      * @param <T>              type that the flag is evaluating against
      * @return resulting context for hook
      */
-    public static <T> HookContext<T> from(
+    static <T> HookContext<T> from(
             String key,
             FlagValueType type,
             ClientMetadata clientMetadata,
             Metadata providerMetadata,
             EvaluationContext ctx,
             T defaultValue) {
-        return HookContext.<T>builder()
+        return HookContextWithoutData.<T>builder()
                 .flagKey(key)
                 .type(type)
                 .clientMetadata(clientMetadata)
@@ -60,4 +36,25 @@ public static <T> HookContext<T> from(
                 .hookData(null) // Explicitly set to null for backward compatibility
                 .build();
     }
+
+    /**
+     * Returns a builder for our default HookContext object.
+     */
+    static <T> HookContextWithoutDataBuilder<T> builder() {
+        return HookContextWithoutData.<T>builder();
+    }
+
+    String getFlagKey();
+
+    FlagValueType getType();
+
+    T getDefaultValue();
+
+    EvaluationContext getCtx();
+
+    ClientMetadata getClientMetadata();
+
+    Metadata getProviderMetadata();
+
+    HookData getHookData();
 }

src/main/java/dev/openfeature/sdk/HookContextWithData.java

@@ -0,0 +1,50 @@
+package dev.openfeature.sdk;
+
+class HookContextWithData<T> implements HookContext<T> {
+    private final HookContext<T> context;
+    private final HookData data;
+
+    private HookContextWithData(HookContext<T> context, HookData data) {
+        this.context = context;
+        this.data = data;
+    }
+
+    public static <T> HookContextWithData<T> of(HookContext<T> context, HookData data) {
+        return new HookContextWithData<>(context, data);
+    }
+
+    @Override
+    public String getFlagKey() {
+        return context.getFlagKey();
+    }
+
+    @Override
+    public FlagValueType getType() {
+        return context.getType();
+    }
+
+    @Override
+    public T getDefaultValue() {
+        return context.getDefaultValue();
+    }
+
+    @Override
+    public EvaluationContext getCtx() {
+        return context.getCtx();
+    }
+
+    @Override
+    public ClientMetadata getClientMetadata() {
+        return context.getClientMetadata();
+    }
+
+    @Override
+    public Metadata getProviderMetadata() {
+        return context.getProviderMetadata();
+    }
+
+    @Override
+    public HookData getHookData() {
+        return data;
+    }
+}

src/main/java/dev/openfeature/sdk/HookContextWithoutData.java

@@ -0,0 +1,33 @@
+package dev.openfeature.sdk;
+
+import lombok.Builder;
+import lombok.NonNull;
+import lombok.Value;
+import lombok.With;
+
+/**
+ * A data class to hold immutable context that {@link Hook} instances use.
+ *
+ * @param <T> the type for the flag being evaluated
+ */
+@Value
+@Builder
+@With
+class HookContextWithoutData<T> implements HookContext<T> {
+    @NonNull String flagKey;
+
+    @NonNull FlagValueType type;
+
+    @NonNull T defaultValue;
+
+    @NonNull EvaluationContext ctx;
+
+    ClientMetadata clientMetadata;
+    Metadata providerMetadata;
+
+    /**
+     * Hook data provides a way for hooks to maintain state across their execution stages.
+     * Each hook instance gets its own isolated data store.
+     */
+    HookData hookData;
+}

src/main/java/dev/openfeature/sdk/HookSupport.java

@@ -90,7 +90,7 @@ private <T> void executeChecked(
             BiConsumer<Hook<T>, HookContext> hookCode,
             String hookMethod) {
         try {
-            var hookCtxWithData = hookContext.withHookData(hookData);
+            var hookCtxWithData = HookContextWithData.of(hookContext, hookData);
             hookCode.accept(hook, hookCtxWithData);
         } catch (Exception exception) {
             log.error(
@@ -112,7 +112,7 @@ private <T> void executeHooksUnchecked(
                 Hook hook = hookDataPair.getLeft();
                 HookData hookData = hookDataPair.getRight();
                 if (hook.supportsFlagValueType(flagValueType)) {
-                    var hookCtxWithData = hookContext.withHookData(hookData);
+                    var hookCtxWithData = HookContextWithData.of(hookContext, hookData);
                     hookCode.accept(hook, hookCtxWithData);
                 }
             }
@@ -135,7 +135,7 @@ private EvaluationContext callBeforeHooks(
 
             if (hook.supportsFlagValueType(flagValueType)) {
                 // Create a new context with this hook's data
-                HookContext contextWithHookData = hookCtx.withHookData(hookData);
+                HookContext contextWithHookData = HookContextWithData.of(hookCtx, hookData);
                 Optional<EvaluationContext> optional = Optional.ofNullable(hook.before(contextWithHookData, hints))
                         .orElse(Optional.empty());
                 if (optional.isPresent()) {

src/test/java/dev/openfeature/sdk/HookContextTest.java

@@ -71,7 +71,7 @@ void shouldCreateHookContextWithHookDataUsingWith() {
         HookData hookData = HookData.create();
         hookData.set("timing", System.currentTimeMillis());
 
-        HookContext<String> contextWithHookData = originalContext.withHookData(hookData);
+        HookContext<String> contextWithHookData = HookContextWithData.of(originalContext, hookData);
 
         assertNull(originalContext.getHookData());
         assertNotNull(contextWithHookData.getHookData());

src/test/java/dev/openfeature/sdk/HookSupportTest.java

@@ -25,7 +25,7 @@ void shouldMergeEvaluationContextsOnBeforeHooksCorrectly() {
         attributes.put("baseKey", new Value("baseValue"));
         EvaluationContext baseContext = new ImmutableContext(attributes);
         FlagValueType valueType = FlagValueType.STRING;
-        HookContext<String> hookContext = HookContext.<String>builder()
+        HookContext<String> hookContext = HookContextWithoutData.<String>builder()
                 .flagKey("flagKey")
                 .type(valueType)
                 .defaultValue("defaultValue")