Struct Item 

pub struct Item {
    pub attributes: HashMap<String, AttributeValue>,
}

dynamodb-formatted json looks something like this:

{
  "profile_picture": { "B": "base64 string" },
  "is_valid": { "BOOL": true },
  "pictures": { "BS": ["base64 1", "base64 2"] },
  "friends": { "L": [{ "S": "bob" }, { "S": "alice" }] },
  "relationship": { "M": { "bob": {"S": "best friend"}, "alice": { "S": "second best friend" } } },
  "age": { "N": "23" },
  "favorite_birthdays": { "NS": ["17", "25"] },
  "children": { "NULL": true },
  "name": { "S": "arthur" },
  "friends": { "SS": ["bob", "alice"] }
}

This stuff exists mostly because WIT maintainers consider list to be dependent on t, which causes much consternation with regard to serialization. Eventually they will likely work it out like json, protocol buffers, msgpack, and many other serialization formats before it.

Examples:

---

Basic explicit lists:

use momento_functions_host::aws::ddb::Item;
let item: Item = vec![("some key", "some value")].into();
let item: Item = vec![("some key", 42)].into();

---

Custom bound types:

use momento_functions_host::aws::ddb::{AttributeValue, Item};
struct MyStruct {
    some_attribute: String,
}

// convert into dynamodb format
impl From<MyStruct> for Item {
    fn from(value: MyStruct) -> Self {
        [
            ("some_attribute", AttributeValue::from(value.some_attribute)),
        ].into()
    }
}

// convert from dynamodb format
impl TryFrom<Item> for MyStruct {
    type Error = String;
    fn try_from(mut value: Item) -> Result<Self, Self::Error> {
        Ok(Self {
            some_attribute: value.attributes.remove("some_attribute").ok_or("missing some_attribute")?.try_into()?,
        })
    }
}

let item: Item = MyStruct { some_attribute: "some value".to_string() }.into();

Fields

attributes: HashMap<String, AttributeValue>

The item object

Trait Implementations

impl Debug for Item

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Item

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<I, S, V> From<I> for Item

where I: IntoIterator<Item = (S, V)>, S: Into<String>, V: Into<AttributeValue>,

fn from(value: I) -> Self

Converts to this type from the input type.

impl Serialize for Item

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.