module Dhall.Kubernetes.Types where

import qualified Data.Text    as Text
import qualified Data.Vector  as Vector
import qualified Dhall.Core   as Dhall
import qualified Dhall.Parser as Dhall

import Control.Applicative (optional)
import Control.Monad       (join)
import Data.Aeson
import Data.Map            (Map)
import Data.Scientific     (Scientific)
import Data.Set            (Set)
import Data.Text           (Text)
import GHC.Generics        (Generic)
import Prettyprinter       (Pretty)


type Expr = Dhall.Expr Dhall.Src Dhall.Import

type DuplicateHandler = (Text, [ModelName]) -> Maybe ModelName

type Prefix = Text

type ModelHierarchy = [ModelName]

{-| Type for the Swagger specification.

There is such a type defined in the `swagger2` package, but Kubernetes' OpenAPI
file doesn't conform to that, so here we implement a small version of that
tailored to our needs.

-}
data Swagger = Swagger
  { Swagger -> Map ModelName Definition
definitions :: Map ModelName Definition
  } deriving ((forall x. Swagger -> Rep Swagger x)
-> (forall x. Rep Swagger x -> Swagger) -> Generic Swagger
forall x. Rep Swagger x -> Swagger
forall x. Swagger -> Rep Swagger x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. Swagger -> Rep Swagger x
from :: forall x. Swagger -> Rep Swagger x
$cto :: forall x. Rep Swagger x -> Swagger
to :: forall x. Rep Swagger x -> Swagger
Generic, Int -> Swagger -> ShowS
[Swagger] -> ShowS
Swagger -> String
(Int -> Swagger -> ShowS)
-> (Swagger -> String) -> ([Swagger] -> ShowS) -> Show Swagger
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Swagger -> ShowS
showsPrec :: Int -> Swagger -> ShowS
$cshow :: Swagger -> String
show :: Swagger -> String
$cshowList :: [Swagger] -> ShowS
showList :: [Swagger] -> ShowS
Show)

instance FromJSON Swagger


data Definition = Definition
  { Definition -> Maybe Text
typ                  :: Maybe Text
  , Definition -> Maybe Ref
ref                  :: Maybe Ref
  , Definition -> Maybe Text
format               :: Maybe Text
  , Definition -> Maybe Scientific
minimum_             :: Maybe Scientific -- Avoid shadowing with Prelude.minimum
  , Definition -> Maybe Bool
exclusiveMinimum     :: Maybe Bool
  , Definition -> Maybe Scientific
maximum_             :: Maybe Scientific -- Avoid shadowing with Prelude.maximum
  , Definition -> Maybe Bool
exclusiveMaximum     :: Maybe Bool
  , Definition -> Maybe Text
description          :: Maybe Text
  , Definition -> Maybe Definition
items                :: Maybe Definition
  , Definition -> Maybe (Map ModelName Definition)
properties           :: Maybe (Map ModelName Definition)
  , Definition -> Maybe Definition
additionalProperties :: Maybe Definition
  , Definition -> Maybe (Set FieldName)
required             :: Maybe (Set FieldName)
  , Definition -> Maybe BaseData
baseData             :: Maybe BaseData
  , Definition -> Maybe Bool
intOrString          :: Maybe Bool
  } deriving ((forall x. Definition -> Rep Definition x)
-> (forall x. Rep Definition x -> Definition) -> Generic Definition
forall x. Rep Definition x -> Definition
forall x. Definition -> Rep Definition x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. Definition -> Rep Definition x
from :: forall x. Definition -> Rep Definition x
$cto :: forall x. Rep Definition x -> Definition
to :: forall x. Rep Definition x -> Definition
Generic, Int -> Definition -> ShowS
[Definition] -> ShowS
Definition -> String
(Int -> Definition -> ShowS)
-> (Definition -> String)
-> ([Definition] -> ShowS)
-> Show Definition
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Definition -> ShowS
showsPrec :: Int -> Definition -> ShowS
$cshow :: Definition -> String
show :: Definition -> String
$cshowList :: [Definition] -> ShowS
showList :: [Definition] -> ShowS
Show, Definition -> Definition -> Bool
(Definition -> Definition -> Bool)
-> (Definition -> Definition -> Bool) -> Eq Definition
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Definition -> Definition -> Bool
== :: Definition -> Definition -> Bool
$c/= :: Definition -> Definition -> Bool
/= :: Definition -> Definition -> Bool
Eq)

instance FromJSON Definition where
  parseJSON :: Value -> Parser Definition
parseJSON = String
-> (Object -> Parser Definition) -> Value -> Parser Definition
forall a. String -> (Object -> Parser a) -> Value -> Parser a
withObject String
"definition" ((Object -> Parser Definition) -> Value -> Parser Definition)
-> (Object -> Parser Definition) -> Value -> Parser Definition
forall a b. (a -> b) -> a -> b
$ \Object
o -> do
    Maybe Text
typ                  <- Object
o Object -> Key -> Parser (Maybe Text)
forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"type"
    Maybe Ref
ref                  <- Object
o Object -> Key -> Parser (Maybe Ref)
forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"$ref"
    Maybe Text
format               <- Object
o Object -> Key -> Parser (Maybe Text)
forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"format"
    Maybe Scientific
minimum_             <- Object
o Object -> Key -> Parser (Maybe Scientific)
forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"minimum"
    Maybe Bool
exclusiveMinimum     <- Object
o Object -> Key -> Parser (Maybe Bool)
forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"exclusiveMinimum"
    Maybe Scientific
maximum_             <- Object
o Object -> Key -> Parser (Maybe Scientific)
forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"maximum"
    Maybe Bool
exclusiveMaximum     <- Object
o Object -> Key -> Parser (Maybe Bool)
forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"exclusiveMaximum"
    Maybe (Map ModelName Definition)
properties           <- Object
o Object -> Key -> Parser (Maybe (Map ModelName Definition))
forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"properties"
    Maybe Definition
additionalProperties <- Object
o Object -> Key -> Parser (Maybe Definition)
forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"additionalProperties"
    Maybe (Set FieldName)
required             <- Object
o Object -> Key -> Parser (Maybe (Set FieldName))
forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"required"
    Maybe Definition
items                <- Object
o Object -> Key -> Parser (Maybe Definition)
forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"items"
    Maybe Text
description          <- Object
o Object -> Key -> Parser (Maybe Text)
forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"description"
    Maybe BaseData
baseData             <- (Maybe (Maybe BaseData) -> Maybe BaseData)
-> Parser (Maybe (Maybe BaseData)) -> Parser (Maybe BaseData)
forall a b. (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Maybe (Maybe BaseData) -> Maybe BaseData
forall (m :: * -> *) a. Monad m => m (m a) -> m a
join (Parser (Maybe (Maybe BaseData)) -> Parser (Maybe BaseData))
-> Parser (Maybe (Maybe BaseData)) -> Parser (Maybe BaseData)
forall a b. (a -> b) -> a -> b
$ Parser (Maybe BaseData) -> Parser (Maybe (Maybe BaseData))
forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional (Object
o Object -> Key -> Parser (Maybe BaseData)
forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"x-kubernetes-group-version-kind")
    Maybe Bool
intOrString          <- Object
o Object -> Key -> Parser (Maybe Bool)
forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"x-kubernetes-int-or-string"
    pure Definition{Maybe Bool
Maybe (Map ModelName Definition)
Maybe Text
Maybe Scientific
Maybe (Set FieldName)
Maybe BaseData
Maybe Ref
Maybe Definition
$sel:typ:Definition :: Maybe Text
$sel:ref:Definition :: Maybe Ref
$sel:format:Definition :: Maybe Text
$sel:minimum_:Definition :: Maybe Scientific
$sel:exclusiveMinimum:Definition :: Maybe Bool
$sel:maximum_:Definition :: Maybe Scientific
$sel:exclusiveMaximum:Definition :: Maybe Bool
$sel:description:Definition :: Maybe Text
$sel:items:Definition :: Maybe Definition
$sel:properties:Definition :: Maybe (Map ModelName Definition)
$sel:additionalProperties:Definition :: Maybe Definition
$sel:required:Definition :: Maybe (Set FieldName)
$sel:baseData:Definition :: Maybe BaseData
$sel:intOrString:Definition :: Maybe Bool
typ :: Maybe Text
ref :: Maybe Ref
format :: Maybe Text
minimum_ :: Maybe Scientific
exclusiveMinimum :: Maybe Bool
maximum_ :: Maybe Scientific
exclusiveMaximum :: Maybe Bool
properties :: Maybe (Map ModelName Definition)
additionalProperties :: Maybe Definition
required :: Maybe (Set FieldName)
items :: Maybe Definition
description :: Maybe Text
baseData :: Maybe BaseData
intOrString :: Maybe Bool
..}


newtype Ref = Ref { Ref -> Text
unRef :: Text }
  deriving ((forall x. Ref -> Rep Ref x)
-> (forall x. Rep Ref x -> Ref) -> Generic Ref
forall x. Rep Ref x -> Ref
forall x. Ref -> Rep Ref x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. Ref -> Rep Ref x
from :: forall x. Ref -> Rep Ref x
$cto :: forall x. Rep Ref x -> Ref
to :: forall x. Rep Ref x -> Ref
Generic, Int -> Ref -> ShowS
[Ref] -> ShowS
Ref -> String
(Int -> Ref -> ShowS)
-> (Ref -> String) -> ([Ref] -> ShowS) -> Show Ref
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Ref -> ShowS
showsPrec :: Int -> Ref -> ShowS
$cshow :: Ref -> String
show :: Ref -> String
$cshowList :: [Ref] -> ShowS
showList :: [Ref] -> ShowS
Show, Maybe Ref
Value -> Parser [Ref]
Value -> Parser Ref
(Value -> Parser Ref)
-> (Value -> Parser [Ref]) -> Maybe Ref -> FromJSON Ref
forall a.
(Value -> Parser a)
-> (Value -> Parser [a]) -> Maybe a -> FromJSON a
$cparseJSON :: Value -> Parser Ref
parseJSON :: Value -> Parser Ref
$cparseJSONList :: Value -> Parser [Ref]
parseJSONList :: Value -> Parser [Ref]
$comittedField :: Maybe Ref
omittedField :: Maybe Ref
FromJSON, Ref -> Ref -> Bool
(Ref -> Ref -> Bool) -> (Ref -> Ref -> Bool) -> Eq Ref
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Ref -> Ref -> Bool
== :: Ref -> Ref -> Bool
$c/= :: Ref -> Ref -> Bool
/= :: Ref -> Ref -> Bool
Eq)


newtype ModelName = ModelName { ModelName -> Text
unModelName :: Text }
  deriving ((forall x. ModelName -> Rep ModelName x)
-> (forall x. Rep ModelName x -> ModelName) -> Generic ModelName
forall x. Rep ModelName x -> ModelName
forall x. ModelName -> Rep ModelName x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. ModelName -> Rep ModelName x
from :: forall x. ModelName -> Rep ModelName x
$cto :: forall x. Rep ModelName x -> ModelName
to :: forall x. Rep ModelName x -> ModelName
Generic, Int -> ModelName -> ShowS
[ModelName] -> ShowS
ModelName -> String
(Int -> ModelName -> ShowS)
-> (ModelName -> String)
-> ([ModelName] -> ShowS)
-> Show ModelName
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ModelName -> ShowS
showsPrec :: Int -> ModelName -> ShowS
$cshow :: ModelName -> String
show :: ModelName -> String
$cshowList :: [ModelName] -> ShowS
showList :: [ModelName] -> ShowS
Show, Eq ModelName
Eq ModelName =>
(ModelName -> ModelName -> Ordering)
-> (ModelName -> ModelName -> Bool)
-> (ModelName -> ModelName -> Bool)
-> (ModelName -> ModelName -> Bool)
-> (ModelName -> ModelName -> Bool)
-> (ModelName -> ModelName -> ModelName)
-> (ModelName -> ModelName -> ModelName)
-> Ord ModelName
ModelName -> ModelName -> Bool
ModelName -> ModelName -> Ordering
ModelName -> ModelName -> ModelName
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: ModelName -> ModelName -> Ordering
compare :: ModelName -> ModelName -> Ordering
$c< :: ModelName -> ModelName -> Bool
< :: ModelName -> ModelName -> Bool
$c<= :: ModelName -> ModelName -> Bool
<= :: ModelName -> ModelName -> Bool
$c> :: ModelName -> ModelName -> Bool
> :: ModelName -> ModelName -> Bool
$c>= :: ModelName -> ModelName -> Bool
>= :: ModelName -> ModelName -> Bool
$cmax :: ModelName -> ModelName -> ModelName
max :: ModelName -> ModelName -> ModelName
$cmin :: ModelName -> ModelName -> ModelName
min :: ModelName -> ModelName -> ModelName
Ord, FromJSONKeyFunction [ModelName]
FromJSONKeyFunction ModelName
FromJSONKeyFunction ModelName
-> FromJSONKeyFunction [ModelName] -> FromJSONKey ModelName
forall a.
FromJSONKeyFunction a -> FromJSONKeyFunction [a] -> FromJSONKey a
$cfromJSONKey :: FromJSONKeyFunction ModelName
fromJSONKey :: FromJSONKeyFunction ModelName
$cfromJSONKeyList :: FromJSONKeyFunction [ModelName]
fromJSONKeyList :: FromJSONKeyFunction [ModelName]
FromJSONKey, ModelName -> ModelName -> Bool
(ModelName -> ModelName -> Bool)
-> (ModelName -> ModelName -> Bool) -> Eq ModelName
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ModelName -> ModelName -> Bool
== :: ModelName -> ModelName -> Bool
$c/= :: ModelName -> ModelName -> Bool
/= :: ModelName -> ModelName -> Bool
Eq, (forall ann. ModelName -> Doc ann)
-> (forall ann. [ModelName] -> Doc ann) -> Pretty ModelName
forall ann. [ModelName] -> Doc ann
forall ann. ModelName -> Doc ann
forall a.
(forall ann. a -> Doc ann)
-> (forall ann. [a] -> Doc ann) -> Pretty a
$cpretty :: forall ann. ModelName -> Doc ann
pretty :: forall ann. ModelName -> Doc ann
$cprettyList :: forall ann. [ModelName] -> Doc ann
prettyList :: forall ann. [ModelName] -> Doc ann
Pretty)

newtype FieldName = FieldName { FieldName -> Text
unFieldName :: Text }
  deriving ((forall x. FieldName -> Rep FieldName x)
-> (forall x. Rep FieldName x -> FieldName) -> Generic FieldName
forall x. Rep FieldName x -> FieldName
forall x. FieldName -> Rep FieldName x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. FieldName -> Rep FieldName x
from :: forall x. FieldName -> Rep FieldName x
$cto :: forall x. Rep FieldName x -> FieldName
to :: forall x. Rep FieldName x -> FieldName
Generic, Int -> FieldName -> ShowS
[FieldName] -> ShowS
FieldName -> String
(Int -> FieldName -> ShowS)
-> (FieldName -> String)
-> ([FieldName] -> ShowS)
-> Show FieldName
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> FieldName -> ShowS
showsPrec :: Int -> FieldName -> ShowS
$cshow :: FieldName -> String
show :: FieldName -> String
$cshowList :: [FieldName] -> ShowS
showList :: [FieldName] -> ShowS
Show, Maybe FieldName
Value -> Parser [FieldName]
Value -> Parser FieldName
(Value -> Parser FieldName)
-> (Value -> Parser [FieldName])
-> Maybe FieldName
-> FromJSON FieldName
forall a.
(Value -> Parser a)
-> (Value -> Parser [a]) -> Maybe a -> FromJSON a
$cparseJSON :: Value -> Parser FieldName
parseJSON :: Value -> Parser FieldName
$cparseJSONList :: Value -> Parser [FieldName]
parseJSONList :: Value -> Parser [FieldName]
$comittedField :: Maybe FieldName
omittedField :: Maybe FieldName
FromJSON, FromJSONKeyFunction [FieldName]
FromJSONKeyFunction FieldName
FromJSONKeyFunction FieldName
-> FromJSONKeyFunction [FieldName] -> FromJSONKey FieldName
forall a.
FromJSONKeyFunction a -> FromJSONKeyFunction [a] -> FromJSONKey a
$cfromJSONKey :: FromJSONKeyFunction FieldName
fromJSONKey :: FromJSONKeyFunction FieldName
$cfromJSONKeyList :: FromJSONKeyFunction [FieldName]
fromJSONKeyList :: FromJSONKeyFunction [FieldName]
FromJSONKey, Eq FieldName
Eq FieldName =>
(FieldName -> FieldName -> Ordering)
-> (FieldName -> FieldName -> Bool)
-> (FieldName -> FieldName -> Bool)
-> (FieldName -> FieldName -> Bool)
-> (FieldName -> FieldName -> Bool)
-> (FieldName -> FieldName -> FieldName)
-> (FieldName -> FieldName -> FieldName)
-> Ord FieldName
FieldName -> FieldName -> Bool
FieldName -> FieldName -> Ordering
FieldName -> FieldName -> FieldName
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: FieldName -> FieldName -> Ordering
compare :: FieldName -> FieldName -> Ordering
$c< :: FieldName -> FieldName -> Bool
< :: FieldName -> FieldName -> Bool
$c<= :: FieldName -> FieldName -> Bool
<= :: FieldName -> FieldName -> Bool
$c> :: FieldName -> FieldName -> Bool
> :: FieldName -> FieldName -> Bool
$c>= :: FieldName -> FieldName -> Bool
>= :: FieldName -> FieldName -> Bool
$cmax :: FieldName -> FieldName -> FieldName
max :: FieldName -> FieldName -> FieldName
$cmin :: FieldName -> FieldName -> FieldName
min :: FieldName -> FieldName -> FieldName
Ord, FieldName -> FieldName -> Bool
(FieldName -> FieldName -> Bool)
-> (FieldName -> FieldName -> Bool) -> Eq FieldName
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: FieldName -> FieldName -> Bool
== :: FieldName -> FieldName -> Bool
$c/= :: FieldName -> FieldName -> Bool
/= :: FieldName -> FieldName -> Bool
Eq, (forall ann. FieldName -> Doc ann)
-> (forall ann. [FieldName] -> Doc ann) -> Pretty FieldName
forall ann. [FieldName] -> Doc ann
forall ann. FieldName -> Doc ann
forall a.
(forall ann. a -> Doc ann)
-> (forall ann. [a] -> Doc ann) -> Pretty a
$cpretty :: forall ann. FieldName -> Doc ann
pretty :: forall ann. FieldName -> Doc ann
$cprettyList :: forall ann. [FieldName] -> Doc ann
prettyList :: forall ann. [FieldName] -> Doc ann
Pretty)


{-| This contains the static data that a Model might have

This applies only to kubernetes resources where ``kind`` and
``apiVersion`` are statically determined by the resource. See the
`Kubernetes OpenAPI Spec Readme`:
https://github.com/kubernetes/kubernetes/blob/master/api/openapi-spec/README.md#x-kubernetes-group-version-kind

For example for a v1 Deployment we have

{ kind = "Deployment"
, apiVersion = "apps/v1"
}

-}
data BaseData = BaseData
  { BaseData -> Text
kind       :: Text
  , BaseData -> Text
apiVersion :: Text
  } deriving ((forall x. BaseData -> Rep BaseData x)
-> (forall x. Rep BaseData x -> BaseData) -> Generic BaseData
forall x. Rep BaseData x -> BaseData
forall x. BaseData -> Rep BaseData x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. BaseData -> Rep BaseData x
from :: forall x. BaseData -> Rep BaseData x
$cto :: forall x. Rep BaseData x -> BaseData
to :: forall x. Rep BaseData x -> BaseData
Generic, Int -> BaseData -> ShowS
[BaseData] -> ShowS
BaseData -> String
(Int -> BaseData -> ShowS)
-> (BaseData -> String) -> ([BaseData] -> ShowS) -> Show BaseData
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> BaseData -> ShowS
showsPrec :: Int -> BaseData -> ShowS
$cshow :: BaseData -> String
show :: BaseData -> String
$cshowList :: [BaseData] -> ShowS
showList :: [BaseData] -> ShowS
Show, BaseData -> BaseData -> Bool
(BaseData -> BaseData -> Bool)
-> (BaseData -> BaseData -> Bool) -> Eq BaseData
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: BaseData -> BaseData -> Bool
== :: BaseData -> BaseData -> Bool
$c/= :: BaseData -> BaseData -> Bool
/= :: BaseData -> BaseData -> Bool
Eq)

instance FromJSON BaseData where
  parseJSON :: Value -> Parser BaseData
parseJSON = String -> (Array -> Parser BaseData) -> Value -> Parser BaseData
forall a. String -> (Array -> Parser a) -> Value -> Parser a
withArray String
"array of values" ((Array -> Parser BaseData) -> Value -> Parser BaseData)
-> (Array -> Parser BaseData) -> Value -> Parser BaseData
forall a b. (a -> b) -> a -> b
$ \Array
arr -> String -> (Object -> Parser BaseData) -> Value -> Parser BaseData
forall a. String -> (Object -> Parser a) -> Value -> Parser a
withObject String
"baseData" (\Object
o -> do
    Text
group   <- Object
o Object -> Key -> Parser (Maybe Text)
forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"group" Parser (Maybe Text) -> Text -> Parser Text
forall a. Parser (Maybe a) -> a -> Parser a
.!= Text
""
    Text
kind    <- Object
o Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"kind"
    Text
version <- Object
o Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"version"
    let apiVersion :: Text
apiVersion = (if Text -> Bool
Text.null Text
group then Text
"" else Text
group Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text
"/") Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text
version
    BaseData -> Parser BaseData
forall a. a -> Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure BaseData{Text
kind :: Text
apiVersion :: Text
kind :: Text
apiVersion :: Text
..})
    ([Value] -> Value
forall a. HasCallStack => [a] -> a
head ([Value] -> Value) -> [Value] -> Value
forall a b. (a -> b) -> a -> b
$ Array -> [Value]
forall a. Vector a -> [a]
Vector.toList Array
arr)