{-# 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.CreateResolver
-- Copyright   : (c) 2013-2023 Brendan Hay
-- License     : Mozilla Public License, v. 2.0.
-- Maintainer  : Brendan Hay
-- Stability   : auto-generated
-- Portability : non-portable (GHC extensions)
--
-- Creates a @Resolver@ object.
--
-- A resolver converts incoming requests into a format that a data source
-- can understand, and converts the data source\'s responses into GraphQL.
module Amazonka.AppSync.CreateResolver
  ( -- * Creating a Request
    CreateResolver (..),
    newCreateResolver,

    -- * Request Lenses
    createResolver_cachingConfig,
    createResolver_code,
    createResolver_dataSourceName,
    createResolver_kind,
    createResolver_maxBatchSize,
    createResolver_pipelineConfig,
    createResolver_requestMappingTemplate,
    createResolver_responseMappingTemplate,
    createResolver_runtime,
    createResolver_syncConfig,
    createResolver_apiId,
    createResolver_typeName,
    createResolver_fieldName,

    -- * Destructuring the Response
    CreateResolverResponse (..),
    newCreateResolverResponse,

    -- * Response Lenses
    createResolverResponse_resolver,
    createResolverResponse_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:/ 'newCreateResolver' smart constructor.
data CreateResolver = CreateResolver'
  { -- | The caching configuration for the resolver.
    CreateResolver -> 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@.
    CreateResolver -> Maybe Text
code :: Prelude.Maybe Prelude.Text,
    -- | The name of the data source for which the resolver is being created.
    CreateResolver -> 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.
    CreateResolver -> Maybe ResolverKind
kind :: Prelude.Maybe ResolverKind,
    -- | The maximum batching size for a resolver.
    CreateResolver -> Maybe Natural
maxBatchSize :: Prelude.Maybe Prelude.Natural,
    -- | The @PipelineConfig@.
    CreateResolver -> Maybe PipelineConfig
pipelineConfig :: Prelude.Maybe PipelineConfig,
    -- | The mapping template to use for requests.
    --
    -- 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.
    CreateResolver -> Maybe Text
requestMappingTemplate :: Prelude.Maybe Prelude.Text,
    -- | The mapping template to use for responses from the data source.
    CreateResolver -> Maybe Text
responseMappingTemplate :: Prelude.Maybe Prelude.Text,
    CreateResolver -> Maybe AppSyncRuntime
runtime :: Prelude.Maybe AppSyncRuntime,
    -- | The @SyncConfig@ for a resolver attached to a versioned data source.
    CreateResolver -> Maybe SyncConfig
syncConfig :: Prelude.Maybe SyncConfig,
    -- | The ID for the GraphQL API for which the resolver is being created.
    CreateResolver -> Text
apiId :: Prelude.Text,
    -- | The name of the @Type@.
    CreateResolver -> Text
typeName :: Prelude.Text,
    -- | The name of the field to attach the resolver to.
    CreateResolver -> Text
fieldName :: Prelude.Text
  }
  deriving (CreateResolver -> CreateResolver -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CreateResolver -> CreateResolver -> Bool
$c/= :: CreateResolver -> CreateResolver -> Bool
== :: CreateResolver -> CreateResolver -> Bool
$c== :: CreateResolver -> CreateResolver -> Bool
Prelude.Eq, ReadPrec [CreateResolver]
ReadPrec CreateResolver
Int -> ReadS CreateResolver
ReadS [CreateResolver]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [CreateResolver]
$creadListPrec :: ReadPrec [CreateResolver]
readPrec :: ReadPrec CreateResolver
$creadPrec :: ReadPrec CreateResolver
readList :: ReadS [CreateResolver]
$creadList :: ReadS [CreateResolver]
readsPrec :: Int -> ReadS CreateResolver
$creadsPrec :: Int -> ReadS CreateResolver
Prelude.Read, Int -> CreateResolver -> ShowS
[CreateResolver] -> ShowS
CreateResolver -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CreateResolver] -> ShowS
$cshowList :: [CreateResolver] -> ShowS
show :: CreateResolver -> String
$cshow :: CreateResolver -> String
showsPrec :: Int -> CreateResolver -> ShowS
$cshowsPrec :: Int -> CreateResolver -> ShowS
Prelude.Show, forall x. Rep CreateResolver x -> CreateResolver
forall x. CreateResolver -> Rep CreateResolver x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep CreateResolver x -> CreateResolver
$cfrom :: forall x. CreateResolver -> Rep CreateResolver x
Prelude.Generic)

-- |
-- Create a value of 'CreateResolver' 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', 'createResolver_cachingConfig' - The caching configuration for the resolver.
--
-- 'code', 'createResolver_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', 'createResolver_dataSourceName' - The name of the data source for which the resolver is being created.
--
-- 'kind', 'createResolver_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', 'createResolver_maxBatchSize' - The maximum batching size for a resolver.
--
-- 'pipelineConfig', 'createResolver_pipelineConfig' - The @PipelineConfig@.
--
-- 'requestMappingTemplate', 'createResolver_requestMappingTemplate' - The mapping template to use for requests.
--
-- 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', 'createResolver_responseMappingTemplate' - The mapping template to use for responses from the data source.
--
-- 'runtime', 'createResolver_runtime' - Undocumented member.
--
-- 'syncConfig', 'createResolver_syncConfig' - The @SyncConfig@ for a resolver attached to a versioned data source.
--
-- 'apiId', 'createResolver_apiId' - The ID for the GraphQL API for which the resolver is being created.
--
-- 'typeName', 'createResolver_typeName' - The name of the @Type@.
--
-- 'fieldName', 'createResolver_fieldName' - The name of the field to attach the resolver to.
newCreateResolver ::
  -- | 'apiId'
  Prelude.Text ->
  -- | 'typeName'
  Prelude.Text ->
  -- | 'fieldName'
  Prelude.Text ->
  CreateResolver
newCreateResolver :: Text -> Text -> Text -> CreateResolver
newCreateResolver Text
pApiId_ Text
pTypeName_ Text
pFieldName_ =
  CreateResolver'
    { $sel:cachingConfig:CreateResolver' :: Maybe CachingConfig
cachingConfig = forall a. Maybe a
Prelude.Nothing,
      $sel:code:CreateResolver' :: Maybe Text
code = forall a. Maybe a
Prelude.Nothing,
      $sel:dataSourceName:CreateResolver' :: Maybe Text
dataSourceName = forall a. Maybe a
Prelude.Nothing,
      $sel:kind:CreateResolver' :: Maybe ResolverKind
kind = forall a. Maybe a
Prelude.Nothing,
      $sel:maxBatchSize:CreateResolver' :: Maybe Natural
maxBatchSize = forall a. Maybe a
Prelude.Nothing,
      $sel:pipelineConfig:CreateResolver' :: Maybe PipelineConfig
pipelineConfig = forall a. Maybe a
Prelude.Nothing,
      $sel:requestMappingTemplate:CreateResolver' :: Maybe Text
requestMappingTemplate = forall a. Maybe a
Prelude.Nothing,
      $sel:responseMappingTemplate:CreateResolver' :: Maybe Text
responseMappingTemplate = forall a. Maybe a
Prelude.Nothing,
      $sel:runtime:CreateResolver' :: Maybe AppSyncRuntime
runtime = forall a. Maybe a
Prelude.Nothing,
      $sel:syncConfig:CreateResolver' :: Maybe SyncConfig
syncConfig = forall a. Maybe a
Prelude.Nothing,
      $sel:apiId:CreateResolver' :: Text
apiId = Text
pApiId_,
      $sel:typeName:CreateResolver' :: Text
typeName = Text
pTypeName_,
      $sel:fieldName:CreateResolver' :: Text
fieldName = Text
pFieldName_
    }

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

-- | 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@.
createResolver_code :: Lens.Lens' CreateResolver (Prelude.Maybe Prelude.Text)
createResolver_code :: Lens' CreateResolver (Maybe Text)
createResolver_code = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateResolver' {Maybe Text
code :: Maybe Text
$sel:code:CreateResolver' :: CreateResolver -> Maybe Text
code} -> Maybe Text
code) (\s :: CreateResolver
s@CreateResolver' {} Maybe Text
a -> CreateResolver
s {$sel:code:CreateResolver' :: Maybe Text
code = Maybe Text
a} :: CreateResolver)

-- | The name of the data source for which the resolver is being created.
createResolver_dataSourceName :: Lens.Lens' CreateResolver (Prelude.Maybe Prelude.Text)
createResolver_dataSourceName :: Lens' CreateResolver (Maybe Text)
createResolver_dataSourceName = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateResolver' {Maybe Text
dataSourceName :: Maybe Text
$sel:dataSourceName:CreateResolver' :: CreateResolver -> Maybe Text
dataSourceName} -> Maybe Text
dataSourceName) (\s :: CreateResolver
s@CreateResolver' {} Maybe Text
a -> CreateResolver
s {$sel:dataSourceName:CreateResolver' :: Maybe Text
dataSourceName = Maybe Text
a} :: CreateResolver)

-- | 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.
createResolver_kind :: Lens.Lens' CreateResolver (Prelude.Maybe ResolverKind)
createResolver_kind :: Lens' CreateResolver (Maybe ResolverKind)
createResolver_kind = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateResolver' {Maybe ResolverKind
kind :: Maybe ResolverKind
$sel:kind:CreateResolver' :: CreateResolver -> Maybe ResolverKind
kind} -> Maybe ResolverKind
kind) (\s :: CreateResolver
s@CreateResolver' {} Maybe ResolverKind
a -> CreateResolver
s {$sel:kind:CreateResolver' :: Maybe ResolverKind
kind = Maybe ResolverKind
a} :: CreateResolver)

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

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

-- | The mapping template to use for requests.
--
-- 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.
createResolver_requestMappingTemplate :: Lens.Lens' CreateResolver (Prelude.Maybe Prelude.Text)
createResolver_requestMappingTemplate :: Lens' CreateResolver (Maybe Text)
createResolver_requestMappingTemplate = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateResolver' {Maybe Text
requestMappingTemplate :: Maybe Text
$sel:requestMappingTemplate:CreateResolver' :: CreateResolver -> Maybe Text
requestMappingTemplate} -> Maybe Text
requestMappingTemplate) (\s :: CreateResolver
s@CreateResolver' {} Maybe Text
a -> CreateResolver
s {$sel:requestMappingTemplate:CreateResolver' :: Maybe Text
requestMappingTemplate = Maybe Text
a} :: CreateResolver)

-- | The mapping template to use for responses from the data source.
createResolver_responseMappingTemplate :: Lens.Lens' CreateResolver (Prelude.Maybe Prelude.Text)
createResolver_responseMappingTemplate :: Lens' CreateResolver (Maybe Text)
createResolver_responseMappingTemplate = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateResolver' {Maybe Text
responseMappingTemplate :: Maybe Text
$sel:responseMappingTemplate:CreateResolver' :: CreateResolver -> Maybe Text
responseMappingTemplate} -> Maybe Text
responseMappingTemplate) (\s :: CreateResolver
s@CreateResolver' {} Maybe Text
a -> CreateResolver
s {$sel:responseMappingTemplate:CreateResolver' :: Maybe Text
responseMappingTemplate = Maybe Text
a} :: CreateResolver)

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

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

-- | The ID for the GraphQL API for which the resolver is being created.
createResolver_apiId :: Lens.Lens' CreateResolver Prelude.Text
createResolver_apiId :: Lens' CreateResolver Text
createResolver_apiId = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateResolver' {Text
apiId :: Text
$sel:apiId:CreateResolver' :: CreateResolver -> Text
apiId} -> Text
apiId) (\s :: CreateResolver
s@CreateResolver' {} Text
a -> CreateResolver
s {$sel:apiId:CreateResolver' :: Text
apiId = Text
a} :: CreateResolver)

-- | The name of the @Type@.
createResolver_typeName :: Lens.Lens' CreateResolver Prelude.Text
createResolver_typeName :: Lens' CreateResolver Text
createResolver_typeName = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateResolver' {Text
typeName :: Text
$sel:typeName:CreateResolver' :: CreateResolver -> Text
typeName} -> Text
typeName) (\s :: CreateResolver
s@CreateResolver' {} Text
a -> CreateResolver
s {$sel:typeName:CreateResolver' :: Text
typeName = Text
a} :: CreateResolver)

-- | The name of the field to attach the resolver to.
createResolver_fieldName :: Lens.Lens' CreateResolver Prelude.Text
createResolver_fieldName :: Lens' CreateResolver Text
createResolver_fieldName = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateResolver' {Text
fieldName :: Text
$sel:fieldName:CreateResolver' :: CreateResolver -> Text
fieldName} -> Text
fieldName) (\s :: CreateResolver
s@CreateResolver' {} Text
a -> CreateResolver
s {$sel:fieldName:CreateResolver' :: Text
fieldName = Text
a} :: CreateResolver)

instance Core.AWSRequest CreateResolver where
  type
    AWSResponse CreateResolver =
      CreateResolverResponse
  request :: (Service -> Service) -> CreateResolver -> Request CreateResolver
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 CreateResolver
-> ClientResponse ClientBody
-> m (Either Error (ClientResponse (AWSResponse CreateResolver)))
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 -> CreateResolverResponse
CreateResolverResponse'
            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 CreateResolver where
  hashWithSalt :: Int -> CreateResolver -> Int
hashWithSalt Int
_salt CreateResolver' {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:CreateResolver' :: CreateResolver -> Text
$sel:typeName:CreateResolver' :: CreateResolver -> Text
$sel:apiId:CreateResolver' :: CreateResolver -> Text
$sel:syncConfig:CreateResolver' :: CreateResolver -> Maybe SyncConfig
$sel:runtime:CreateResolver' :: CreateResolver -> Maybe AppSyncRuntime
$sel:responseMappingTemplate:CreateResolver' :: CreateResolver -> Maybe Text
$sel:requestMappingTemplate:CreateResolver' :: CreateResolver -> Maybe Text
$sel:pipelineConfig:CreateResolver' :: CreateResolver -> Maybe PipelineConfig
$sel:maxBatchSize:CreateResolver' :: CreateResolver -> Maybe Natural
$sel:kind:CreateResolver' :: CreateResolver -> Maybe ResolverKind
$sel:dataSourceName:CreateResolver' :: CreateResolver -> Maybe Text
$sel:code:CreateResolver' :: CreateResolver -> Maybe Text
$sel:cachingConfig:CreateResolver' :: CreateResolver -> 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 CreateResolver where
  rnf :: CreateResolver -> ()
rnf CreateResolver' {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:CreateResolver' :: CreateResolver -> Text
$sel:typeName:CreateResolver' :: CreateResolver -> Text
$sel:apiId:CreateResolver' :: CreateResolver -> Text
$sel:syncConfig:CreateResolver' :: CreateResolver -> Maybe SyncConfig
$sel:runtime:CreateResolver' :: CreateResolver -> Maybe AppSyncRuntime
$sel:responseMappingTemplate:CreateResolver' :: CreateResolver -> Maybe Text
$sel:requestMappingTemplate:CreateResolver' :: CreateResolver -> Maybe Text
$sel:pipelineConfig:CreateResolver' :: CreateResolver -> Maybe PipelineConfig
$sel:maxBatchSize:CreateResolver' :: CreateResolver -> Maybe Natural
$sel:kind:CreateResolver' :: CreateResolver -> Maybe ResolverKind
$sel:dataSourceName:CreateResolver' :: CreateResolver -> Maybe Text
$sel:code:CreateResolver' :: CreateResolver -> Maybe Text
$sel:cachingConfig:CreateResolver' :: CreateResolver -> 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 CreateResolver where
  toHeaders :: CreateResolver -> 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 CreateResolver where
  toJSON :: CreateResolver -> Value
toJSON CreateResolver' {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:CreateResolver' :: CreateResolver -> Text
$sel:typeName:CreateResolver' :: CreateResolver -> Text
$sel:apiId:CreateResolver' :: CreateResolver -> Text
$sel:syncConfig:CreateResolver' :: CreateResolver -> Maybe SyncConfig
$sel:runtime:CreateResolver' :: CreateResolver -> Maybe AppSyncRuntime
$sel:responseMappingTemplate:CreateResolver' :: CreateResolver -> Maybe Text
$sel:requestMappingTemplate:CreateResolver' :: CreateResolver -> Maybe Text
$sel:pipelineConfig:CreateResolver' :: CreateResolver -> Maybe PipelineConfig
$sel:maxBatchSize:CreateResolver' :: CreateResolver -> Maybe Natural
$sel:kind:CreateResolver' :: CreateResolver -> Maybe ResolverKind
$sel:dataSourceName:CreateResolver' :: CreateResolver -> Maybe Text
$sel:code:CreateResolver' :: CreateResolver -> Maybe Text
$sel:cachingConfig:CreateResolver' :: CreateResolver -> 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,
            forall a. a -> Maybe a
Prelude.Just (Key
"fieldName" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= Text
fieldName)
          ]
      )

instance Data.ToPath CreateResolver where
  toPath :: CreateResolver -> ByteString
toPath CreateResolver' {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:CreateResolver' :: CreateResolver -> Text
$sel:typeName:CreateResolver' :: CreateResolver -> Text
$sel:apiId:CreateResolver' :: CreateResolver -> Text
$sel:syncConfig:CreateResolver' :: CreateResolver -> Maybe SyncConfig
$sel:runtime:CreateResolver' :: CreateResolver -> Maybe AppSyncRuntime
$sel:responseMappingTemplate:CreateResolver' :: CreateResolver -> Maybe Text
$sel:requestMappingTemplate:CreateResolver' :: CreateResolver -> Maybe Text
$sel:pipelineConfig:CreateResolver' :: CreateResolver -> Maybe PipelineConfig
$sel:maxBatchSize:CreateResolver' :: CreateResolver -> Maybe Natural
$sel:kind:CreateResolver' :: CreateResolver -> Maybe ResolverKind
$sel:dataSourceName:CreateResolver' :: CreateResolver -> Maybe Text
$sel:code:CreateResolver' :: CreateResolver -> Maybe Text
$sel:cachingConfig:CreateResolver' :: CreateResolver -> 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"
      ]

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

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

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

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

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

instance Prelude.NFData CreateResolverResponse where
  rnf :: CreateResolverResponse -> ()
rnf CreateResolverResponse' {Int
Maybe Resolver
httpStatus :: Int
resolver :: Maybe Resolver
$sel:httpStatus:CreateResolverResponse' :: CreateResolverResponse -> Int
$sel:resolver:CreateResolverResponse' :: CreateResolverResponse -> 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