{-# 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.AppSync.UpdateResolver
-- Copyright   : (c) 2013-2023 Brendan Hay
-- License     : Mozilla Public License, v. 2.0.
-- Maintainer  : Brendan Hay
-- Stability   : auto-generated
-- Portability : non-portable (GHC extensions)
--
-- Updates a @Resolver@ object.
module Amazonka.AppSync.UpdateResolver
  ( -- * Creating a Request
    UpdateResolver (..),
    newUpdateResolver,

    -- * Request Lenses
    updateResolver_cachingConfig,
    updateResolver_code,
    updateResolver_dataSourceName,
    updateResolver_kind,
    updateResolver_maxBatchSize,
    updateResolver_pipelineConfig,
    updateResolver_requestMappingTemplate,
    updateResolver_responseMappingTemplate,
    updateResolver_runtime,
    updateResolver_syncConfig,
    updateResolver_apiId,
    updateResolver_typeName,
    updateResolver_fieldName,

    -- * Destructuring the Response
    UpdateResolverResponse (..),
    newUpdateResolverResponse,

    -- * Response Lenses
    updateResolverResponse_resolver,
    updateResolverResponse_httpStatus,
  )
where

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

-- | /See:/ 'newUpdateResolver' smart constructor.
data UpdateResolver = UpdateResolver'
  { -- | The caching configuration for the resolver.
    UpdateResolver -> Maybe CachingConfig
cachingConfig :: Prelude.Maybe CachingConfig,
    -- | The @resolver@ code that contains the request and response functions.
    -- When code is used, the @runtime@ is required. The @runtime@ value must
    -- be @APPSYNC_JS@.
    UpdateResolver -> Maybe Text
code :: Prelude.Maybe Prelude.Text,
    -- | The new data source name.
    UpdateResolver -> Maybe Text
dataSourceName :: Prelude.Maybe Prelude.Text,
    -- | The resolver type.
    --
    -- -   __UNIT__: A UNIT resolver type. A UNIT resolver is the default
    --     resolver type. You can use a UNIT resolver to run a GraphQL query
    --     against a single data source.
    --
    -- -   __PIPELINE__: A PIPELINE resolver type. You can use a PIPELINE
    --     resolver to invoke a series of @Function@ objects in a serial
    --     manner. You can use a pipeline resolver to run a GraphQL query
    --     against multiple data sources.
    UpdateResolver -> Maybe ResolverKind
kind :: Prelude.Maybe ResolverKind,
    -- | The maximum batching size for a resolver.
    UpdateResolver -> Maybe Natural
maxBatchSize :: Prelude.Maybe Prelude.Natural,
    -- | The @PipelineConfig@.
    UpdateResolver -> Maybe PipelineConfig
pipelineConfig :: Prelude.Maybe PipelineConfig,
    -- | The new request mapping template.
    --
    -- A resolver uses a request mapping template to convert a GraphQL
    -- expression into a format that a data source can understand. Mapping
    -- templates are written in Apache Velocity Template Language (VTL).
    --
    -- VTL request mapping templates are optional when using an Lambda data
    -- source. For all other data sources, VTL request and response mapping
    -- templates are required.
    UpdateResolver -> Maybe Text
requestMappingTemplate :: Prelude.Maybe Prelude.Text,
    -- | The new response mapping template.
    UpdateResolver -> Maybe Text
responseMappingTemplate :: Prelude.Maybe Prelude.Text,
    UpdateResolver -> Maybe AppSyncRuntime
runtime :: Prelude.Maybe AppSyncRuntime,
    -- | The @SyncConfig@ for a resolver attached to a versioned data source.
    UpdateResolver -> Maybe SyncConfig
syncConfig :: Prelude.Maybe SyncConfig,
    -- | The API ID.
    UpdateResolver -> Text
apiId :: Prelude.Text,
    -- | The new type name.
    UpdateResolver -> Text
typeName :: Prelude.Text,
    -- | The new field name.
    UpdateResolver -> Text
fieldName :: Prelude.Text
  }
  deriving (UpdateResolver -> UpdateResolver -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: UpdateResolver -> UpdateResolver -> Bool
$c/= :: UpdateResolver -> UpdateResolver -> Bool
== :: UpdateResolver -> UpdateResolver -> Bool
$c== :: UpdateResolver -> UpdateResolver -> Bool
Prelude.Eq, ReadPrec [UpdateResolver]
ReadPrec UpdateResolver
Int -> ReadS UpdateResolver
ReadS [UpdateResolver]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [UpdateResolver]
$creadListPrec :: ReadPrec [UpdateResolver]
readPrec :: ReadPrec UpdateResolver
$creadPrec :: ReadPrec UpdateResolver
readList :: ReadS [UpdateResolver]
$creadList :: ReadS [UpdateResolver]
readsPrec :: Int -> ReadS UpdateResolver
$creadsPrec :: Int -> ReadS UpdateResolver
Prelude.Read, Int -> UpdateResolver -> ShowS
[UpdateResolver] -> ShowS
UpdateResolver -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [UpdateResolver] -> ShowS
$cshowList :: [UpdateResolver] -> ShowS
show :: UpdateResolver -> String
$cshow :: UpdateResolver -> String
showsPrec :: Int -> UpdateResolver -> ShowS
$cshowsPrec :: Int -> UpdateResolver -> ShowS
Prelude.Show, forall x. Rep UpdateResolver x -> UpdateResolver
forall x. UpdateResolver -> Rep UpdateResolver x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep UpdateResolver x -> UpdateResolver
$cfrom :: forall x. UpdateResolver -> Rep UpdateResolver x
Prelude.Generic)

-- |
-- Create a value of 'UpdateResolver' 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:
--
-- 'cachingConfig', 'updateResolver_cachingConfig' - The caching configuration for the resolver.
--
-- 'code', 'updateResolver_code' - The @resolver@ code that contains the request and response functions.
-- When code is used, the @runtime@ is required. The @runtime@ value must
-- be @APPSYNC_JS@.
--
-- 'dataSourceName', 'updateResolver_dataSourceName' - The new data source name.
--
-- 'kind', 'updateResolver_kind' - The resolver type.
--
-- -   __UNIT__: A UNIT resolver type. A UNIT resolver is the default
--     resolver type. You can use a UNIT resolver to run a GraphQL query
--     against a single data source.
--
-- -   __PIPELINE__: A PIPELINE resolver type. You can use a PIPELINE
--     resolver to invoke a series of @Function@ objects in a serial
--     manner. You can use a pipeline resolver to run a GraphQL query
--     against multiple data sources.
--
-- 'maxBatchSize', 'updateResolver_maxBatchSize' - The maximum batching size for a resolver.
--
-- 'pipelineConfig', 'updateResolver_pipelineConfig' - The @PipelineConfig@.
--
-- 'requestMappingTemplate', 'updateResolver_requestMappingTemplate' - The new request mapping template.
--
-- A resolver uses a request mapping template to convert a GraphQL
-- expression into a format that a data source can understand. Mapping
-- templates are written in Apache Velocity Template Language (VTL).
--
-- VTL request mapping templates are optional when using an Lambda data
-- source. For all other data sources, VTL request and response mapping
-- templates are required.
--
-- 'responseMappingTemplate', 'updateResolver_responseMappingTemplate' - The new response mapping template.
--
-- 'runtime', 'updateResolver_runtime' - Undocumented member.
--
-- 'syncConfig', 'updateResolver_syncConfig' - The @SyncConfig@ for a resolver attached to a versioned data source.
--
-- 'apiId', 'updateResolver_apiId' - The API ID.
--
-- 'typeName', 'updateResolver_typeName' - The new type name.
--
-- 'fieldName', 'updateResolver_fieldName' - The new field name.
newUpdateResolver ::
  -- | 'apiId'
  Prelude.Text ->
  -- | 'typeName'
  Prelude.Text ->
  -- | 'fieldName'
  Prelude.Text ->
  UpdateResolver
newUpdateResolver :: Text -> Text -> Text -> UpdateResolver
newUpdateResolver Text
pApiId_ Text
pTypeName_ Text
pFieldName_ =
  UpdateResolver'
    { $sel:cachingConfig:UpdateResolver' :: Maybe CachingConfig
cachingConfig = forall a. Maybe a
Prelude.Nothing,
      $sel:code:UpdateResolver' :: Maybe Text
code = forall a. Maybe a
Prelude.Nothing,
      $sel:dataSourceName:UpdateResolver' :: Maybe Text
dataSourceName = forall a. Maybe a
Prelude.Nothing,
      $sel:kind:UpdateResolver' :: Maybe ResolverKind
kind = forall a. Maybe a
Prelude.Nothing,
      $sel:maxBatchSize:UpdateResolver' :: Maybe Natural
maxBatchSize = forall a. Maybe a
Prelude.Nothing,
      $sel:pipelineConfig:UpdateResolver' :: Maybe PipelineConfig
pipelineConfig = forall a. Maybe a
Prelude.Nothing,
      $sel:requestMappingTemplate:UpdateResolver' :: Maybe Text
requestMappingTemplate = forall a. Maybe a
Prelude.Nothing,
      $sel:responseMappingTemplate:UpdateResolver' :: Maybe Text
responseMappingTemplate = forall a. Maybe a
Prelude.Nothing,
      $sel:runtime:UpdateResolver' :: Maybe AppSyncRuntime
runtime = forall a. Maybe a
Prelude.Nothing,
      $sel:syncConfig:UpdateResolver' :: Maybe SyncConfig
syncConfig = forall a. Maybe a
Prelude.Nothing,
      $sel:apiId:UpdateResolver' :: Text
apiId = Text
pApiId_,
      $sel:typeName:UpdateResolver' :: Text
typeName = Text
pTypeName_,
      $sel:fieldName:UpdateResolver' :: Text
fieldName = Text
pFieldName_
    }

-- | The caching configuration for the resolver.
updateResolver_cachingConfig :: Lens.Lens' UpdateResolver (Prelude.Maybe CachingConfig)
updateResolver_cachingConfig :: Lens' UpdateResolver (Maybe CachingConfig)
updateResolver_cachingConfig = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\UpdateResolver' {Maybe CachingConfig
cachingConfig :: Maybe CachingConfig
$sel:cachingConfig:UpdateResolver' :: UpdateResolver -> Maybe CachingConfig
cachingConfig} -> Maybe CachingConfig
cachingConfig) (\s :: UpdateResolver
s@UpdateResolver' {} Maybe CachingConfig
a -> UpdateResolver
s {$sel:cachingConfig:UpdateResolver' :: Maybe CachingConfig
cachingConfig = Maybe CachingConfig
a} :: UpdateResolver)

-- | The @resolver@ code that contains the request and response functions.
-- When code is used, the @runtime@ is required. The @runtime@ value must
-- be @APPSYNC_JS@.
updateResolver_code :: Lens.Lens' UpdateResolver (Prelude.Maybe Prelude.Text)
updateResolver_code :: Lens' UpdateResolver (Maybe Text)
updateResolver_code = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\UpdateResolver' {Maybe Text
code :: Maybe Text
$sel:code:UpdateResolver' :: UpdateResolver -> Maybe Text
code} -> Maybe Text
code) (\s :: UpdateResolver
s@UpdateResolver' {} Maybe Text
a -> UpdateResolver
s {$sel:code:UpdateResolver' :: Maybe Text
code = Maybe Text
a} :: UpdateResolver)

-- | The new data source name.
updateResolver_dataSourceName :: Lens.Lens' UpdateResolver (Prelude.Maybe Prelude.Text)
updateResolver_dataSourceName :: Lens' UpdateResolver (Maybe Text)
updateResolver_dataSourceName = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\UpdateResolver' {Maybe Text
dataSourceName :: Maybe Text
$sel:dataSourceName:UpdateResolver' :: UpdateResolver -> Maybe Text
dataSourceName} -> Maybe Text
dataSourceName) (\s :: UpdateResolver
s@UpdateResolver' {} Maybe Text
a -> UpdateResolver
s {$sel:dataSourceName:UpdateResolver' :: Maybe Text
dataSourceName = Maybe Text
a} :: UpdateResolver)

-- | The resolver type.
--
-- -   __UNIT__: A UNIT resolver type. A UNIT resolver is the default
--     resolver type. You can use a UNIT resolver to run a GraphQL query
--     against a single data source.
--
-- -   __PIPELINE__: A PIPELINE resolver type. You can use a PIPELINE
--     resolver to invoke a series of @Function@ objects in a serial
--     manner. You can use a pipeline resolver to run a GraphQL query
--     against multiple data sources.
updateResolver_kind :: Lens.Lens' UpdateResolver (Prelude.Maybe ResolverKind)
updateResolver_kind :: Lens' UpdateResolver (Maybe ResolverKind)
updateResolver_kind = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\UpdateResolver' {Maybe ResolverKind
kind :: Maybe ResolverKind
$sel:kind:UpdateResolver' :: UpdateResolver -> Maybe ResolverKind
kind} -> Maybe ResolverKind
kind) (\s :: UpdateResolver
s@UpdateResolver' {} Maybe ResolverKind
a -> UpdateResolver
s {$sel:kind:UpdateResolver' :: Maybe ResolverKind
kind = Maybe ResolverKind
a} :: UpdateResolver)

-- | The maximum batching size for a resolver.
updateResolver_maxBatchSize :: Lens.Lens' UpdateResolver (Prelude.Maybe Prelude.Natural)
updateResolver_maxBatchSize :: Lens' UpdateResolver (Maybe Natural)
updateResolver_maxBatchSize = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\UpdateResolver' {Maybe Natural
maxBatchSize :: Maybe Natural
$sel:maxBatchSize:UpdateResolver' :: UpdateResolver -> Maybe Natural
maxBatchSize} -> Maybe Natural
maxBatchSize) (\s :: UpdateResolver
s@UpdateResolver' {} Maybe Natural
a -> UpdateResolver
s {$sel:maxBatchSize:UpdateResolver' :: Maybe Natural
maxBatchSize = Maybe Natural
a} :: UpdateResolver)

-- | The @PipelineConfig@.
updateResolver_pipelineConfig :: Lens.Lens' UpdateResolver (Prelude.Maybe PipelineConfig)
updateResolver_pipelineConfig :: Lens' UpdateResolver (Maybe PipelineConfig)
updateResolver_pipelineConfig = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\UpdateResolver' {Maybe PipelineConfig
pipelineConfig :: Maybe PipelineConfig
$sel:pipelineConfig:UpdateResolver' :: UpdateResolver -> Maybe PipelineConfig
pipelineConfig} -> Maybe PipelineConfig
pipelineConfig) (\s :: UpdateResolver
s@UpdateResolver' {} Maybe PipelineConfig
a -> UpdateResolver
s {$sel:pipelineConfig:UpdateResolver' :: Maybe PipelineConfig
pipelineConfig = Maybe PipelineConfig
a} :: UpdateResolver)

-- | The new request mapping template.
--
-- A resolver uses a request mapping template to convert a GraphQL
-- expression into a format that a data source can understand. Mapping
-- templates are written in Apache Velocity Template Language (VTL).
--
-- VTL request mapping templates are optional when using an Lambda data
-- source. For all other data sources, VTL request and response mapping
-- templates are required.
updateResolver_requestMappingTemplate :: Lens.Lens' UpdateResolver (Prelude.Maybe Prelude.Text)
updateResolver_requestMappingTemplate :: Lens' UpdateResolver (Maybe Text)
updateResolver_requestMappingTemplate = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\UpdateResolver' {Maybe Text
requestMappingTemplate :: Maybe Text
$sel:requestMappingTemplate:UpdateResolver' :: UpdateResolver -> Maybe Text
requestMappingTemplate} -> Maybe Text
requestMappingTemplate) (\s :: UpdateResolver
s@UpdateResolver' {} Maybe Text
a -> UpdateResolver
s {$sel:requestMappingTemplate:UpdateResolver' :: Maybe Text
requestMappingTemplate = Maybe Text
a} :: UpdateResolver)

-- | The new response mapping template.
updateResolver_responseMappingTemplate :: Lens.Lens' UpdateResolver (Prelude.Maybe Prelude.Text)
updateResolver_responseMappingTemplate :: Lens' UpdateResolver (Maybe Text)
updateResolver_responseMappingTemplate = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\UpdateResolver' {Maybe Text
responseMappingTemplate :: Maybe Text
$sel:responseMappingTemplate:UpdateResolver' :: UpdateResolver -> Maybe Text
responseMappingTemplate} -> Maybe Text
responseMappingTemplate) (\s :: UpdateResolver
s@UpdateResolver' {} Maybe Text
a -> UpdateResolver
s {$sel:responseMappingTemplate:UpdateResolver' :: Maybe Text
responseMappingTemplate = Maybe Text
a} :: UpdateResolver)

-- | Undocumented member.
updateResolver_runtime :: Lens.Lens' UpdateResolver (Prelude.Maybe AppSyncRuntime)
updateResolver_runtime :: Lens' UpdateResolver (Maybe AppSyncRuntime)
updateResolver_runtime = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\UpdateResolver' {Maybe AppSyncRuntime
runtime :: Maybe AppSyncRuntime
$sel:runtime:UpdateResolver' :: UpdateResolver -> Maybe AppSyncRuntime
runtime} -> Maybe AppSyncRuntime
runtime) (\s :: UpdateResolver
s@UpdateResolver' {} Maybe AppSyncRuntime
a -> UpdateResolver
s {$sel:runtime:UpdateResolver' :: Maybe AppSyncRuntime
runtime = Maybe AppSyncRuntime
a} :: UpdateResolver)

-- | The @SyncConfig@ for a resolver attached to a versioned data source.
updateResolver_syncConfig :: Lens.Lens' UpdateResolver (Prelude.Maybe SyncConfig)
updateResolver_syncConfig :: Lens' UpdateResolver (Maybe SyncConfig)
updateResolver_syncConfig = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\UpdateResolver' {Maybe SyncConfig
syncConfig :: Maybe SyncConfig
$sel:syncConfig:UpdateResolver' :: UpdateResolver -> Maybe SyncConfig
syncConfig} -> Maybe SyncConfig
syncConfig) (\s :: UpdateResolver
s@UpdateResolver' {} Maybe SyncConfig
a -> UpdateResolver
s {$sel:syncConfig:UpdateResolver' :: Maybe SyncConfig
syncConfig = Maybe SyncConfig
a} :: UpdateResolver)

-- | The API ID.
updateResolver_apiId :: Lens.Lens' UpdateResolver Prelude.Text
updateResolver_apiId :: Lens' UpdateResolver Text
updateResolver_apiId = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\UpdateResolver' {Text
apiId :: Text
$sel:apiId:UpdateResolver' :: UpdateResolver -> Text
apiId} -> Text
apiId) (\s :: UpdateResolver
s@UpdateResolver' {} Text
a -> UpdateResolver
s {$sel:apiId:UpdateResolver' :: Text
apiId = Text
a} :: UpdateResolver)

-- | The new type name.
updateResolver_typeName :: Lens.Lens' UpdateResolver Prelude.Text
updateResolver_typeName :: Lens' UpdateResolver Text
updateResolver_typeName = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\UpdateResolver' {Text
typeName :: Text
$sel:typeName:UpdateResolver' :: UpdateResolver -> Text
typeName} -> Text
typeName) (\s :: UpdateResolver
s@UpdateResolver' {} Text
a -> UpdateResolver
s {$sel:typeName:UpdateResolver' :: Text
typeName = Text
a} :: UpdateResolver)

-- | The new field name.
updateResolver_fieldName :: Lens.Lens' UpdateResolver Prelude.Text
updateResolver_fieldName :: Lens' UpdateResolver Text
updateResolver_fieldName = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\UpdateResolver' {Text
fieldName :: Text
$sel:fieldName:UpdateResolver' :: UpdateResolver -> Text
fieldName} -> Text
fieldName) (\s :: UpdateResolver
s@UpdateResolver' {} Text
a -> UpdateResolver
s {$sel:fieldName:UpdateResolver' :: Text
fieldName = Text
a} :: UpdateResolver)

instance Core.AWSRequest UpdateResolver where
  type
    AWSResponse UpdateResolver =
      UpdateResolverResponse
  request :: (Service -> Service) -> UpdateResolver -> Request UpdateResolver
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 UpdateResolver
-> ClientResponse ClientBody
-> m (Either Error (ClientResponse (AWSResponse UpdateResolver)))
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 Resolver -> Int -> UpdateResolverResponse
UpdateResolverResponse'
            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
"resolver")
            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 UpdateResolver where
  hashWithSalt :: Int -> UpdateResolver -> Int
hashWithSalt Int
_salt UpdateResolver' {Maybe Natural
Maybe Text
Maybe CachingConfig
Maybe PipelineConfig
Maybe ResolverKind
Maybe AppSyncRuntime
Maybe SyncConfig
Text
fieldName :: Text
typeName :: Text
apiId :: Text
syncConfig :: Maybe SyncConfig
runtime :: Maybe AppSyncRuntime
responseMappingTemplate :: Maybe Text
requestMappingTemplate :: Maybe Text
pipelineConfig :: Maybe PipelineConfig
maxBatchSize :: Maybe Natural
kind :: Maybe ResolverKind
dataSourceName :: Maybe Text
code :: Maybe Text
cachingConfig :: Maybe CachingConfig
$sel:fieldName:UpdateResolver' :: UpdateResolver -> Text
$sel:typeName:UpdateResolver' :: UpdateResolver -> Text
$sel:apiId:UpdateResolver' :: UpdateResolver -> Text
$sel:syncConfig:UpdateResolver' :: UpdateResolver -> Maybe SyncConfig
$sel:runtime:UpdateResolver' :: UpdateResolver -> Maybe AppSyncRuntime
$sel:responseMappingTemplate:UpdateResolver' :: UpdateResolver -> Maybe Text
$sel:requestMappingTemplate:UpdateResolver' :: UpdateResolver -> Maybe Text
$sel:pipelineConfig:UpdateResolver' :: UpdateResolver -> Maybe PipelineConfig
$sel:maxBatchSize:UpdateResolver' :: UpdateResolver -> Maybe Natural
$sel:kind:UpdateResolver' :: UpdateResolver -> Maybe ResolverKind
$sel:dataSourceName:UpdateResolver' :: UpdateResolver -> Maybe Text
$sel:code:UpdateResolver' :: UpdateResolver -> Maybe Text
$sel:cachingConfig:UpdateResolver' :: UpdateResolver -> Maybe CachingConfig
..} =
    Int
_salt
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe CachingConfig
cachingConfig
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
code
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
dataSourceName
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe ResolverKind
kind
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Natural
maxBatchSize
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe PipelineConfig
pipelineConfig
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
requestMappingTemplate
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
responseMappingTemplate
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe AppSyncRuntime
runtime
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe SyncConfig
syncConfig
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
apiId
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
typeName
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
fieldName

instance Prelude.NFData UpdateResolver where
  rnf :: UpdateResolver -> ()
rnf UpdateResolver' {Maybe Natural
Maybe Text
Maybe CachingConfig
Maybe PipelineConfig
Maybe ResolverKind
Maybe AppSyncRuntime
Maybe SyncConfig
Text
fieldName :: Text
typeName :: Text
apiId :: Text
syncConfig :: Maybe SyncConfig
runtime :: Maybe AppSyncRuntime
responseMappingTemplate :: Maybe Text
requestMappingTemplate :: Maybe Text
pipelineConfig :: Maybe PipelineConfig
maxBatchSize :: Maybe Natural
kind :: Maybe ResolverKind
dataSourceName :: Maybe Text
code :: Maybe Text
cachingConfig :: Maybe CachingConfig
$sel:fieldName:UpdateResolver' :: UpdateResolver -> Text
$sel:typeName:UpdateResolver' :: UpdateResolver -> Text
$sel:apiId:UpdateResolver' :: UpdateResolver -> Text
$sel:syncConfig:UpdateResolver' :: UpdateResolver -> Maybe SyncConfig
$sel:runtime:UpdateResolver' :: UpdateResolver -> Maybe AppSyncRuntime
$sel:responseMappingTemplate:UpdateResolver' :: UpdateResolver -> Maybe Text
$sel:requestMappingTemplate:UpdateResolver' :: UpdateResolver -> Maybe Text
$sel:pipelineConfig:UpdateResolver' :: UpdateResolver -> Maybe PipelineConfig
$sel:maxBatchSize:UpdateResolver' :: UpdateResolver -> Maybe Natural
$sel:kind:UpdateResolver' :: UpdateResolver -> Maybe ResolverKind
$sel:dataSourceName:UpdateResolver' :: UpdateResolver -> Maybe Text
$sel:code:UpdateResolver' :: UpdateResolver -> Maybe Text
$sel:cachingConfig:UpdateResolver' :: UpdateResolver -> Maybe CachingConfig
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe CachingConfig
cachingConfig
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
code
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
dataSourceName
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe ResolverKind
kind
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Natural
maxBatchSize
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe PipelineConfig
pipelineConfig
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
requestMappingTemplate
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
responseMappingTemplate
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe AppSyncRuntime
runtime
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe SyncConfig
syncConfig
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
apiId
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
typeName
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
fieldName

instance Data.ToHeaders UpdateResolver where
  toHeaders :: UpdateResolver -> ResponseHeaders
toHeaders =
    forall a b. a -> b -> a
Prelude.const
      ( forall a. Monoid a => [a] -> a
Prelude.mconcat
          [ HeaderName
"Content-Type"
              forall a. ToHeader a => HeaderName -> a -> ResponseHeaders
Data.=# ( ByteString
"application/x-amz-json-1.1" ::
                          Prelude.ByteString
                      )
          ]
      )

instance Data.ToJSON UpdateResolver where
  toJSON :: UpdateResolver -> Value
toJSON UpdateResolver' {Maybe Natural
Maybe Text
Maybe CachingConfig
Maybe PipelineConfig
Maybe ResolverKind
Maybe AppSyncRuntime
Maybe SyncConfig
Text
fieldName :: Text
typeName :: Text
apiId :: Text
syncConfig :: Maybe SyncConfig
runtime :: Maybe AppSyncRuntime
responseMappingTemplate :: Maybe Text
requestMappingTemplate :: Maybe Text
pipelineConfig :: Maybe PipelineConfig
maxBatchSize :: Maybe Natural
kind :: Maybe ResolverKind
dataSourceName :: Maybe Text
code :: Maybe Text
cachingConfig :: Maybe CachingConfig
$sel:fieldName:UpdateResolver' :: UpdateResolver -> Text
$sel:typeName:UpdateResolver' :: UpdateResolver -> Text
$sel:apiId:UpdateResolver' :: UpdateResolver -> Text
$sel:syncConfig:UpdateResolver' :: UpdateResolver -> Maybe SyncConfig
$sel:runtime:UpdateResolver' :: UpdateResolver -> Maybe AppSyncRuntime
$sel:responseMappingTemplate:UpdateResolver' :: UpdateResolver -> Maybe Text
$sel:requestMappingTemplate:UpdateResolver' :: UpdateResolver -> Maybe Text
$sel:pipelineConfig:UpdateResolver' :: UpdateResolver -> Maybe PipelineConfig
$sel:maxBatchSize:UpdateResolver' :: UpdateResolver -> Maybe Natural
$sel:kind:UpdateResolver' :: UpdateResolver -> Maybe ResolverKind
$sel:dataSourceName:UpdateResolver' :: UpdateResolver -> Maybe Text
$sel:code:UpdateResolver' :: UpdateResolver -> Maybe Text
$sel:cachingConfig:UpdateResolver' :: UpdateResolver -> Maybe CachingConfig
..} =
    [Pair] -> Value
Data.object
      ( forall a. [Maybe a] -> [a]
Prelude.catMaybes
          [ (Key
"cachingConfig" 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 CachingConfig
cachingConfig,
            (Key
"code" 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
code,
            (Key
"dataSourceName" 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
dataSourceName,
            (Key
"kind" 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 ResolverKind
kind,
            (Key
"maxBatchSize" 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 Natural
maxBatchSize,
            (Key
"pipelineConfig" 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 PipelineConfig
pipelineConfig,
            (Key
"requestMappingTemplate" 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
requestMappingTemplate,
            (Key
"responseMappingTemplate" 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
responseMappingTemplate,
            (Key
"runtime" 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 AppSyncRuntime
runtime,
            (Key
"syncConfig" 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 SyncConfig
syncConfig
          ]
      )

instance Data.ToPath UpdateResolver where
  toPath :: UpdateResolver -> ByteString
toPath UpdateResolver' {Maybe Natural
Maybe Text
Maybe CachingConfig
Maybe PipelineConfig
Maybe ResolverKind
Maybe AppSyncRuntime
Maybe SyncConfig
Text
fieldName :: Text
typeName :: Text
apiId :: Text
syncConfig :: Maybe SyncConfig
runtime :: Maybe AppSyncRuntime
responseMappingTemplate :: Maybe Text
requestMappingTemplate :: Maybe Text
pipelineConfig :: Maybe PipelineConfig
maxBatchSize :: Maybe Natural
kind :: Maybe ResolverKind
dataSourceName :: Maybe Text
code :: Maybe Text
cachingConfig :: Maybe CachingConfig
$sel:fieldName:UpdateResolver' :: UpdateResolver -> Text
$sel:typeName:UpdateResolver' :: UpdateResolver -> Text
$sel:apiId:UpdateResolver' :: UpdateResolver -> Text
$sel:syncConfig:UpdateResolver' :: UpdateResolver -> Maybe SyncConfig
$sel:runtime:UpdateResolver' :: UpdateResolver -> Maybe AppSyncRuntime
$sel:responseMappingTemplate:UpdateResolver' :: UpdateResolver -> Maybe Text
$sel:requestMappingTemplate:UpdateResolver' :: UpdateResolver -> Maybe Text
$sel:pipelineConfig:UpdateResolver' :: UpdateResolver -> Maybe PipelineConfig
$sel:maxBatchSize:UpdateResolver' :: UpdateResolver -> Maybe Natural
$sel:kind:UpdateResolver' :: UpdateResolver -> Maybe ResolverKind
$sel:dataSourceName:UpdateResolver' :: UpdateResolver -> Maybe Text
$sel:code:UpdateResolver' :: UpdateResolver -> Maybe Text
$sel:cachingConfig:UpdateResolver' :: UpdateResolver -> Maybe CachingConfig
..} =
    forall a. Monoid a => [a] -> a
Prelude.mconcat
      [ ByteString
"/v1/apis/",
        forall a. ToByteString a => a -> ByteString
Data.toBS Text
apiId,
        ByteString
"/types/",
        forall a. ToByteString a => a -> ByteString
Data.toBS Text
typeName,
        ByteString
"/resolvers/",
        forall a. ToByteString a => a -> ByteString
Data.toBS Text
fieldName
      ]

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

-- | /See:/ 'newUpdateResolverResponse' smart constructor.
data UpdateResolverResponse = UpdateResolverResponse'
  { -- | The updated @Resolver@ object.
    UpdateResolverResponse -> Maybe Resolver
resolver :: Prelude.Maybe Resolver,
    -- | The response's http status code.
    UpdateResolverResponse -> Int
httpStatus :: Prelude.Int
  }
  deriving (UpdateResolverResponse -> UpdateResolverResponse -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: UpdateResolverResponse -> UpdateResolverResponse -> Bool
$c/= :: UpdateResolverResponse -> UpdateResolverResponse -> Bool
== :: UpdateResolverResponse -> UpdateResolverResponse -> Bool
$c== :: UpdateResolverResponse -> UpdateResolverResponse -> Bool
Prelude.Eq, ReadPrec [UpdateResolverResponse]
ReadPrec UpdateResolverResponse
Int -> ReadS UpdateResolverResponse
ReadS [UpdateResolverResponse]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [UpdateResolverResponse]
$creadListPrec :: ReadPrec [UpdateResolverResponse]
readPrec :: ReadPrec UpdateResolverResponse
$creadPrec :: ReadPrec UpdateResolverResponse
readList :: ReadS [UpdateResolverResponse]
$creadList :: ReadS [UpdateResolverResponse]
readsPrec :: Int -> ReadS UpdateResolverResponse
$creadsPrec :: Int -> ReadS UpdateResolverResponse
Prelude.Read, Int -> UpdateResolverResponse -> ShowS
[UpdateResolverResponse] -> ShowS
UpdateResolverResponse -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [UpdateResolverResponse] -> ShowS
$cshowList :: [UpdateResolverResponse] -> ShowS
show :: UpdateResolverResponse -> String
$cshow :: UpdateResolverResponse -> String
showsPrec :: Int -> UpdateResolverResponse -> ShowS
$cshowsPrec :: Int -> UpdateResolverResponse -> ShowS
Prelude.Show, forall x. Rep UpdateResolverResponse x -> UpdateResolverResponse
forall x. UpdateResolverResponse -> Rep UpdateResolverResponse x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep UpdateResolverResponse x -> UpdateResolverResponse
$cfrom :: forall x. UpdateResolverResponse -> Rep UpdateResolverResponse x
Prelude.Generic)

-- |
-- Create a value of 'UpdateResolverResponse' 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:
--
-- 'resolver', 'updateResolverResponse_resolver' - The updated @Resolver@ object.
--
-- 'httpStatus', 'updateResolverResponse_httpStatus' - The response's http status code.
newUpdateResolverResponse ::
  -- | 'httpStatus'
  Prelude.Int ->
  UpdateResolverResponse
newUpdateResolverResponse :: Int -> UpdateResolverResponse
newUpdateResolverResponse Int
pHttpStatus_ =
  UpdateResolverResponse'
    { $sel:resolver:UpdateResolverResponse' :: Maybe Resolver
resolver = forall a. Maybe a
Prelude.Nothing,
      $sel:httpStatus:UpdateResolverResponse' :: Int
httpStatus = Int
pHttpStatus_
    }

-- | The updated @Resolver@ object.
updateResolverResponse_resolver :: Lens.Lens' UpdateResolverResponse (Prelude.Maybe Resolver)
updateResolverResponse_resolver :: Lens' UpdateResolverResponse (Maybe Resolver)
updateResolverResponse_resolver = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\UpdateResolverResponse' {Maybe Resolver
resolver :: Maybe Resolver
$sel:resolver:UpdateResolverResponse' :: UpdateResolverResponse -> Maybe Resolver
resolver} -> Maybe Resolver
resolver) (\s :: UpdateResolverResponse
s@UpdateResolverResponse' {} Maybe Resolver
a -> UpdateResolverResponse
s {$sel:resolver:UpdateResolverResponse' :: Maybe Resolver
resolver = Maybe Resolver
a} :: UpdateResolverResponse)

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

instance Prelude.NFData UpdateResolverResponse where
  rnf :: UpdateResolverResponse -> ()
rnf UpdateResolverResponse' {Int
Maybe Resolver
httpStatus :: Int
resolver :: Maybe Resolver
$sel:httpStatus:UpdateResolverResponse' :: UpdateResolverResponse -> Int
$sel:resolver:UpdateResolverResponse' :: UpdateResolverResponse -> Maybe Resolver
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe Resolver
resolver
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Int
httpStatus