choonkeat / elm-aws / AWS.DynamoDB


type Base64String

A wrapper to differentiate from regular String


type JsonEncoded a
    = JsonEncoded a

wrapper type to store data as a String in a dynamodb column


type alias QueryResponse a =
{ count : Basics.Int
, items : List a
, lastEvaluatedKey : Json.Encode.Value 
}

Structure of DynamoDB response

decodeB : Json.Decode.Decoder Base64String

import Json.Decode

toBase64 "aGVsbG8="
|> Result.andThen (\v ->
    Json.Decode.decodeValue decodeB (encodeB v)
        |> Result.mapError Json.Decode.errorToString
)
--> toBase64 "aGVsbG8="

decodeBOOL : Json.Decode.Decoder Basics.Bool

import Json.Decode

Json.Decode.decodeValue decodeBOOL (encodeBOOL True)
--> Ok True

decodeBS : Json.Decode.Decoder (List Base64String)

import Json.Decode

toBase64 "aGVsbG8="
|> Result.andThen (\v ->
    Json.Decode.decodeValue decodeBS (encodeBS [v])
        |> Result.mapError Json.Decode.errorToString
)
--> Result.map (\v -> [v]) (toBase64 "aGVsbG8=")

decodeJsonEncoded : Json.Decode.Decoder a -> Json.Decode.Decoder (JsonEncoded a)

decodeL : Json.Decode.Decoder a -> Json.Decode.Decoder (List a)

import Json.Decode

toBase64 "aGVsbG8="
|> Result.andThen (\v ->
    Json.Decode.decodeValue (decodeL decodeB) (encodeL encodeB [v])
        |> Result.mapError Json.Decode.errorToString
)
--> Result.map (\v -> [v]) (toBase64 "aGVsbG8=")

Json.Decode.decodeValue (decodeL decodeN) (encodeL encodeN [3.14, 42])
--> Ok [3.14, 42]

decodeM : Json.Decode.Decoder a -> Json.Decode.Decoder (Dict String a)

import Json.Decode
import Dict

Json.Decode.decodeValue (decodeM decodeN) (encodeM encodeN (Dict.fromList [("hello", 3.14)]))
--> Ok (Dict.fromList [("hello", 3.14)])

decodeN : Json.Decode.Decoder Basics.Float

import Json.Decode

Json.Decode.decodeValue decodeN (encodeN 3.14)
--> Ok 3.14

decodeNS : Json.Decode.Decoder (Set Basics.Float)

import Json.Decode
import Set

Json.Decode.decodeValue decodeNS (encodeNS (Set.fromList [1, 3, 5, 7]))
--> Ok (Set.fromList [1, 3, 5, 7])

decodeNULL : Json.Decode.Decoder Basics.Bool

import Json.Decode

Json.Decode.decodeValue decodeNULL (encodeNULL False)
--> Ok False

decodeQueryResponse : Json.Decode.Decoder a -> Json.Decode.Decoder (QueryResponse a)

decodeS : Json.Decode.Decoder String

import Json.Decode

Json.Decode.decodeValue decodeS (encodeS "Hello")
--> Ok "Hello"

decodeSS : Json.Decode.Decoder (Set String)

import Json.Decode
import Set

Json.Decode.decodeValue decodeSS (encodeSS (Set.fromList ["hello", "world"]))
--> Ok (Set.fromList ["hello", "world"])

encodeB : Base64String -> Json.Encode.Value

import Json.Encode

toBase64 "aGVsbG8="
|> Result.map (\v -> Json.Encode.encode 0 (encodeB v))
--> Ok """{"B":"aGVsbG8="}"""

encodeBOOL : Basics.Bool -> Json.Encode.Value

import Json.Encode

Json.Encode.encode 0 (encodeBOOL False)
--> """{"BOOL":false}"""

encodeBS : List Base64String -> Json.Encode.Value

import Json.Encode

toBase64 "aGVsbG8="
|> Result.map (\v -> Json.Encode.encode 0 (encodeBS ([v])))
--> Ok """{"BS":["aGVsbG8="]}"""

encodeJsonEncoded : (a -> Json.Encode.Value) -> JsonEncoded a -> Json.Encode.Value

encodeL : (a -> Json.Encode.Value) -> List a -> Json.Encode.Value

import Json.Encode

Json.Encode.encode 0 (encodeL encodeN [1,3,5,7])
--> """{"L":[{"N":"1"},{"N":"3"},{"N":"5"},{"N":"7"}]}"""

encodeM : (a -> Json.Encode.Value) -> Dict String a -> Json.Encode.Value

import Json.Encode
import Dict

Json.Encode.encode 0 (encodeM encodeN (Dict.fromList [("width", 800), ("height", 600)]))
--> """{"M":{"height":{"N":"600"},"width":{"N":"800"}}}"""

encodeN : Basics.Float -> Json.Encode.Value

import Json.Encode

Json.Encode.encode 0 (encodeN 3.14)
--> """{"N":"3.14"}"""

encodeNS : Set Basics.Float -> Json.Encode.Value

import Json.Encode
import Set

Json.Encode.encode 0 (encodeNS (Set.fromList [1,3,5,7]))
--> """{"NS":["1","3","5","7"]}"""

encodeNULL : Basics.Bool -> Json.Encode.Value

import Json.Encode

Json.Encode.encode 0 (encodeNULL True)
--> """{"NULL":true}"""

encodeS : String -> Json.Encode.Value

import Json.Encode

Json.Encode.encode 0 (encodeS "Hello")
--> """{"S":"Hello"}"""

encodeSS : Set String -> Json.Encode.Value

import Json.Encode
import Set

Json.Encode.encode 0 (encodeSS (Set.fromList ["hello", "world"]))
--> """{"SS":["hello","world"]}"""

fromBase64 : Base64String -> String

Obtain the regular String content. Decode it yourself, e.g. https://package.elm-lang.org/packages/waratuman/elm-coder/3.0.1/Base64#decode

toBase64 : String -> Result String Base64String