{-# LANGUAGE DeriveGeneric #-}
{-# LANGUAGE DuplicateRecordFields #-}
{-# LANGUAGE NamedFieldPuns #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE RecordWildCards #-}
{-# LANGUAGE StrictData #-}
{-# LANGUAGE TypeFamilies #-}
{-# LANGUAGE NoImplicitPrelude #-}
{-# OPTIONS_GHC -fno-warn-unused-binds #-}
{-# OPTIONS_GHC -fno-warn-unused-imports #-}
{-# OPTIONS_GHC -fno-warn-unused-matches #-}

-- Derived from AWS service descriptions, licensed under Apache 2.0.

-- |
-- Module      : Amazonka.DynamoDB.TransactWriteItems
-- Copyright   : (c) 2013-2021 Brendan Hay
-- License     : Mozilla Public License, v. 2.0.
-- Maintainer  : Brendan Hay <brendan.g.hay+amazonka@gmail.com>
-- Stability   : auto-generated
-- Portability : non-portable (GHC extensions)
--
-- @TransactWriteItems@ is a synchronous write operation that groups up to
-- 25 action requests. These actions can target items in different tables,
-- but not in different AWS accounts or Regions, and no two actions can
-- target the same item. For example, you cannot both @ConditionCheck@ and
-- @Update@ the same item. The aggregate size of the items in the
-- transaction cannot exceed 4 MB.
--
-- The actions are completed atomically so that either all of them succeed,
-- or all of them fail. They are defined by the following objects:
--
-- -   @Put@  —   Initiates a @PutItem@ operation to write a new item. This
--     structure specifies the primary key of the item to be written, the
--     name of the table to write it in, an optional condition expression
--     that must be satisfied for the write to succeed, a list of the
--     item\'s attributes, and a field indicating whether to retrieve the
--     item\'s attributes if the condition is not met.
--
-- -   @Update@  —   Initiates an @UpdateItem@ operation to update an
--     existing item. This structure specifies the primary key of the item
--     to be updated, the name of the table where it resides, an optional
--     condition expression that must be satisfied for the update to
--     succeed, an expression that defines one or more attributes to be
--     updated, and a field indicating whether to retrieve the item\'s
--     attributes if the condition is not met.
--
-- -   @Delete@  —   Initiates a @DeleteItem@ operation to delete an
--     existing item. This structure specifies the primary key of the item
--     to be deleted, the name of the table where it resides, an optional
--     condition expression that must be satisfied for the deletion to
--     succeed, and a field indicating whether to retrieve the item\'s
--     attributes if the condition is not met.
--
-- -   @ConditionCheck@  —   Applies a condition to an item that is not
--     being modified by the transaction. This structure specifies the
--     primary key of the item to be checked, the name of the table where
--     it resides, a condition expression that must be satisfied for the
--     transaction to succeed, and a field indicating whether to retrieve
--     the item\'s attributes if the condition is not met.
--
-- DynamoDB rejects the entire @TransactWriteItems@ request if any of the
-- following is true:
--
-- -   A condition in one of the condition expressions is not met.
--
-- -   An ongoing operation is in the process of updating the same item.
--
-- -   There is insufficient provisioned capacity for the transaction to be
--     completed.
--
-- -   An item size becomes too large (bigger than 400 KB), a local
--     secondary index (LSI) becomes too large, or a similar validation
--     error occurs because of changes made by the transaction.
--
-- -   The aggregate size of the items in the transaction exceeds 4 MB.
--
-- -   There is a user error, such as an invalid data format.
module Amazonka.DynamoDB.TransactWriteItems
  ( -- * Creating a Request
    TransactWriteItems (..),
    newTransactWriteItems,

    -- * Request Lenses
    transactWriteItems_returnConsumedCapacity,
    transactWriteItems_returnItemCollectionMetrics,
    transactWriteItems_clientRequestToken,
    transactWriteItems_transactItems,

    -- * Destructuring the Response
    TransactWriteItemsResponse (..),
    newTransactWriteItemsResponse,

    -- * Response Lenses
    transactWriteItemsResponse_itemCollectionMetrics,
    transactWriteItemsResponse_consumedCapacity,
    transactWriteItemsResponse_httpStatus,
  )
where

import qualified Amazonka.Core as Core
import Amazonka.DynamoDB.Types
import qualified Amazonka.Lens as Lens
import qualified Amazonka.Prelude as Prelude
import qualified Amazonka.Request as Request
import qualified Amazonka.Response as Response

-- | /See:/ 'newTransactWriteItems' smart constructor.
data TransactWriteItems = TransactWriteItems'
  { TransactWriteItems -> Maybe ReturnConsumedCapacity
returnConsumedCapacity :: Prelude.Maybe ReturnConsumedCapacity,
    -- | Determines whether item collection metrics are returned. If set to
    -- @SIZE@, the response includes statistics about item collections (if
    -- any), that were modified during the operation and are returned in the
    -- response. If set to @NONE@ (the default), no statistics are returned.
    TransactWriteItems -> Maybe ReturnItemCollectionMetrics
returnItemCollectionMetrics :: Prelude.Maybe ReturnItemCollectionMetrics,
    -- | Providing a @ClientRequestToken@ makes the call to @TransactWriteItems@
    -- idempotent, meaning that multiple identical calls have the same effect
    -- as one single call.
    --
    -- Although multiple identical calls using the same client request token
    -- produce the same result on the server (no side effects), the responses
    -- to the calls might not be the same. If the @ReturnConsumedCapacity>@
    -- parameter is set, then the initial @TransactWriteItems@ call returns the
    -- amount of write capacity units consumed in making the changes.
    -- Subsequent @TransactWriteItems@ calls with the same client token return
    -- the number of read capacity units consumed in reading the item.
    --
    -- A client request token is valid for 10 minutes after the first request
    -- that uses it is completed. After 10 minutes, any request with the same
    -- client token is treated as a new request. Do not resubmit the same
    -- request with the same client token for more than 10 minutes, or the
    -- result might not be idempotent.
    --
    -- If you submit a request with the same client token but a change in other
    -- parameters within the 10-minute idempotency window, DynamoDB returns an
    -- @IdempotentParameterMismatch@ exception.
    TransactWriteItems -> Maybe Text
clientRequestToken :: Prelude.Maybe Prelude.Text,
    -- | An ordered array of up to 25 @TransactWriteItem@ objects, each of which
    -- contains a @ConditionCheck@, @Put@, @Update@, or @Delete@ object. These
    -- can operate on items in different tables, but the tables must reside in
    -- the same AWS account and Region, and no two of them can operate on the
    -- same item.
    TransactWriteItems -> NonEmpty TransactWriteItem
transactItems :: Prelude.NonEmpty TransactWriteItem
  }
  deriving (TransactWriteItems -> TransactWriteItems -> Bool
(TransactWriteItems -> TransactWriteItems -> Bool)
-> (TransactWriteItems -> TransactWriteItems -> Bool)
-> Eq TransactWriteItems
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: TransactWriteItems -> TransactWriteItems -> Bool
$c/= :: TransactWriteItems -> TransactWriteItems -> Bool
== :: TransactWriteItems -> TransactWriteItems -> Bool
$c== :: TransactWriteItems -> TransactWriteItems -> Bool
Prelude.Eq, ReadPrec [TransactWriteItems]
ReadPrec TransactWriteItems
Int -> ReadS TransactWriteItems
ReadS [TransactWriteItems]
(Int -> ReadS TransactWriteItems)
-> ReadS [TransactWriteItems]
-> ReadPrec TransactWriteItems
-> ReadPrec [TransactWriteItems]
-> Read TransactWriteItems
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [TransactWriteItems]
$creadListPrec :: ReadPrec [TransactWriteItems]
readPrec :: ReadPrec TransactWriteItems
$creadPrec :: ReadPrec TransactWriteItems
readList :: ReadS [TransactWriteItems]
$creadList :: ReadS [TransactWriteItems]
readsPrec :: Int -> ReadS TransactWriteItems
$creadsPrec :: Int -> ReadS TransactWriteItems
Prelude.Read, Int -> TransactWriteItems -> ShowS
[TransactWriteItems] -> ShowS
TransactWriteItems -> String
(Int -> TransactWriteItems -> ShowS)
-> (TransactWriteItems -> String)
-> ([TransactWriteItems] -> ShowS)
-> Show TransactWriteItems
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [TransactWriteItems] -> ShowS
$cshowList :: [TransactWriteItems] -> ShowS
show :: TransactWriteItems -> String
$cshow :: TransactWriteItems -> String
showsPrec :: Int -> TransactWriteItems -> ShowS
$cshowsPrec :: Int -> TransactWriteItems -> ShowS
Prelude.Show, (forall x. TransactWriteItems -> Rep TransactWriteItems x)
-> (forall x. Rep TransactWriteItems x -> TransactWriteItems)
-> Generic TransactWriteItems
forall x. Rep TransactWriteItems x -> TransactWriteItems
forall x. TransactWriteItems -> Rep TransactWriteItems x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep TransactWriteItems x -> TransactWriteItems
$cfrom :: forall x. TransactWriteItems -> Rep TransactWriteItems x
Prelude.Generic)

-- |
-- Create a value of 'TransactWriteItems' with all optional fields omitted.
--
-- Use <https://hackage.haskell.org/package/generic-lens generic-lens> or <https://hackage.haskell.org/package/optics optics> to modify other optional fields.
--
-- The following record fields are available, with the corresponding lenses provided
-- for backwards compatibility:
--
-- 'returnConsumedCapacity', 'transactWriteItems_returnConsumedCapacity' - Undocumented member.
--
-- 'returnItemCollectionMetrics', 'transactWriteItems_returnItemCollectionMetrics' - Determines whether item collection metrics are returned. If set to
-- @SIZE@, the response includes statistics about item collections (if
-- any), that were modified during the operation and are returned in the
-- response. If set to @NONE@ (the default), no statistics are returned.
--
-- 'clientRequestToken', 'transactWriteItems_clientRequestToken' - Providing a @ClientRequestToken@ makes the call to @TransactWriteItems@
-- idempotent, meaning that multiple identical calls have the same effect
-- as one single call.
--
-- Although multiple identical calls using the same client request token
-- produce the same result on the server (no side effects), the responses
-- to the calls might not be the same. If the @ReturnConsumedCapacity>@
-- parameter is set, then the initial @TransactWriteItems@ call returns the
-- amount of write capacity units consumed in making the changes.
-- Subsequent @TransactWriteItems@ calls with the same client token return
-- the number of read capacity units consumed in reading the item.
--
-- A client request token is valid for 10 minutes after the first request
-- that uses it is completed. After 10 minutes, any request with the same
-- client token is treated as a new request. Do not resubmit the same
-- request with the same client token for more than 10 minutes, or the
-- result might not be idempotent.
--
-- If you submit a request with the same client token but a change in other
-- parameters within the 10-minute idempotency window, DynamoDB returns an
-- @IdempotentParameterMismatch@ exception.
--
-- 'transactItems', 'transactWriteItems_transactItems' - An ordered array of up to 25 @TransactWriteItem@ objects, each of which
-- contains a @ConditionCheck@, @Put@, @Update@, or @Delete@ object. These
-- can operate on items in different tables, but the tables must reside in
-- the same AWS account and Region, and no two of them can operate on the
-- same item.
newTransactWriteItems ::
  -- | 'transactItems'
  Prelude.NonEmpty TransactWriteItem ->
  TransactWriteItems
newTransactWriteItems :: NonEmpty TransactWriteItem -> TransactWriteItems
newTransactWriteItems NonEmpty TransactWriteItem
pTransactItems_ =
  TransactWriteItems' :: Maybe ReturnConsumedCapacity
-> Maybe ReturnItemCollectionMetrics
-> Maybe Text
-> NonEmpty TransactWriteItem
-> TransactWriteItems
TransactWriteItems'
    { $sel:returnConsumedCapacity:TransactWriteItems' :: Maybe ReturnConsumedCapacity
returnConsumedCapacity =
        Maybe ReturnConsumedCapacity
forall a. Maybe a
Prelude.Nothing,
      $sel:returnItemCollectionMetrics:TransactWriteItems' :: Maybe ReturnItemCollectionMetrics
returnItemCollectionMetrics = Maybe ReturnItemCollectionMetrics
forall a. Maybe a
Prelude.Nothing,
      $sel:clientRequestToken:TransactWriteItems' :: Maybe Text
clientRequestToken = Maybe Text
forall a. Maybe a
Prelude.Nothing,
      $sel:transactItems:TransactWriteItems' :: NonEmpty TransactWriteItem
transactItems = Tagged
  (NonEmpty TransactWriteItem)
  (Identity (NonEmpty TransactWriteItem))
-> Tagged
     (NonEmpty TransactWriteItem)
     (Identity (NonEmpty TransactWriteItem))
forall s t a b. (Coercible s a, Coercible t b) => Iso s t a b
Lens.coerced (Tagged
   (NonEmpty TransactWriteItem)
   (Identity (NonEmpty TransactWriteItem))
 -> Tagged
      (NonEmpty TransactWriteItem)
      (Identity (NonEmpty TransactWriteItem)))
-> NonEmpty TransactWriteItem -> NonEmpty TransactWriteItem
forall t b. AReview t b -> b -> t
Lens.# NonEmpty TransactWriteItem
pTransactItems_
    }

-- | Undocumented member.
transactWriteItems_returnConsumedCapacity :: Lens.Lens' TransactWriteItems (Prelude.Maybe ReturnConsumedCapacity)
transactWriteItems_returnConsumedCapacity :: (Maybe ReturnConsumedCapacity -> f (Maybe ReturnConsumedCapacity))
-> TransactWriteItems -> f TransactWriteItems
transactWriteItems_returnConsumedCapacity = (TransactWriteItems -> Maybe ReturnConsumedCapacity)
-> (TransactWriteItems
    -> Maybe ReturnConsumedCapacity -> TransactWriteItems)
-> Lens
     TransactWriteItems
     TransactWriteItems
     (Maybe ReturnConsumedCapacity)
     (Maybe ReturnConsumedCapacity)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\TransactWriteItems' {Maybe ReturnConsumedCapacity
returnConsumedCapacity :: Maybe ReturnConsumedCapacity
$sel:returnConsumedCapacity:TransactWriteItems' :: TransactWriteItems -> Maybe ReturnConsumedCapacity
returnConsumedCapacity} -> Maybe ReturnConsumedCapacity
returnConsumedCapacity) (\s :: TransactWriteItems
s@TransactWriteItems' {} Maybe ReturnConsumedCapacity
a -> TransactWriteItems
s {$sel:returnConsumedCapacity:TransactWriteItems' :: Maybe ReturnConsumedCapacity
returnConsumedCapacity = Maybe ReturnConsumedCapacity
a} :: TransactWriteItems)

-- | Determines whether item collection metrics are returned. If set to
-- @SIZE@, the response includes statistics about item collections (if
-- any), that were modified during the operation and are returned in the
-- response. If set to @NONE@ (the default), no statistics are returned.
transactWriteItems_returnItemCollectionMetrics :: Lens.Lens' TransactWriteItems (Prelude.Maybe ReturnItemCollectionMetrics)
transactWriteItems_returnItemCollectionMetrics :: (Maybe ReturnItemCollectionMetrics
 -> f (Maybe ReturnItemCollectionMetrics))
-> TransactWriteItems -> f TransactWriteItems
transactWriteItems_returnItemCollectionMetrics = (TransactWriteItems -> Maybe ReturnItemCollectionMetrics)
-> (TransactWriteItems
    -> Maybe ReturnItemCollectionMetrics -> TransactWriteItems)
-> Lens
     TransactWriteItems
     TransactWriteItems
     (Maybe ReturnItemCollectionMetrics)
     (Maybe ReturnItemCollectionMetrics)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\TransactWriteItems' {Maybe ReturnItemCollectionMetrics
returnItemCollectionMetrics :: Maybe ReturnItemCollectionMetrics
$sel:returnItemCollectionMetrics:TransactWriteItems' :: TransactWriteItems -> Maybe ReturnItemCollectionMetrics
returnItemCollectionMetrics} -> Maybe ReturnItemCollectionMetrics
returnItemCollectionMetrics) (\s :: TransactWriteItems
s@TransactWriteItems' {} Maybe ReturnItemCollectionMetrics
a -> TransactWriteItems
s {$sel:returnItemCollectionMetrics:TransactWriteItems' :: Maybe ReturnItemCollectionMetrics
returnItemCollectionMetrics = Maybe ReturnItemCollectionMetrics
a} :: TransactWriteItems)

-- | Providing a @ClientRequestToken@ makes the call to @TransactWriteItems@
-- idempotent, meaning that multiple identical calls have the same effect
-- as one single call.
--
-- Although multiple identical calls using the same client request token
-- produce the same result on the server (no side effects), the responses
-- to the calls might not be the same. If the @ReturnConsumedCapacity>@
-- parameter is set, then the initial @TransactWriteItems@ call returns the
-- amount of write capacity units consumed in making the changes.
-- Subsequent @TransactWriteItems@ calls with the same client token return
-- the number of read capacity units consumed in reading the item.
--
-- A client request token is valid for 10 minutes after the first request
-- that uses it is completed. After 10 minutes, any request with the same
-- client token is treated as a new request. Do not resubmit the same
-- request with the same client token for more than 10 minutes, or the
-- result might not be idempotent.
--
-- If you submit a request with the same client token but a change in other
-- parameters within the 10-minute idempotency window, DynamoDB returns an
-- @IdempotentParameterMismatch@ exception.
transactWriteItems_clientRequestToken :: Lens.Lens' TransactWriteItems (Prelude.Maybe Prelude.Text)
transactWriteItems_clientRequestToken :: (Maybe Text -> f (Maybe Text))
-> TransactWriteItems -> f TransactWriteItems
transactWriteItems_clientRequestToken = (TransactWriteItems -> Maybe Text)
-> (TransactWriteItems -> Maybe Text -> TransactWriteItems)
-> Lens
     TransactWriteItems TransactWriteItems (Maybe Text) (Maybe Text)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\TransactWriteItems' {Maybe Text
clientRequestToken :: Maybe Text
$sel:clientRequestToken:TransactWriteItems' :: TransactWriteItems -> Maybe Text
clientRequestToken} -> Maybe Text
clientRequestToken) (\s :: TransactWriteItems
s@TransactWriteItems' {} Maybe Text
a -> TransactWriteItems
s {$sel:clientRequestToken:TransactWriteItems' :: Maybe Text
clientRequestToken = Maybe Text
a} :: TransactWriteItems)

-- | An ordered array of up to 25 @TransactWriteItem@ objects, each of which
-- contains a @ConditionCheck@, @Put@, @Update@, or @Delete@ object. These
-- can operate on items in different tables, but the tables must reside in
-- the same AWS account and Region, and no two of them can operate on the
-- same item.
transactWriteItems_transactItems :: Lens.Lens' TransactWriteItems (Prelude.NonEmpty TransactWriteItem)
transactWriteItems_transactItems :: (NonEmpty TransactWriteItem -> f (NonEmpty TransactWriteItem))
-> TransactWriteItems -> f TransactWriteItems
transactWriteItems_transactItems = (TransactWriteItems -> NonEmpty TransactWriteItem)
-> (TransactWriteItems
    -> NonEmpty TransactWriteItem -> TransactWriteItems)
-> Lens
     TransactWriteItems
     TransactWriteItems
     (NonEmpty TransactWriteItem)
     (NonEmpty TransactWriteItem)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\TransactWriteItems' {NonEmpty TransactWriteItem
transactItems :: NonEmpty TransactWriteItem
$sel:transactItems:TransactWriteItems' :: TransactWriteItems -> NonEmpty TransactWriteItem
transactItems} -> NonEmpty TransactWriteItem
transactItems) (\s :: TransactWriteItems
s@TransactWriteItems' {} NonEmpty TransactWriteItem
a -> TransactWriteItems
s {$sel:transactItems:TransactWriteItems' :: NonEmpty TransactWriteItem
transactItems = NonEmpty TransactWriteItem
a} :: TransactWriteItems) ((NonEmpty TransactWriteItem -> f (NonEmpty TransactWriteItem))
 -> TransactWriteItems -> f TransactWriteItems)
-> ((NonEmpty TransactWriteItem -> f (NonEmpty TransactWriteItem))
    -> NonEmpty TransactWriteItem -> f (NonEmpty TransactWriteItem))
-> (NonEmpty TransactWriteItem -> f (NonEmpty TransactWriteItem))
-> TransactWriteItems
-> f TransactWriteItems
forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. (NonEmpty TransactWriteItem -> f (NonEmpty TransactWriteItem))
-> NonEmpty TransactWriteItem -> f (NonEmpty TransactWriteItem)
forall s t a b. (Coercible s a, Coercible t b) => Iso s t a b
Lens.coerced

instance Core.AWSRequest TransactWriteItems where
  type
    AWSResponse TransactWriteItems =
      TransactWriteItemsResponse
  request :: TransactWriteItems -> Request TransactWriteItems
request = Service -> TransactWriteItems -> Request TransactWriteItems
forall a. (ToRequest a, ToJSON a) => Service -> a -> Request a
Request.postJSON Service
defaultService
  response :: Logger
-> Service
-> Proxy TransactWriteItems
-> ClientResponse ClientBody
-> m (Either
        Error (ClientResponse (AWSResponse TransactWriteItems)))
response =
    (Int
 -> ResponseHeaders
 -> Object
 -> Either String (AWSResponse TransactWriteItems))
-> Logger
-> Service
-> Proxy TransactWriteItems
-> ClientResponse ClientBody
-> m (Either
        Error (ClientResponse (AWSResponse TransactWriteItems)))
forall (m :: * -> *) a.
MonadResource m =>
(Int -> ResponseHeaders -> Object -> Either String (AWSResponse a))
-> Logger
-> Service
-> Proxy a
-> ClientResponse ClientBody
-> m (Either Error (ClientResponse (AWSResponse a)))
Response.receiveJSON
      ( \Int
s ResponseHeaders
h Object
x ->
          Maybe (HashMap Text [ItemCollectionMetrics])
-> Maybe [ConsumedCapacity] -> Int -> TransactWriteItemsResponse
TransactWriteItemsResponse'
            (Maybe (HashMap Text [ItemCollectionMetrics])
 -> Maybe [ConsumedCapacity] -> Int -> TransactWriteItemsResponse)
-> Either String (Maybe (HashMap Text [ItemCollectionMetrics]))
-> Either
     String
     (Maybe [ConsumedCapacity] -> Int -> TransactWriteItemsResponse)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> ( Object
x Object
-> Text
-> Either
     String (Maybe (Maybe (HashMap Text [ItemCollectionMetrics])))
forall a. FromJSON a => Object -> Text -> Either String (Maybe a)
Core..?> Text
"ItemCollectionMetrics"
                            Either
  String (Maybe (Maybe (HashMap Text [ItemCollectionMetrics])))
-> Maybe (HashMap Text [ItemCollectionMetrics])
-> Either String (Maybe (HashMap Text [ItemCollectionMetrics]))
forall (f :: * -> *) a. Functor f => f (Maybe a) -> a -> f a
Core..!@ Maybe (HashMap Text [ItemCollectionMetrics])
forall a. Monoid a => a
Prelude.mempty
                        )
            Either
  String
  (Maybe [ConsumedCapacity] -> Int -> TransactWriteItemsResponse)
-> Either String (Maybe [ConsumedCapacity])
-> Either String (Int -> TransactWriteItemsResponse)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> ( Object
x Object -> Text -> Either String (Maybe (Maybe [ConsumedCapacity]))
forall a. FromJSON a => Object -> Text -> Either String (Maybe a)
Core..?> Text
"ConsumedCapacity"
                            Either String (Maybe (Maybe [ConsumedCapacity]))
-> Maybe [ConsumedCapacity]
-> Either String (Maybe [ConsumedCapacity])
forall (f :: * -> *) a. Functor f => f (Maybe a) -> a -> f a
Core..!@ Maybe [ConsumedCapacity]
forall a. Monoid a => a
Prelude.mempty
                        )
            Either String (Int -> TransactWriteItemsResponse)
-> Either String Int -> Either String TransactWriteItemsResponse
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Int -> Either String Int
forall (f :: * -> *) a. Applicative f => a -> f a
Prelude.pure (Int -> Int
forall a. Enum a => a -> Int
Prelude.fromEnum Int
s))
      )

instance Prelude.Hashable TransactWriteItems

instance Prelude.NFData TransactWriteItems

instance Core.ToHeaders TransactWriteItems where
  toHeaders :: TransactWriteItems -> ResponseHeaders
toHeaders =
    ResponseHeaders -> TransactWriteItems -> ResponseHeaders
forall a b. a -> b -> a
Prelude.const
      ( [ResponseHeaders] -> ResponseHeaders
forall a. Monoid a => [a] -> a
Prelude.mconcat
          [ HeaderName
"X-Amz-Target"
              HeaderName -> ByteString -> ResponseHeaders
forall a. ToHeader a => HeaderName -> a -> ResponseHeaders
Core.=# ( ByteString
"DynamoDB_20120810.TransactWriteItems" ::
                          Prelude.ByteString
                      ),
            HeaderName
"Content-Type"
              HeaderName -> ByteString -> ResponseHeaders
forall a. ToHeader a => HeaderName -> a -> ResponseHeaders
Core.=# ( ByteString
"application/x-amz-json-1.0" ::
                          Prelude.ByteString
                      )
          ]
      )

instance Core.ToJSON TransactWriteItems where
  toJSON :: TransactWriteItems -> Value
toJSON TransactWriteItems' {Maybe Text
Maybe ReturnConsumedCapacity
Maybe ReturnItemCollectionMetrics
NonEmpty TransactWriteItem
transactItems :: NonEmpty TransactWriteItem
clientRequestToken :: Maybe Text
returnItemCollectionMetrics :: Maybe ReturnItemCollectionMetrics
returnConsumedCapacity :: Maybe ReturnConsumedCapacity
$sel:transactItems:TransactWriteItems' :: TransactWriteItems -> NonEmpty TransactWriteItem
$sel:clientRequestToken:TransactWriteItems' :: TransactWriteItems -> Maybe Text
$sel:returnItemCollectionMetrics:TransactWriteItems' :: TransactWriteItems -> Maybe ReturnItemCollectionMetrics
$sel:returnConsumedCapacity:TransactWriteItems' :: TransactWriteItems -> Maybe ReturnConsumedCapacity
..} =
    [Pair] -> Value
Core.object
      ( [Maybe Pair] -> [Pair]
forall a. [Maybe a] -> [a]
Prelude.catMaybes
          [ (Text
"ReturnConsumedCapacity" Text -> ReturnConsumedCapacity -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=)
              (ReturnConsumedCapacity -> Pair)
-> Maybe ReturnConsumedCapacity -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe ReturnConsumedCapacity
returnConsumedCapacity,
            (Text
"ReturnItemCollectionMetrics" Text -> ReturnItemCollectionMetrics -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=)
              (ReturnItemCollectionMetrics -> Pair)
-> Maybe ReturnItemCollectionMetrics -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe ReturnItemCollectionMetrics
returnItemCollectionMetrics,
            (Text
"ClientRequestToken" Text -> Text -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=)
              (Text -> Pair) -> Maybe Text -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe Text
clientRequestToken,
            Pair -> Maybe Pair
forall a. a -> Maybe a
Prelude.Just
              (Text
"TransactItems" Text -> NonEmpty TransactWriteItem -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..= NonEmpty TransactWriteItem
transactItems)
          ]
      )

instance Core.ToPath TransactWriteItems where
  toPath :: TransactWriteItems -> ByteString
toPath = ByteString -> TransactWriteItems -> ByteString
forall a b. a -> b -> a
Prelude.const ByteString
"/"

instance Core.ToQuery TransactWriteItems where
  toQuery :: TransactWriteItems -> QueryString
toQuery = QueryString -> TransactWriteItems -> QueryString
forall a b. a -> b -> a
Prelude.const QueryString
forall a. Monoid a => a
Prelude.mempty

-- | /See:/ 'newTransactWriteItemsResponse' smart constructor.
data TransactWriteItemsResponse = TransactWriteItemsResponse'
  { -- | A list of tables that were processed by @TransactWriteItems@ and, for
    -- each table, information about any item collections that were affected by
    -- individual @UpdateItem@, @PutItem@, or @DeleteItem@ operations.
    TransactWriteItemsResponse
-> Maybe (HashMap Text [ItemCollectionMetrics])
itemCollectionMetrics :: Prelude.Maybe (Prelude.HashMap Prelude.Text [ItemCollectionMetrics]),
    -- | The capacity units consumed by the entire @TransactWriteItems@
    -- operation. The values of the list are ordered according to the ordering
    -- of the @TransactItems@ request parameter.
    TransactWriteItemsResponse -> Maybe [ConsumedCapacity]
consumedCapacity :: Prelude.Maybe [ConsumedCapacity],
    -- | The response's http status code.
    TransactWriteItemsResponse -> Int
httpStatus :: Prelude.Int
  }
  deriving (TransactWriteItemsResponse -> TransactWriteItemsResponse -> Bool
(TransactWriteItemsResponse -> TransactWriteItemsResponse -> Bool)
-> (TransactWriteItemsResponse
    -> TransactWriteItemsResponse -> Bool)
-> Eq TransactWriteItemsResponse
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: TransactWriteItemsResponse -> TransactWriteItemsResponse -> Bool
$c/= :: TransactWriteItemsResponse -> TransactWriteItemsResponse -> Bool
== :: TransactWriteItemsResponse -> TransactWriteItemsResponse -> Bool
$c== :: TransactWriteItemsResponse -> TransactWriteItemsResponse -> Bool
Prelude.Eq, ReadPrec [TransactWriteItemsResponse]
ReadPrec TransactWriteItemsResponse
Int -> ReadS TransactWriteItemsResponse
ReadS [TransactWriteItemsResponse]
(Int -> ReadS TransactWriteItemsResponse)
-> ReadS [TransactWriteItemsResponse]
-> ReadPrec TransactWriteItemsResponse
-> ReadPrec [TransactWriteItemsResponse]
-> Read TransactWriteItemsResponse
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [TransactWriteItemsResponse]
$creadListPrec :: ReadPrec [TransactWriteItemsResponse]
readPrec :: ReadPrec TransactWriteItemsResponse
$creadPrec :: ReadPrec TransactWriteItemsResponse
readList :: ReadS [TransactWriteItemsResponse]
$creadList :: ReadS [TransactWriteItemsResponse]
readsPrec :: Int -> ReadS TransactWriteItemsResponse
$creadsPrec :: Int -> ReadS TransactWriteItemsResponse
Prelude.Read, Int -> TransactWriteItemsResponse -> ShowS
[TransactWriteItemsResponse] -> ShowS
TransactWriteItemsResponse -> String
(Int -> TransactWriteItemsResponse -> ShowS)
-> (TransactWriteItemsResponse -> String)
-> ([TransactWriteItemsResponse] -> ShowS)
-> Show TransactWriteItemsResponse
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [TransactWriteItemsResponse] -> ShowS
$cshowList :: [TransactWriteItemsResponse] -> ShowS
show :: TransactWriteItemsResponse -> String
$cshow :: TransactWriteItemsResponse -> String
showsPrec :: Int -> TransactWriteItemsResponse -> ShowS
$cshowsPrec :: Int -> TransactWriteItemsResponse -> ShowS
Prelude.Show, (forall x.
 TransactWriteItemsResponse -> Rep TransactWriteItemsResponse x)
-> (forall x.
    Rep TransactWriteItemsResponse x -> TransactWriteItemsResponse)
-> Generic TransactWriteItemsResponse
forall x.
Rep TransactWriteItemsResponse x -> TransactWriteItemsResponse
forall x.
TransactWriteItemsResponse -> Rep TransactWriteItemsResponse x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x.
Rep TransactWriteItemsResponse x -> TransactWriteItemsResponse
$cfrom :: forall x.
TransactWriteItemsResponse -> Rep TransactWriteItemsResponse x
Prelude.Generic)

-- |
-- Create a value of 'TransactWriteItemsResponse' with all optional fields omitted.
--
-- Use <https://hackage.haskell.org/package/generic-lens generic-lens> or <https://hackage.haskell.org/package/optics optics> to modify other optional fields.
--
-- The following record fields are available, with the corresponding lenses provided
-- for backwards compatibility:
--
-- 'itemCollectionMetrics', 'transactWriteItemsResponse_itemCollectionMetrics' - A list of tables that were processed by @TransactWriteItems@ and, for
-- each table, information about any item collections that were affected by
-- individual @UpdateItem@, @PutItem@, or @DeleteItem@ operations.
--
-- 'consumedCapacity', 'transactWriteItemsResponse_consumedCapacity' - The capacity units consumed by the entire @TransactWriteItems@
-- operation. The values of the list are ordered according to the ordering
-- of the @TransactItems@ request parameter.
--
-- 'httpStatus', 'transactWriteItemsResponse_httpStatus' - The response's http status code.
newTransactWriteItemsResponse ::
  -- | 'httpStatus'
  Prelude.Int ->
  TransactWriteItemsResponse
newTransactWriteItemsResponse :: Int -> TransactWriteItemsResponse
newTransactWriteItemsResponse Int
pHttpStatus_ =
  TransactWriteItemsResponse' :: Maybe (HashMap Text [ItemCollectionMetrics])
-> Maybe [ConsumedCapacity] -> Int -> TransactWriteItemsResponse
TransactWriteItemsResponse'
    { $sel:itemCollectionMetrics:TransactWriteItemsResponse' :: Maybe (HashMap Text [ItemCollectionMetrics])
itemCollectionMetrics =
        Maybe (HashMap Text [ItemCollectionMetrics])
forall a. Maybe a
Prelude.Nothing,
      $sel:consumedCapacity:TransactWriteItemsResponse' :: Maybe [ConsumedCapacity]
consumedCapacity = Maybe [ConsumedCapacity]
forall a. Maybe a
Prelude.Nothing,
      $sel:httpStatus:TransactWriteItemsResponse' :: Int
httpStatus = Int
pHttpStatus_
    }

-- | A list of tables that were processed by @TransactWriteItems@ and, for
-- each table, information about any item collections that were affected by
-- individual @UpdateItem@, @PutItem@, or @DeleteItem@ operations.
transactWriteItemsResponse_itemCollectionMetrics :: Lens.Lens' TransactWriteItemsResponse (Prelude.Maybe (Prelude.HashMap Prelude.Text [ItemCollectionMetrics]))
transactWriteItemsResponse_itemCollectionMetrics :: (Maybe (HashMap Text [ItemCollectionMetrics])
 -> f (Maybe (HashMap Text [ItemCollectionMetrics])))
-> TransactWriteItemsResponse -> f TransactWriteItemsResponse
transactWriteItemsResponse_itemCollectionMetrics = (TransactWriteItemsResponse
 -> Maybe (HashMap Text [ItemCollectionMetrics]))
-> (TransactWriteItemsResponse
    -> Maybe (HashMap Text [ItemCollectionMetrics])
    -> TransactWriteItemsResponse)
-> Lens
     TransactWriteItemsResponse
     TransactWriteItemsResponse
     (Maybe (HashMap Text [ItemCollectionMetrics]))
     (Maybe (HashMap Text [ItemCollectionMetrics]))
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\TransactWriteItemsResponse' {Maybe (HashMap Text [ItemCollectionMetrics])
itemCollectionMetrics :: Maybe (HashMap Text [ItemCollectionMetrics])
$sel:itemCollectionMetrics:TransactWriteItemsResponse' :: TransactWriteItemsResponse
-> Maybe (HashMap Text [ItemCollectionMetrics])
itemCollectionMetrics} -> Maybe (HashMap Text [ItemCollectionMetrics])
itemCollectionMetrics) (\s :: TransactWriteItemsResponse
s@TransactWriteItemsResponse' {} Maybe (HashMap Text [ItemCollectionMetrics])
a -> TransactWriteItemsResponse
s {$sel:itemCollectionMetrics:TransactWriteItemsResponse' :: Maybe (HashMap Text [ItemCollectionMetrics])
itemCollectionMetrics = Maybe (HashMap Text [ItemCollectionMetrics])
a} :: TransactWriteItemsResponse) ((Maybe (HashMap Text [ItemCollectionMetrics])
  -> f (Maybe (HashMap Text [ItemCollectionMetrics])))
 -> TransactWriteItemsResponse -> f TransactWriteItemsResponse)
-> ((Maybe (HashMap Text [ItemCollectionMetrics])
     -> f (Maybe (HashMap Text [ItemCollectionMetrics])))
    -> Maybe (HashMap Text [ItemCollectionMetrics])
    -> f (Maybe (HashMap Text [ItemCollectionMetrics])))
-> (Maybe (HashMap Text [ItemCollectionMetrics])
    -> f (Maybe (HashMap Text [ItemCollectionMetrics])))
-> TransactWriteItemsResponse
-> f TransactWriteItemsResponse
forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. AnIso
  (HashMap Text [ItemCollectionMetrics])
  (HashMap Text [ItemCollectionMetrics])
  (HashMap Text [ItemCollectionMetrics])
  (HashMap Text [ItemCollectionMetrics])
-> Iso
     (Maybe (HashMap Text [ItemCollectionMetrics]))
     (Maybe (HashMap Text [ItemCollectionMetrics]))
     (Maybe (HashMap Text [ItemCollectionMetrics]))
     (Maybe (HashMap Text [ItemCollectionMetrics]))
forall (f :: * -> *) (g :: * -> *) s t a b.
(Functor f, Functor g) =>
AnIso s t a b -> Iso (f s) (g t) (f a) (g b)
Lens.mapping AnIso
  (HashMap Text [ItemCollectionMetrics])
  (HashMap Text [ItemCollectionMetrics])
  (HashMap Text [ItemCollectionMetrics])
  (HashMap Text [ItemCollectionMetrics])
forall s t a b. (Coercible s a, Coercible t b) => Iso s t a b
Lens.coerced

-- | The capacity units consumed by the entire @TransactWriteItems@
-- operation. The values of the list are ordered according to the ordering
-- of the @TransactItems@ request parameter.
transactWriteItemsResponse_consumedCapacity :: Lens.Lens' TransactWriteItemsResponse (Prelude.Maybe [ConsumedCapacity])
transactWriteItemsResponse_consumedCapacity :: (Maybe [ConsumedCapacity] -> f (Maybe [ConsumedCapacity]))
-> TransactWriteItemsResponse -> f TransactWriteItemsResponse
transactWriteItemsResponse_consumedCapacity = (TransactWriteItemsResponse -> Maybe [ConsumedCapacity])
-> (TransactWriteItemsResponse
    -> Maybe [ConsumedCapacity] -> TransactWriteItemsResponse)
-> Lens
     TransactWriteItemsResponse
     TransactWriteItemsResponse
     (Maybe [ConsumedCapacity])
     (Maybe [ConsumedCapacity])
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\TransactWriteItemsResponse' {Maybe [ConsumedCapacity]
consumedCapacity :: Maybe [ConsumedCapacity]
$sel:consumedCapacity:TransactWriteItemsResponse' :: TransactWriteItemsResponse -> Maybe [ConsumedCapacity]
consumedCapacity} -> Maybe [ConsumedCapacity]
consumedCapacity) (\s :: TransactWriteItemsResponse
s@TransactWriteItemsResponse' {} Maybe [ConsumedCapacity]
a -> TransactWriteItemsResponse
s {$sel:consumedCapacity:TransactWriteItemsResponse' :: Maybe [ConsumedCapacity]
consumedCapacity = Maybe [ConsumedCapacity]
a} :: TransactWriteItemsResponse) ((Maybe [ConsumedCapacity] -> f (Maybe [ConsumedCapacity]))
 -> TransactWriteItemsResponse -> f TransactWriteItemsResponse)
-> ((Maybe [ConsumedCapacity] -> f (Maybe [ConsumedCapacity]))
    -> Maybe [ConsumedCapacity] -> f (Maybe [ConsumedCapacity]))
-> (Maybe [ConsumedCapacity] -> f (Maybe [ConsumedCapacity]))
-> TransactWriteItemsResponse
-> f TransactWriteItemsResponse
forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. AnIso
  [ConsumedCapacity]
  [ConsumedCapacity]
  [ConsumedCapacity]
  [ConsumedCapacity]
-> Iso
     (Maybe [ConsumedCapacity])
     (Maybe [ConsumedCapacity])
     (Maybe [ConsumedCapacity])
     (Maybe [ConsumedCapacity])
forall (f :: * -> *) (g :: * -> *) s t a b.
(Functor f, Functor g) =>
AnIso s t a b -> Iso (f s) (g t) (f a) (g b)
Lens.mapping AnIso
  [ConsumedCapacity]
  [ConsumedCapacity]
  [ConsumedCapacity]
  [ConsumedCapacity]
forall s t a b. (Coercible s a, Coercible t b) => Iso s t a b
Lens.coerced

-- | The response's http status code.
transactWriteItemsResponse_httpStatus :: Lens.Lens' TransactWriteItemsResponse Prelude.Int
transactWriteItemsResponse_httpStatus :: (Int -> f Int)
-> TransactWriteItemsResponse -> f TransactWriteItemsResponse
transactWriteItemsResponse_httpStatus = (TransactWriteItemsResponse -> Int)
-> (TransactWriteItemsResponse
    -> Int -> TransactWriteItemsResponse)
-> Lens
     TransactWriteItemsResponse TransactWriteItemsResponse Int Int
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\TransactWriteItemsResponse' {Int
httpStatus :: Int
$sel:httpStatus:TransactWriteItemsResponse' :: TransactWriteItemsResponse -> Int
httpStatus} -> Int
httpStatus) (\s :: TransactWriteItemsResponse
s@TransactWriteItemsResponse' {} Int
a -> TransactWriteItemsResponse
s {$sel:httpStatus:TransactWriteItemsResponse' :: Int
httpStatus = Int
a} :: TransactWriteItemsResponse)

instance Prelude.NFData TransactWriteItemsResponse