    {-# LANGUAGE RecordWildCards #-}
    {-# LANGUAGE TypeFamilies    #-}
    -----------------------------------------------------------------------------
    -- |
    -- Module      :  Aws.DynamoDb.Commands.Query
    -- Copyright   :  Soostone Inc
    -- License     :  BSD3
    --
    -- Maintainer  :  Ozgun Ataman <ozgun.ataman@soostone.com>
    -- Stability   :  experimental
    --
    -- Implementation of Amazon DynamoDb Query command.
    --
    -- See: @http:\/\/docs.aws.amazon.com\/amazondynamodb\/latest\/APIReference\/API_Query.html@
    ----------------------------------------------------------------------------

    module Aws.DynamoDb.Commands.Query
        ( Query (..)
        , Slice (..)
        , query
        , QueryResponse (..)
        ) where

    -------------------------------------------------------------------------------
    import           Control.Applicative
    import           Data.Aeson
    import           Data.Default
    import           Data.Maybe
    import qualified Data.Text           as T
    import           Data.Typeable
    import qualified Data.Vector         as V
    -------------------------------------------------------------------------------
    import           Aws.Core
    import           Aws.DynamoDb.Core
    -------------------------------------------------------------------------------

    -------------------------------------------------------------------------------
    -- | 'Slice' is the primary constraint in a 'Query' command, per AWS
    -- requirements.
    --
    -- All 'Query' commands must specify a hash attribute via 'DEq' and
    -- optionally provide a secondary range attribute.
    data Slice = Slice {
          Slice -> Attribute
    sliceHash :: Attribute
        -- ^ Hash value of the primary key or index being used
        , Slice -> Maybe Condition
    sliceCond :: Maybe Condition
        -- ^ An optional condition specified on the range component, if
        -- present, of the primary key or index being used.
        }  deriving (Slice -> Slice -> Bool
    (Slice -> Slice -> Bool) -> (Slice -> Slice -> Bool) -> Eq Slice
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: Slice -> Slice -> Bool
    == :: Slice -> Slice -> Bool
    $c/= :: Slice -> Slice -> Bool
    /= :: Slice -> Slice -> Bool
    Eq,Int -> Slice -> ShowS
    [Slice] -> ShowS
    Slice -> String
    (Int -> Slice -> ShowS)
    -> (Slice -> String) -> ([Slice] -> ShowS) -> Show Slice
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> Slice -> ShowS
    showsPrec :: Int -> Slice -> ShowS
    $cshow :: Slice -> String
    show :: Slice -> String
    $cshowList :: [Slice] -> ShowS
    showList :: [Slice] -> ShowS
    Show,ReadPrec [Slice]
    ReadPrec Slice
    Int -> ReadS Slice
    ReadS [Slice]
    (Int -> ReadS Slice)
    -> ReadS [Slice]
    -> ReadPrec Slice
    -> ReadPrec [Slice]
    -> Read Slice
    forall a.
    (Int -> ReadS a)
    -> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
    $creadsPrec :: Int -> ReadS Slice
    readsPrec :: Int -> ReadS Slice
    $creadList :: ReadS [Slice]
    readList :: ReadS [Slice]
    $creadPrec :: ReadPrec Slice
    readPrec :: ReadPrec Slice
    $creadListPrec :: ReadPrec [Slice]
    readListPrec :: ReadPrec [Slice]
    Read,Eq Slice
    Eq Slice =>
    (Slice -> Slice -> Ordering)
    -> (Slice -> Slice -> Bool)
    -> (Slice -> Slice -> Bool)
    -> (Slice -> Slice -> Bool)
    -> (Slice -> Slice -> Bool)
    -> (Slice -> Slice -> Slice)
    -> (Slice -> Slice -> Slice)
    -> Ord Slice
    Slice -> Slice -> Bool
    Slice -> Slice -> Ordering
    Slice -> Slice -> Slice
    forall a.
    Eq a =>
    (a -> a -> Ordering)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> Ord a
    $ccompare :: Slice -> Slice -> Ordering
    compare :: Slice -> Slice -> Ordering
    $c< :: Slice -> Slice -> Bool
    < :: Slice -> Slice -> Bool
    $c<= :: Slice -> Slice -> Bool
    <= :: Slice -> Slice -> Bool
    $c> :: Slice -> Slice -> Bool
    > :: Slice -> Slice -> Bool
    $c>= :: Slice -> Slice -> Bool
    >= :: Slice -> Slice -> Bool
    $cmax :: Slice -> Slice -> Slice
    max :: Slice -> Slice -> Slice
    $cmin :: Slice -> Slice -> Slice
    min :: Slice -> Slice -> Slice
    Ord,Typeable)

    -- | A Query command that uses primary keys for an expedient scan.
    data Query = Query {
          Query -> Text
    qTableName     :: T.Text
        -- ^ Required.
        , Query -> Slice
    qKeyConditions :: Slice
        -- ^ Required. Hash or hash-range main condition.
        , Query -> Conditions
    qFilter        :: Conditions
        -- ^ Whether to filter results before returning to client
        , Query -> Maybe [Attribute]
    qStartKey      :: Maybe [Attribute]
        -- ^ Exclusive start key to resume a previous query.
        , Query -> Maybe Int
    qLimit         :: Maybe Int
        -- ^ Whether to limit result set size
        , Query -> Bool
    qForwardScan   :: Bool
        -- ^ Set to False for descending results
        , Query -> QuerySelect
    qSelect        :: QuerySelect
        -- ^ What to return from 'Query'
        , Query -> ReturnConsumption
    qRetCons       :: ReturnConsumption
        , Query -> Maybe Text
    qIndex         :: Maybe T.Text
        -- ^ Whether to use a secondary/global index
        , Query -> Bool
    qConsistent    :: Bool
        } deriving (Query -> Query -> Bool
    (Query -> Query -> Bool) -> (Query -> Query -> Bool) -> Eq Query
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: Query -> Query -> Bool
    == :: Query -> Query -> Bool
    $c/= :: Query -> Query -> Bool
    /= :: Query -> Query -> Bool
    Eq,Int -> Query -> ShowS
    [Query] -> ShowS
    Query -> String
    (Int -> Query -> ShowS)
    -> (Query -> String) -> ([Query] -> ShowS) -> Show Query
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> Query -> ShowS
    showsPrec :: Int -> Query -> ShowS
    $cshow :: Query -> String
    show :: Query -> String
    $cshowList :: [Query] -> ShowS
    showList :: [Query] -> ShowS
    Show,ReadPrec [Query]
    ReadPrec Query
    Int -> ReadS Query
    ReadS [Query]
    (Int -> ReadS Query)
    -> ReadS [Query]
    -> ReadPrec Query
    -> ReadPrec [Query]
    -> Read Query
    forall a.
    (Int -> ReadS a)
    -> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
    $creadsPrec :: Int -> ReadS Query
    readsPrec :: Int -> ReadS Query
    $creadList :: ReadS [Query]
    readList :: ReadS [Query]
    $creadPrec :: ReadPrec Query
    readPrec :: ReadPrec Query
    $creadListPrec :: ReadPrec [Query]
    readListPrec :: ReadPrec [Query]
    Read,Eq Query
    Eq Query =>
    (Query -> Query -> Ordering)
    -> (Query -> Query -> Bool)
    -> (Query -> Query -> Bool)
    -> (Query -> Query -> Bool)
    -> (Query -> Query -> Bool)
    -> (Query -> Query -> Query)
    -> (Query -> Query -> Query)
    -> Ord Query
    Query -> Query -> Bool
    Query -> Query -> Ordering
    Query -> Query -> Query
    forall a.
    Eq a =>
    (a -> a -> Ordering)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> Ord a
    $ccompare :: Query -> Query -> Ordering
    compare :: Query -> Query -> Ordering
    $c< :: Query -> Query -> Bool
    < :: Query -> Query -> Bool
    $c<= :: Query -> Query -> Bool
    <= :: Query -> Query -> Bool
    $c> :: Query -> Query -> Bool
    > :: Query -> Query -> Bool
    $c>= :: Query -> Query -> Bool
    >= :: Query -> Query -> Bool
    $cmax :: Query -> Query -> Query
    max :: Query -> Query -> Query
    $cmin :: Query -> Query -> Query
    min :: Query -> Query -> Query
    Ord,Typeable)

    -------------------------------------------------------------------------------
    instance ToJSON Query where
        toJSON :: Query -> Value
    toJSON Query{Bool
    Maybe Int
    Maybe [Attribute]
    Maybe Text
    Text
    QuerySelect
    ReturnConsumption
    Conditions
    Slice
    qTableName :: Query -> Text
    qKeyConditions :: Query -> Slice
    qFilter :: Query -> Conditions
    qStartKey :: Query -> Maybe [Attribute]
    qLimit :: Query -> Maybe Int
    qForwardScan :: Query -> Bool
    qSelect :: Query -> QuerySelect
    qRetCons :: Query -> ReturnConsumption
    qIndex :: Query -> Maybe Text
    qConsistent :: Query -> Bool
    qTableName :: Text
    qKeyConditions :: Slice
    qFilter :: Conditions
    qStartKey :: Maybe [Attribute]
    qLimit :: Maybe Int
    qForwardScan :: Bool
    qSelect :: QuerySelect
    qRetCons :: ReturnConsumption
    qIndex :: Maybe Text
    qConsistent :: Bool
    ..} = [Pair] -> Value
    object ([Pair] -> Value) -> [Pair] -> Value
    forall a b. (a -> b) -> a -> b
    $
          [Maybe Pair] -> [Pair]
    forall a. [Maybe a] -> [a]
    catMaybes
            [ ((Key
    "ExclusiveStartKey" Key -> Value -> Pair
    forall v. ToJSON v => Key -> v -> Pair
    forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
    .= ) (Value -> Pair) -> ([Attribute] -> Value) -> [Attribute] -> Pair
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . [Attribute] -> Value
    attributesJson) ([Attribute] -> Pair) -> Maybe [Attribute] -> Maybe Pair
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Maybe [Attribute]
    qStartKey
            , (Key
    "Limit" Key -> Int -> Pair
    forall v. ToJSON v => Key -> v -> Pair
    forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
    .= ) (Int -> Pair) -> Maybe Int -> Maybe Pair
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Maybe Int
    qLimit
            , (Key
    "IndexName" Key -> Text -> Pair
    forall v. ToJSON v => Key -> v -> Pair
    forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
    .= ) (Text -> Pair) -> Maybe Text -> Maybe Pair
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Maybe Text
    qIndex
            ] [Pair] -> [Pair] -> [Pair]
    forall a. [a] -> [a] -> [a]
    ++
          Text -> Conditions -> [Pair]
    conditionsJson Text
    "QueryFilter" Conditions
    qFilter [Pair] -> [Pair] -> [Pair]
    forall a. [a] -> [a] -> [a]
    ++
          QuerySelect -> [Pair]
    forall t. KeyValue Value t => QuerySelect -> [t]
    querySelectJson QuerySelect
    qSelect [Pair] -> [Pair] -> [Pair]
    forall a. [a] -> [a] -> [a]
    ++
          [ Key
    "ScanIndexForward" Key -> Bool -> Pair
    forall v. ToJSON v => Key -> v -> Pair
    forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
    .= Bool
    qForwardScan
          , Key
    "TableName"Key -> Text -> Pair
    forall v. ToJSON v => Key -> v -> Pair
    forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
    .= Text
    qTableName
          , Key
    "KeyConditions" Key -> Value -> Pair
    forall v. ToJSON v => Key -> v -> Pair
    forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
    .= Slice -> Value
    sliceJson Slice
    qKeyConditions
          , Key
    "ReturnConsumedCapacity" Key -> ReturnConsumption -> Pair
    forall v. ToJSON v => Key -> v -> Pair
    forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
    .= ReturnConsumption
    qRetCons
          , Key
    "ConsistentRead" Key -> Bool -> Pair
    forall v. ToJSON v => Key -> v -> Pair
    forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
    .= Bool
    qConsistent
          ]

    -------------------------------------------------------------------------------
    -- | Construct a minimal 'Query' request.
    query
        :: T.Text
        -- ^ Table name
        -> Slice
        -- ^ Primary key slice for query
        -> Query
    query :: Text -> Slice -> Query
    query Text
    tn Slice
    sl = Text
    -> Slice
    -> Conditions
    -> Maybe [Attribute]
    -> Maybe Int
    -> Bool
    -> QuerySelect
    -> ReturnConsumption
    -> Maybe Text
    -> Bool
    -> Query
    Query Text
    tn Slice
    sl Conditions
    forall a. Default a => a
    def Maybe [Attribute]
    forall a. Maybe a
    Nothing Maybe Int
    forall a. Maybe a
    Nothing Bool
    True QuerySelect
    forall a. Default a => a
    def ReturnConsumption
    forall a. Default a => a
    def Maybe Text
    forall a. Maybe a
    Nothing Bool
    False

    -- | Response to a 'Query' query.
    data QueryResponse = QueryResponse {
          QueryResponse -> Vector Item
    qrItems    :: V.Vector Item
        , QueryResponse -> Maybe [Attribute]
    qrLastKey  :: Maybe [Attribute]
        , QueryResponse -> Int
    qrCount    :: Int
        , QueryResponse -> Int
    qrScanned  :: Int
        , QueryResponse -> Maybe ConsumedCapacity
    qrConsumed :: Maybe ConsumedCapacity
        } deriving (QueryResponse -> QueryResponse -> Bool
    (QueryResponse -> QueryResponse -> Bool)
    -> (QueryResponse -> QueryResponse -> Bool) -> Eq QueryResponse
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: QueryResponse -> QueryResponse -> Bool
    == :: QueryResponse -> QueryResponse -> Bool
    $c/= :: QueryResponse -> QueryResponse -> Bool
    /= :: QueryResponse -> QueryResponse -> Bool
    Eq,Int -> QueryResponse -> ShowS
    [QueryResponse] -> ShowS
    QueryResponse -> String
    (Int -> QueryResponse -> ShowS)
    -> (QueryResponse -> String)
    -> ([QueryResponse] -> ShowS)
    -> Show QueryResponse
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> QueryResponse -> ShowS
    showsPrec :: Int -> QueryResponse -> ShowS
    $cshow :: QueryResponse -> String
    show :: QueryResponse -> String
    $cshowList :: [QueryResponse] -> ShowS
    showList :: [QueryResponse] -> ShowS
    Show,ReadPrec [QueryResponse]
    ReadPrec QueryResponse
    Int -> ReadS QueryResponse
    ReadS [QueryResponse]
    (Int -> ReadS QueryResponse)
    -> ReadS [QueryResponse]
    -> ReadPrec QueryResponse
    -> ReadPrec [QueryResponse]
    -> Read QueryResponse
    forall a.
    (Int -> ReadS a)
    -> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
    $creadsPrec :: Int -> ReadS QueryResponse
    readsPrec :: Int -> ReadS QueryResponse
    $creadList :: ReadS [QueryResponse]
    readList :: ReadS [QueryResponse]
    $creadPrec :: ReadPrec QueryResponse
    readPrec :: ReadPrec QueryResponse
    $creadListPrec :: ReadPrec [QueryResponse]
    readListPrec :: ReadPrec [QueryResponse]
    Read,Eq QueryResponse
    Eq QueryResponse =>
    (QueryResponse -> QueryResponse -> Ordering)
    -> (QueryResponse -> QueryResponse -> Bool)
    -> (QueryResponse -> QueryResponse -> Bool)
    -> (QueryResponse -> QueryResponse -> Bool)
    -> (QueryResponse -> QueryResponse -> Bool)
    -> (QueryResponse -> QueryResponse -> QueryResponse)
    -> (QueryResponse -> QueryResponse -> QueryResponse)
    -> Ord QueryResponse
    QueryResponse -> QueryResponse -> Bool
    QueryResponse -> QueryResponse -> Ordering
    QueryResponse -> QueryResponse -> QueryResponse
    forall a.
    Eq a =>
    (a -> a -> Ordering)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> Ord a
    $ccompare :: QueryResponse -> QueryResponse -> Ordering
    compare :: QueryResponse -> QueryResponse -> Ordering
    $c< :: QueryResponse -> QueryResponse -> Bool
    < :: QueryResponse -> QueryResponse -> Bool
    $c<= :: QueryResponse -> QueryResponse -> Bool
    <= :: QueryResponse -> QueryResponse -> Bool
    $c> :: QueryResponse -> QueryResponse -> Bool
    > :: QueryResponse -> QueryResponse -> Bool
    $c>= :: QueryResponse -> QueryResponse -> Bool
    >= :: QueryResponse -> QueryResponse -> Bool
    $cmax :: QueryResponse -> QueryResponse -> QueryResponse
    max :: QueryResponse -> QueryResponse -> QueryResponse
    $cmin :: QueryResponse -> QueryResponse -> QueryResponse
    min :: QueryResponse -> QueryResponse -> QueryResponse
    Ord)

    instance FromJSON QueryResponse where
        parseJSON :: Value -> Parser QueryResponse
    parseJSON (Object Object
    v) = Vector Item
    -> Maybe [Attribute]
    -> Int
    -> Int
    -> Maybe ConsumedCapacity
    -> QueryResponse
    QueryResponse
            (Vector Item
     -> Maybe [Attribute]
     -> Int
     -> Int
     -> Maybe ConsumedCapacity
     -> QueryResponse)
    -> Parser (Vector Item)
    -> Parser
         (Maybe [Attribute]
          -> Int -> Int -> Maybe ConsumedCapacity -> QueryResponse)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Object
    v Object -> Key -> Parser (Maybe (Vector Item))
    forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
    .:?  Key
    "Items" Parser (Maybe (Vector Item)) -> Vector Item -> Parser (Vector Item)
    forall a. Parser (Maybe a) -> a -> Parser a
    .!= Vector Item
    forall a. Vector a
    V.empty
            Parser
      (Maybe [Attribute]
       -> Int -> Int -> Maybe ConsumedCapacity -> QueryResponse)
    -> Parser (Maybe [Attribute])
    -> Parser (Int -> Int -> Maybe ConsumedCapacity -> QueryResponse)
    forall a b. Parser (a -> b) -> Parser a -> Parser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> ((do o <- Object
    v Object -> Key -> Parser Value
    forall a. FromJSON a => Object -> Key -> Parser a
    .: Key
    "LastEvaluatedKey"
                     Just <$> parseAttributeJson o)
                 Parser (Maybe [Attribute])
    -> Parser (Maybe [Attribute]) -> Parser (Maybe [Attribute])
    forall a. Parser a -> Parser a -> Parser a
    forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
    <|> Maybe [Attribute] -> Parser (Maybe [Attribute])
    forall a. a -> Parser a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure Maybe [Attribute]
    forall a. Maybe a
    Nothing)
            Parser (Int -> Int -> Maybe ConsumedCapacity -> QueryResponse)
    -> Parser Int
    -> Parser (Int -> Maybe ConsumedCapacity -> QueryResponse)
    forall a b. Parser (a -> b) -> Parser a -> Parser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Object
    v Object -> Key -> Parser Int
    forall a. FromJSON a => Object -> Key -> Parser a
    .:  Key
    "Count"
            Parser (Int -> Maybe ConsumedCapacity -> QueryResponse)
    -> Parser Int -> Parser (Maybe ConsumedCapacity -> QueryResponse)
    forall a b. Parser (a -> b) -> Parser a -> Parser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Object
    v Object -> Key -> Parser Int
    forall a. FromJSON a => Object -> Key -> Parser a
    .:  Key
    "ScannedCount"
            Parser (Maybe ConsumedCapacity -> QueryResponse)
    -> Parser (Maybe ConsumedCapacity) -> Parser QueryResponse
    forall a b. Parser (a -> b) -> Parser a -> Parser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Object
    v Object -> Key -> Parser (Maybe ConsumedCapacity)
    forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
    .:? Key
    "ConsumedCapacity"
        parseJSON Value
    _ = String -> Parser QueryResponse
    forall a. String -> Parser a
    forall (m :: * -> *) a. MonadFail m => String -> m a
    fail String
    "QueryResponse must be an object."

    instance Transaction Query QueryResponse

    instance SignQuery Query where
        type ServiceConfiguration Query = DdbConfiguration
        signQuery :: forall queryType.
    Query
    -> ServiceConfiguration Query queryType
    -> SignatureData
    -> SignedQuery
    signQuery Query
    gi = ByteString
    -> Query
    -> DdbConfiguration queryType
    -> SignatureData
    -> SignedQuery
    forall a qt.
    ToJSON a =>
    ByteString
    -> a -> DdbConfiguration qt -> SignatureData -> SignedQuery
    ddbSignQuery ByteString
    "Query" Query
    gi

    instance ResponseConsumer r QueryResponse where
        type ResponseMetadata QueryResponse = DdbResponse
        responseConsumer :: Request
    -> r
    -> IORef (ResponseMetadata QueryResponse)
    -> HTTPResponseConsumer QueryResponse
    responseConsumer Request
    _ r
    _ IORef (ResponseMetadata QueryResponse)
    ref Response (ConduitM () ByteString (ResourceT IO) ())
    resp
            = IORef DdbResponse -> HTTPResponseConsumer QueryResponse
    forall a. FromJSON a => IORef DdbResponse -> HTTPResponseConsumer a
    ddbResponseConsumer IORef (ResponseMetadata QueryResponse)
    IORef DdbResponse
    ref Response (ConduitM () ByteString (ResourceT IO) ())
    resp

    instance AsMemoryResponse QueryResponse where
        type MemoryResponse QueryResponse = QueryResponse
        loadToMemory :: QueryResponse -> ResourceT IO (MemoryResponse QueryResponse)
    loadToMemory = QueryResponse -> ResourceT IO (MemoryResponse QueryResponse)
    QueryResponse -> ResourceT IO QueryResponse
    forall a. a -> ResourceT IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return

    instance ListResponse QueryResponse Item where
        listResponse :: QueryResponse -> [Item]
    listResponse = Vector Item -> [Item]
    forall a. Vector a -> [a]
    V.toList (Vector Item -> [Item])
    -> (QueryResponse -> Vector Item) -> QueryResponse -> [Item]
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . QueryResponse -> Vector Item
    qrItems

    instance IteratedTransaction Query QueryResponse where
        nextIteratedRequest :: Query -> QueryResponse -> Maybe Query
    nextIteratedRequest Query
    request QueryResponse
    response = case QueryResponse -> Maybe [Attribute]
    qrLastKey QueryResponse
    response of
            Maybe [Attribute]
    Nothing -> Maybe Query
    forall a. Maybe a
    Nothing
            Maybe [Attribute]
    key -> Query -> Maybe Query
    forall a. a -> Maybe a
    Just Query
    request { qStartKey = key }

    sliceJson :: Slice -> Value
    sliceJson :: Slice -> Value
    sliceJson Slice{Maybe Condition
    Attribute
    sliceHash :: Slice -> Attribute
    sliceCond :: Slice -> Maybe Condition
    sliceHash :: Attribute
    sliceCond :: Maybe Condition
    ..} = [Pair] -> Value
    object ((Condition -> Pair) -> [Condition] -> [Pair]
    forall a b. (a -> b) -> [a] -> [b]
    map Condition -> Pair
    conditionJson [Condition]
    cs)
        where
          cs :: [Condition]
    cs = [Condition]
    -> (Condition -> [Condition]) -> Maybe Condition -> [Condition]
    forall b a. b -> (a -> b) -> Maybe a -> b
    maybe [] Condition -> [Condition]
    forall a. a -> [a]
    forall (m :: * -> *) a. Monad m => a -> m a
    return Maybe Condition
    sliceCond [Condition] -> [Condition] -> [Condition]
    forall a. [a] -> [a] -> [a]
    ++ [Condition
    hashCond]
          hashCond :: Condition
    hashCond = Text -> CondOp -> Condition
    Condition (Attribute -> Text
    attrName Attribute
    sliceHash) (DValue -> CondOp
    DEq (Attribute -> DValue
    attrVal Attribute
    sliceHash))