{-# LANGUAGE UndecidableInstances #-}

module Mensam.Server.Application where

import Mensam.Server.Application.Configured
import Mensam.Server.Application.Configured.Class
import Mensam.Server.Application.Email
import Mensam.Server.Application.Email.Class
import Mensam.Server.Application.Environment
import Mensam.Server.Application.Environment.Acquisition
import Mensam.Server.Application.Environment.Class
import Mensam.Server.Application.LoggerCustom
import Mensam.Server.Application.LoggerCustom.Class
import Mensam.Server.Application.Options
import Mensam.Server.Application.Options.Class
import Mensam.Server.Application.Secret
import Mensam.Server.Application.Secret.Class
import Mensam.Server.Application.SeldaPool
import Mensam.Server.Application.SeldaPool.Class

import Control.Monad.Base
import Control.Monad.Catch
import Control.Monad.IO.Unlift
import Control.Monad.Logger.CallStack
import Control.Monad.Trans.Class
import Control.Monad.Trans.Compose.Stack
import Control.Monad.Trans.Control
import Control.Monad.Trans.Control.Identity
import Data.Foldable
import Data.Kind

type Transformers :: Stack
type Transformers =
  NilT
    :.|> EnvironmentT
    :.|> OptionsT
    :.|> CustomLoggingT
    :.|> ConfiguredT
    :.|> SeldaPoolT
    :.|> SecretT
    :.|> EmailT

type ApplicationT :: (Type -> Type) -> Type -> Type
newtype ApplicationT m a = ApplicationT {forall (m :: * -> *) a. ApplicationT m a -> StackT Transformers m a
unApplicationT :: StackT Transformers m a}
  deriving newtype (Functor (ApplicationT m)
Functor (ApplicationT m) =>
(forall a. a -> ApplicationT m a)
-> (forall a b.
    ApplicationT m (a -> b) -> ApplicationT m a -> ApplicationT m b)
-> (forall a b c.
    (a -> b -> c)
    -> ApplicationT m a -> ApplicationT m b -> ApplicationT m c)
-> (forall a b.
    ApplicationT m a -> ApplicationT m b -> ApplicationT m b)
-> (forall a b.
    ApplicationT m a -> ApplicationT m b -> ApplicationT m a)
-> Applicative (ApplicationT m)
forall a. a -> ApplicationT m a
forall a b.
ApplicationT m a -> ApplicationT m b -> ApplicationT m a
forall a b.
ApplicationT m a -> ApplicationT m b -> ApplicationT m b
forall a b.
ApplicationT m (a -> b) -> ApplicationT m a -> ApplicationT m b
forall a b c.
(a -> b -> c)
-> ApplicationT m a -> ApplicationT m b -> ApplicationT m c
forall (f :: * -> *).
Functor f =>
(forall a. a -> f a)
-> (forall a b. f (a -> b) -> f a -> f b)
-> (forall a b c. (a -> b -> c) -> f a -> f b -> f c)
-> (forall a b. f a -> f b -> f b)
-> (forall a b. f a -> f b -> f a)
-> Applicative f
forall (m :: * -> *). Applicative m => Functor (ApplicationT m)
forall (m :: * -> *) a. Applicative m => a -> ApplicationT m a
forall (m :: * -> *) a b.
Applicative m =>
ApplicationT m a -> ApplicationT m b -> ApplicationT m a
forall (m :: * -> *) a b.
Applicative m =>
ApplicationT m a -> ApplicationT m b -> ApplicationT m b
forall (m :: * -> *) a b.
Applicative m =>
ApplicationT m (a -> b) -> ApplicationT m a -> ApplicationT m b
forall (m :: * -> *) a b c.
Applicative m =>
(a -> b -> c)
-> ApplicationT m a -> ApplicationT m b -> ApplicationT m c
$cpure :: forall (m :: * -> *) a. Applicative m => a -> ApplicationT m a
pure :: forall a. a -> ApplicationT m a
$c<*> :: forall (m :: * -> *) a b.
Applicative m =>
ApplicationT m (a -> b) -> ApplicationT m a -> ApplicationT m b
<*> :: forall a b.
ApplicationT m (a -> b) -> ApplicationT m a -> ApplicationT m b
$cliftA2 :: forall (m :: * -> *) a b c.
Applicative m =>
(a -> b -> c)
-> ApplicationT m a -> ApplicationT m b -> ApplicationT m c
liftA2 :: forall a b c.
(a -> b -> c)
-> ApplicationT m a -> ApplicationT m b -> ApplicationT m c
$c*> :: forall (m :: * -> *) a b.
Applicative m =>
ApplicationT m a -> ApplicationT m b -> ApplicationT m b
*> :: forall a b.
ApplicationT m a -> ApplicationT m b -> ApplicationT m b
$c<* :: forall (m :: * -> *) a b.
Applicative m =>
ApplicationT m a -> ApplicationT m b -> ApplicationT m a
<* :: forall a b.
ApplicationT m a -> ApplicationT m b -> ApplicationT m a
Applicative, (forall a b. (a -> b) -> ApplicationT m a -> ApplicationT m b)
-> (forall a b. a -> ApplicationT m b -> ApplicationT m a)
-> Functor (ApplicationT m)
forall a b. a -> ApplicationT m b -> ApplicationT m a
forall a b. (a -> b) -> ApplicationT m a -> ApplicationT m b
forall (m :: * -> *) a b.
Functor m =>
a -> ApplicationT m b -> ApplicationT m a
forall (m :: * -> *) a b.
Functor m =>
(a -> b) -> ApplicationT m a -> ApplicationT m b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
$cfmap :: forall (m :: * -> *) a b.
Functor m =>
(a -> b) -> ApplicationT m a -> ApplicationT m b
fmap :: forall a b. (a -> b) -> ApplicationT m a -> ApplicationT m b
$c<$ :: forall (m :: * -> *) a b.
Functor m =>
a -> ApplicationT m b -> ApplicationT m a
<$ :: forall a b. a -> ApplicationT m b -> ApplicationT m a
Functor, Applicative (ApplicationT m)
Applicative (ApplicationT m) =>
(forall a b.
 ApplicationT m a -> (a -> ApplicationT m b) -> ApplicationT m b)
-> (forall a b.
    ApplicationT m a -> ApplicationT m b -> ApplicationT m b)
-> (forall a. a -> ApplicationT m a)
-> Monad (ApplicationT m)
forall a. a -> ApplicationT m a
forall a b.
ApplicationT m a -> ApplicationT m b -> ApplicationT m b
forall a b.
ApplicationT m a -> (a -> ApplicationT m b) -> ApplicationT m b
forall (m :: * -> *). Monad m => Applicative (ApplicationT m)
forall (m :: * -> *) a. Monad m => a -> ApplicationT m a
forall (m :: * -> *) a b.
Monad m =>
ApplicationT m a -> ApplicationT m b -> ApplicationT m b
forall (m :: * -> *) a b.
Monad m =>
ApplicationT m a -> (a -> ApplicationT m b) -> ApplicationT m b
forall (m :: * -> *).
Applicative m =>
(forall a b. m a -> (a -> m b) -> m b)
-> (forall a b. m a -> m b -> m b)
-> (forall a. a -> m a)
-> Monad m
$c>>= :: forall (m :: * -> *) a b.
Monad m =>
ApplicationT m a -> (a -> ApplicationT m b) -> ApplicationT m b
>>= :: forall a b.
ApplicationT m a -> (a -> ApplicationT m b) -> ApplicationT m b
$c>> :: forall (m :: * -> *) a b.
Monad m =>
ApplicationT m a -> ApplicationT m b -> ApplicationT m b
>> :: forall a b.
ApplicationT m a -> ApplicationT m b -> ApplicationT m b
$creturn :: forall (m :: * -> *) a. Monad m => a -> ApplicationT m a
return :: forall a. a -> ApplicationT m a
Monad)
  deriving newtype ((forall (m :: * -> *). Monad m => Monad (ApplicationT m)) =>
(forall (m :: * -> *) a. Monad m => m a -> ApplicationT m a)
-> MonadTrans ApplicationT
forall (m :: * -> *). Monad m => Monad (ApplicationT m)
forall (m :: * -> *) a. Monad m => m a -> ApplicationT m a
forall (t :: (* -> *) -> * -> *).
(forall (m :: * -> *). Monad m => Monad (t m)) =>
(forall (m :: * -> *) a. Monad m => m a -> t m a) -> MonadTrans t
$clift :: forall (m :: * -> *) a. Monad m => m a -> ApplicationT m a
lift :: forall (m :: * -> *) a. Monad m => m a -> ApplicationT m a
MonadTrans, MonadTrans ApplicationT
MonadTrans ApplicationT =>
(forall (m :: * -> *) a.
 Monad m =>
 (Run ApplicationT -> m a) -> ApplicationT m a)
-> (forall (m :: * -> *) a.
    Monad m =>
    m (StT ApplicationT a) -> ApplicationT m a)
-> MonadTransControl ApplicationT
forall (m :: * -> *) a.
Monad m =>
m (StT ApplicationT a) -> ApplicationT m a
forall (m :: * -> *) a.
Monad m =>
(Run ApplicationT -> m a) -> ApplicationT m a
forall (t :: (* -> *) -> * -> *).
MonadTrans t =>
(forall (m :: * -> *) a. Monad m => (Run t -> m a) -> t m a)
-> (forall (m :: * -> *) a. Monad m => m (StT t a) -> t m a)
-> MonadTransControl t
$cliftWith :: forall (m :: * -> *) a.
Monad m =>
(Run ApplicationT -> m a) -> ApplicationT m a
liftWith :: forall (m :: * -> *) a.
Monad m =>
(Run ApplicationT -> m a) -> ApplicationT m a
$crestoreT :: forall (m :: * -> *) a.
Monad m =>
m (StT ApplicationT a) -> ApplicationT m a
restoreT :: forall (m :: * -> *) a.
Monad m =>
m (StT ApplicationT a) -> ApplicationT m a
MonadTransControl, MonadTransControl ApplicationT
MonadTransControl ApplicationT =>
(forall (m :: * -> *) a.
 Monad m =>
 ((forall x. ApplicationT m x -> m x) -> m a) -> ApplicationT m a)
-> MonadTransControlIdentity ApplicationT
forall (m :: * -> *) a.
Monad m =>
((forall x. ApplicationT m x -> m x) -> m a) -> ApplicationT m a
forall (t :: (* -> *) -> * -> *).
MonadTransControl t =>
(forall (m :: * -> *) a.
 Monad m =>
 ((forall x. t m x -> m x) -> m a) -> t m a)
-> MonadTransControlIdentity t
$cliftWithIdentity :: forall (m :: * -> *) a.
Monad m =>
((forall x. ApplicationT m x -> m x) -> m a) -> ApplicationT m a
liftWithIdentity :: forall (m :: * -> *) a.
Monad m =>
((forall x. ApplicationT m x -> m x) -> m a) -> ApplicationT m a
MonadTransControlIdentity)
  deriving newtype (MonadBase b, MonadBaseControl b, MonadBaseControlIdentity b)
  deriving newtype (Monad (ApplicationT m)
Monad (ApplicationT m) =>
(forall a. IO a -> ApplicationT m a) -> MonadIO (ApplicationT m)
forall a. IO a -> ApplicationT m a
forall (m :: * -> *).
Monad m =>
(forall a. IO a -> m a) -> MonadIO m
forall (m :: * -> *). MonadIO m => Monad (ApplicationT m)
forall (m :: * -> *) a. MonadIO m => IO a -> ApplicationT m a
$cliftIO :: forall (m :: * -> *) a. MonadIO m => IO a -> ApplicationT m a
liftIO :: forall a. IO a -> ApplicationT m a
MonadIO, MonadIO (ApplicationT m)
MonadIO (ApplicationT m) =>
(forall b.
 ((forall a. ApplicationT m a -> IO a) -> IO b) -> ApplicationT m b)
-> MonadUnliftIO (ApplicationT m)
forall b.
((forall a. ApplicationT m a -> IO a) -> IO b) -> ApplicationT m b
forall (m :: * -> *).
MonadIO m =>
(forall b. ((forall a. m a -> IO a) -> IO b) -> m b)
-> MonadUnliftIO m
forall (m :: * -> *). MonadUnliftIO m => MonadIO (ApplicationT m)
forall (m :: * -> *) b.
MonadUnliftIO m =>
((forall a. ApplicationT m a -> IO a) -> IO b) -> ApplicationT m b
$cwithRunInIO :: forall (m :: * -> *) b.
MonadUnliftIO m =>
((forall a. ApplicationT m a -> IO a) -> IO b) -> ApplicationT m b
withRunInIO :: forall b.
((forall a. ApplicationT m a -> IO a) -> IO b) -> ApplicationT m b
MonadUnliftIO)
  deriving newtype (Monad (ApplicationT m)
Monad (ApplicationT m) =>
(forall e a. (HasCallStack, Exception e) => e -> ApplicationT m a)
-> MonadThrow (ApplicationT m)
forall e a. (HasCallStack, Exception e) => e -> ApplicationT m a
forall (m :: * -> *).
Monad m =>
(forall e a. (HasCallStack, Exception e) => e -> m a)
-> MonadThrow m
forall (m :: * -> *). MonadThrow m => Monad (ApplicationT m)
forall (m :: * -> *) e a.
(MonadThrow m, HasCallStack, Exception e) =>
e -> ApplicationT m a
$cthrowM :: forall (m :: * -> *) e a.
(MonadThrow m, HasCallStack, Exception e) =>
e -> ApplicationT m a
throwM :: forall e a. (HasCallStack, Exception e) => e -> ApplicationT m a
MonadThrow, MonadThrow (ApplicationT m)
MonadThrow (ApplicationT m) =>
(forall e a.
 (HasCallStack, Exception e) =>
 ApplicationT m a -> (e -> ApplicationT m a) -> ApplicationT m a)
-> MonadCatch (ApplicationT m)
forall e a.
(HasCallStack, Exception e) =>
ApplicationT m a -> (e -> ApplicationT m a) -> ApplicationT m a
forall (m :: * -> *).
MonadThrow m =>
(forall e a.
 (HasCallStack, Exception e) =>
 m a -> (e -> m a) -> m a)
-> MonadCatch m
forall (m :: * -> *). MonadCatch m => MonadThrow (ApplicationT m)
forall (m :: * -> *) e a.
(MonadCatch m, HasCallStack, Exception e) =>
ApplicationT m a -> (e -> ApplicationT m a) -> ApplicationT m a
$ccatch :: forall (m :: * -> *) e a.
(MonadCatch m, HasCallStack, Exception e) =>
ApplicationT m a -> (e -> ApplicationT m a) -> ApplicationT m a
catch :: forall e a.
(HasCallStack, Exception e) =>
ApplicationT m a -> (e -> ApplicationT m a) -> ApplicationT m a
MonadCatch, MonadCatch (ApplicationT m)
MonadCatch (ApplicationT m) =>
(forall b.
 HasCallStack =>
 ((forall a. ApplicationT m a -> ApplicationT m a)
  -> ApplicationT m b)
 -> ApplicationT m b)
-> (forall b.
    HasCallStack =>
    ((forall a. ApplicationT m a -> ApplicationT m a)
     -> ApplicationT m b)
    -> ApplicationT m b)
-> (forall a b c.
    HasCallStack =>
    ApplicationT m a
    -> (a -> ExitCase b -> ApplicationT m c)
    -> (a -> ApplicationT m b)
    -> ApplicationT m (b, c))
-> MonadMask (ApplicationT m)
forall b.
HasCallStack =>
((forall a. ApplicationT m a -> ApplicationT m a)
 -> ApplicationT m b)
-> ApplicationT m b
forall a b c.
HasCallStack =>
ApplicationT m a
-> (a -> ExitCase b -> ApplicationT m c)
-> (a -> ApplicationT m b)
-> ApplicationT m (b, c)
forall (m :: * -> *). MonadMask m => MonadCatch (ApplicationT m)
forall (m :: * -> *) b.
(MonadMask m, HasCallStack) =>
((forall a. ApplicationT m a -> ApplicationT m a)
 -> ApplicationT m b)
-> ApplicationT m b
forall (m :: * -> *) a b c.
(MonadMask m, HasCallStack) =>
ApplicationT m a
-> (a -> ExitCase b -> ApplicationT m c)
-> (a -> ApplicationT m b)
-> ApplicationT m (b, c)
forall (m :: * -> *).
MonadCatch m =>
(forall b. HasCallStack => ((forall a. m a -> m a) -> m b) -> m b)
-> (forall b.
    HasCallStack =>
    ((forall a. m a -> m a) -> m b) -> m b)
-> (forall a b c.
    HasCallStack =>
    m a -> (a -> ExitCase b -> m c) -> (a -> m b) -> m (b, c))
-> MonadMask m
$cmask :: forall (m :: * -> *) b.
(MonadMask m, HasCallStack) =>
((forall a. ApplicationT m a -> ApplicationT m a)
 -> ApplicationT m b)
-> ApplicationT m b
mask :: forall b.
HasCallStack =>
((forall a. ApplicationT m a -> ApplicationT m a)
 -> ApplicationT m b)
-> ApplicationT m b
$cuninterruptibleMask :: forall (m :: * -> *) b.
(MonadMask m, HasCallStack) =>
((forall a. ApplicationT m a -> ApplicationT m a)
 -> ApplicationT m b)
-> ApplicationT m b
uninterruptibleMask :: forall b.
HasCallStack =>
((forall a. ApplicationT m a -> ApplicationT m a)
 -> ApplicationT m b)
-> ApplicationT m b
$cgeneralBracket :: forall (m :: * -> *) a b c.
(MonadMask m, HasCallStack) =>
ApplicationT m a
-> (a -> ExitCase b -> ApplicationT m c)
-> (a -> ApplicationT m b)
-> ApplicationT m (b, c)
generalBracket :: forall a b c.
HasCallStack =>
ApplicationT m a
-> (a -> ExitCase b -> ApplicationT m c)
-> (a -> ApplicationT m b)
-> ApplicationT m (b, c)
MonadMask)
  deriving newtype (Monad (ApplicationT m)
Monad (ApplicationT m) =>
(forall (envVar :: EnvVar).
 SingI envVar =>
 ProxyEnvVarName (EnvVarName envVar)
 -> ApplicationT m (EnvVarValue envVar))
-> MonadEnvironment (ApplicationT m)
forall (envVar :: EnvVar).
SingI envVar =>
ProxyEnvVarName (EnvVarName envVar)
-> ApplicationT m (EnvVarValue envVar)
forall (m :: * -> *). Monad m => Monad (ApplicationT m)
forall (m :: * -> *).
Monad m =>
(forall (envVar :: EnvVar).
 SingI envVar =>
 ProxyEnvVarName (EnvVarName envVar) -> m (EnvVarValue envVar))
-> MonadEnvironment m
forall (m :: * -> *) (envVar :: EnvVar).
(Monad m, SingI envVar) =>
ProxyEnvVarName (EnvVarName envVar)
-> ApplicationT m (EnvVarValue envVar)
$cenvironmentVariable :: forall (m :: * -> *) (envVar :: EnvVar).
(Monad m, SingI envVar) =>
ProxyEnvVarName (EnvVarName envVar)
-> ApplicationT m (EnvVarValue envVar)
environmentVariable :: forall (envVar :: EnvVar).
SingI envVar =>
ProxyEnvVarName (EnvVarName envVar)
-> ApplicationT m (EnvVarValue envVar)
MonadEnvironment)
  deriving newtype (Monad (ApplicationT m)
ApplicationT m Options
Monad (ApplicationT m) =>
ApplicationT m Options -> MonadOptions (ApplicationT m)
forall (m :: * -> *). Monad m => Monad (ApplicationT m)
forall (m :: * -> *). Monad m => ApplicationT m Options
forall (m :: * -> *). Monad m => m Options -> MonadOptions m
$coptions :: forall (m :: * -> *). Monad m => ApplicationT m Options
options :: ApplicationT m Options
MonadOptions)
  deriving newtype (Monad (ApplicationT m)
Monad (ApplicationT m) =>
(forall msg.
 ToLogStr msg =>
 Loc -> LogSource -> LogLevel -> msg -> ApplicationT m ())
-> MonadLogger (ApplicationT m)
forall msg.
ToLogStr msg =>
Loc -> LogSource -> LogLevel -> msg -> ApplicationT m ()
forall (m :: * -> *).
Monad m =>
(forall msg.
 ToLogStr msg =>
 Loc -> LogSource -> LogLevel -> msg -> m ())
-> MonadLogger m
forall (m :: * -> *). MonadIO m => Monad (ApplicationT m)
forall (m :: * -> *) msg.
(MonadIO m, ToLogStr msg) =>
Loc -> LogSource -> LogLevel -> msg -> ApplicationT m ()
$cmonadLoggerLog :: forall (m :: * -> *) msg.
(MonadIO m, ToLogStr msg) =>
Loc -> LogSource -> LogLevel -> msg -> ApplicationT m ()
monadLoggerLog :: forall msg.
ToLogStr msg =>
Loc -> LogSource -> LogLevel -> msg -> ApplicationT m ()
MonadLogger, MonadLogger (ApplicationT m)
ApplicationT m Bool
MonadLogger (ApplicationT m) =>
ApplicationT m Bool -> MonadLoggerCustom (ApplicationT m)
forall (m :: * -> *). MonadIO m => MonadLogger (ApplicationT m)
forall (m :: * -> *). MonadIO m => ApplicationT m Bool
forall (m :: * -> *).
MonadLogger m =>
m Bool -> MonadLoggerCustom m
$ccolorfulLogCapability :: forall (m :: * -> *). MonadIO m => ApplicationT m Bool
colorfulLogCapability :: ApplicationT m Bool
MonadLoggerCustom)
  deriving newtype (Monad (ApplicationT m)
ApplicationT m Configuration
Monad (ApplicationT m) =>
ApplicationT m Configuration -> MonadConfigured (ApplicationT m)
forall (m :: * -> *). Monad m => Monad (ApplicationT m)
forall (m :: * -> *). Monad m => ApplicationT m Configuration
forall (m :: * -> *).
Monad m =>
m Configuration -> MonadConfigured m
$cconfiguration :: forall (m :: * -> *). Monad m => ApplicationT m Configuration
configuration :: ApplicationT m Configuration
MonadConfigured)
  deriving newtype (Monad (ApplicationT m)
MonadMask (SeldaTransactionT (ApplicationT m))
MonadSelda (SeldaTransactionT (ApplicationT m))
(Monad (ApplicationT m),
 MonadMask (SeldaTransactionT (ApplicationT m)),
 MonadSelda (SeldaTransactionT (ApplicationT m))) =>
(forall a.
 SeldaTransactionT (ApplicationT m) a
 -> ApplicationT m (SeldaResult a))
-> MonadSeldaPool (ApplicationT m)
forall a.
SeldaTransactionT (ApplicationT m) a
-> ApplicationT m (SeldaResult a)
forall (m :: * -> *).
(Monad m, MonadMask (SeldaTransactionT m),
 MonadSelda (SeldaTransactionT m)) =>
(forall a. SeldaTransactionT m a -> m (SeldaResult a))
-> MonadSeldaPool m
forall (m :: * -> *).
(MonadMask m, MonadUnliftIO m) =>
Monad (ApplicationT m)
forall (m :: * -> *).
(MonadMask m, MonadUnliftIO m) =>
MonadMask (SeldaTransactionT (ApplicationT m))
forall (m :: * -> *).
(MonadMask m, MonadUnliftIO m) =>
MonadSelda (SeldaTransactionT (ApplicationT m))
forall (m :: * -> *) a.
(MonadMask m, MonadUnliftIO m) =>
SeldaTransactionT (ApplicationT m) a
-> ApplicationT m (SeldaResult a)
$crunSeldaTransactionT :: forall (m :: * -> *) a.
(MonadMask m, MonadUnliftIO m) =>
SeldaTransactionT (ApplicationT m) a
-> ApplicationT m (SeldaResult a)
runSeldaTransactionT :: forall a.
SeldaTransactionT (ApplicationT m) a
-> ApplicationT m (SeldaResult a)
MonadSeldaPool)
  deriving newtype (Monad (ApplicationT m)
ApplicationT m Secrets
Monad (ApplicationT m) =>
ApplicationT m Secrets -> MonadSecret (ApplicationT m)
forall (m :: * -> *). Monad m => Monad (ApplicationT m)
forall (m :: * -> *). Monad m => ApplicationT m Secrets
forall (m :: * -> *). Monad m => m Secrets -> MonadSecret m
$csecrets :: forall (m :: * -> *). Monad m => ApplicationT m Secrets
secrets :: ApplicationT m Secrets
MonadSecret)
  deriving newtype (Monad (ApplicationT m)
Monad (ApplicationT m) =>
(Email -> ApplicationT m SendEmailResult)
-> MonadEmail (ApplicationT m)
Email -> ApplicationT m SendEmailResult
forall (m :: * -> *).
Monad m =>
(Email -> m SendEmailResult) -> MonadEmail m
forall (m :: * -> *). MonadIO m => Monad (ApplicationT m)
forall (m :: * -> *).
MonadIO m =>
Email -> ApplicationT m SendEmailResult
$csendEmail :: forall (m :: * -> *).
MonadIO m =>
Email -> ApplicationT m SendEmailResult
sendEmail :: Email -> ApplicationT m SendEmailResult
MonadEmail)

runApplicationT ::
  (MonadBaseControlIdentity IO m, MonadMask m, MonadUnliftIO m) =>
  ApplicationT m a ->
  m a
runApplicationT :: forall (m :: * -> *) a.
(MonadBaseControlIdentity IO m, MonadMask m, MonadUnliftIO m) =>
ApplicationT m a -> m a
runApplicationT ApplicationT m a
app = do
  (Environment
env, [LogLine]
preLog) <- WriterLoggingT m Environment -> m (Environment, [LogLine])
forall (m :: * -> *) a.
Functor m =>
WriterLoggingT m a -> m (a, [LogLine])
runWriterLoggingT (WriterLoggingT m Environment -> m (Environment, [LogLine]))
-> WriterLoggingT m Environment -> m (Environment, [LogLine])
forall a b. (a -> b) -> a -> b
$ do
    LogSource -> WriterLoggingT m ()
forall (m :: * -> *).
(HasCallStack, MonadLogger m) =>
LogSource -> m ()
logInfo LogSource
"Startup."
    WriterLoggingT m Environment
forall (m :: * -> *). (MonadIO m, MonadLogger m) => m Environment
acquireEnvironment

  let runTransformers :: RunStackT Transformers m a
runTransformers =
        RunStackT NilT m a
forall (b :: * -> *) c. RunStackT NilT b c
RunNilT
          RunStackT NilT m a
-> (EnvironmentT (StackT NilT m) a -> StackT NilT m a)
-> RunStackT (NilT :.|> EnvironmentT) m a
forall (ts :: Stack) (b :: * -> *) c (t :: (* -> *) -> * -> *).
RunStackT ts b c
-> (t (StackT ts b) c -> StackT ts b c)
-> RunStackT (ts :.|> t) b c
:..> Environment -> EnvironmentT (Elevator NoT m) a -> Elevator NoT m a
forall (m :: * -> *) a. Environment -> EnvironmentT m a -> m a
runEnvironmentT Environment
env
          RunStackT (NilT :.|> EnvironmentT) m a
-> (OptionsT (StackT (NilT :.|> EnvironmentT) m) a
    -> StackT (NilT :.|> EnvironmentT) m a)
-> RunStackT ((NilT :.|> EnvironmentT) :.|> OptionsT) m a
forall (ts :: Stack) (b :: * -> *) c (t :: (* -> *) -> * -> *).
RunStackT ts b c
-> (t (StackT ts b) c -> StackT ts b c)
-> RunStackT (ts :.|> t) b c
:..> OptionsT (ComposeT EnvironmentT TransparentT m) a
-> ComposeT EnvironmentT TransparentT m a
OptionsT (StackT (NilT :.|> EnvironmentT) m) a
-> StackT (NilT :.|> EnvironmentT) m a
forall (m :: * -> *) a. MonadIO m => OptionsT m a -> m a
runAppOptionsT
          RunStackT ((NilT :.|> EnvironmentT) :.|> OptionsT) m a
-> (CustomLoggingT
      (StackT ((NilT :.|> EnvironmentT) :.|> OptionsT) m) a
    -> StackT ((NilT :.|> EnvironmentT) :.|> OptionsT) m a)
-> RunStackT
     (((NilT :.|> EnvironmentT) :.|> OptionsT) :.|> CustomLoggingT) m a
forall (ts :: Stack) (b :: * -> *) c (t :: (* -> *) -> * -> *).
RunStackT ts b c
-> (t (StackT ts b) c -> StackT ts b c)
-> RunStackT (ts :.|> t) b c
:..> CustomLoggingT
  (ComposeT OptionsT (ComposeT EnvironmentT TransparentT) m) a
-> ComposeT OptionsT (ComposeT EnvironmentT TransparentT) m a
forall (m :: * -> *) a.
(MonadEnvironment m, MonadIO m, MonadMask m) =>
CustomLoggingT m a -> m a
runAppCustomLoggingT
            (CustomLoggingT
   (ComposeT OptionsT (ComposeT EnvironmentT TransparentT) m) a
 -> ComposeT OptionsT (ComposeT EnvironmentT TransparentT) m a)
-> (CustomLoggingT
      (ComposeT OptionsT (ComposeT EnvironmentT TransparentT) m) a
    -> CustomLoggingT
         (ComposeT OptionsT (ComposeT EnvironmentT TransparentT) m) a)
-> CustomLoggingT
     (ComposeT OptionsT (ComposeT EnvironmentT TransparentT) m) a
-> ComposeT OptionsT (ComposeT EnvironmentT TransparentT) m a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ((LogLine
 -> CustomLoggingT
      (ComposeT OptionsT (ComposeT EnvironmentT TransparentT) m) ())
-> [LogLine]
-> CustomLoggingT
     (ComposeT OptionsT (ComposeT EnvironmentT TransparentT) m) ()
forall (t :: * -> *) (f :: * -> *) a b.
(Foldable t, Applicative f) =>
(a -> f b) -> t a -> f ()
traverse_ LogLine
-> CustomLoggingT
     (ComposeT OptionsT (ComposeT EnvironmentT TransparentT) m) ()
forall (m :: * -> *). MonadLogger m => LogLine -> m ()
logLine [LogLine]
preLog >>)
          RunStackT
  (((NilT :.|> EnvironmentT) :.|> OptionsT) :.|> CustomLoggingT) m a
-> (ConfiguredT
      (StackT
         (((NilT :.|> EnvironmentT) :.|> OptionsT) :.|> CustomLoggingT) m)
      a
    -> StackT
         (((NilT :.|> EnvironmentT) :.|> OptionsT) :.|> CustomLoggingT) m a)
-> RunStackT
     ((((NilT :.|> EnvironmentT) :.|> OptionsT) :.|> CustomLoggingT)
      :.|> ConfiguredT)
     m
     a
forall (ts :: Stack) (b :: * -> *) c (t :: (* -> *) -> * -> *).
RunStackT ts b c
-> (t (StackT ts b) c -> StackT ts b c)
-> RunStackT (ts :.|> t) b c
:..> ConfiguredT
  (ComposeT
     CustomLoggingT
     (ComposeT OptionsT (ComposeT EnvironmentT TransparentT))
     m)
  a
-> ComposeT
     CustomLoggingT
     (ComposeT OptionsT (ComposeT EnvironmentT TransparentT))
     m
     a
ConfiguredT
  (StackT
     (((NilT :.|> EnvironmentT) :.|> OptionsT) :.|> CustomLoggingT) m)
  a
-> StackT
     (((NilT :.|> EnvironmentT) :.|> OptionsT) :.|> CustomLoggingT) m a
forall (m :: * -> *) a.
(MonadEnvironment m, MonadIO m, MonadLogger m) =>
ConfiguredT m a -> m a
runAppConfiguredT
          RunStackT
  ((((NilT :.|> EnvironmentT) :.|> OptionsT) :.|> CustomLoggingT)
   :.|> ConfiguredT)
  m
  a
-> (SeldaPoolT
      (StackT
         ((((NilT :.|> EnvironmentT) :.|> OptionsT) :.|> CustomLoggingT)
          :.|> ConfiguredT)
         m)
      a
    -> StackT
         ((((NilT :.|> EnvironmentT) :.|> OptionsT) :.|> CustomLoggingT)
          :.|> ConfiguredT)
         m
         a)
-> RunStackT
     (((((NilT :.|> EnvironmentT) :.|> OptionsT) :.|> CustomLoggingT)
       :.|> ConfiguredT)
      :.|> SeldaPoolT)
     m
     a
forall (ts :: Stack) (b :: * -> *) c (t :: (* -> *) -> * -> *).
RunStackT ts b c
-> (t (StackT ts b) c -> StackT ts b c)
-> RunStackT (ts :.|> t) b c
:..> SeldaPoolT
  (ComposeT
     ConfiguredT
     (ComposeT
        CustomLoggingT
        (ComposeT OptionsT (ComposeT EnvironmentT TransparentT)))
     m)
  a
-> ComposeT
     ConfiguredT
     (ComposeT
        CustomLoggingT
        (ComposeT OptionsT (ComposeT EnvironmentT TransparentT)))
     m
     a
SeldaPoolT
  (StackT
     ((((NilT :.|> EnvironmentT) :.|> OptionsT) :.|> CustomLoggingT)
      :.|> ConfiguredT)
     m)
  a
-> StackT
     ((((NilT :.|> EnvironmentT) :.|> OptionsT) :.|> CustomLoggingT)
      :.|> ConfiguredT)
     m
     a
forall (m :: * -> *) a.
(MonadConfigured m, MonadLogger m, MonadMask m, MonadUnliftIO m) =>
SeldaPoolT m a -> m a
runSeldaPoolT
          RunStackT
  (((((NilT :.|> EnvironmentT) :.|> OptionsT) :.|> CustomLoggingT)
    :.|> ConfiguredT)
   :.|> SeldaPoolT)
  m
  a
-> (SecretT
      (StackT
         (((((NilT :.|> EnvironmentT) :.|> OptionsT) :.|> CustomLoggingT)
           :.|> ConfiguredT)
          :.|> SeldaPoolT)
         m)
      a
    -> StackT
         (((((NilT :.|> EnvironmentT) :.|> OptionsT) :.|> CustomLoggingT)
           :.|> ConfiguredT)
          :.|> SeldaPoolT)
         m
         a)
-> RunStackT
     ((((((NilT :.|> EnvironmentT) :.|> OptionsT) :.|> CustomLoggingT)
        :.|> ConfiguredT)
       :.|> SeldaPoolT)
      :.|> SecretT)
     m
     a
forall (ts :: Stack) (b :: * -> *) c (t :: (* -> *) -> * -> *).
RunStackT ts b c
-> (t (StackT ts b) c -> StackT ts b c)
-> RunStackT (ts :.|> t) b c
:..> SecretT
  (ComposeT
     SeldaPoolT
     (ComposeT
        ConfiguredT
        (ComposeT
           CustomLoggingT
           (ComposeT OptionsT (ComposeT EnvironmentT TransparentT))))
     m)
  a
-> ComposeT
     SeldaPoolT
     (ComposeT
        ConfiguredT
        (ComposeT
           CustomLoggingT
           (ComposeT OptionsT (ComposeT EnvironmentT TransparentT))))
     m
     a
SecretT
  (StackT
     (((((NilT :.|> EnvironmentT) :.|> OptionsT) :.|> CustomLoggingT)
       :.|> ConfiguredT)
      :.|> SeldaPoolT)
     m)
  a
-> StackT
     (((((NilT :.|> EnvironmentT) :.|> OptionsT) :.|> CustomLoggingT)
       :.|> ConfiguredT)
      :.|> SeldaPoolT)
     m
     a
forall (m :: * -> *) a.
(MonadConfigured m, MonadLogger m, MonadSeldaPool m) =>
SecretT m a -> m a
runAppSecretT
          RunStackT
  ((((((NilT :.|> EnvironmentT) :.|> OptionsT) :.|> CustomLoggingT)
     :.|> ConfiguredT)
    :.|> SeldaPoolT)
   :.|> SecretT)
  m
  a
-> (EmailT
      (StackT
         ((((((NilT :.|> EnvironmentT) :.|> OptionsT) :.|> CustomLoggingT)
            :.|> ConfiguredT)
           :.|> SeldaPoolT)
          :.|> SecretT)
         m)
      a
    -> StackT
         ((((((NilT :.|> EnvironmentT) :.|> OptionsT) :.|> CustomLoggingT)
            :.|> ConfiguredT)
           :.|> SeldaPoolT)
          :.|> SecretT)
         m
         a)
-> RunStackT Transformers m a
forall (ts :: Stack) (b :: * -> *) c (t :: (* -> *) -> * -> *).
RunStackT ts b c
-> (t (StackT ts b) c -> StackT ts b c)
-> RunStackT (ts :.|> t) b c
:..> EmailT
  (ComposeT
     SecretT
     (ComposeT
        SeldaPoolT
        (ComposeT
           ConfiguredT
           (ComposeT
              CustomLoggingT
              (ComposeT OptionsT (ComposeT EnvironmentT TransparentT)))))
     m)
  a
-> ComposeT
     SecretT
     (ComposeT
        SeldaPoolT
        (ComposeT
           ConfiguredT
           (ComposeT
              CustomLoggingT
              (ComposeT OptionsT (ComposeT EnvironmentT TransparentT)))))
     m
     a
EmailT
  (StackT
     ((((((NilT :.|> EnvironmentT) :.|> OptionsT) :.|> CustomLoggingT)
        :.|> ConfiguredT)
       :.|> SeldaPoolT)
      :.|> SecretT)
     m)
  a
-> StackT
     ((((((NilT :.|> EnvironmentT) :.|> OptionsT) :.|> CustomLoggingT)
        :.|> ConfiguredT)
       :.|> SeldaPoolT)
      :.|> SecretT)
     m
     a
forall (m :: * -> *) a. MonadConfigured m => EmailT m a -> m a
runAppEmailT

  RunStackT Transformers m a -> StackT Transformers m a -> m a
forall (ts :: Stack) (m :: * -> *) a.
RunStackT ts m a -> StackT ts m a -> m a
runStackT RunStackT Transformers m a
runTransformers (StackT Transformers m a -> m a) -> StackT Transformers m a -> m a
forall a b. (a -> b) -> a -> b
$ ApplicationT m a -> StackT Transformers m a
forall (m :: * -> *) a. ApplicationT m a -> StackT Transformers m a
unApplicationT ApplicationT m a
app