qrock 0.2.2

Helpers for Rocket HTTP server 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

pub mod fields;

use std::collections::HashMap;

use rocket::{
  form::{error::ErrorKind, Contextual, Form},
  serde::json::Json,
  Responder
};

#[derive(Responder)]
pub enum ApiError {
  #[response(status = 422)]
  BadForm(Json<HashMap<String, Vec<String>>>)
}


/// Compatibility wrapper for [`unpack()`].
///
/// # Notes
/// This function will be removed in a future version.  Use `unpack()` instead.
#[allow(clippy::missing_errors_doc)]
#[deprecated(since = "0.2.0", note = "please use `unpack()` instead")]
pub fn unpack_field_errors<T>(
  form: Form<Contextual<'_, T>>
) -> Result<T, ApiError>
where
  T: std::fmt::Debug
{
  unpack(form)
}


/// Given a [`Contextual`] form, return the inner form type if no form errors
/// are detected.
///
/// # Errors
/// If there are field errors, return [`ApiError::BadForm`].  The `BadForm`
/// will contain a `HashMap<String, Vec<String>>`, where the keys are form
/// field names, and their values (`Vec<String>`) are string representation of
/// the errors these fields caused.
pub fn unpack<T>(form: Form<Contextual<'_, T>>) -> Result<T, ApiError>
where
  T: std::fmt::Debug
{
  let form = form.into_inner();

  if let Some(form) = form.value {
    Ok(form)
  } else {
    let mut field_errors = HashMap::new();

    for err in form.context.errors() {
      let Some(ref name) = err.name else {
        continue;
      };
      let errmsg = match &err.kind {
        ErrorKind::Validation(errmsg) => {
          format!("validation failed; {errmsg}")
        }
        ErrorKind::InvalidLength { .. } => {
          format!("invalid length; {}", err.kind)
        }
        ErrorKind::InvalidChoice { choices: _ } => "invalid choice".into(),
        ErrorKind::OutOfRange { .. } => {
          format!("out of range; {}", err.kind)
        }
        _ => {
          eprintln!("Unhandled error kind: {err:?}");
          continue;
        }
      };
      field_errors
        .entry(name.to_string())
        .or_insert_with(Vec::<String>::new)
        .push(errmsg);
    }

    Err(ApiError::BadForm(Json(field_errors)))
  }
}

// vim: set ft=rust et sw=2 ts=2 sts=2 cinoptions=2 tw=79 :