{-# 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.ExecuteTransaction
-- Copyright   : (c) 2013-2023 Brendan Hay
-- License     : Mozilla Public License, v. 2.0.
-- Maintainer  : Brendan Hay
-- Stability   : auto-generated
-- Portability : non-portable (GHC extensions)
--
-- This operation allows you to perform transactional reads or writes on
-- data stored in DynamoDB, using PartiQL.
--
-- The entire transaction must consist of either read statements or write
-- statements, you cannot mix both in one transaction. The EXISTS function
-- is an exception and can be used to check the condition of specific
-- attributes of the item in a similar manner to @ConditionCheck@ in the
-- <https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/transaction-apis.html#transaction-apis-txwriteitems TransactWriteItems>
-- API.
module Amazonka.DynamoDB.ExecuteTransaction
  ( -- * Creating a Request
    ExecuteTransaction (..),
    newExecuteTransaction,

    -- * Request Lenses
    executeTransaction_clientRequestToken,
    executeTransaction_returnConsumedCapacity,
    executeTransaction_transactStatements,

    -- * Destructuring the Response
    ExecuteTransactionResponse (..),
    newExecuteTransactionResponse,

    -- * Response Lenses
    executeTransactionResponse_consumedCapacity,
    executeTransactionResponse_responses,
    executeTransactionResponse_httpStatus,
  )
where

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

-- | /See:/ 'newExecuteTransaction' smart constructor.
data ExecuteTransaction = ExecuteTransaction'
  { -- | Set this value to get remaining results, if @NextToken@ was returned in
    -- the statement response.
    ExecuteTransaction -> Maybe Text
clientRequestToken :: Prelude.Maybe Prelude.Text,
    -- | Determines the level of detail about either provisioned or on-demand
    -- throughput consumption that is returned in the response. For more
    -- information, see
    -- <https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_TransactGetItems.html TransactGetItems>
    -- and
    -- <https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_TransactWriteItems.html TransactWriteItems>.
    ExecuteTransaction -> Maybe ReturnConsumedCapacity
returnConsumedCapacity :: Prelude.Maybe ReturnConsumedCapacity,
    -- | The list of PartiQL statements representing the transaction to run.
    ExecuteTransaction -> NonEmpty ParameterizedStatement
transactStatements :: Prelude.NonEmpty ParameterizedStatement
  }
  deriving (ExecuteTransaction -> ExecuteTransaction -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ExecuteTransaction -> ExecuteTransaction -> Bool
$c/= :: ExecuteTransaction -> ExecuteTransaction -> Bool
== :: ExecuteTransaction -> ExecuteTransaction -> Bool
$c== :: ExecuteTransaction -> ExecuteTransaction -> Bool
Prelude.Eq, ReadPrec [ExecuteTransaction]
ReadPrec ExecuteTransaction
Int -> ReadS ExecuteTransaction
ReadS [ExecuteTransaction]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [ExecuteTransaction]
$creadListPrec :: ReadPrec [ExecuteTransaction]
readPrec :: ReadPrec ExecuteTransaction
$creadPrec :: ReadPrec ExecuteTransaction
readList :: ReadS [ExecuteTransaction]
$creadList :: ReadS [ExecuteTransaction]
readsPrec :: Int -> ReadS ExecuteTransaction
$creadsPrec :: Int -> ReadS ExecuteTransaction
Prelude.Read, Int -> ExecuteTransaction -> ShowS
[ExecuteTransaction] -> ShowS
ExecuteTransaction -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ExecuteTransaction] -> ShowS
$cshowList :: [ExecuteTransaction] -> ShowS
show :: ExecuteTransaction -> String
$cshow :: ExecuteTransaction -> String
showsPrec :: Int -> ExecuteTransaction -> ShowS
$cshowsPrec :: Int -> ExecuteTransaction -> ShowS
Prelude.Show, forall x. Rep ExecuteTransaction x -> ExecuteTransaction
forall x. ExecuteTransaction -> Rep ExecuteTransaction x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep ExecuteTransaction x -> ExecuteTransaction
$cfrom :: forall x. ExecuteTransaction -> Rep ExecuteTransaction x
Prelude.Generic)

-- |
-- Create a value of 'ExecuteTransaction' 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:
--
-- 'clientRequestToken', 'executeTransaction_clientRequestToken' - Set this value to get remaining results, if @NextToken@ was returned in
-- the statement response.
--
-- 'returnConsumedCapacity', 'executeTransaction_returnConsumedCapacity' - Determines the level of detail about either provisioned or on-demand
-- throughput consumption that is returned in the response. For more
-- information, see
-- <https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_TransactGetItems.html TransactGetItems>
-- and
-- <https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_TransactWriteItems.html TransactWriteItems>.
--
-- 'transactStatements', 'executeTransaction_transactStatements' - The list of PartiQL statements representing the transaction to run.
newExecuteTransaction ::
  -- | 'transactStatements'
  Prelude.NonEmpty ParameterizedStatement ->
  ExecuteTransaction
newExecuteTransaction :: NonEmpty ParameterizedStatement -> ExecuteTransaction
newExecuteTransaction NonEmpty ParameterizedStatement
pTransactStatements_ =
  ExecuteTransaction'
    { $sel:clientRequestToken:ExecuteTransaction' :: Maybe Text
clientRequestToken =
        forall a. Maybe a
Prelude.Nothing,
      $sel:returnConsumedCapacity:ExecuteTransaction' :: Maybe ReturnConsumedCapacity
returnConsumedCapacity = forall a. Maybe a
Prelude.Nothing,
      $sel:transactStatements:ExecuteTransaction' :: NonEmpty ParameterizedStatement
transactStatements =
        forall s t a b. (Coercible s a, Coercible t b) => Iso s t a b
Lens.coerced forall t b. AReview t b -> b -> t
Lens.# NonEmpty ParameterizedStatement
pTransactStatements_
    }

-- | Set this value to get remaining results, if @NextToken@ was returned in
-- the statement response.
executeTransaction_clientRequestToken :: Lens.Lens' ExecuteTransaction (Prelude.Maybe Prelude.Text)
executeTransaction_clientRequestToken :: Lens' ExecuteTransaction (Maybe Text)
executeTransaction_clientRequestToken = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ExecuteTransaction' {Maybe Text
clientRequestToken :: Maybe Text
$sel:clientRequestToken:ExecuteTransaction' :: ExecuteTransaction -> Maybe Text
clientRequestToken} -> Maybe Text
clientRequestToken) (\s :: ExecuteTransaction
s@ExecuteTransaction' {} Maybe Text
a -> ExecuteTransaction
s {$sel:clientRequestToken:ExecuteTransaction' :: Maybe Text
clientRequestToken = Maybe Text
a} :: ExecuteTransaction)

-- | Determines the level of detail about either provisioned or on-demand
-- throughput consumption that is returned in the response. For more
-- information, see
-- <https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_TransactGetItems.html TransactGetItems>
-- and
-- <https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_TransactWriteItems.html TransactWriteItems>.
executeTransaction_returnConsumedCapacity :: Lens.Lens' ExecuteTransaction (Prelude.Maybe ReturnConsumedCapacity)
executeTransaction_returnConsumedCapacity :: Lens' ExecuteTransaction (Maybe ReturnConsumedCapacity)
executeTransaction_returnConsumedCapacity = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ExecuteTransaction' {Maybe ReturnConsumedCapacity
returnConsumedCapacity :: Maybe ReturnConsumedCapacity
$sel:returnConsumedCapacity:ExecuteTransaction' :: ExecuteTransaction -> Maybe ReturnConsumedCapacity
returnConsumedCapacity} -> Maybe ReturnConsumedCapacity
returnConsumedCapacity) (\s :: ExecuteTransaction
s@ExecuteTransaction' {} Maybe ReturnConsumedCapacity
a -> ExecuteTransaction
s {$sel:returnConsumedCapacity:ExecuteTransaction' :: Maybe ReturnConsumedCapacity
returnConsumedCapacity = Maybe ReturnConsumedCapacity
a} :: ExecuteTransaction)

-- | The list of PartiQL statements representing the transaction to run.
executeTransaction_transactStatements :: Lens.Lens' ExecuteTransaction (Prelude.NonEmpty ParameterizedStatement)
executeTransaction_transactStatements :: Lens' ExecuteTransaction (NonEmpty ParameterizedStatement)
executeTransaction_transactStatements = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ExecuteTransaction' {NonEmpty ParameterizedStatement
transactStatements :: NonEmpty ParameterizedStatement
$sel:transactStatements:ExecuteTransaction' :: ExecuteTransaction -> NonEmpty ParameterizedStatement
transactStatements} -> NonEmpty ParameterizedStatement
transactStatements) (\s :: ExecuteTransaction
s@ExecuteTransaction' {} NonEmpty ParameterizedStatement
a -> ExecuteTransaction
s {$sel:transactStatements:ExecuteTransaction' :: NonEmpty ParameterizedStatement
transactStatements = NonEmpty ParameterizedStatement
a} :: ExecuteTransaction) forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. forall s t a b. (Coercible s a, Coercible t b) => Iso s t a b
Lens.coerced

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

instance Prelude.Hashable ExecuteTransaction where
  hashWithSalt :: Int -> ExecuteTransaction -> Int
hashWithSalt Int
_salt ExecuteTransaction' {Maybe Text
Maybe ReturnConsumedCapacity
NonEmpty ParameterizedStatement
transactStatements :: NonEmpty ParameterizedStatement
returnConsumedCapacity :: Maybe ReturnConsumedCapacity
clientRequestToken :: Maybe Text
$sel:transactStatements:ExecuteTransaction' :: ExecuteTransaction -> NonEmpty ParameterizedStatement
$sel:returnConsumedCapacity:ExecuteTransaction' :: ExecuteTransaction -> Maybe ReturnConsumedCapacity
$sel:clientRequestToken:ExecuteTransaction' :: ExecuteTransaction -> Maybe Text
..} =
    Int
_salt
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
clientRequestToken
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe ReturnConsumedCapacity
returnConsumedCapacity
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` NonEmpty ParameterizedStatement
transactStatements

instance Prelude.NFData ExecuteTransaction where
  rnf :: ExecuteTransaction -> ()
rnf ExecuteTransaction' {Maybe Text
Maybe ReturnConsumedCapacity
NonEmpty ParameterizedStatement
transactStatements :: NonEmpty ParameterizedStatement
returnConsumedCapacity :: Maybe ReturnConsumedCapacity
clientRequestToken :: Maybe Text
$sel:transactStatements:ExecuteTransaction' :: ExecuteTransaction -> NonEmpty ParameterizedStatement
$sel:returnConsumedCapacity:ExecuteTransaction' :: ExecuteTransaction -> Maybe ReturnConsumedCapacity
$sel:clientRequestToken:ExecuteTransaction' :: ExecuteTransaction -> Maybe Text
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
clientRequestToken
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe ReturnConsumedCapacity
returnConsumedCapacity
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf NonEmpty ParameterizedStatement
transactStatements

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

instance Data.ToJSON ExecuteTransaction where
  toJSON :: ExecuteTransaction -> Value
toJSON ExecuteTransaction' {Maybe Text
Maybe ReturnConsumedCapacity
NonEmpty ParameterizedStatement
transactStatements :: NonEmpty ParameterizedStatement
returnConsumedCapacity :: Maybe ReturnConsumedCapacity
clientRequestToken :: Maybe Text
$sel:transactStatements:ExecuteTransaction' :: ExecuteTransaction -> NonEmpty ParameterizedStatement
$sel:returnConsumedCapacity:ExecuteTransaction' :: ExecuteTransaction -> Maybe ReturnConsumedCapacity
$sel:clientRequestToken:ExecuteTransaction' :: ExecuteTransaction -> Maybe Text
..} =
    [Pair] -> Value
Data.object
      ( forall a. [Maybe a] -> [a]
Prelude.catMaybes
          [ (Key
"ClientRequestToken" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..=)
              forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe Text
clientRequestToken,
            (Key
"ReturnConsumedCapacity" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..=)
              forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe ReturnConsumedCapacity
returnConsumedCapacity,
            forall a. a -> Maybe a
Prelude.Just
              (Key
"TransactStatements" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= NonEmpty ParameterizedStatement
transactStatements)
          ]
      )

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

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

-- | /See:/ 'newExecuteTransactionResponse' smart constructor.
data ExecuteTransactionResponse = ExecuteTransactionResponse'
  { -- | The capacity units consumed by the entire operation. The values of the
    -- list are ordered according to the ordering of the statements.
    ExecuteTransactionResponse -> Maybe [ConsumedCapacity]
consumedCapacity :: Prelude.Maybe [ConsumedCapacity],
    -- | The response to a PartiQL transaction.
    ExecuteTransactionResponse -> Maybe (NonEmpty ItemResponse)
responses :: Prelude.Maybe (Prelude.NonEmpty ItemResponse),
    -- | The response's http status code.
    ExecuteTransactionResponse -> Int
httpStatus :: Prelude.Int
  }
  deriving (ExecuteTransactionResponse -> ExecuteTransactionResponse -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ExecuteTransactionResponse -> ExecuteTransactionResponse -> Bool
$c/= :: ExecuteTransactionResponse -> ExecuteTransactionResponse -> Bool
== :: ExecuteTransactionResponse -> ExecuteTransactionResponse -> Bool
$c== :: ExecuteTransactionResponse -> ExecuteTransactionResponse -> Bool
Prelude.Eq, ReadPrec [ExecuteTransactionResponse]
ReadPrec ExecuteTransactionResponse
Int -> ReadS ExecuteTransactionResponse
ReadS [ExecuteTransactionResponse]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [ExecuteTransactionResponse]
$creadListPrec :: ReadPrec [ExecuteTransactionResponse]
readPrec :: ReadPrec ExecuteTransactionResponse
$creadPrec :: ReadPrec ExecuteTransactionResponse
readList :: ReadS [ExecuteTransactionResponse]
$creadList :: ReadS [ExecuteTransactionResponse]
readsPrec :: Int -> ReadS ExecuteTransactionResponse
$creadsPrec :: Int -> ReadS ExecuteTransactionResponse
Prelude.Read, Int -> ExecuteTransactionResponse -> ShowS
[ExecuteTransactionResponse] -> ShowS
ExecuteTransactionResponse -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ExecuteTransactionResponse] -> ShowS
$cshowList :: [ExecuteTransactionResponse] -> ShowS
show :: ExecuteTransactionResponse -> String
$cshow :: ExecuteTransactionResponse -> String
showsPrec :: Int -> ExecuteTransactionResponse -> ShowS
$cshowsPrec :: Int -> ExecuteTransactionResponse -> ShowS
Prelude.Show, forall x.
Rep ExecuteTransactionResponse x -> ExecuteTransactionResponse
forall x.
ExecuteTransactionResponse -> Rep ExecuteTransactionResponse x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x.
Rep ExecuteTransactionResponse x -> ExecuteTransactionResponse
$cfrom :: forall x.
ExecuteTransactionResponse -> Rep ExecuteTransactionResponse x
Prelude.Generic)

-- |
-- Create a value of 'ExecuteTransactionResponse' 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:
--
-- 'consumedCapacity', 'executeTransactionResponse_consumedCapacity' - The capacity units consumed by the entire operation. The values of the
-- list are ordered according to the ordering of the statements.
--
-- 'responses', 'executeTransactionResponse_responses' - The response to a PartiQL transaction.
--
-- 'httpStatus', 'executeTransactionResponse_httpStatus' - The response's http status code.
newExecuteTransactionResponse ::
  -- | 'httpStatus'
  Prelude.Int ->
  ExecuteTransactionResponse
newExecuteTransactionResponse :: Int -> ExecuteTransactionResponse
newExecuteTransactionResponse Int
pHttpStatus_ =
  ExecuteTransactionResponse'
    { $sel:consumedCapacity:ExecuteTransactionResponse' :: Maybe [ConsumedCapacity]
consumedCapacity =
        forall a. Maybe a
Prelude.Nothing,
      $sel:responses:ExecuteTransactionResponse' :: Maybe (NonEmpty ItemResponse)
responses = forall a. Maybe a
Prelude.Nothing,
      $sel:httpStatus:ExecuteTransactionResponse' :: Int
httpStatus = Int
pHttpStatus_
    }

-- | The capacity units consumed by the entire operation. The values of the
-- list are ordered according to the ordering of the statements.
executeTransactionResponse_consumedCapacity :: Lens.Lens' ExecuteTransactionResponse (Prelude.Maybe [ConsumedCapacity])
executeTransactionResponse_consumedCapacity :: Lens' ExecuteTransactionResponse (Maybe [ConsumedCapacity])
executeTransactionResponse_consumedCapacity = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ExecuteTransactionResponse' {Maybe [ConsumedCapacity]
consumedCapacity :: Maybe [ConsumedCapacity]
$sel:consumedCapacity:ExecuteTransactionResponse' :: ExecuteTransactionResponse -> Maybe [ConsumedCapacity]
consumedCapacity} -> Maybe [ConsumedCapacity]
consumedCapacity) (\s :: ExecuteTransactionResponse
s@ExecuteTransactionResponse' {} Maybe [ConsumedCapacity]
a -> ExecuteTransactionResponse
s {$sel:consumedCapacity:ExecuteTransactionResponse' :: Maybe [ConsumedCapacity]
consumedCapacity = Maybe [ConsumedCapacity]
a} :: ExecuteTransactionResponse) forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. 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 forall s t a b. (Coercible s a, Coercible t b) => Iso s t a b
Lens.coerced

-- | The response to a PartiQL transaction.
executeTransactionResponse_responses :: Lens.Lens' ExecuteTransactionResponse (Prelude.Maybe (Prelude.NonEmpty ItemResponse))
executeTransactionResponse_responses :: Lens' ExecuteTransactionResponse (Maybe (NonEmpty ItemResponse))
executeTransactionResponse_responses = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ExecuteTransactionResponse' {Maybe (NonEmpty ItemResponse)
responses :: Maybe (NonEmpty ItemResponse)
$sel:responses:ExecuteTransactionResponse' :: ExecuteTransactionResponse -> Maybe (NonEmpty ItemResponse)
responses} -> Maybe (NonEmpty ItemResponse)
responses) (\s :: ExecuteTransactionResponse
s@ExecuteTransactionResponse' {} Maybe (NonEmpty ItemResponse)
a -> ExecuteTransactionResponse
s {$sel:responses:ExecuteTransactionResponse' :: Maybe (NonEmpty ItemResponse)
responses = Maybe (NonEmpty ItemResponse)
a} :: ExecuteTransactionResponse) forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. 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 forall s t a b. (Coercible s a, Coercible t b) => Iso s t a b
Lens.coerced

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

instance Prelude.NFData ExecuteTransactionResponse where
  rnf :: ExecuteTransactionResponse -> ()
rnf ExecuteTransactionResponse' {Int
Maybe [ConsumedCapacity]
Maybe (NonEmpty ItemResponse)
httpStatus :: Int
responses :: Maybe (NonEmpty ItemResponse)
consumedCapacity :: Maybe [ConsumedCapacity]
$sel:httpStatus:ExecuteTransactionResponse' :: ExecuteTransactionResponse -> Int
$sel:responses:ExecuteTransactionResponse' :: ExecuteTransactionResponse -> Maybe (NonEmpty ItemResponse)
$sel:consumedCapacity:ExecuteTransactionResponse' :: ExecuteTransactionResponse -> Maybe [ConsumedCapacity]
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe [ConsumedCapacity]
consumedCapacity
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe (NonEmpty ItemResponse)
responses
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Int
httpStatus