packages feed

tricorder-1.1.0.0: src/Tricorder/Config/LoadedConfig.hs

{-# LANGUAGE AllowAmbiguousTypes #-}

module Tricorder.Config.LoadedConfig
    ( LoadedConfig (..)
    , asInput
    , asNestedInput
    , decodeNestedValue
    , configFileName
    )
where

import Atelier.Effects.Input (Input)
import Atelier.FileSystem.Path ((</>))
import Data.Aeson (FromJSON)
import Effectful.FileSystem (FileSystem)
import Effectful.Reader.Static (Reader)
import GHC.TypeLits (KnownSymbol, Symbol, symbolVal)

import Atelier.Effects.Input qualified as Input
import Atelier.FileSystem.File qualified as File
import Atelier.FileSystem.Path qualified as Path
import Data.Aeson qualified as Aeson
import Data.Aeson.KeyMap qualified as KM
import Data.List qualified as List
import Data.Text qualified as T
import Data.Yaml qualified as Yaml
import Effectful.Reader.Static qualified as Reader

import Tricorder.Runtime.ProjectRoot (ProjectRoot (..))


newtype LoadedConfig = LoadedConfig {getLoadedConfig :: ByteString}


asInput
    :: (FileSystem :> es, Reader ProjectRoot :> es)
    => Eff (Input LoadedConfig : es) a -> Eff es a
asInput = Input.withEff do
    ProjectRoot projectRoot <- Reader.ask
    let configFilePath = projectRoot </> configFileName
    exists <- File.exists configFilePath
    if exists
        then do
            bs <- File.read configFilePath
            pure $ LoadedConfig bs
        else pure $ LoadedConfig ""


asNestedInput
    :: forall (key :: Symbol) r es a
     . ( FromJSON r
       , Input LoadedConfig :> es
       , KnownSymbol key
       )
    => Eff (Input (Either Text r) : es) a -> Eff es a
asNestedInput = Input.withEff do
    loadedConfig <- Input.input
    pure $ decodeNestedValue @key loadedConfig


configFileName :: Path.Relative
configFileName = Path.relative @".tricorder.yaml"


decodeNestedValue
    :: forall (key :: Symbol) r. (FromJSON r, KnownSymbol key) => LoadedConfig -> Either Text r
decodeNestedValue (LoadedConfig root) =
    go [] props
        =<< first
            (toText . Yaml.prettyPrintParseException)
            (Yaml.decodeEither' root)
  where
    props = T.splitOn "." $ toText $ symbolVal $ Proxy @key

    go :: [Text] -> [Text] -> Aeson.Value -> Either Text r
    go prev (p : ps) (Aeson.Object m) =
        maybe
            (Left $ "missing property '" <> p <> "' at " <> formatPrev prev)
            (go (p : prev) ps)
            $ KM.lookup (fromString $ toString p) m
    go prev (_ : _) _ =
        Left $ "expected property to be an object: " <> formatPrev prev
    go prev [] x =
        first (\e -> "parse error for property " <> formatPrev prev <> ": " <> e)
            $ fromJSON x

    fromJSON x = case Aeson.fromJSON x of
        Aeson.Success a -> Right a
        Aeson.Error err -> Left $ toText err

    formatPrev prev
        | List.null prev = "<root object>"
        | otherwise = T.intercalate "." $ List.reverse prev