feat: $flagd.timestamp added to in-process evaluator

providers/flagd/src/main/java/dev/openfeature/contrib/providers/flagd/resolver/process/targeting/Operator.java

@@ -3,22 +3,24 @@
 import java.util.HashMap;
 import java.util.Map;
 import java.util.Optional;
+import java.time.Instant;
 
 import dev.openfeature.sdk.EvaluationContext;
 import io.github.jamsesso.jsonlogic.JsonLogic;
 import io.github.jamsesso.jsonlogic.JsonLogicException;
 import lombok.Getter;
 
-
 /**
- * Targeting operator wraps JsonLogic handlers and expose a simple API for external layers.
+ * Targeting operator wraps JsonLogic handlers and expose a simple API for
+ * external layers.
  * This helps to isolate external dependencies to this package.
  */
 public class Operator {
 
     static final String FLAGD_PROPS_KEY = "$flagd";
     static final String FLAG_KEY = "flagKey";
     static final String TARGET_KEY = "targetingKey";
+    static final String TIME_STAMP = "timestamp";
 
     private final JsonLogic jsonLogicHandler;
 
@@ -38,8 +40,12 @@ public Operator() {
      */
     public Object apply(final String flagKey, final String targetingRule, final EvaluationContext ctx)
             throws TargetingRuleException {
-        final Map<String, String> flagdProperties = new HashMap<>();
+        final Map<String, Object> flagdProperties = new HashMap<>();
         flagdProperties.put(FLAG_KEY, flagKey);
+
+        long unixTimestamp = Instant.now().getEpochSecond();
+        flagdProperties.put(TIME_STAMP, unixTimestamp);
+
         final Map<String, Object> valueMap = ctx.asObjectMap();
         valueMap.put(FLAGD_PROPS_KEY, flagdProperties);
 
@@ -52,35 +58,37 @@ public Object apply(final String flagKey, final String targetingRule, final Eval
 
     @Getter
     static class FlagProperties {
-        private final String flagKey;
+        private final Object flagKey;
+        private final Object timestamp;
         private final String targetingKey;
 
         FlagProperties(Object from) {
             if (from instanceof Map) {
                 Map<?, ?> dataMap = (Map<?, ?>) from;
 
-                final Object flagKey = Optional.ofNullable(dataMap.get(FLAGD_PROPS_KEY))
-                    .filter(flagdProps -> flagdProps instanceof Map)
-                    .map(flagdProps -> ((Map<?, ?>)flagdProps).get(FLAG_KEY))
-                    .orElse(null);
-
-                if (flagKey instanceof String) {
-                    this.flagKey = (String) flagKey;
-                } else {
-                    this.flagKey = null;
-                }
+                this.flagKey = extractSubPropertyFromFlagd(dataMap, FLAG_KEY);
+                this.timestamp = extractSubPropertyFromFlagd(dataMap, TIME_STAMP);
 
                 final Object targetKey = dataMap.get(TARGET_KEY);
-
+                
                 if (targetKey instanceof String) {
                     targetingKey = (String) targetKey;
                 } else {
                     targetingKey = null;
                 }
+
             } else {
                 flagKey = null;
+                timestamp = null;
                 targetingKey = null;
             }
         }
+
+        private static Object extractSubPropertyFromFlagd(Map<?, ?> dataMap, String propertyName) {
+            return Optional.ofNullable(dataMap.get(FLAGD_PROPS_KEY))
+                    .filter(flagdProps -> flagdProps instanceof Map)
+                    .map(flagdProps -> ((Map<?, ?>) flagdProps).get(propertyName))
+                    .orElse(null);
+        } 
     }
 }

providers/flagd/src/test/java/dev/openfeature/contrib/providers/flagd/resolver/process/targeting/OperatorTest.java

@@ -1,9 +1,11 @@
 package dev.openfeature.contrib.providers.flagd.resolver.process.targeting;
 
 import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
 
 import java.util.HashMap;
 import java.util.Map;
+import java.time.Instant;
 
 import org.junit.jupiter.api.BeforeAll;
 import org.junit.jupiter.api.Test;
@@ -33,6 +35,45 @@ void flagKeyPresent() throws TargetingRuleException {
         assertEquals(true, evalVariant);
     }
 
+    @Test
+    void timestampPresent() throws TargetingRuleException {
+        // given
+
+        // rule asserting $flagd.timestamp is a number (i.e., a Unix timestamp)
+        final String targetingRule = "{\"var\":[\"$flagd.timestamp\"]}";
+
+        // when
+        Object timestampString = OPERATOR.apply("some-key", targetingRule, new ImmutableContext());
+
+        long timestamp = (long) Double.parseDouble(timestampString.toString());
+
+        // generating current unix timestamp & 5 minute threshold
+        long currentTimestamp = Instant.now().getEpochSecond();
+        long thresholdPast = currentTimestamp - (5);
+        long thresholdFuture = currentTimestamp + (5);
+
+        // checks if the timestamp is within 5 minutes of the current time
+        assertTrue(timestamp >= thresholdPast && timestamp <= thresholdFuture);
+    }
+
+    @Test
+    void testFlagPropertiesConstructor() {
+        // Given
+        Map<String, Object> flagdProperties = new HashMap<>();
+        flagdProperties.put(Operator.FLAG_KEY, "some-key");
+        flagdProperties.put(Operator.TIME_STAMP, 1634000000L);
+
+        Map<String, Object> dataMap = new HashMap<>();
+        dataMap.put(Operator.FLAGD_PROPS_KEY, flagdProperties);
+
+        // When
+        Operator.FlagProperties flagProperties = new Operator.FlagProperties(dataMap);
+
+        // Then
+        assertEquals("some-key", flagProperties.getFlagKey());
+        assertEquals(1634000000L, flagProperties.getTimestamp());
+    }
+
     @Test
     void fractionalTestA() throws TargetingRuleException {
         // given
@@ -64,7 +105,6 @@ void fractionalTestA() throws TargetingRuleException {
         Map<String, Value> ctxData = new HashMap<>();
         ctxData.put("email", new Value("[email protected]"));
 
-
         // when
         Object evalVariant = OPERATOR.apply("headerColor", targetingRule, new ImmutableContext(ctxData));
 
@@ -103,7 +143,6 @@ void fractionalTestB() throws TargetingRuleException {
         Map<String, Value> ctxData = new HashMap<>();
         ctxData.put("email", new Value("[email protected]"));
 
-
         // when
         Object evalVariant = OPERATOR.apply("headerColor", targetingRule, new ImmutableContext(ctxData));
 
@@ -142,7 +181,6 @@ void fractionalTestC() throws TargetingRuleException {
         Map<String, Value> ctxData = new HashMap<>();
         ctxData.put("email", new Value("[email protected]"));
 
-
         // when
         Object evalVariant = OPERATOR.apply("headerColor", targetingRule, new ImmutableContext(ctxData));
 
@@ -166,7 +204,6 @@ void stringCompStartsWith() throws TargetingRuleException {
         Map<String, Value> ctxData = new HashMap<>();
         ctxData.put("email", new Value("[email protected]"));
 
-
         // when
         Object evalVariant = OPERATOR.apply("adminRule", targetingRule, new ImmutableContext(ctxData));
 
@@ -190,7 +227,6 @@ void stringCompEndsWith() throws TargetingRuleException {
         Map<String, Value> ctxData = new HashMap<>();
         ctxData.put("email", new Value("[email protected]"));
 
-
         // when
         Object evalVariant = OPERATOR.apply("isFaas", targetingRule, new ImmutableContext(ctxData));
 
@@ -215,7 +251,6 @@ void semVerA() throws TargetingRuleException {
         Map<String, Value> ctxData = new HashMap<>();
         ctxData.put("version", new Value("1.1.0"));
 
-
         // when
         Object evalVariant = OPERATOR.apply("versionFlag", targetingRule, new ImmutableContext(ctxData));