Merge commit 'c203d2e3eed2b989281346455757a467329fbfa2' into RFC30/kotlin-codegen-core

Author: thomas-k-cameron

rust-runtime/aws-smithy-types/Cargo.toml

@@ -14,6 +14,11 @@ ryu = "1.0.5"
 time = { version = "0.3.4", features = ["parsing"] }
 base64-simd = "0.8"
 
+
+[target."cfg(aws_sdk_unstable)".dependencies.serde]
+version = "1"
+features = ["derive"]
+
 [dev-dependencies]
 base64 = "0.13.0"
 lazy_static = "1.4"

rust-runtime/aws-smithy-types/src/blob.rs

@@ -0,0 +1,160 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#[cfg(all(
+    aws_sdk_unstable,
+    any(feature = "serde-deserialize", feature = "serde-serialize")
+))]
+use crate::base64;
+#[cfg(all(aws_sdk_unstable, feature = "serde-serialize"))]
+use serde::Serialize;
+#[cfg(all(aws_sdk_unstable, feature = "serde-deserialize"))]
+use serde::{de::Visitor, Deserialize};
+/// Binary Blob Type
+///
+/// Blobs represent protocol-agnostic binary content.
+#[derive(Debug, PartialEq, Eq, Hash, Clone)]
+pub struct Blob {
+    inner: Vec<u8>,
+}
+
+impl Blob {
+    /// Creates a new blob from the given `input`.
+    pub fn new<T: Into<Vec<u8>>>(input: T) -> Self {
+        Blob {
+            inner: input.into(),
+        }
+    }
+
+    /// Consumes the `Blob` and returns a `Vec<u8>` with its contents.
+    pub fn into_inner(self) -> Vec<u8> {
+        self.inner
+    }
+}
+
+impl AsRef<[u8]> for Blob {
+    fn as_ref(&self) -> &[u8] {
+        &self.inner
+    }
+}
+
+#[cfg(all(aws_sdk_unstable, feature = "serde-serialize"))]
+impl Serialize for Blob {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        if serializer.is_human_readable() {
+            serializer.serialize_str(&crate::base64::encode(&self.inner))
+        } else {
+            serializer.serialize_bytes(&self.inner)
+        }
+    }
+}
+
+#[cfg(all(aws_sdk_unstable, feature = "serde-deserialize"))]
+struct HumanReadableBlobVisitor;
+
+#[cfg(all(aws_sdk_unstable, feature = "serde-deserialize"))]
+impl<'de> Visitor<'de> for HumanReadableBlobVisitor {
+    type Value = Blob;
+    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        formatter.write_str("expected base64 encoded string")
+    }
+
+    fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
+    where
+        E: serde::de::Error,
+    {
+        match base64::decode(v) {
+            Ok(inner) => Ok(Blob { inner }),
+            Err(e) => Err(serde::de::Error::custom(e)),
+        }
+    }
+}
+
+#[cfg(all(aws_sdk_unstable, feature = "serde-deserialize"))]
+struct NotHumanReadableBlobVisitor;
+
+#[cfg(all(aws_sdk_unstable, feature = "serde-deserialize"))]
+impl<'de> Visitor<'de> for NotHumanReadableBlobVisitor {
+    type Value = Blob;
+    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        formatter.write_str("expected base64 encoded string")
+    }
+
+    fn visit_byte_buf<E>(self, v: Vec<u8>) -> Result<Self::Value, E>
+    where
+        E: serde::de::Error,
+    {
+        Ok(Blob { inner: v })
+    }
+}
+
+#[cfg(all(aws_sdk_unstable, feature = "serde-deserialize"))]
+impl<'de> Deserialize<'de> for Blob {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        if deserializer.is_human_readable() {
+            deserializer.deserialize_str(HumanReadableBlobVisitor)
+        } else {
+            deserializer.deserialize_byte_buf(NotHumanReadableBlobVisitor)
+        }
+    }
+}
+
+#[cfg(test)]
+#[cfg(all(
+    aws_sdk_unstable,
+    feature = "serde-serialize",
+    feature = "serde-deserialize"
+))]
+mod test {
+    use crate::Blob;
+    use serde::{Deserialize, Serialize};
+    use std::collections::HashMap;
+
+    #[derive(Deserialize, Serialize, Debug, PartialEq)]
+    struct ForTest {
+        blob: Blob,
+    }
+
+    #[test]
+    fn human_readable_blob() {
+        let aws_in_base64 = r#"{"blob":"QVdT"}"#;
+        let for_test = ForTest {
+            blob: Blob {
+                inner: vec![b'A', b'W', b'S'],
+            },
+        };
+        assert_eq!(for_test, serde_json::from_str(aws_in_base64).unwrap());
+        assert_eq!(serde_json::to_string(&for_test).unwrap(), aws_in_base64);
+    }
+
+    #[test]
+    fn not_human_readable_blob() {
+        use std::ffi::CString;
+
+        let for_test = ForTest {
+            blob: Blob {
+                inner: vec![b'A', b'W', b'S'],
+            },
+        };
+        let mut buf = vec![];
+        let res = ciborium::ser::into_writer(&for_test, &mut buf);
+        assert!(res.is_ok());
+
+        // checks whether the bytes are deserialiezd properly
+        let n: HashMap<String, CString> =
+            ciborium::de::from_reader(std::io::Cursor::new(buf.clone())).unwrap();
+        assert!(n.get("blob").is_some());
+        assert!(n.get("blob") == CString::new([65, 87, 83]).ok().as_ref());
+
+        let de: ForTest = ciborium::de::from_reader(std::io::Cursor::new(buf)).unwrap();
+        assert_eq!(for_test, de);
+    }
+}

rust-runtime/aws-smithy-types/src/date_time/mod.rs

@@ -16,7 +16,12 @@ use std::time::Duration;
 use std::time::SystemTime;
 use std::time::UNIX_EPOCH;
 
+#[cfg(all(aws_sdk_unstable, feature = "serde-deserialize"))]
+mod de;
 mod format;
+#[cfg(all(aws_sdk_unstable, feature = "serde-serialize"))]
+mod ser;
+
 pub use self::format::DateTimeFormatError;
 pub use self::format::DateTimeParseError;
 
@@ -552,4 +557,50 @@ mod test {
             SystemTime::try_from(date_time).unwrap()
         );
     }
+
+    #[cfg(all(
+        test,
+        aws_sdk_unstable,
+        feature = "serde-deserialize",
+        feature = "serde-serialize"
+    ))]
+    #[test]
+    fn human_readable_datetime() {
+        use serde::{Deserialize, Serialize};
+
+        let datetime = DateTime::from_secs(1576540098);
+        #[derive(Serialize, Deserialize, PartialEq)]
+        struct Test {
+            datetime: DateTime,
+        }
+        let datetime_json = r#"{"datetime":"2019-12-16T23:48:18Z"}"#;
+        assert!(serde_json::to_string(&Test { datetime }).ok() == Some(datetime_json.to_string()));
+
+        let test = serde_json::from_str::<Test>(&datetime_json).ok();
+        assert!(test.is_some());
+        assert!(test.unwrap().datetime == datetime);
+    }
+
+    /// checks that they are serialized into tuples
+    #[cfg(all(
+        test,
+        aws_sdk_unstable,
+        feature = "serde-deserialize",
+        feature = "serde-serialize"
+    ))]
+    #[test]
+    fn not_human_readable_datetime() {
+        let cbor = ciborium::value::Value::Array(vec![
+            ciborium::value::Value::Integer(1576540098i64.into()),
+            ciborium::value::Value::Integer(0u32.into()),
+        ]);
+        let datetime = DateTime::from_secs(1576540098);
+
+        let mut buf1 = vec![];
+        let mut buf2 = vec![];
+        let res1 = ciborium::ser::into_writer(&datetime, &mut buf1);
+        let res2 = ciborium::ser::into_writer(&cbor, &mut buf2);
+        assert!(res1.is_ok() && res2.is_ok());
+        assert!(buf1 == buf2, "{:#?}", (buf1, buf2));
+    }
 }

rust-runtime/aws-smithy-types/src/document.rs

@@ -0,0 +1,145 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+use crate::Number;
+use std::collections::HashMap;
+
+/* ANCHOR: document */
+
+/// Document Type
+///
+/// Document types represents protocol-agnostic open content that is accessed like JSON data.
+/// Open content is useful for modeling unstructured data that has no schema, data that can't be
+/// modeled using rigid types, or data that has a schema that evolves outside of the purview of a model.
+/// The serialization format of a document is an implementation detail of a protocol.
+#[derive(Debug, Clone, PartialEq)]
+#[cfg_attr(
+    all(aws_sdk_unstable, feature = "serde-serialize"),
+    derive(serde::Serialize)
+)]
+#[cfg_attr(
+    all(aws_sdk_unstable, feature = "serde-deserialize"),
+    derive(serde::Deserialize)
+)]
+#[cfg_attr(
+    any(
+        all(aws_sdk_unstable, feature = "serde-deserialize"),
+        all(aws_sdk_unstable, feature = "serde-serialize")
+    ),
+    serde(untagged)
+)]
+pub enum Document {
+    /// JSON object
+    Object(HashMap<String, Document>),
+    /// JSON array
+    Array(Vec<Document>),
+    /// JSON number
+    Number(Number),
+    /// JSON string
+    String(String),
+    /// JSON boolean
+    Bool(bool),
+    /// JSON null
+    Null,
+}
+
+impl From<bool> for Document {
+    fn from(value: bool) -> Self {
+        Document::Bool(value)
+    }
+}
+
+impl From<String> for Document {
+    fn from(value: String) -> Self {
+        Document::String(value)
+    }
+}
+
+impl From<Vec<Document>> for Document {
+    fn from(values: Vec<Document>) -> Self {
+        Document::Array(values)
+    }
+}
+
+impl From<HashMap<String, Document>> for Document {
+    fn from(values: HashMap<String, Document>) -> Self {
+        Document::Object(values)
+    }
+}
+
+impl From<u64> for Document {
+    fn from(value: u64) -> Self {
+        Document::Number(Number::PosInt(value))
+    }
+}
+
+impl From<i64> for Document {
+    fn from(value: i64) -> Self {
+        Document::Number(Number::NegInt(value))
+    }
+}
+
+impl From<i32> for Document {
+    fn from(value: i32) -> Self {
+        Document::Number(Number::NegInt(value as i64))
+    }
+}
+
+/* ANCHOR END: document */
+
+#[cfg(test)]
+mod test {
+    /// checks if a) serialization of json suceeds and b) it is compatible with serde_json
+    #[test]
+    #[cfg(all(
+        aws_sdk_unstable,
+        feature = "serde-serialize",
+        feature = "serde-deserialize"
+    ))]
+    fn serialize_json() {
+        use crate::Document;
+        use crate::Number;
+        use std::collections::HashMap;
+        let mut map: HashMap<String, Document> = HashMap::new();
+        // string
+        map.insert("hello".into(), "world".to_string().into());
+        // numbers
+        map.insert("pos_int".into(), Document::Number(Number::PosInt(1).into()));
+        map.insert(
+            "neg_int".into(),
+            Document::Number(Number::NegInt(-1).into()),
+        );
+        map.insert(
+            "float".into(),
+            Document::Number(Number::Float(0.1 + 0.2).into()),
+        );
+        // booleans
+        map.insert("true".into(), true.into());
+        map.insert("false".into(), false.into());
+        // check if array with different datatypes would succeed
+        map.insert(
+            "array".into(),
+            vec![
+                map.clone().into(),
+                "hello-world".to_string().into(),
+                true.into(),
+                false.into(),
+            ]
+            .into(),
+        );
+        // map
+        map.insert("map".into(), map.clone().into());
+        // null
+        map.insert("null".into(), Document::Null);
+        let obj = Document::Object(map);
+        // comparing string isnt going to work since there is no gurantee for the ordering of the keys
+        let target_file = include_str!("../test_data/serialize_document.json");
+        let json: Result<serde_json::Value, _> = serde_json::from_str(target_file);
+        // serializer
+        assert_eq!(serde_json::to_value(&obj).unwrap(), json.unwrap());
+        let doc: Result<Document, _> = serde_json::from_str(target_file);
+        assert_eq!(obj, doc.unwrap());
+    }
+}