better naming, import qualified

Author: dandoh

src/Database/Base.hs

@@ -12,38 +12,38 @@ import Opaleye.Internal.Manipulation (Updater)
 type F a = Field a
 
 -------------------------------------------------------------------------------
-data Entity a b c
+data EntityT a b c
   = Entity
       { record :: a,
         recordCreatedAt :: b,
         recordUpdatedAt :: c
       }
 
-$(makeAdaptorAndInstance "pEntity" ''Entity)
+$(makeAdaptorAndInstance "pEntity" ''EntityT)
 
 -------------------------------------------------------------------------------
-type EntityData a =
-  Entity
+type Entity a =
+  EntityT
     a
     UTCTime
     UTCTime
 
 type EntityWriteField a =
-  Entity
+  EntityT
     a
     (Maybe (F SqlTimestamptz))
     (Maybe (F SqlTimestamptz))
 
 type EntityField a =
-  Entity
+  EntityT
     a
     (F SqlTimestamptz)
     (F SqlTimestamptz)
 
 -------------------------------------------------------------------------------
 withTimestampFields ::
   a ->
-  Entity
+  EntityT
     a
     (TableFields (Maybe (F SqlTimestamptz)) (F SqlTimestamptz))
     (TableFields (Maybe (F SqlTimestamptz)) (F SqlTimestamptz))
@@ -55,15 +55,15 @@ withTimestampFields mapping =
     }
 
 -------------------------------------------------------------------------------
-withTimestamp :: [row] -> [Entity row (Maybe timestamp) (Maybe timestamp)]
+withTimestamp :: [row] -> [EntityT row (Maybe timestamp) (Maybe timestamp)]
 withTimestamp = map f
   where
     f r = Entity {record = r, recordCreatedAt = Nothing, recordUpdatedAt = Nothing}
 
 -------------------------------------------------------------------------------
 updateRecord ::
-  Default Updater (Entity record t t) fieldsW =>
+  Default Updater (EntityT record t t) fieldsW =>
   (record -> record) ->
-  Entity record t t ->
+  EntityT record t t ->
   fieldsW
 updateRecord f = updateEasy (\r -> r {record = f (record r)})

src/Database/Model.hs

@@ -11,7 +11,7 @@ import Opaleye.Internal.Manipulation (Updater)
 
 -------------------------------------------------------------------------------
 data UserT a b c d
-  = UserRecord
+  = User
       { userId :: a,
         userEmail :: b,
         userPasswordHash :: c,
@@ -20,8 +20,8 @@ data UserT a b c d
 
 $(makeAdaptorAndInstance "pUser" ''UserT)
 
-type UserData =
-  EntityData
+type User =
+  Entity
     ( UserT
         Int
         Text
@@ -49,7 +49,7 @@ type UserField =
 userTable :: Table UserWriteField UserField
 userTable =
   table "users" . pEntity . withTimestampFields $
-    pUser UserRecord
+    pUser User
       { userId = tableField "id",
         userEmail = tableField "email",
         userPasswordHash = tableField "password_hash",

src/Database/User.hs

@@ -18,7 +18,7 @@ insertUser (userEmail, userPasswordHash, userName) =
     { iTable = userTable,
       iRows =
         withTimestamp
-          [ UserRecord
+          [ User
               { userId = Nothing,
                 userEmail = toFields userEmail,
                 userPasswordHash = toFields userPasswordHash,

src/Graphql.hs

@@ -22,9 +22,7 @@ import Data.Text (Text)
 import qualified Data.Text as T
 import qualified Data.Text.Lazy as LT
 import Data.Time.Clock (getCurrentTime)
-import Database.Model
 import Database.PostgreSQL.Simple (Connection)
-import Database.User
 import GHC.Int (Int64)
 import qualified Opaleye
 import Opaleye (FromFields, Insert, Select, Update)

src/Graphql/Resolver/User.hs

@@ -15,16 +15,16 @@ import qualified Data.Text as T
 import qualified Data.Text.Lazy as LT
 import Data.Time.Clock (getCurrentTime)
 import Database.Base
-import Database.Model
+import qualified Database.Model as DB
 import Database.PostgreSQL.Simple (Connection)
 import Database.User
 import GHC.Int (Int64)
 import Graphql
 
 -------------------------------------------------------------------------------
-userResolver :: GraphQL o => UserData -> Object o User
+userResolver :: GraphQL o => DB.User -> Object o User
 userResolver user =
-  let UserRecord {userId, userEmail, userName} = record user
+  let DB.User {userId, userEmail, userName} = record user
    in return User
         { id = pure userId,
           email = pure userEmail,
@@ -36,19 +36,19 @@ userResolver user =
 -------------------------------------------------------------------------------
 loginResolver :: GraphQL o => LoginArgs -> Object o Session
 loginResolver LoginArgs {email, password} = do
-  res :: [UserData] <- runSelect $ findUserByEmail email
+  res :: [DB.User] <- runSelect $ findUserByEmail email
   case res of
-    [user] | validateHashedPassword (userPasswordHash . record $ user) password -> do
+    [user] | validateHashedPassword (DB.userPasswordHash . record $ user) password -> do
       time <- liftIO getCurrentTime
       secret <- lift $ asks (jwtSecret . config)
-      let jwt = makeJWT time secret (userId . record $ user)
+      let jwt = makeJWT time secret (DB.userId . record $ user)
       return Session {token = pure jwt, user = userResolver user}
     _ -> failRes "Wrong email or password"
 
 -------------------------------------------------------------------------------
 registerResolver :: RegisterArgs -> Object MUTATION Session
 registerResolver RegisterArgs {email, password, name} = do
-  res :: [UserData] <- runSelect $ findUserByEmail email
+  res :: [DB.User] <- runSelect $ findUserByEmail email
   case res of
     _ : _ -> failRes "This email is already taken"
     [] -> do
@@ -66,8 +66,8 @@ myUserInfoResolver = do
 changePasswordResolver :: ChangePasswordArgs -> Value MUTATION Bool
 changePasswordResolver ChangePasswordArgs {oldPassword, newPassword} = do
   myUserId <- requireAuthorized
-  userData :: UserData <- runSelectOne (findUserByID myUserId) "Invalid user"
-  if validateHashedPassword (userPasswordHash . record $ userData) oldPassword
+  userData :: DB.User <- runSelectOne (findUserByID myUserId) "Invalid user"
+  if validateHashedPassword (DB.userPasswordHash . record $ userData) oldPassword
     then do
       ph <- liftIO $ hashPassword newPassword
       runUpdate $ updateUserPassword myUserId ph