deps: update dependency flagsmith/sdk-spec to v0.7.0

.github/workflows/sdk-spec.yml

@@ -11,7 +11,7 @@ permissions:
 jobs:
   sdk-spec:
     # Keep the ref in `uses:` and `spec-ref` in sync.
-    uses: Flagsmith/sdk-spec/.github/workflows/run-spec.yml@v0.3.0
+    uses: Flagsmith/sdk-spec/.github/workflows/run-spec.yml@v0.7.0
     with:
-      spec-ref: v0.3.0
+      spec-ref: v0.7.0
       language: rust

sdk-spec/Cargo.toml

@@ -12,3 +12,4 @@ path = "steps.rs"
 flagsmith = { path = ".." }
 flagsmith-flag-engine = "0.6"
 serde = { version = "1.0", features = ["derive"] }
+serde_json = "1.0"

sdk-spec/steps.rs

@@ -5,10 +5,12 @@
 use std::collections::HashMap;
 
 use flagsmith::error::Error;
-use flagsmith::flagsmith::models::{Flags, SDKTrait};
+use flagsmith::flagsmith::events::EventOptions;
+use flagsmith::flagsmith::models::{Flag, Flags, SDKTrait};
 use flagsmith::{Flagsmith, FlagsmithOptions};
 use flagsmith_flag_engine::types::FlagsmithValue;
 use serde::Serialize;
+use serde_json::Value;
 
 #[derive(Serialize)]
 pub struct SpecFlag {
@@ -17,15 +19,22 @@ pub struct SpecFlag {
     value: FlagsmithValue,
 }
 
+fn as_spec_flag(flag: Flag) -> SpecFlag {
+    SpecFlag {
+        feature: flag.feature_name,
+        enabled: flag.enabled,
+        value: flag.value,
+    }
+}
+
 fn as_spec_flags(flags: Flags) -> Vec<SpecFlag> {
-    flags
-        .all_flags()
+    flags.all_flags().into_iter().map(as_spec_flag).collect()
+}
+
+fn as_sdk_traits(traits: HashMap<String, FlagsmithValue>) -> Vec<SDKTrait> {
+    traits
         .into_iter()
-        .map(|flag| SpecFlag {
-            feature: flag.feature_name,
-            enabled: flag.enabled,
-            value: flag.value,
-        })
+        .map(|(key, value)| SDKTrait::new(key, value))
         .collect()
 }
 
@@ -38,6 +47,21 @@ pub fn create_client(environment_key: String, api_url: String) -> Flagsmith {
     Flagsmith::new(environment_key, options)
 }
 
+// Create the SDK client with events enabled
+pub fn create_client_with_events(
+    environment_key: String,
+    api_url: String,
+    events_api_url: String,
+) -> Flagsmith {
+    let options = FlagsmithOptions {
+        api_url,
+        enable_events: true,
+        events_api_url,
+        ..Default::default()
+    };
+    Flagsmith::new(environment_key, options)
+}
+
 // When the application gets the environment flags
 pub fn get_environment_flags(flagsmith: &Flagsmith) -> Result<Vec<SpecFlag>, Error> {
     flagsmith.get_environment_flags().map(as_spec_flags)
@@ -49,11 +73,53 @@ pub fn get_identity_flags(
     identifier: String,
     traits: HashMap<String, FlagsmithValue>,
 ) -> Result<Vec<SpecFlag>, Error> {
-    let traits = traits
-        .into_iter()
-        .map(|(key, value)| SDKTrait::new(key, value))
-        .collect();
     flagsmith
-        .get_identity_flags(&identifier, Some(traits), None)
+        .get_identity_flags(&identifier, Some(as_sdk_traits(traits)), None)
         .map(as_spec_flags)
 }
+
+// When the application gets the experiment flag "{feature}" for identity "{identifier}" with traits:
+pub fn get_experiment_flag(
+    flagsmith: &Flagsmith,
+    feature: String,
+    identifier: String,
+    traits: HashMap<String, FlagsmithValue>,
+) -> Result<Vec<SpecFlag>, Error> {
+    flagsmith
+        .get_experiment_flag(&feature, &identifier, Some(as_sdk_traits(traits)))
+        .map(|flag| vec![as_spec_flag(flag)])
+}
+
+// When the application tracks event "{event}" for identity "{identifier}" with value {value} and metadata:
+pub fn track_event(
+    flagsmith: &Flagsmith,
+    event: String,
+    identifier: String,
+    value: FlagsmithValue,
+    metadata: HashMap<String, Value>,
+) -> Result<(), Error> {
+    let options = EventOptions {
+        identifier: Some(identifier),
+        value: Some(value),
+        metadata: Some(metadata),
+        ..Default::default()
+    };
+    flagsmith.track_event(&event, options)
+}
+
+// When the application tracks an exposure of feature "{feature}" for identity "{identifier}" with value {value} and metadata:
+pub fn track_exposure_event(
+    flagsmith: &Flagsmith,
+    feature: String,
+    identifier: String,
+    value: FlagsmithValue,
+    metadata: HashMap<String, Value>,
+) -> Result<(), Error> {
+    let options = EventOptions {
+        identifier: Some(identifier),
+        value: Some(value),
+        metadata: Some(metadata),
+        ..Default::default()
+    };
+    flagsmith.track_exposure_event(&feature, options)
+}