{-# 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.Glue.CreateScript
-- Copyright   : (c) 2013-2023 Brendan Hay
-- License     : Mozilla Public License, v. 2.0.
-- Maintainer  : Brendan Hay
-- Stability   : auto-generated
-- Portability : non-portable (GHC extensions)
--
-- Transforms a directed acyclic graph (DAG) into code.
module Amazonka.Glue.CreateScript
  ( -- * Creating a Request
    CreateScript (..),
    newCreateScript,

    -- * Request Lenses
    createScript_dagEdges,
    createScript_dagNodes,
    createScript_language,

    -- * Destructuring the Response
    CreateScriptResponse (..),
    newCreateScriptResponse,

    -- * Response Lenses
    createScriptResponse_pythonScript,
    createScriptResponse_scalaCode,
    createScriptResponse_httpStatus,
  )
where

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

-- | /See:/ 'newCreateScript' smart constructor.
data CreateScript = CreateScript'
  { -- | A list of the edges in the DAG.
    CreateScript -> Maybe [CodeGenEdge]
dagEdges :: Prelude.Maybe [CodeGenEdge],
    -- | A list of the nodes in the DAG.
    CreateScript -> Maybe [CodeGenNode]
dagNodes :: Prelude.Maybe [CodeGenNode],
    -- | The programming language of the resulting code from the DAG.
    CreateScript -> Maybe Language
language :: Prelude.Maybe Language
  }
  deriving (CreateScript -> CreateScript -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CreateScript -> CreateScript -> Bool
$c/= :: CreateScript -> CreateScript -> Bool
== :: CreateScript -> CreateScript -> Bool
$c== :: CreateScript -> CreateScript -> Bool
Prelude.Eq, ReadPrec [CreateScript]
ReadPrec CreateScript
Int -> ReadS CreateScript
ReadS [CreateScript]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [CreateScript]
$creadListPrec :: ReadPrec [CreateScript]
readPrec :: ReadPrec CreateScript
$creadPrec :: ReadPrec CreateScript
readList :: ReadS [CreateScript]
$creadList :: ReadS [CreateScript]
readsPrec :: Int -> ReadS CreateScript
$creadsPrec :: Int -> ReadS CreateScript
Prelude.Read, Int -> CreateScript -> ShowS
[CreateScript] -> ShowS
CreateScript -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CreateScript] -> ShowS
$cshowList :: [CreateScript] -> ShowS
show :: CreateScript -> String
$cshow :: CreateScript -> String
showsPrec :: Int -> CreateScript -> ShowS
$cshowsPrec :: Int -> CreateScript -> ShowS
Prelude.Show, forall x. Rep CreateScript x -> CreateScript
forall x. CreateScript -> Rep CreateScript x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep CreateScript x -> CreateScript
$cfrom :: forall x. CreateScript -> Rep CreateScript x
Prelude.Generic)

-- |
-- Create a value of 'CreateScript' 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:
--
-- 'dagEdges', 'createScript_dagEdges' - A list of the edges in the DAG.
--
-- 'dagNodes', 'createScript_dagNodes' - A list of the nodes in the DAG.
--
-- 'language', 'createScript_language' - The programming language of the resulting code from the DAG.
newCreateScript ::
  CreateScript
newCreateScript :: CreateScript
newCreateScript =
  CreateScript'
    { $sel:dagEdges:CreateScript' :: Maybe [CodeGenEdge]
dagEdges = forall a. Maybe a
Prelude.Nothing,
      $sel:dagNodes:CreateScript' :: Maybe [CodeGenNode]
dagNodes = forall a. Maybe a
Prelude.Nothing,
      $sel:language:CreateScript' :: Maybe Language
language = forall a. Maybe a
Prelude.Nothing
    }

-- | A list of the edges in the DAG.
createScript_dagEdges :: Lens.Lens' CreateScript (Prelude.Maybe [CodeGenEdge])
createScript_dagEdges :: Lens' CreateScript (Maybe [CodeGenEdge])
createScript_dagEdges = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateScript' {Maybe [CodeGenEdge]
dagEdges :: Maybe [CodeGenEdge]
$sel:dagEdges:CreateScript' :: CreateScript -> Maybe [CodeGenEdge]
dagEdges} -> Maybe [CodeGenEdge]
dagEdges) (\s :: CreateScript
s@CreateScript' {} Maybe [CodeGenEdge]
a -> CreateScript
s {$sel:dagEdges:CreateScript' :: Maybe [CodeGenEdge]
dagEdges = Maybe [CodeGenEdge]
a} :: CreateScript) 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

-- | A list of the nodes in the DAG.
createScript_dagNodes :: Lens.Lens' CreateScript (Prelude.Maybe [CodeGenNode])
createScript_dagNodes :: Lens' CreateScript (Maybe [CodeGenNode])
createScript_dagNodes = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateScript' {Maybe [CodeGenNode]
dagNodes :: Maybe [CodeGenNode]
$sel:dagNodes:CreateScript' :: CreateScript -> Maybe [CodeGenNode]
dagNodes} -> Maybe [CodeGenNode]
dagNodes) (\s :: CreateScript
s@CreateScript' {} Maybe [CodeGenNode]
a -> CreateScript
s {$sel:dagNodes:CreateScript' :: Maybe [CodeGenNode]
dagNodes = Maybe [CodeGenNode]
a} :: CreateScript) 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 programming language of the resulting code from the DAG.
createScript_language :: Lens.Lens' CreateScript (Prelude.Maybe Language)
createScript_language :: Lens' CreateScript (Maybe Language)
createScript_language = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateScript' {Maybe Language
language :: Maybe Language
$sel:language:CreateScript' :: CreateScript -> Maybe Language
language} -> Maybe Language
language) (\s :: CreateScript
s@CreateScript' {} Maybe Language
a -> CreateScript
s {$sel:language:CreateScript' :: Maybe Language
language = Maybe Language
a} :: CreateScript)

instance Core.AWSRequest CreateScript where
  type AWSResponse CreateScript = CreateScriptResponse
  request :: (Service -> Service) -> CreateScript -> Request CreateScript
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 CreateScript
-> ClientResponse ClientBody
-> m (Either Error (ClientResponse (AWSResponse CreateScript)))
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 Text -> Maybe Text -> Int -> CreateScriptResponse
CreateScriptResponse'
            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
"PythonScript")
            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
"ScalaCode")
            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 CreateScript where
  hashWithSalt :: Int -> CreateScript -> Int
hashWithSalt Int
_salt CreateScript' {Maybe [CodeGenEdge]
Maybe [CodeGenNode]
Maybe Language
language :: Maybe Language
dagNodes :: Maybe [CodeGenNode]
dagEdges :: Maybe [CodeGenEdge]
$sel:language:CreateScript' :: CreateScript -> Maybe Language
$sel:dagNodes:CreateScript' :: CreateScript -> Maybe [CodeGenNode]
$sel:dagEdges:CreateScript' :: CreateScript -> Maybe [CodeGenEdge]
..} =
    Int
_salt
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe [CodeGenEdge]
dagEdges
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe [CodeGenNode]
dagNodes
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Language
language

instance Prelude.NFData CreateScript where
  rnf :: CreateScript -> ()
rnf CreateScript' {Maybe [CodeGenEdge]
Maybe [CodeGenNode]
Maybe Language
language :: Maybe Language
dagNodes :: Maybe [CodeGenNode]
dagEdges :: Maybe [CodeGenEdge]
$sel:language:CreateScript' :: CreateScript -> Maybe Language
$sel:dagNodes:CreateScript' :: CreateScript -> Maybe [CodeGenNode]
$sel:dagEdges:CreateScript' :: CreateScript -> Maybe [CodeGenEdge]
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe [CodeGenEdge]
dagEdges
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe [CodeGenNode]
dagNodes
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Language
language

instance Data.ToHeaders CreateScript where
  toHeaders :: CreateScript -> 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
"AWSGlue.CreateScript" :: Prelude.ByteString),
            HeaderName
"Content-Type"
              forall a. ToHeader a => HeaderName -> a -> ResponseHeaders
Data.=# ( ByteString
"application/x-amz-json-1.1" ::
                          Prelude.ByteString
                      )
          ]
      )

instance Data.ToJSON CreateScript where
  toJSON :: CreateScript -> Value
toJSON CreateScript' {Maybe [CodeGenEdge]
Maybe [CodeGenNode]
Maybe Language
language :: Maybe Language
dagNodes :: Maybe [CodeGenNode]
dagEdges :: Maybe [CodeGenEdge]
$sel:language:CreateScript' :: CreateScript -> Maybe Language
$sel:dagNodes:CreateScript' :: CreateScript -> Maybe [CodeGenNode]
$sel:dagEdges:CreateScript' :: CreateScript -> Maybe [CodeGenEdge]
..} =
    [Pair] -> Value
Data.object
      ( forall a. [Maybe a] -> [a]
Prelude.catMaybes
          [ (Key
"DagEdges" 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 [CodeGenEdge]
dagEdges,
            (Key
"DagNodes" 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 [CodeGenNode]
dagNodes,
            (Key
"Language" 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 Language
language
          ]
      )

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

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

-- | /See:/ 'newCreateScriptResponse' smart constructor.
data CreateScriptResponse = CreateScriptResponse'
  { -- | The Python script generated from the DAG.
    CreateScriptResponse -> Maybe Text
pythonScript :: Prelude.Maybe Prelude.Text,
    -- | The Scala code generated from the DAG.
    CreateScriptResponse -> Maybe Text
scalaCode :: Prelude.Maybe Prelude.Text,
    -- | The response's http status code.
    CreateScriptResponse -> Int
httpStatus :: Prelude.Int
  }
  deriving (CreateScriptResponse -> CreateScriptResponse -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CreateScriptResponse -> CreateScriptResponse -> Bool
$c/= :: CreateScriptResponse -> CreateScriptResponse -> Bool
== :: CreateScriptResponse -> CreateScriptResponse -> Bool
$c== :: CreateScriptResponse -> CreateScriptResponse -> Bool
Prelude.Eq, ReadPrec [CreateScriptResponse]
ReadPrec CreateScriptResponse
Int -> ReadS CreateScriptResponse
ReadS [CreateScriptResponse]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [CreateScriptResponse]
$creadListPrec :: ReadPrec [CreateScriptResponse]
readPrec :: ReadPrec CreateScriptResponse
$creadPrec :: ReadPrec CreateScriptResponse
readList :: ReadS [CreateScriptResponse]
$creadList :: ReadS [CreateScriptResponse]
readsPrec :: Int -> ReadS CreateScriptResponse
$creadsPrec :: Int -> ReadS CreateScriptResponse
Prelude.Read, Int -> CreateScriptResponse -> ShowS
[CreateScriptResponse] -> ShowS
CreateScriptResponse -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CreateScriptResponse] -> ShowS
$cshowList :: [CreateScriptResponse] -> ShowS
show :: CreateScriptResponse -> String
$cshow :: CreateScriptResponse -> String
showsPrec :: Int -> CreateScriptResponse -> ShowS
$cshowsPrec :: Int -> CreateScriptResponse -> ShowS
Prelude.Show, forall x. Rep CreateScriptResponse x -> CreateScriptResponse
forall x. CreateScriptResponse -> Rep CreateScriptResponse x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep CreateScriptResponse x -> CreateScriptResponse
$cfrom :: forall x. CreateScriptResponse -> Rep CreateScriptResponse x
Prelude.Generic)

-- |
-- Create a value of 'CreateScriptResponse' 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:
--
-- 'pythonScript', 'createScriptResponse_pythonScript' - The Python script generated from the DAG.
--
-- 'scalaCode', 'createScriptResponse_scalaCode' - The Scala code generated from the DAG.
--
-- 'httpStatus', 'createScriptResponse_httpStatus' - The response's http status code.
newCreateScriptResponse ::
  -- | 'httpStatus'
  Prelude.Int ->
  CreateScriptResponse
newCreateScriptResponse :: Int -> CreateScriptResponse
newCreateScriptResponse Int
pHttpStatus_ =
  CreateScriptResponse'
    { $sel:pythonScript:CreateScriptResponse' :: Maybe Text
pythonScript =
        forall a. Maybe a
Prelude.Nothing,
      $sel:scalaCode:CreateScriptResponse' :: Maybe Text
scalaCode = forall a. Maybe a
Prelude.Nothing,
      $sel:httpStatus:CreateScriptResponse' :: Int
httpStatus = Int
pHttpStatus_
    }

-- | The Python script generated from the DAG.
createScriptResponse_pythonScript :: Lens.Lens' CreateScriptResponse (Prelude.Maybe Prelude.Text)
createScriptResponse_pythonScript :: Lens' CreateScriptResponse (Maybe Text)
createScriptResponse_pythonScript = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateScriptResponse' {Maybe Text
pythonScript :: Maybe Text
$sel:pythonScript:CreateScriptResponse' :: CreateScriptResponse -> Maybe Text
pythonScript} -> Maybe Text
pythonScript) (\s :: CreateScriptResponse
s@CreateScriptResponse' {} Maybe Text
a -> CreateScriptResponse
s {$sel:pythonScript:CreateScriptResponse' :: Maybe Text
pythonScript = Maybe Text
a} :: CreateScriptResponse)

-- | The Scala code generated from the DAG.
createScriptResponse_scalaCode :: Lens.Lens' CreateScriptResponse (Prelude.Maybe Prelude.Text)
createScriptResponse_scalaCode :: Lens' CreateScriptResponse (Maybe Text)
createScriptResponse_scalaCode = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateScriptResponse' {Maybe Text
scalaCode :: Maybe Text
$sel:scalaCode:CreateScriptResponse' :: CreateScriptResponse -> Maybe Text
scalaCode} -> Maybe Text
scalaCode) (\s :: CreateScriptResponse
s@CreateScriptResponse' {} Maybe Text
a -> CreateScriptResponse
s {$sel:scalaCode:CreateScriptResponse' :: Maybe Text
scalaCode = Maybe Text
a} :: CreateScriptResponse)

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

instance Prelude.NFData CreateScriptResponse where
  rnf :: CreateScriptResponse -> ()
rnf CreateScriptResponse' {Int
Maybe Text
httpStatus :: Int
scalaCode :: Maybe Text
pythonScript :: Maybe Text
$sel:httpStatus:CreateScriptResponse' :: CreateScriptResponse -> Int
$sel:scalaCode:CreateScriptResponse' :: CreateScriptResponse -> Maybe Text
$sel:pythonScript:CreateScriptResponse' :: CreateScriptResponse -> Maybe Text
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
pythonScript
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
scalaCode
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Int
httpStatus