Flag.hs.golden

{-# LANGUAGE AllowAmbiguousTypes #-}
{-# LANGUAGE DataKinds #-}
{-# LANGUAGE DuplicateRecordFields #-}
{-# LANGUAGE NoFieldSelectors #-}
{-# LANGUAGE OverloadedRecordDot #-}
{-# LANGUAGE TypeApplications #-}

module Schema.Flag
  ( FlagTable (..),
    FlagRow (..),
    FlagSelect (..),
    FlagPicked (..),
    flagSelect,
    flagSelectColumns,
    parseFlagPicked,
    toFlagPicked,
    FlagCreate (..),
    FlagUpdate (..),
    flagId,
    flagActive
  )
where

import Data.Text (Text)
import Data.UUID (UUID)
import Poppy.Internal.Generated
  ( FromRow (..),
    RowParser,
    field,
    Entity (..),
    Field (..),
    PrimaryKeyType,
    ModelTable,
    Picked (..),
    picked,
    Insertable (..),
    emptyInsert,
    set,
    setMaybe,
    Updatable (..),
    emptyUpdate,
    setFieldMaybe
  )

data FlagTable = FlagTable

type instance PrimaryKeyType FlagTable = UUID

type instance ModelTable "Flag" = FlagTable

instance Entity FlagTable where
  tableName = "flag"
  primaryKey = flagId
  tableColumns = ["id", "active"]

instance Insertable FlagTable where
  type CreateInput FlagTable = FlagCreate
  toInsertBuilder input =
    setMaybe flagId input.id $
      set flagActive input.active $
      emptyInsert @FlagTable


instance Updatable FlagTable where
  type UpdateInput FlagTable = FlagUpdate
  updatedAtField = Nothing
  toUpdateBuilder input =
    setFieldMaybe flagActive input.active $
      emptyUpdate @FlagTable


data FlagRow = FlagRow
  { id :: UUID,
    active :: Bool
  }
  deriving (Show, Eq)


data FlagCreate = FlagCreate
  { id :: Maybe UUID,
    active :: Bool
  }
  deriving (Show, Eq)


data FlagUpdate = FlagUpdate
  { active :: Maybe Bool
  }
  deriving (Show, Eq)


instance FromRow FlagRow where
  fromRow = FlagRow <$> field <*> field


data FlagSelect = FlagSelect
  { id :: Bool,
    active :: Bool
  }
  deriving (Show, Eq)
data FlagPicked = FlagPicked
  { id :: UUID,
    active :: Picked Bool
  }
  deriving (Show, Eq)
flagSelect :: FlagSelect
flagSelect =
  FlagSelect
    { id = False,
      active = False
    }
flagSelectColumns :: FlagSelect -> [Text]
flagSelectColumns select_ =
  fieldColumn flagId
    : concat
      [ [fieldColumn flagActive | select_.active]
      ]
parseFlagPicked :: FlagSelect -> RowParser FlagPicked
parseFlagPicked select_ = do
  idVal <- field
  activeVal <- if select_.active then Picked <$> field else pure Skipped
  pure FlagPicked { id = idVal, active = activeVal }
toFlagPicked :: FlagSelect -> FlagRow -> FlagPicked
toFlagPicked select_ row =
  FlagPicked
    { id = row.id,
      active = picked select_.active row.active
    }


flagId :: Field FlagTable UUID
flagId = Field "id" "id"

flagActive :: Field FlagTable Bool
flagActive = Field "active" "active"