Codec.hs

{-# LANGUAGE OverloadedRecordDot #-}
-- @generated by keiro-dsl 0.11.0.0 (language keiro-dsl 4) from aggregate ScalarLedger; do not edit.
module Generated.AggregateScalars.ScalarLedger.Codec (
    scalarLedgerCodec,
    parseScalarLedgerEvent,
    encodeScalarLedgerEvent,
) where

import Generated.AggregateScalars.ScalarLedger.Domain
import Data.Aeson (Value, object, withObject, (.:), (.=))
import Data.Aeson.Types (parseEither)
import Data.List.NonEmpty (NonEmpty (..))
import Data.List.NonEmpty qualified as NonEmpty
import Data.Text (Text)
import qualified Data.Text as T
import Keiro.Codec (Codec (..), EventType (..))





scalarLedgerEventTypes :: NonEmpty EventType
scalarLedgerEventTypes = EventType "ScalarsRecorded" :| [EventType "FieldIdentityObserved"]

scalarLedgerCodec :: Codec ScalarLedgerEvent
scalarLedgerCodec =
  Codec
    { eventTypes = scalarLedgerEventTypes
    , eventType = \case
        ScalarsRecorded{} -> EventType "ScalarsRecorded"
        FieldIdentityObserved{} -> EventType "FieldIdentityObserved"
    , schemaVersion = 1
    , encode = encodeScalarLedgerEvent
    , decode = parseScalarLedgerEvent
    , upcasters = []
    }

encodeScalarLedgerEvent :: ScalarLedgerEvent -> Value
encodeScalarLedgerEvent = \case
  ScalarsRecorded payload ->
    object
      [ "kind" .= ("ScalarsRecorded" :: Text)
      , "observedAt" .= payload.observedAt
      , "revision" .= payload.revision
      ]
  FieldIdentityObserved payload ->
    object
      [ "kind" .= ("FieldIdentityObserved" :: Text)
      , "as" .= payload.as
      , "family" .= payload.family
      , "mdo" .= payload.mdo
      , "proc" .= payload.proc
      , "qualified" .= payload.qualified
      , "rec" .= payload.rec
      , "safe" .= payload.safe
      , "signature" .= payload.signature
      , "stock" .= payload.stock
      , "unsafe" .= payload.unsafe
      , "via" .= payload.via
      , "type" .= payload.payloadType
      , "region_code" .= payload.serviceRegion
      ]

parseScalarLedgerEvent :: EventType -> Value -> Either Text ScalarLedgerEvent
parseScalarLedgerEvent (EventType tag) = mapLeftText . parseEither (withObject "ScalarLedgerEvent" go)
  where
    go o = do
      case tag of
        "ScalarsRecorded" ->
          ScalarsRecorded
            <$> ( ScalarsRecordedData
                    <$> o .: "observedAt"
                    <*> o .: "revision"
                )
        "FieldIdentityObserved" ->
          FieldIdentityObserved
            <$> ( FieldIdentityObservedData
                    <$> o .: "as"
                    <*> o .: "family"
                    <*> o .: "mdo"
                    <*> o .: "proc"
                    <*> o .: "qualified"
                    <*> o .: "rec"
                    <*> o .: "safe"
                    <*> o .: "signature"
                    <*> o .: "stock"
                    <*> o .: "unsafe"
                    <*> o .: "via"
                    <*> o .: "type"
                    <*> o .: "region_code"
                )
        _ -> fail ("unknown event type " <> show tag <> "; expected one of: " <> renderExpectedEventTypes scalarLedgerEventTypes)

mapLeftText :: Either String b -> Either Text b
mapLeftText = either (Left . T.pack) Right

renderExpectedEventTypes :: NonEmpty EventType -> String
renderExpectedEventTypes =
  T.unpack
    . T.intercalate ", "
    . map (\(EventType eventTypeName) -> eventTypeName)
    . NonEmpty.toList