fix: support ProviderStateGenerator shorthand expression format for query, header, and body (FFI)

When a JSON object contains an `expression` key (without `pact:matcher:type`), it is now
treated as a ProviderStateGenerator shorthand. The `value` field is extracted as the example
value, and a ProviderStateGenerator is configured with the expression.

This fixes the issue where `{"expression":"${var}","value":"100"}` was not working for
query parameters, headers, and bodies - only the path case worked before.

Agent-Logs-Url: https://github.com/pact-foundation/pact-reference/sessions/fb2a6dd6-ef83-46ac-af88-f8edd5445fc0

Co-authored-by: mefellows <53900+mefellows@users.noreply.github.com>

Author: Copilot

rust/pact_ffi/IntegrationJson.md

@@ -30,6 +30,40 @@ we can use the JSON format with a regex matcher (which requires a "regex" attrib
 pactffi_with_request(handle, "PUT", "{\"value\": \"/path/to/100\", \"pact:matcher:type\": \"regex\", \"regex\": \"\\\\/path\\\\/to\\\\/\\\\d+\"}")
 ```
 
+## Using ProviderState generators
+
+The `ProviderState` generator allows values to be sourced from provider state parameters during provider verification.
+There are two formats for specifying a `ProviderState` generator:
+
+### Shorthand format (expression only)
+
+When you only need a `ProviderState` generator (without any matching rule), you can use the shorthand format with just
+the `expression` and `value` keys:
+
+```json
+{
+  "expression": "${accountNumber}",
+  "value": "100"
+}
+```
+
+This sets up a `ProviderStateGenerator` with the given expression and uses the `value` as the example value. This
+shorthand is supported for query parameters, headers, path, and request/response bodies.
+
+### Full format (with matcher)
+
+To combine a `ProviderState` generator with a matching rule, use the full format with `pact:generator:type` and
+`pact:matcher:type`:
+
+```json
+{
+  "value": "100",
+  "pact:matcher:type": "type",
+  "pact:generator:type": "ProviderState",
+  "expression": "${accountNumber}"
+}
+```
+
 ## Matching on Paths
 
 function: `pactffi_with_request`

rust/pact_ffi/src/mock_server/bodies.rs

@@ -67,6 +67,13 @@ pub fn process_object(
   let result = if let Some(matcher_type) = obj.get("pact:matcher:type") {
     debug!("detected pact:matcher:type, will configure a matcher");
     process_matcher(obj, matching_rules, generators, &path, type_matcher, &matcher_type.clone())
+  } else if obj.contains_key("expression") && !obj.contains_key("pact:matcher:type") {
+    debug!("detected 'expression' without 'pact:matcher:type', configuring ProviderStateGenerator");
+    if let Some(generator) = Generator::from_map("ProviderState", obj) {
+      let category = generator_category(matching_rules);
+      generators.add_generator_with_subcategory(category, path.clone(), generator);
+    }
+    obj.get("value").cloned().unwrap_or(Value::Null)
   } else {
     debug!("Configuring a normal object");
     Value::Object(obj.iter()
@@ -461,6 +468,57 @@ use pretty_assertions::assert_eq;
     expect!(result).to(be_equal_to(json));
   }
 
+  // Issue #460 - ProviderStateGenerator shorthand with expression key (no pact:matcher:type)
+  #[test_log::test]
+  fn process_object_with_expression_provider_state_generator() {
+    // A body where accountNumber uses the expression shorthand
+    let json = json!({
+      "accountNumber": {
+        "expression": "${accountNumber}",
+        "value": 100
+      }
+    });
+    let mut matching_rules = MatchingRuleCategory::empty("body");
+    let mut generators = Generators::default();
+    let result = process_object(json.as_object().unwrap(), &mut matching_rules,
+                                &mut generators, DocPath::root(), false);
+
+    // The value should be extracted, not the full object
+    expect!(result).to(be_equal_to(json!({"accountNumber": 100})));
+    // No matching rules should be added (no pact:matcher:type)
+    expect!(matching_rules.is_empty()).to(be_true());
+    // A ProviderStateGenerator should be configured
+    expect!(generators).to(be_equal_to(generators! {
+      "BODY" => {
+        "$.accountNumber" => Generator::ProviderStateGenerator("${accountNumber}".to_string(), None)
+      }
+    }));
+  }
+
+  // Issue #460 - ProviderStateGenerator shorthand with string value
+  #[test_log::test]
+  fn process_object_with_expression_provider_state_generator_string_value() {
+    let json = json!({
+      "expression": "${accountNumber}",
+      "value": "100"
+    });
+    let mut matching_rules = MatchingRuleCategory::empty("body");
+    let mut generators = Generators::default();
+    let result = process_object(json.as_object().unwrap(), &mut matching_rules,
+                                &mut generators, DocPath::root(), false);
+
+    // The value should be extracted
+    expect!(result).to(be_equal_to(json!("100")));
+    // No matching rules
+    expect!(matching_rules.is_empty()).to(be_true());
+    // A ProviderStateGenerator should be configured at root
+    expect!(generators).to(be_equal_to(generators! {
+      "BODY" => {
+        "$" => Generator::ProviderStateGenerator("${accountNumber}".to_string(), None)
+      }
+    }));
+  }
+
   #[test]
   fn process_object_with_matching_rule_test() {
     let json = json!({

rust/pact_ffi/src/mock_server/handles.rs

@@ -1069,6 +1069,18 @@ fn from_integration_json_v2(
           }
 
           result_value
+        } else if map.contains_key("expression") {
+          debug!("detected 'expression' without 'pact:matcher:type', configuring ProviderStateGenerator");
+          if let Some(generator) = Generator::from_map("ProviderState", map) {
+            let category = generator_category(matching_rules);
+            let gen_path = if path_or_status {
+              path.parent().unwrap_or(DocPath::root())
+            } else {
+              path.clone()
+            };
+            generators.add_generator_with_subcategory(category, gen_path, generator);
+          }
+          map.get("value").cloned().unwrap_or_default()
         } else {
           debug!("Configuring a normal value using the 'value' attribute");
           map.get("value").cloned().unwrap_or_default()
@@ -3488,6 +3500,82 @@ mod tests {
       .to(be_equal_to(Either::Right(vec!["100".to_string(), "200".to_string()])));
   }
 
+  // Issue #460 - ProviderStateGenerator shorthand with expression key (no pact:matcher:type)
+  #[test_log::test]
+  fn from_integration_json_expression_provider_state_generator() {
+    let mut rules = MatchingRules::default();
+    let mut generators = Generators::default();
+    let mut path = DocPath::root();
+    path.push_field("accountNumber");
+
+    let result = from_integration_json_v2(
+      &mut rules, &mut generators,
+      r#"{"expression":"${accountNumber}","value":"100"}"#,
+      path.clone(), "query", 0
+    );
+
+    expect!(result).to(be_equal_to(Either::Left("100".to_string())));
+    let gen_cat = generators.categories.get(&pact_models::generators::GeneratorCategory::QUERY);
+    assert!(gen_cat.is_some(), "Expected QUERY generator category to be present");
+    let gen_path = DocPath::root().join("accountNumber");
+    let gen = gen_cat.unwrap().get(&gen_path);
+    assert_eq!(gen, Some(&pact_models::generators::Generator::ProviderStateGenerator("${accountNumber}".to_string(), None)));
+  }
+
+  // Issue #460 - query parameter with ProviderStateGenerator shorthand (no pact:matcher:type)
+  #[test_log::test]
+  fn query_with_provider_state_generator_shorthand() {
+    let pact_handle = PactHandle::new("TestQPSG1", "TestQPSGP1");
+    let description = CString::new("query_with_provider_state_generator_shorthand").unwrap();
+    let handle = pactffi_new_interaction(pact_handle, description.as_ptr());
+
+    let name = CString::new("accountNumber").unwrap();
+    let value = CString::new(r#"{"expression":"${accountNumber}","value":"100"}"#).unwrap();
+    pactffi_with_query_parameter_v2(handle, name.as_ptr(), 0, value.as_ptr());
+
+    let interaction = handle.with_interaction(&|_, _, inner| {
+      inner.as_v4_http().unwrap()
+    }).unwrap();
+
+    pactffi_free_pact_handle(pact_handle);
+
+    expect!(interaction.request.query.clone()).to(be_some().value(hashmap!{
+      "accountNumber".to_string() => vec![Some("100".to_string())]
+    }));
+    expect!(&interaction.request.generators).to(be_equal_to(&generators! {
+      "query" => {
+        "$.accountNumber" => pact_models::generators::Generator::ProviderStateGenerator("${accountNumber}".to_string(), None)
+      }
+    }));
+  }
+
+  // Issue #460 - header with ProviderStateGenerator shorthand (no pact:matcher:type)
+  #[test_log::test]
+  fn header_with_provider_state_generator_shorthand() {
+    let pact_handle = PactHandle::new("TestHPSG1", "TestHPSGP1");
+    let description = CString::new("header_with_provider_state_generator_shorthand").unwrap();
+    let handle = pactffi_new_interaction(pact_handle, description.as_ptr());
+
+    let name = CString::new("x-account-id").unwrap();
+    let value = CString::new(r#"{"expression":"${accountId}","value":"ABC123"}"#).unwrap();
+    pactffi_with_header_v2(handle, InteractionPart::Request, name.as_ptr(), 0, value.as_ptr());
+
+    let interaction = handle.with_interaction(&|_, _, inner| {
+      inner.as_v4_http().unwrap()
+    }).unwrap();
+
+    pactffi_free_pact_handle(pact_handle);
+
+    expect!(interaction.request.headers.clone()).to(be_some().value(hashmap!{
+      "x-account-id".to_string() => vec!["ABC123".to_string()]
+    }));
+    expect!(&interaction.request.generators).to(be_equal_to(&generators! {
+      "header" => {
+        "$['x-account-id']" => pact_models::generators::Generator::ProviderStateGenerator("${accountId}".to_string(), None)
+      }
+    }));
+  }
+
   #[test]
   fn pactffi_with_metadata_async() {
     let pact_handle = PactHandle::new("metadata-consumer", "metadata-provider");
@@ -4604,4 +4692,37 @@ mod tests {
     expect!(headers.get("Content-Type").unwrap().first().unwrap())
       .to(be_equal_to(&JSON.to_string()));
   }
+
+  // Issue #460 - body with ProviderStateGenerator shorthand (expression key, no pact:matcher:type)
+  #[test_log::test]
+  fn body_with_provider_state_generator_shorthand() {
+    let pact_handle = PactHandle::new("TestBPSG1", "TestBPSGP1");
+    let description = CString::new("body_with_provider_state_generator_shorthand").unwrap();
+    let i_handle = pactffi_new_interaction(pact_handle, description.as_ptr());
+
+    let json_ct = CString::new(JSON.to_string()).unwrap();
+    // Body where accountNumber field uses the expression shorthand for ProviderStateGenerator
+    let body = CString::new(r#"{"accountNumber":{"expression":"${accountNumber}","value":100}}"#).unwrap();
+    let result = pactffi_with_body(i_handle, InteractionPart::Request, json_ct.as_ptr(), body.as_ptr());
+
+    let interaction = i_handle
+      .with_interaction(&|_, _, inner| inner.as_v4_http().unwrap())
+      .unwrap();
+
+    pactffi_free_pact_handle(pact_handle);
+
+    expect!(result).to(be_true());
+
+    // The body should have the value extracted (100), not the full expression object
+    let body_bytes = interaction.request.body.value().unwrap();
+    let body_json: serde_json::Value = serde_json::from_slice(&body_bytes).unwrap();
+    assert_eq!(body_json, json!({"accountNumber": 100}));
+
+    // A ProviderStateGenerator should be configured for the accountNumber field
+    expect!(&interaction.request.generators).to(be_equal_to(&generators! {
+      "body" => {
+        "$.accountNumber" => pact_models::generators::Generator::ProviderStateGenerator("${accountNumber}".to_string(), None)
+      }
+    }));
+  }
 }