Struct Json 

pub struct Json<T>(pub T);

ncryptf::rocket::Json represents a application/vnd.ncryptf+json, JSON string The JSON struct supports both serialization and de-serialization to reduce implementation time within your application

Usage

Encryption keys and identifiers are stored in Redis. Make sure you have a rocket_db_pool::Config setup for Redis, and added to your rocket figment() You do not have to setup a RequestGuard for Redis, this just uses the same configuration

.merge(("databases.cache", rocket_db_pools::Config {
        url: format!("redis://127.0.0.1:6379/"),
        min_connections: None,
        max_connections: 1024,
        connect_timeout: 3,
        idle_timeout: None,
    }))

Next, create a struct to represent the request data. This struct MUST implement Serialize if you want to return a ncryptf encrypted response

 use rocket::serde::{Serialize, json::Json};

 [derive(Serialize)]
 #[serde(crate = "rocket::serde")]
 struct TestStruct<'r> {
     pub hello: &'r str
 }

our request can now be parsed using data tags. Responses can be automatically converted into an JSON encrypted ncryptf response by returning ncryptf::rocket::Json<T>

If your header is application/vnd.ncryptf+json, returning a ncryptf::rocket::Json will return an encrypted response If the header is an application/json (or anything else), ncryptf::rocket::Json will return a rocket::serde::json::Json equivalent JSON response in plain text

    #[post("/echo", data="<data>")]
    fn echo(data: ncryptf::rocket::Json<TestStruct>) -> ncryptf::rocket::Json<TestStruct> {
        // data.0 is your TestStruct
        //
        return ncryptf::rocket::Json(data.0);
    }

nryptf::rocket::Jsonsupercedes rocket::serde::json::Json<T> for both encrypted messages, and regular JSON. If you intend to use theAuthorization` trait to authenticate users, you MUST receive and return this for your data type

Tuple Fields

0: T

Implementations

impl<T> Json<T>

pub fn into_inner(self) -> T

Returns the underlying serde_json::Value object

pub fn from_value(value: T) -> Self

Returns a serde_json::Value wrapped as an ncryptf::Json representation

pub fn deserialize_req_from_string<'r>( req: &'r Request<'_>, string: String, cache: &CacheWrapper, ) -> Result<String, Error<'r>>

Deserializes the request sting into a raw JSON string

impl<'r, T: Deserialize<'r>> Json<T>

pub fn from_str(s: &'r str) -> Result<Self, Error<'r>>

pub async fn from_data( req: &'r Request<'_>, data: Data<'r>, ) -> Result<Self, Error<'r>>

Trait Implementations

impl<T: Clone> Clone for Json<T>

fn clone(&self) -> Json<T>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T: Debug> Debug for Json<T>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'r, T: Deserialize<'r>> FromData<'r> for Json<T>

type Error = Error<'r>

The associated error to be returned when the guard fails.

fn from_data<'life0, 'async_trait>( req: &'r Request<'life0>, data: Data<'r>, ) -> Pin<Box<dyn Future<Output = Outcome<'r, Self>> + Send + 'async_trait>>

where Self: 'async_trait, 'r: 'async_trait, 'life0: 'async_trait,

Asynchronously validates, parses, and converts an instance of Self from the incoming request body data.

impl<'r, T: Serialize> Responder<'r, 'static> for Json<T>

Allows for ncryptf::rocket::Json to be emitted as a responder to reduce code overhead This responder will handle encrypting the underlying request data correctly for all supported ncryptf versionn

fn respond_to(self, req: &'r Request<'_>) -> Result<'static>

Returns Ok if a Response could be generated successfully. Otherwise, returns an Err with a failing Status.