open-feature-forking
diff --git a/‎src/lib.rs‎
Lines changed: 26 additions & 11 deletions b/‎src/lib.rs‎
Lines changed: 26 additions & 11 deletions
diff --git a/‎src/model/feature_flag.rs‎
Lines changed: 34 additions & 0 deletions b/‎src/model/feature_flag.rs‎
Lines changed: 34 additions & 0 deletions
diff --git a/‎src/model/mod.rs‎
Lines changed: 20 additions & 0 deletions b/‎src/model/mod.rs‎
Lines changed: 20 additions & 0 deletions
@@ -54,7 +54,7 @@ pub use evaluation::{
 pub use memory::{
     pack_ptr_len, string_from_memory, string_to_memory, unpack_ptr_len, wasm_alloc, wasm_dealloc,
 };
-pub use model::{FeatureFlag, ParsingResult};
+pub use model::{FeatureFlag, ParsingResult, UpdateStateResponse};
 pub use operators::{create_evaluator, ends_with, fractional, sem_ver, starts_with};
 pub use storage::{
     clear_flag_state, get_flag_state, set_validation_mode, update_flag_state, ValidationMode,
@@ -252,24 +252,31 @@ pub extern "C" fn set_validation_mode_wasm(mode: u32) -> u64 {
 /// Updates the feature flag state with a new configuration.
 ///
 /// This function parses the provided JSON configuration and stores it in
-/// thread-local storage for later evaluation.
+/// thread-local storage for later evaluation. It also detects which flags
+/// have changed by comparing the new configuration with the previous state.
 ///
 /// # Arguments
 /// * `config_ptr` - Pointer to the JSON configuration string in WASM memory
 /// * `config_len` - Length of the JSON configuration string
 ///
 /// # Returns
 /// A packed u64 containing the pointer (upper 32 bits) and length (lower 32 bits)
-/// of the response JSON string. The response indicates success or failure.
+/// of the response JSON string. The response includes a list of changed flag keys.
 ///
 /// # Response Format
 /// ```json
 /// {
 ///   "success": true|false,
-///   "error": null|"error message"
+///   "error": null|"error message",
+///   "changedFlags": ["flag1", "flag2", ...]
 /// }
 /// ```
 ///
+/// The `changedFlags` array contains the keys of all flags that were:
+/// - Added (present in new config but not in old)
+/// - Removed (present in old config but not in new)
+/// - Mutated (default variant, targeting rules, or metadata changed)
+///
 /// # Safety
 /// The caller must ensure:
 /// - `config_ptr` points to valid memory
@@ -289,22 +296,30 @@ fn update_state_internal(config_ptr: *const u8, config_len: u32) -> String {
         Err(e) => {
             return serde_json::json!({
                 "success": false,
-                "error": format!("Failed to read configuration: {}", e)
+                "error": format!("Failed to read configuration: {}", e),
+                "changedFlags": null
             })
             .to_string()
         }
     };
 
     // Parse and store the configuration using the storage module
     match update_flag_state(&config_str) {
-        Ok(()) => serde_json::json!({
-            "success": true,
-            "error": null
-        })
-        .to_string(),
+        Ok(response) => {
+            // Convert UpdateStateResponse to JSON
+            serde_json::to_string(&response).unwrap_or_else(|e| {
+                serde_json::json!({
+                    "success": false,
+                    "error": format!("Failed to serialize response: {}", e),
+                    "changedFlags": null
+                })
+                .to_string()
+            })
+        }
         Err(e) => serde_json::json!({
             "success": false,
-            "error": e
+            "error": e,
+            "changedFlags": null
         })
         .to_string(),
     }
 
@@ -86,6 +86,40 @@ impl FeatureFlag {
             .map(|t| t.to_string())
             .unwrap_or_else(|| "{}".to_string())
     }
+
+    /// Checks if this flag is different from another flag.
+    ///
+    /// Compares all fields of the flag using the derived PartialEq implementation.
+    /// This includes state, default variant, variants, targeting rules, and metadata.
+    ///
+    /// # Arguments
+    ///
+    /// * `other` - The flag to compare against
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use flagd_evaluator::model::FeatureFlag;
+    /// use serde_json::json;
+    /// use std::collections::HashMap;
+    ///
+    /// let flag1 = FeatureFlag {
+    ///     key: Some("test".to_string()),
+    ///     state: "ENABLED".to_string(),
+    ///     default_variant: "on".to_string(),
+    ///     variants: HashMap::new(),
+    ///     targeting: Some(json!({"==": [1, 1]})),
+    ///     metadata: HashMap::new(),
+    /// };
+    ///
+    /// let mut flag2 = flag1.clone();
+    /// flag2.default_variant = "off".to_string();
+    ///
+    /// assert!(flag1.is_different_from(&flag2));
+    /// ```
+    pub fn is_different_from(&self, other: &FeatureFlag) -> bool {
+        self != other
+    }
 }
 
 /// Result of parsing a flagd configuration file.
 
@@ -6,3 +6,23 @@
 mod feature_flag;
 
 pub use feature_flag::{FeatureFlag, ParsingResult};
+
+use serde::{Deserialize, Serialize};
+
+/// Response from updating flag state indicating which flags have changed.
+///
+/// This is used for PROVIDER_CONFIGURATION_CHANGED events per the provider spec.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct UpdateStateResponse {
+    /// Whether the update was successful
+    pub success: bool,
+
+    /// Error message if the update failed
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub error: Option<String>,
+
+    /// List of flag keys that were changed (added, removed, or mutated)
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub changed_flags: Option<Vec<String>>,
+}