refactor: atproto-client-dpop supports query and procedure methods

Signed-off-by: Nick Gerakines <[e-mail]>

crates/atproto-client/src/bin/atproto-client-dpop.rs

···
 //! subjects to DID documents and constructing authenticated requests.
 
 use anyhow::Result;
-use atproto_client::client::{DPoPAuth, get_dpop_json_with_headers};
+use atproto_client::client::{DPoPAuth, get_dpop_json_with_headers, post_dpop_json_with_headers};
 use atproto_identity::{
     config::{CertificateBundles, DnsNameservers, default_env, optional_env, version},
     key::identify_key,
···
     println!();
     println!("Usage:");
     println!(
-        "  atproto-client-dpop <subject> <private_dpop_key> <access_token> <xrpc_path> [key=value]..."
+        "  atproto-client-dpop <subject> <private_dpop_key> <access_token> <xrpc_path> [args...]"
     );
     println!();
     println!("Arguments:");
     println!("  subject               Subject identifier to resolve");
     println!("  private_dpop_key      Private DPoP key for authentication");
     println!("  access_token          OAuth access token");
-    println!("  xrpc_path             XRPC path (e.g., com.atproto.repo.listRecords)");
+    println!("  xrpc_path             XRPC path with optional prefix:");
+    println!("                        - query:<path> for GET requests (default)");
+    println!("                        - procedure:<path> for POST requests");
+    println!("                        - <path> defaults to GET request");
     println!(
-        "  key=value             Additional query parameters
-  header=name=value     Additional HTTP headers"
+        "  key=value             Additional query parameters (for GET requests)
+  header=name=value     Additional HTTP headers
+  <file_path>           JSON file path (required for procedure: prefix)"
     );
     println!();
-    println!("Example:");
+    println!("Examples:");
     println!(
-        "  atproto-client-dpop alice.bsky.social dpop.pem token123 com.atproto.repo.listRecords repo=alice.bsky.social collection=app.bsky.feed.post header=X-Custom-Header=value"
+        "  # GET request (default behavior without prefix)"
+    );
+    println!(
+        "  atproto-client-dpop alice.bsky.social dpop.pem token123 com.atproto.repo.listRecords repo=alice.bsky.social collection=app.bsky.feed.post"
+    );
+    println!(
+        "  # GET request (explicit query: prefix)"
+    );
+    println!(
+        "  atproto-client-dpop alice.bsky.social dpop.pem token123 query:com.atproto.repo.listRecords repo=alice.bsky.social collection=app.bsky.feed.post"
+    );
+    println!(
+        "  # POST request (requires procedure: prefix and JSON file)"
+    );
+    println!(
+        "  atproto-client-dpop alice.bsky.social dpop.pem token123 procedure:com.atproto.repo.createRecord data.json"
     );
 }
 
···
     let subject = &args[0];
     let private_dpop_key = &args[1];
     let access_token = &args[2];
-    let xrpc_path = &args[3];
+    let xrpc_path_with_prefix = &args[3];
 
-    // Parse additional key=value arguments and header=name=value arguments
+    // Parse the xrpc_path prefix (optional, defaults to query:)
+    let (is_procedure, xrpc_path) = if let Some(path) = xrpc_path_with_prefix.strip_prefix("query:") {
+        (false, path)
+    } else if let Some(path) = xrpc_path_with_prefix.strip_prefix("procedure:") {
+        (true, path)
+    } else {
+        // Default to query if no prefix is provided
+        (false, xrpc_path_with_prefix.as_str())
+    };
+
+    // Parse additional arguments based on request type
     let mut query_params = HashMap::new();
     let mut header_params = HashMap::new();
-    for arg in &args[4..] {
+    let mut json_data: Option<serde_json::Value> = None;
+    let mut arg_index = 4;
+
+    // For procedure calls, expect the next argument to be a file path
+    if is_procedure {
+        if arg_index >= args.len() {
+            anyhow::bail!("procedure: prefix requires a JSON file path as the next argument");
+        }
+        let file_path = &args[arg_index];
+        let file_content = std::fs::read_to_string(file_path)
+            .map_err(|e| anyhow::anyhow!("Failed to read file '{}': {}", file_path, e))?;
+        json_data = Some(serde_json::from_str(&file_content)
+            .map_err(|e| anyhow::anyhow!("Failed to parse JSON from file '{}': {}", file_path, e))?);
+        arg_index += 1;
+    }
+
+    // Parse remaining key=value arguments and header=name=value arguments
+    for arg in &args[arg_index..] {
         if let Some((key, value)) = arg.split_once('=') {
             if key == "header" {
                 // Parse header=name=value format
···
                     eprintln!("Warning: Ignoring invalid header format: {}", arg);
                     eprintln!("Expected format: header=name=value");
                 }
+            } else if is_procedure {
+                eprintln!("Warning: Query parameters are not supported for procedure calls. Ignoring: {}", arg);
             } else {
                 query_params.insert(key.to_string(), value.to_string());
             }
···
 
     println!("Making DPoP authenticated XRPC call");
     println!("Subject: {}", subject);
+    println!("Request Type: {}", if is_procedure { "POST (procedure)" } else { "GET (query)" });
     println!("XRPC Path: {}", xrpc_path);
     if !query_params.is_empty() {
         println!("Query Parameters: {:?}", query_params);
     }
     if !header_params.is_empty() {
         println!("Additional Headers: {:?}", header_params);
+    }
+    if let Some(ref data) = json_data {
+        println!("JSON Data: {}", serde_json::to_string_pretty(data)?);
     }
 
     // Set up HTTP client configuration
···
     // Construct the URL
     let mut url = format!("{}/xrpc/{}", pds_endpoint, xrpc_path);
 
-    // Add query parameters if any
-    if !query_params.is_empty() {
+    // Add query parameters if any (only for GET requests)
+    if !is_procedure && !query_params.is_empty() {
         let query_string: Vec<String> = query_params
             .iter()
             .map(|(k, v)| format!("{}={}", urlencoding::encode(k), urlencoding::encode(v)))
···
     // Make the authenticated request
     println!("Making DPoP authenticated request...");
 
-    let response =
-        get_dpop_json_with_headers(&http_client, &dpop_auth, &url, &additional_headers).await?;
+    let response = if is_procedure {
+        let data = json_data.ok_or_else(|| anyhow::anyhow!("No JSON data provided for procedure call"))?;
+        post_dpop_json_with_headers(&http_client, &dpop_auth, &url, data, &additional_headers).await?
+    } else {
+        get_dpop_json_with_headers(&http_client, &dpop_auth, &url, &additional_headers).await?
+    };
 
     // Print the response
     println!("Response:");

crates/atproto-client/src/client.rs

···
     url: &str,
     record: serde_json::Value,
 ) -> Result<serde_json::Value> {
+    let empty = HeaderMap::default();
+    post_dpop_json_with_headers(http_client, dpop_auth, url, record, &empty).await
+}
+
+/// Performs a DPoP-authenticated HTTP POST request with JSON body and additional headers, and parses the response as JSON.
+///
+/// This function extends `post_dpop_json` by allowing custom headers to be included
+/// in the request. Useful for adding custom content types, user agents, or other
+/// protocol-specific headers while maintaining DPoP authentication.
+///
+/// # Arguments
+///
+/// * `http_client` - The HTTP client to use for the request
+/// * `dpop_auth` - DPoP authentication credentials
+/// * `url` - The URL to request
+/// * `record` - The JSON data to send in the request body
+/// * `additional_headers` - Additional HTTP headers to include in the request
+///
+/// # Returns
+///
+/// The parsed JSON response as a `serde_json::Value`
+///
+/// # Errors
+///
+/// Returns `DPoPError::ProofGenerationFailed` if DPoP proof generation fails,
+/// `DPoPError::HttpRequestFailed` if the HTTP request fails,
+/// or `DPoPError::JsonParseFailed` if JSON parsing fails.
+///
+/// # Example
+///
+/// ```no_run
+/// use atproto_client::client::{DPoPAuth, post_dpop_json_with_headers};
+/// use atproto_identity::key::identify_key;
+/// use reqwest::{Client, header::{HeaderMap, USER_AGENT}};
+/// use serde_json::json;
+///
+/// # async fn example() -> anyhow::Result<()> {
+/// let client = Client::new();
+/// let dpop_auth = DPoPAuth {
+///     dpop_private_key_data: identify_key("did:key:zQ3sh...")?,
+///     oauth_access_token: "access_token".to_string(),
+///     oauth_issuer: "did:plc:issuer123".to_string(),
+/// };
+///
+/// let mut headers = HeaderMap::new();
+/// headers.insert(USER_AGENT, "my-app/1.0".parse()?);
+///
+/// let response = post_dpop_json_with_headers(
+///     &client,
+///     &dpop_auth,
+///     "https://pds.example.com/xrpc/com.atproto.repo.createRecord",
+///     json!({"$type": "app.bsky.feed.post", "text": "Hello!"}),
+///     &headers
+/// ).await?;
+/// # Ok(())
+/// # }
+/// ```
+pub async fn post_dpop_json_with_headers(
+    http_client: &reqwest::Client,
+    dpop_auth: &DPoPAuth,
+    url: &str,
+    record: serde_json::Value,
+    additional_headers: &HeaderMap,
+) -> Result<serde_json::Value> {
     let (dpop_proof_token, dpop_proof_header, dpop_proof_claim) = request_dpop(
         &dpop_auth.dpop_private_key_data,
         "POST",
···
 
     let http_response = dpop_retry_client
         .post(url)
+        .headers(additional_headers.clone())
         .header(
             "Authorization",
             &format!("DPoP {}", dpop_auth.oauth_access_token),