actix-idempotent 0.1.0

A middleware for handling idempotent requests in actix-web applications.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96

use std::collections::HashSet;
use actix_web::http::header::{HeaderMap, HeaderName, HeaderValue};

/// Configuration options for the idempotency layer.
///
/// Configure:
/// - How long responses should be cached
/// - Which headers should be ignored when calculating the request hash
/// - Whether to ignore all headers entirely
///
/// # Example
/// ```rust
/// use actix_idempotent::IdempotentOptions;
/// use actix_web::http::header::HeaderName;
///
/// let options_1 = IdempotentOptions::default()
///     .ignore_header(HeaderName::from_static("x-request-id"))
///     .ignore_all_headers();
///
/// let options_2 = IdempotentOptions::new();
/// ```
#[derive(Clone, Debug)]
pub struct IdempotentOptions {
  pub(crate) ignored_headers: HashSet<HeaderName>,
  pub(crate) ignored_header_values: HeaderMap,
  pub(crate) ignore_all_headers: bool,
}

impl IdempotentOptions {
  pub fn new() -> Self {
    Self {
      ignored_headers: HashSet::new(),
      ignored_header_values: HeaderMap::new(),
      ignore_all_headers: false,
    }
  }

  /// Adds a header to the list of headers that should be ignored when calculating the request hash.
  pub fn ignore_header(mut self, name: HeaderName) -> Self {
    self.ignored_headers.insert(name);
    self
  }

  /// Adds a header with a specific value to be ignored when calculating the request hash.
  ///
  /// If the header exists with a different value, it will still be included in the hash.
  pub fn ignore_header_with_value(mut self, name: HeaderName, value: HeaderValue) -> Self {
    self.ignored_header_values.insert(name, value);
    self
  }

  /// Configures the layer to ignore all headers when calculating the request hash.
  ///
  /// When enabled, only the method, path, and body will be used to determine idempotency.
  pub fn ignore_all_headers(mut self) -> Self {
    self.ignore_all_headers = true;
    self
  }
}

impl Default for IdempotentOptions {
  fn default() -> Self {
    let mut options = Self {
      ignored_headers: HashSet::new(),
      ignored_header_values: HeaderMap::new(),
      ignore_all_headers: false,
    };

    let default_ignored = [
      "user-agent",
      "accept",
      "accept-encoding",
      "accept-language",
      "cache-control",
      "connection",
      "cookie",
      "host",
      "pragma",
      "referer",
      "sec-fetch-dest",
      "sec-fetch-mode",
      "sec-fetch-site",
      "sec-ch-ua",
      "sec-ch-ua-mobile",
      "sec-ch-ua-platform",
    ];

    for header in default_ignored {
      options
        .ignored_headers
        .insert(HeaderName::from_static(header));
    }

    options
  }
}