tii 0.0.6

//! Provides a basic cookie implementation according to [RFC 6265](http://tools.ietf.org/html/rfc6265).

use crate::http::headers::HttpHeader;

use std::time::Duration;

/// Represents an HTTP cookie as in the `Cookie` header.
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct Cookie {
  /// The name of the cookie.
  pub name: String,
  /// The value of the cookie.
  pub value: String,
}

/// Represents an HTTP cookie as in the `Set-Cookie` header.
///
/// Contains additional information about the cookie, such as its expiration.
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct SetCookie {
  /// The name of the cookie.
  pub name: String,
  /// The value of the cookie.
  pub value: String,
  /// The expiry date of the cookie as an HTTP timestamp.
  pub expires: Option<String>,
  /// The maximum age of the cookie.
  pub max_age: Option<Duration>,
  /// The domain of the cookie.
  pub domain: Option<String>,
  /// The path of the cookie.
  pub path: Option<String>,
  /// Whether the cookie is secure.
  pub secure: bool,
  /// Whether the cookie is HTTP-only.
  pub http_only: bool,
  /// The SameSite configuration of the cookie.
  pub same_site: Option<SameSite>,
}

/// Represents the SameSite value of the cookie.
#[derive(Clone, Debug, PartialEq, Eq)]
pub enum SameSite {
  /// Cookies will only be sent in a first-party context and not be sent along with requests
  ///   initiated by third party websites.
  Strict,
  /// Cookies are not sent on normal cross-site subrequests (for example to load images or frames
  ///   into a third party site), but are sent when a user is navigating to the origin site
  ///   (i.e., when following a link).
  Lax,
  /// Cookies will be sent in all contexts, i.e. in responses to both first-party and cross-origin requests.
  /// If SameSite=None is set, the cookie Secure attribute must also be set (or the cookie will be blocked).
  None,
}

impl Cookie {
  /// Create a new cookie with the given name and value.
  pub fn new(name: impl AsRef<str>, value: impl AsRef<str>) -> Self {
    Self { name: name.as_ref().to_string(), value: value.as_ref().to_string() }
  }

  /// Convert a collection of cookies into a `Cookie` header.
  pub fn to_header(cookies: impl AsRef<[Cookie]>) -> Option<HttpHeader> {
    let cookies = cookies.as_ref();

    if cookies.is_empty() {
      return None;
    }

    let mut value = String::with_capacity(cookies.len() * 32);

    for cookie in cookies {
      value.push_str(&cookie.name);
      value.push('=');
      value.push_str(&cookie.value);
      value.push_str("; ");
    }

    Some(HttpHeader::new("Cookie", &value[..value.len() - 2]))
  }
}

impl SetCookie {
  /// Create a new cookie with the given name and value.
  pub fn new(name: impl AsRef<str>, value: impl AsRef<str>) -> Self {
    Self {
      name: name.as_ref().to_string(),
      value: value.as_ref().to_string(),
      expires: None,
      max_age: None,
      domain: None,
      path: None,
      secure: false,
      http_only: false,
      same_site: None,
    }
  }

  /// Set the expiry date of the cookie.
  ///
  /// **Warning:** This must be a valid HTTP timestamp.
  pub fn with_expires(mut self, expires: impl AsRef<str>) -> Self {
    self.expires = Some(expires.as_ref().to_string());
    self
  }

  /// Set the maximum age of the cookie.
  pub fn with_max_age(mut self, max_age: Duration) -> Self {
    self.max_age = Some(max_age);
    self
  }

  /// Set the domain of the cookie.
  pub fn with_domain(mut self, domain: impl AsRef<str>) -> Self {
    self.domain = Some(domain.as_ref().to_string());
    self
  }

  /// Set the path of the cookie.
  pub fn with_path(mut self, path: impl AsRef<str>) -> Self {
    self.path = Some(path.as_ref().to_string());
    self
  }

  /// Set the secure flag of the cookie.
  pub fn with_secure(mut self, secure: bool) -> Self {
    self.secure = secure;
    self
  }

  /// Set the HTTP-only flag of the cookie.
  pub fn with_http_only(mut self, http_only: bool) -> Self {
    self.http_only = http_only;
    self
  }

  /// Set the SameSite configuration of the cookie.
  pub fn with_same_site(mut self, same_site: SameSite) -> Self {
    self.same_site = Some(same_site);
    self
  }
}

impl From<SetCookie> for HttpHeader {
  fn from(cookie: SetCookie) -> Self {
    let mut value = format!("{}={}", cookie.name, cookie.value);

    if let Some(expires) = cookie.expires {
      value = format!("{value}; Expires={expires}");
    }

    if let Some(max_age) = cookie.max_age {
      value = format!("{}; Max-Age={}", value, max_age.as_secs());
    }

    if let Some(domain) = cookie.domain {
      value = format!("{value}; Domain={domain}");
    }

    if let Some(path) = cookie.path {
      value = format!("{value}; Path={path}");
    }

    if let Some(same_site) = cookie.same_site {
      value = format!(
        "{}; SameSite={}",
        value,
        match same_site {
          SameSite::Strict => "Strict",
          SameSite::Lax => "Lax",
          SameSite::None => "None",
        }
      );
    }

    if cookie.secure {
      value = format!("{value}; Secure");
    }

    if cookie.http_only {
      value = format!("{value}; HttpOnly");
    }

    HttpHeader::new("Set-Cookie", value)
  }
}