{-# LANGUAGE BlockArguments #-}
{-# LANGUAGE DataKinds #-}
{-# LANGUAGE TypeApplications #-}

{- HLINT ignore "Redundant flip" -}

module Data.RdsData.Encode.Param
  ( EncodeParam(..)

  , rdsParam

  , named
  , typed

  , maybe

  , array
  , bool
  , bytestring
  , double
  , integer
  , null
  , text

  , base64
  , day
  , int
  , int16
  , int32
  , int64
  , int8
  , json
  , lazyBytestring
  , lazyText
  , timeOfDay
  , ulid
  , utcTime
  , uuid
  , word
  , word16
  , word32
  , word64
  , word8
  ) where

import Control.Lens
import Data.ByteString (ByteString)
import Data.Functor.Contravariant
import Data.Generics.Product.Any
import Data.Int
import Data.RdsData.Encode.Array
import Data.RdsData.Types.Value
import Data.RdsData.Types.Param
import Data.Text (Text)
import Data.Time
import Data.ULID (ULID)
import Data.UUID (UUID)
import Data.Word
import Prelude hiding (maybe, null)

import qualified Amazonka.Bytes                 as AWS
import qualified Amazonka.Data.Base64           as AWS
import qualified Amazonka.RDSData               as AWS
import qualified Data.Aeson                     as J
import qualified Data.ByteString.Lazy           as LBS
import qualified Data.RdsData.Internal.Convert  as CONV
import qualified Data.Text.Lazy                 as LT
import qualified Prelude                        as P

newtype EncodeParam a = EncodeParam
  { forall a. EncodeParam a -> a -> Param
encodeParam :: a -> Param
  }

instance Contravariant EncodeParam where
  contramap :: forall a' a. (a' -> a) -> EncodeParam a -> EncodeParam a'
contramap a' -> a
f (EncodeParam a -> Param
g) =
    (a' -> Param) -> EncodeParam a'
forall a. (a -> Param) -> EncodeParam a
EncodeParam (a -> Param
g (a -> Param) -> (a' -> a) -> a' -> Param
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a' -> a
f)

--------------------------------------------------------------------------------

named :: Text -> EncodeParam a -> EncodeParam a
named :: forall a. Text -> EncodeParam a -> EncodeParam a
named Text
n (EncodeParam a -> Param
f) =
  (a -> Param) -> EncodeParam a
forall a. (a -> Param) -> EncodeParam a
EncodeParam \a
a -> a -> Param
f a
a Param -> (Param -> Param) -> Param
forall a b. a -> (a -> b) -> b
& forall {k} (sel :: k) s t a b. HasAny sel s t a b => Lens s t a b
forall (sel :: Symbol) s t a b. HasAny sel s t a b => Lens s t a b
the @"name" ((Maybe Text -> Identity (Maybe Text)) -> Param -> Identity Param)
-> Maybe Text -> Param -> Param
forall s t a b. ASetter s t a b -> b -> s -> t
.~ Text -> Maybe Text
forall a. a -> Maybe a
Just Text
n

typed :: AWS.TypeHint -> EncodeParam a -> EncodeParam a
typed :: forall a. TypeHint -> EncodeParam a -> EncodeParam a
typed TypeHint
t (EncodeParam a -> Param
f) =
  (a -> Param) -> EncodeParam a
forall a. (a -> Param) -> EncodeParam a
EncodeParam \a
a -> a -> Param
f a
a Param -> (Param -> Param) -> Param
forall a b. a -> (a -> b) -> b
& forall {k} (sel :: k) s t a b. HasAny sel s t a b => Lens s t a b
forall (sel :: Symbol) s t a b. HasAny sel s t a b => Lens s t a b
the @"hint" ((Maybe TypeHint -> Identity (Maybe TypeHint))
 -> Param -> Identity Param)
-> Maybe TypeHint -> Param -> Param
forall s t a b. ASetter s t a b -> b -> s -> t
.~ TypeHint -> Maybe TypeHint
forall a. a -> Maybe a
Just TypeHint
t

rdsParam :: EncodeParam Param
rdsParam :: EncodeParam Param
rdsParam =
  (Param -> Param) -> EncodeParam Param
forall a. (a -> Param) -> EncodeParam a
EncodeParam Param -> Param
forall a. a -> a
id

--------------------------------------------------------------------------------

maybe :: EncodeParam a -> EncodeParam (Maybe a)
maybe :: forall a. EncodeParam a -> EncodeParam (Maybe a)
maybe =
  (Maybe a -> Param) -> EncodeParam (Maybe a)
forall a. (a -> Param) -> EncodeParam a
EncodeParam ((Maybe a -> Param) -> EncodeParam (Maybe a))
-> (EncodeParam a -> Maybe a -> Param)
-> EncodeParam a
-> EncodeParam (Maybe a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Param -> (a -> Param) -> Maybe a -> Param
forall b a. b -> (a -> b) -> Maybe a -> b
P.maybe (Maybe Text -> Maybe TypeHint -> Value -> Param
Param Maybe Text
forall a. Maybe a
Nothing Maybe TypeHint
forall a. Maybe a
Nothing Value
ValueOfNull) ((a -> Param) -> Maybe a -> Param)
-> (EncodeParam a -> a -> Param)
-> EncodeParam a
-> Maybe a
-> Param
forall b c a. (b -> c) -> (a -> b) -> a -> c
. EncodeParam a -> a -> Param
forall a. EncodeParam a -> a -> Param
encodeParam

--------------------------------------------------------------------------------

array :: EncodeArray a -> EncodeParam a
array :: forall a. EncodeArray a -> EncodeParam a
array EncodeArray a
enc =
  Maybe Text -> Maybe TypeHint -> Value -> Param
Param Maybe Text
forall a. Maybe a
Nothing Maybe TypeHint
forall a. Maybe a
Nothing (Value -> Param) -> (a -> Value) -> a -> Param
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Array -> Value
ValueOfArray (Array -> Value) -> (a -> Array) -> a -> Value
forall b c a. (b -> c) -> (a -> b) -> a -> c
. EncodeArray a -> a -> Array
forall a. EncodeArray a -> a -> Array
encodeArray EncodeArray a
enc (a -> Param) -> EncodeParam Param -> EncodeParam a
forall (f :: * -> *) a b. Contravariant f => (a -> b) -> f b -> f a
>$< EncodeParam Param
rdsParam

base64 :: EncodeParam AWS.Base64
base64 :: EncodeParam Base64
base64 =
  Maybe Text -> Maybe TypeHint -> Value -> Param
Param Maybe Text
forall a. Maybe a
Nothing Maybe TypeHint
forall a. Maybe a
Nothing (Value -> Param) -> (Base64 -> Value) -> Base64 -> Param
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Base64 -> Value
ValueOfBase64 (Base64 -> Param) -> EncodeParam Param -> EncodeParam Base64
forall (f :: * -> *) a b. Contravariant f => (a -> b) -> f b -> f a
>$< EncodeParam Param
rdsParam

bool :: EncodeParam Bool
bool :: EncodeParam Bool
bool =
  Maybe Text -> Maybe TypeHint -> Value -> Param
Param Maybe Text
forall a. Maybe a
Nothing Maybe TypeHint
forall a. Maybe a
Nothing (Value -> Param) -> (Bool -> Value) -> Bool -> Param
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Value
ValueOfBool (Bool -> Param) -> EncodeParam Param -> EncodeParam Bool
forall (f :: * -> *) a b. Contravariant f => (a -> b) -> f b -> f a
>$< EncodeParam Param
rdsParam

double :: EncodeParam Double
double :: EncodeParam Double
double =
  Maybe Text -> Maybe TypeHint -> Value -> Param
Param Maybe Text
forall a. Maybe a
Nothing Maybe TypeHint
forall a. Maybe a
Nothing (Value -> Param) -> (Double -> Value) -> Double -> Param
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Double -> Value
ValueOfDouble (Double -> Param) -> EncodeParam Param -> EncodeParam Double
forall (f :: * -> *) a b. Contravariant f => (a -> b) -> f b -> f a
>$< EncodeParam Param
rdsParam

null :: EncodeParam ()
null :: EncodeParam ()
null =
  Maybe Text -> Maybe TypeHint -> Value -> Param
Param Maybe Text
forall a. Maybe a
Nothing Maybe TypeHint
forall a. Maybe a
Nothing (Value -> Param) -> (() -> Value) -> () -> Param
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Value -> () -> Value
forall a b. a -> b -> a
const Value
ValueOfNull (() -> Param) -> EncodeParam Param -> EncodeParam ()
forall (f :: * -> *) a b. Contravariant f => (a -> b) -> f b -> f a
>$< EncodeParam Param
rdsParam

integer :: EncodeParam Integer
integer :: EncodeParam Integer
integer =
  Maybe Text -> Maybe TypeHint -> Value -> Param
Param Maybe Text
forall a. Maybe a
Nothing Maybe TypeHint
forall a. Maybe a
Nothing (Value -> Param) -> (Integer -> Value) -> Integer -> Param
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Integer -> Value
ValueOfInteger (Integer -> Param) -> EncodeParam Param -> EncodeParam Integer
forall (f :: * -> *) a b. Contravariant f => (a -> b) -> f b -> f a
>$< EncodeParam Param
rdsParam

text :: EncodeParam Text
text :: EncodeParam Text
text =
  Maybe Text -> Maybe TypeHint -> Value -> Param
Param Maybe Text
forall a. Maybe a
Nothing Maybe TypeHint
forall a. Maybe a
Nothing (Value -> Param) -> (Text -> Value) -> Text -> Param
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> Value
ValueOfText (Text -> Param) -> EncodeParam Param -> EncodeParam Text
forall (f :: * -> *) a b. Contravariant f => (a -> b) -> f b -> f a
>$< EncodeParam Param
rdsParam

--------------------------------------------------------------------------------

int :: EncodeParam Int
int :: EncodeParam Int
int =
  Int -> Integer
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> Integer) -> EncodeParam Integer -> EncodeParam Int
forall (f :: * -> *) a b. Contravariant f => (a -> b) -> f b -> f a
>$< EncodeParam Integer
integer

int8 :: EncodeParam Int8
int8 :: EncodeParam Int8
int8 =
  Int8 -> Integer
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int8 -> Integer) -> EncodeParam Integer -> EncodeParam Int8
forall (f :: * -> *) a b. Contravariant f => (a -> b) -> f b -> f a
>$< EncodeParam Integer
integer

int16 :: EncodeParam Int16
int16 :: EncodeParam Int16
int16 =
  Int16 -> Integer
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int16 -> Integer) -> EncodeParam Integer -> EncodeParam Int16
forall (f :: * -> *) a b. Contravariant f => (a -> b) -> f b -> f a
>$< EncodeParam Integer
integer

int32 :: EncodeParam Int32
int32 :: EncodeParam Int32
int32 =
  Int32 -> Integer
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int32 -> Integer) -> EncodeParam Integer -> EncodeParam Int32
forall (f :: * -> *) a b. Contravariant f => (a -> b) -> f b -> f a
>$< EncodeParam Integer
integer

int64 :: EncodeParam Int64
int64 :: EncodeParam Int64
int64 =
  Int64 -> Integer
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int64 -> Integer) -> EncodeParam Integer -> EncodeParam Int64
forall (f :: * -> *) a b. Contravariant f => (a -> b) -> f b -> f a
>$< EncodeParam Integer
integer

word :: EncodeParam Word
word :: EncodeParam Word
word =
  Word -> Integer
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Word -> Integer) -> EncodeParam Integer -> EncodeParam Word
forall (f :: * -> *) a b. Contravariant f => (a -> b) -> f b -> f a
>$< EncodeParam Integer
integer

word8 :: EncodeParam Word8
word8 :: EncodeParam Word8
word8 =
  Word8 -> Integer
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Word8 -> Integer) -> EncodeParam Integer -> EncodeParam Word8
forall (f :: * -> *) a b. Contravariant f => (a -> b) -> f b -> f a
>$< EncodeParam Integer
integer

word16 :: EncodeParam Word16
word16 :: EncodeParam Word16
word16 =
  Word16 -> Integer
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Word16 -> Integer) -> EncodeParam Integer -> EncodeParam Word16
forall (f :: * -> *) a b. Contravariant f => (a -> b) -> f b -> f a
>$< EncodeParam Integer
integer

word32 :: EncodeParam Word32
word32 :: EncodeParam Word32
word32 =
  Word32 -> Integer
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Word32 -> Integer) -> EncodeParam Integer -> EncodeParam Word32
forall (f :: * -> *) a b. Contravariant f => (a -> b) -> f b -> f a
>$< EncodeParam Integer
integer

word64 :: EncodeParam Word64
word64 :: EncodeParam Word64
word64 =
  Word64 -> Integer
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Word64 -> Integer) -> EncodeParam Integer -> EncodeParam Word64
forall (f :: * -> *) a b. Contravariant f => (a -> b) -> f b -> f a
>$< EncodeParam Integer
integer

lazyText :: EncodeParam LT.Text
lazyText :: EncodeParam Text
lazyText =
  Text -> Text
LT.toStrict (Text -> Text) -> EncodeParam Text -> EncodeParam Text
forall (f :: * -> *) a b. Contravariant f => (a -> b) -> f b -> f a
>$< EncodeParam Text
text

bytestring :: EncodeParam ByteString
bytestring :: EncodeParam ByteString
bytestring =
  (ByteString -> Base64
AWS.Base64 (ByteString -> Base64)
-> (ByteString -> ByteString) -> ByteString -> Base64
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString -> ByteString
forall a. ByteArrayAccess a => a -> ByteString
AWS.encodeBase64) (ByteString -> Base64)
-> EncodeParam Base64 -> EncodeParam ByteString
forall (f :: * -> *) a b. Contravariant f => (a -> b) -> f b -> f a
>$< EncodeParam Base64
base64

lazyBytestring :: EncodeParam LBS.ByteString
lazyBytestring :: EncodeParam ByteString
lazyBytestring =
  ByteString -> ByteString
LBS.toStrict (ByteString -> ByteString)
-> EncodeParam ByteString -> EncodeParam ByteString
forall (f :: * -> *) a b. Contravariant f => (a -> b) -> f b -> f a
>$< EncodeParam ByteString
bytestring

timeOfDay :: EncodeParam TimeOfDay
timeOfDay :: EncodeParam TimeOfDay
timeOfDay =
  TimeOfDay -> Text
CONV.timeOfDayToText (TimeOfDay -> Text) -> EncodeParam Text -> EncodeParam TimeOfDay
forall (f :: * -> *) a b. Contravariant f => (a -> b) -> f b -> f a
>$< EncodeParam Text
text EncodeParam TimeOfDay
-> (EncodeParam TimeOfDay -> EncodeParam TimeOfDay)
-> EncodeParam TimeOfDay
forall a b. a -> (a -> b) -> b
& TypeHint -> EncodeParam TimeOfDay -> EncodeParam TimeOfDay
forall a. TypeHint -> EncodeParam a -> EncodeParam a
typed TypeHint
AWS.TypeHint_TIME

day :: EncodeParam Day
day :: EncodeParam Day
day =
  Day -> Text
CONV.dayToText (Day -> Text) -> EncodeParam Text -> EncodeParam Day
forall (f :: * -> *) a b. Contravariant f => (a -> b) -> f b -> f a
>$< EncodeParam Text
text EncodeParam Day
-> (EncodeParam Day -> EncodeParam Day) -> EncodeParam Day
forall a b. a -> (a -> b) -> b
& TypeHint -> EncodeParam Day -> EncodeParam Day
forall a. TypeHint -> EncodeParam a -> EncodeParam a
typed TypeHint
AWS.TypeHint_DATE

json :: EncodeParam J.Value
json :: EncodeParam Value
json =
  Value -> Text
CONV.jsonToText (Value -> Text) -> EncodeParam Text -> EncodeParam Value
forall (f :: * -> *) a b. Contravariant f => (a -> b) -> f b -> f a
>$< EncodeParam Text
text EncodeParam Value
-> (EncodeParam Value -> EncodeParam Value) -> EncodeParam Value
forall a b. a -> (a -> b) -> b
& TypeHint -> EncodeParam Value -> EncodeParam Value
forall a. TypeHint -> EncodeParam a -> EncodeParam a
typed TypeHint
AWS.TypeHint_JSON

ulid :: EncodeParam ULID
ulid :: EncodeParam ULID
ulid =
  ULID -> Text
CONV.ulidToText (ULID -> Text) -> EncodeParam Text -> EncodeParam ULID
forall (f :: * -> *) a b. Contravariant f => (a -> b) -> f b -> f a
>$< EncodeParam Text
text

utcTime :: EncodeParam UTCTime
utcTime :: EncodeParam UTCTime
utcTime =
  UTCTime -> Text
CONV.utcTimeToText (UTCTime -> Text) -> EncodeParam Text -> EncodeParam UTCTime
forall (f :: * -> *) a b. Contravariant f => (a -> b) -> f b -> f a
>$< EncodeParam Text
text EncodeParam UTCTime
-> (EncodeParam UTCTime -> EncodeParam UTCTime)
-> EncodeParam UTCTime
forall a b. a -> (a -> b) -> b
& TypeHint -> EncodeParam UTCTime -> EncodeParam UTCTime
forall a. TypeHint -> EncodeParam a -> EncodeParam a
typed TypeHint
AWS.TypeHint_TIMESTAMP

uuid :: EncodeParam UUID
uuid :: EncodeParam UUID
uuid =
  UUID -> Text
CONV.uuidToText (UUID -> Text) -> EncodeParam Text -> EncodeParam UUID
forall (f :: * -> *) a b. Contravariant f => (a -> b) -> f b -> f a
>$< EncodeParam Text
text EncodeParam UUID
-> (EncodeParam UUID -> EncodeParam UUID) -> EncodeParam UUID
forall a b. a -> (a -> b) -> b
& TypeHint -> EncodeParam UUID -> EncodeParam UUID
forall a. TypeHint -> EncodeParam a -> EncodeParam a
typed TypeHint
AWS.TypeHint_UUID