{-# LANGUAGE ScopedTypeVariables #-}
{-# LANGUAGE TypeApplications #-}

module Hasql.Interpolate.Internal.Json
  ( Json (..),
    Jsonb (..),
    AsJson (..),
    AsJsonb (..),
  )
where

import Data.Aeson
import qualified Data.Aeson as Aeson
import Data.Bifunctor (first)
import qualified Data.ByteString.Lazy as BL
import Data.Coerce
import Data.Functor.Contravariant
import qualified Data.Text as T
import qualified Hasql.Decoders as D
import qualified Hasql.Encoders as E
import Hasql.Interpolate.Internal.Decoder
import Hasql.Interpolate.Internal.Encoder

-- | Newtype for 'Hasql.Interpolate.Decoder.DecodeValue' /
-- 'Hasql.Interpolate.Encoder.EncodeValue' instances that converts
-- between a postgres json type and an Aeson 'Value'
newtype Jsonb = Jsonb Value

-- | Newtype for 'Hasql.Interpolate.Decoder.DecodeValue' /
-- 'Hasql.Interpolate.Encoder.EncodeValue' instances that converts
-- between a postgres json type and an Aeson 'Value'
newtype Json = Json Value

-- | Newtype for 'Hasql.Interpolate.Decoder.DecodeValue' /
-- 'Hasql.Interpolate.Encoder.EncodeValue' instances that converts
-- between a postgres json type and anything that is an instance of
-- 'FromJSON' / 'ToJSON'
newtype AsJson a = AsJson a

-- | Newtype for 'Hasql.Interpolate.Decoder.DecodeValue' /
-- 'Hasql.Interpolate.Encoder.EncodeValue' instances that converts
-- between a postgres jsonb type and anything that is an instance of
-- 'FromJSON' / 'ToJSON'
newtype AsJsonb a = AsJsonb a

-- | Parse a postgres @jsonb@ using 'D.jsonb'
instance DecodeValue Jsonb where
  decodeValue :: Value Jsonb
decodeValue = coerce :: forall a b. Coercible a b => a -> b
coerce Value Value
D.jsonb

-- | Parse a postgres @json@ using 'D.json'
instance DecodeValue Json where
  decodeValue :: Value Json
decodeValue = coerce :: forall a b. Coercible a b => a -> b
coerce Value Value
D.json

-- | Parse a postgres @json@ to anything that is an instance of
-- 'Aeson.FromJSON'
instance Aeson.FromJSON a => DecodeValue (AsJson a) where
  decodeValue :: Value (AsJson a)
decodeValue = forall a. a -> AsJson a
AsJson forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall a. (ByteString -> Either Text a) -> Value a
D.jsonBytes (forall (p :: * -> * -> *) a b c.
Bifunctor p =>
(a -> b) -> p a c -> p b c
first String -> Text
T.pack forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. FromJSON a => ByteString -> Either String a
Aeson.eitherDecodeStrict)

-- | Parse a postgres @jsonb@ to anything that is an instance of
-- 'Aeson.FromJSON'
instance Aeson.FromJSON a => DecodeValue (AsJsonb a) where
  decodeValue :: Value (AsJsonb a)
decodeValue = forall a. a -> AsJsonb a
AsJsonb forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall a. (ByteString -> Either Text a) -> Value a
D.jsonbBytes (forall (p :: * -> * -> *) a b c.
Bifunctor p =>
(a -> b) -> p a c -> p b c
first String -> Text
T.pack forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. FromJSON a => ByteString -> Either String a
Aeson.eitherDecodeStrict)

-- | Encode an Aeson 'Aeson.Value' to a postgres @json@ using 'E.json'
instance EncodeValue Json where
  encodeValue :: Value Json
encodeValue = coerce :: forall a b. Coercible a b => a -> b
coerce Value Value
E.json

-- | Encode an Aeson 'Aeson.Value' to a postgres @jsonb@ using 'E.jsonb'
instance EncodeValue Jsonb where
  encodeValue :: Value Jsonb
encodeValue = coerce :: forall a b. Coercible a b => a -> b
coerce Value Value
E.jsonb

-- | Encode anything that is an instance of 'Aeson.ToJSON' to a postgres @json@
instance Aeson.ToJSON a => EncodeValue (AsJson a) where
  encodeValue :: Value (AsJson a)
encodeValue = ByteString -> ByteString
BL.toStrict forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. ToJSON a => a -> ByteString
Aeson.encode forall b c a. (b -> c) -> (a -> b) -> a -> c
. coerce :: forall a b. Coercible a b => a -> b
coerce @_ @a forall (f :: * -> *) a b. Contravariant f => (a -> b) -> f b -> f a
>$< Value ByteString
E.jsonBytes

-- | Encode anything that is an instance of 'Aeson.ToJSON' to a postgres @jsonb@
instance Aeson.ToJSON a => EncodeValue (AsJsonb a) where
  encodeValue :: Value (AsJsonb a)
encodeValue = ByteString -> ByteString
BL.toStrict forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. ToJSON a => a -> ByteString
Aeson.encode forall b c a. (b -> c) -> (a -> b) -> a -> c
. coerce :: forall a b. Coercible a b => a -> b
coerce @_ @a forall (f :: * -> *) a b. Contravariant f => (a -> b) -> f b -> f a
>$< Value ByteString
E.jsonbBytes