Codec.hs

{-# LANGUAGE DataKinds #-}
{-# LANGUAGE TypeApplications #-}
{-# LANGUAGE LambdaCase #-}
{-# LANGUAGE OverloadedRecordDot #-}
-- @generated by keiro-dsl 0.8.0.0 (language keiro-dsl 4) from aggregate NominalLedger; do not edit.
module Generated.NominalScalars.NominalLedger.Codec (
    nominalLedgerCodec,
    parseNominalLedgerEvent,
    encodeNominalLedgerEvent,
) where

import Generated.NominalScalars.NominalLedger.Domain
import Data.Aeson (Value, object, withObject, withText, (.:), (.=))
import Data.Aeson.Types (Parser, explicitParseField, parseEither)
import Data.List.NonEmpty (NonEmpty (..))
import Data.Text (Text)
import qualified Data.Text as T
import Data.KindID qualified as KindID
import Keiro.Codec.IdDomain (typeIdV7Domain, validateIdDomainText)
import Keiro.Codec.Nominal (nominalFromRepresentation, nominalToRepresentation)
import Keiro.Codec (Codec (..), EventType (..))

import Generated.NominalScalars.Nominal.Shape.OrderStatus qualified
import NominalConformance.Bindings qualified
import NominalConformance.Domain qualified








parseOrderIdNominal :: Text -> Parser NominalConformance.Domain.OrderId
parseOrderIdNominal input = case validateIdDomainText (typeIdV7Domain "ord") input of
  Left reason -> fail (show reason)
  Right () -> case KindID.parseText @"ord" input of
    Left reason -> fail (show reason)
    Right representation -> pure (nominalFromRepresentation NominalConformance.Bindings.orderIdBinding representation)

parseOrderStatusNominal :: Text -> Parser NominalConformance.Domain.OrderStatus
parseOrderStatusNominal = \case
  "draft" -> pure (nominalFromRepresentation NominalConformance.Bindings.orderStatusBinding Generated.NominalScalars.Nominal.Shape.OrderStatus.Draft)
  "submitted" -> pure (nominalFromRepresentation NominalConformance.Bindings.orderStatusBinding Generated.NominalScalars.Nominal.Shape.OrderStatus.Submitted)
  tag -> fail ("unknown OrderStatus wire value " <> show tag <> "; expected one of: draft, submitted")





nominalLedgerCodec :: Codec NominalLedgerEvent
nominalLedgerCodec =
  Codec
    { eventTypes = EventType "NominalsRecorded" :| []
    , eventType = \case
        NominalsRecorded{} -> EventType "NominalsRecorded"
    , schemaVersion = 1
    , encode = encodeNominalLedgerEvent
    , decode = parseNominalLedgerEvent
    , upcasters = []
    }

encodeNominalLedgerEvent :: NominalLedgerEvent -> Value
encodeNominalLedgerEvent = \case
  NominalsRecorded payload ->
    object
      [ "kind" .= ("NominalsRecorded" :: Text)
      , "orderId" .= KindID.toText (nominalToRepresentation NominalConformance.Bindings.orderIdBinding payload.orderId)
      , "status" .= Generated.NominalScalars.Nominal.Shape.OrderStatus.orderStatusRepresentationText (nominalToRepresentation NominalConformance.Bindings.orderStatusBinding payload.status)
      , "accountNumber" .= nominalToRepresentation NominalConformance.Bindings.accountNumberBinding payload.accountNumber
      , "riskScore" .= nominalToRepresentation NominalConformance.Bindings.riskScoreBinding payload.riskScore
      , "sequenceNumber" .= nominalToRepresentation NominalConformance.Bindings.sequenceNumberBinding payload.sequenceNumber
      , "featureFlag" .= nominalToRepresentation NominalConformance.Bindings.featureFlagBinding payload.featureFlag
      , "observedAt" .= nominalToRepresentation NominalConformance.Bindings.observedAtBinding payload.observedAt
      ]

parseNominalLedgerEvent :: EventType -> Value -> Either Text NominalLedgerEvent
parseNominalLedgerEvent (EventType tag) = mapLeftText . parseEither (withObject "NominalLedgerEvent" go)
  where
    go o = do
      case tag of
        "NominalsRecorded" ->
          NominalsRecorded
            <$> ( NominalsRecordedData
                    <$> explicitParseField (withText "OrderId" parseOrderIdNominal) o "orderId"
                    <*> explicitParseField (withText "OrderStatus" parseOrderStatusNominal) o "status"
                    <*> (nominalFromRepresentation NominalConformance.Bindings.accountNumberBinding <$> o .: "accountNumber")
                    <*> (nominalFromRepresentation NominalConformance.Bindings.riskScoreBinding <$> o .: "riskScore")
                    <*> (nominalFromRepresentation NominalConformance.Bindings.sequenceNumberBinding <$> o .: "sequenceNumber")
                    <*> (nominalFromRepresentation NominalConformance.Bindings.featureFlagBinding <$> o .: "featureFlag")
                    <*> (nominalFromRepresentation NominalConformance.Bindings.observedAtBinding <$> o .: "observedAt")
                )
        _ -> fail ("unknown event type " <> show tag <> "; expected one of: NominalsRecorded")

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