• One typo: just after proto-lens: Protobugf
• The link for co-log points to relude
• Also, I find the description for co-log ill-suited. I would assume the intended audience is has more an engineering mindset, but "composable contravariant comonadic logging library" seems straight out of an academic paper. If someone is comfortable with all of that, they are probably too busy writing another cool library using their latest paper, for other people, it's just off-putting.
  How about composable and configurable logging library?

As @vrom911 noticed, this is more useful than copy-pasting structure description.

When I tried cabal new-repl, I got the following errors:
'packedFileDescriptor' is not a (visible) method of class 'Data.ProtoLens.Message'. I checked the proto-lens package and this method is at version 0.7.0.0, but I use 'proto-lens' 0.5.0.0. I don't know why it generated the haskell source for 'proto-lens` 0.7.0.0

Beginner friendly

• Add -Wall to tests and executables
• Pattern-matching in String jwtId
• Move Jwt from Util.* to Lib.Core.Jwt
• Move Password from Util.* to Lib.Core.Password
• Move database-related functions from Util.App to Lib.Db
• Move error-related functions from Util.App to Lib.App.Error
• Add perform to Lib.Db
• Add Makefile with ghcid command
• Left HeaderDecodeError -> throwError err404 should be err401
• Extend default-extensions
• Update stack.yaml with -fhide-src-paths
• Deriving order for newtypes
• Split Lib.Util.App module
• Refactor errors to new model in protobuf and enum and with toHttpError

Medium friendly

• JwtSpec and PasswordSpec
• Add ekg
• Add Date data type to protobuf
• Add newtype Seconds to Lib.Time module and refactor existing functions

Hard friendly

• Server.Types module with convenient type aliases
• Decide on katip vs. monad-logger, migrate to released katip version if chosen, remove forked repo

We need tool which will copy three-layer repository and rename all modules and directories according to provided names of new project and module prefix.

What should be changed?

• Name of the project inside package.yaml
• GitHub user and package name inside package.yaml
• Name of Lib/ folder inside src/ to new prefix
• Every module name
• Every Lib.* import inside each module

Specification

1. Tool takes two CLI arguments: name of new project and module prefix.
2. Should be implemented as separate executable/package inside three-layer repository and should clone everything from repo except tool itself.
3. New project should be buildable without errors and warnings after using the tool.
4. ★ Implement automated tests for this executable.

• Add Makefile with all relevant commands
• Make DbPool field strict
• Get rid of MockApp

Candidates

• Email
• Id
• JwtSecret
• JwtToken
• Label

It doesn't give us the required flexibility when the time comes to testing SQL.

• Use newer .stylish-haskell.yaml
• Update .gitignore
• Add {-# INLINE #-} to some small functions
• Use Type -> Type in Server.Types
• Use bcrypt extension in psql, use WHERE email = LOWER(?)
• Make fields strict in all data types
• Update comment to User data type mentioning SQL table

Motivated by this blog-post:

• https://chrisdone.com/posts/measuring-duration-in-haskell

I've been trying to make a simpler version of three-layers, which doesn't have logging but I'm not able to find out what I need to put in place of hoistServer from bellow?

This is what I have so far but also unsure if I should be passing my AppEnv through to my httpServer:

type AppApi = ToApi HttpSite

-- | These are the routes to the http app
data HttpSite route = HttpSite
    { -- | Post Hello
      helloRoute :: route
        :- "hello"
        :> Post '[JSON] HelloRes
    } deriving (Generic)

newtype HelloRes = HelloRes { msg :: String }
  deriving Generic

instance ToJSON HelloRes

httpServer :: HttpSite AppServer
httpServer = HttpSite
    { helloRoute = helloHandler
    }

-- | update the request count by one and return
helloHandler :: ( MonadStats m ) => m HelloRes
helloHandler = do
    reqCount <- getStats
    let newReqCount = (reqCount + 1)
    putStats newReqCount
    pure $ HelloRes (show newReqCount)

httpApp :: AppEnv -> Application
httpApp env = serve
    (Proxy @AppApi)
    httpServer -- ?? should I pass the env

right now I get the error:

Couldn't match type ‘Handler HelloRes’ with ‘HttpSite AppServer’
Expected type: Server ("hello" :> Post '[JSON] HelloRes)

I've been trying to look through the docs for servant but can't find anything that helps 😸

This library:

• https://github.com/chpatrick/servant-generic#tldr

Just replace with ordinary function.

Should these be turned into a type synonym?

• Run HLint properly on CI
• Use another Docker image
• Move a file to a directory (as suggested in Circle CI)

It would be good to the check this property:

verifyPassword pwd (mkPasswordHash pwd) === True

It's quite outdated. Requires huge rewriting.

Thank you for this starter project! Being relatively new to Haskell, the structure seems clear and easy to follow with nice separation of concerns.

I would like to integrate the servant-auth library for easy JWT authentication, but whatever I try, I do not get it to compile. Could maybe somebody give me an indication about the general approach that would be necessary?
What I tried:

• I took this tutorial as a general guide: https://haskell-servant.readthedocs.io/en/stable/cookbook/hoist-server-with-context/HoistServerWithContext.html.
• I created a new "Effect" to abstract the IO away from acceptLogin.
• Already here I get an "Overlapping Instances" error arising from a use of Servant.Auth.Server.acceptLogin

Maybe I have approached this all wrong? How would you use JWT authentication without repeating authentication logic for each handler?

We also depend on lens. So there's no need to have an extra dependency.

The error with grab and TypeApplications.

• https://github.com/Holmusk/three-layer/blob/master/src/Lib/Effects/Session.hs

To be able to run the application, add some tests to them

Current approach with MonadReader AppEnv m is not very convenient. It doesn't allow convenient mocks. So this type class signature is not perfect:

class (MonadReader AppEnv m, MonadError AppError m, MonadIO m) => MonadUser m where

It's better to have:

class MonadUser m where
instance MonadUser App where

We can go further and introduce Has* type classes. So we will have:

data AppEnv = AppEnv
  { dbPool    :: Pool Connection
  , sessions  :: MVar (Map Text Session)
  , jwtSecret :: Text
  , timings   :: IORef (Map Text Distribution)
  , ekgStore  :: Store
  }

class HasDbPool r
class HasSessions r
class HasJwtSecret r
...

And instead of having type like this:

getUserDetailImpl 
  :: ( MonadReader AppEnv m
     , MonadError AppError m
     , MonadIO m
     ) => Text -> m UserDetail

We will have type:

getUserDetailImpl 
  :: ( MonadReader r m, HasDbPool r
     , MonadError AppError m
     , MonadIO m
     ) => Text -> m UserDetail

So it's completely clear from type that this function uses only DB.

• Route suffix for endpoints
• Handler suffix for endpoint implementations
• Impl suffix for effects implementation

Not sure how this can be done. But what we want:

1. Generate new project using fix-point.
2. Build this new project to check whether it actually builds.

The Left case can be simplified to appError `shouldBe` err.

By moving most common to the Prelude

Because it will be always Text. And don't export it, it should be only for DB.