refactor(models): resolvers corrected

src/models/chatMessage/chatMessage.resolvers.js

+const { logger } = require('../../index')
+
+const {
+  labels: { CHAT_MESSAGE_RESOLVER },
+} = require('./constants')
+const {
+  sendMessage,
+  deleteMessage,
+  editMessage,
+} = require('./chatMessage.controller')
+
+const sendMessageResolver = async (_, { input }, ctx) => {
+  try {
+    const { chatThreadId, content, userId, mentions } = input
+    logger.error(`${CHAT_MESSAGE_RESOLVER} sendMessage`)
+    return sendMessage(chatThreadId, content, userId, mentions)
+  } catch (e) {
+    logger.error(`${CHAT_MESSAGE_RESOLVER} sendMessage: ${e.message}`)
+    throw new Error(e)
+  }
+}
+
+const editMessageResolver = async (_, { input }, ctx) => {
+  try {
+    const { id, content, mentions } = input
+    logger.error(`${CHAT_MESSAGE_RESOLVER} editMessage`)
+    return editMessage(id, content, mentions)
+  } catch (e) {
+    logger.error(`${CHAT_MESSAGE_RESOLVER} editMessage: ${e.message}`)
+    throw new Error(e)
+  }
+}
+
+const deleteMessageResolver = async (_, { id }, ctx) => {
+  try {
+    logger.error(`${CHAT_MESSAGE_RESOLVER} deleteMessage`)
+    return deleteMessage(id)
+  } catch (e) {
+    logger.error(`${CHAT_MESSAGE_RESOLVER} deleteMessage: ${e.message}`)
+    throw new Error(e)
+  }
+}
+
+module.exports = {
+  Mutation: {
+    sendMessage: sendMessageResolver,
+    editMessage: editMessageResolver,
+    deleteMessage: deleteMessageResolver,
+  },
+}

src/models/chatMessage/index.js

 const model = require('./chatMessage.model')
+const gqlLoader = require('../graphqlLoaderUtil')
 const { messagesBasedOnChatThreadIdsLoader } = require('./chatMessage.loaders')
+const chatMessageResolvers = require('./chatMessage.resolvers')
 
 module.exports = {
   model,
@@ -7,4 +9,6 @@ module.exports = {
   modelLoaders: {
     messagesBasedOnChatThreadIdsLoader,
   },
+  typeDefs: gqlLoader('./chatMessage.graphql'),
+  resolvers: chatMessageResolvers,
 }

src/models/chatThread/chatThread.resolvers.js

+const { logger } = require('../../index')
+
+const {
+  labels: { CHAT_THREAD_RESOLVER },
+} = require('./constants')
 const { getChatThread, getChatThreads } = require('./chatThread.controller')
 
+const chatThreadResolver = async (_, { id }, ctx) => {
+  try {
+    logger.error(`${CHAT_THREAD_RESOLVER} getChatThread`)
+    return getChatThread(id)
+  } catch (e) {
+    logger.error(`${CHAT_THREAD_RESOLVER} getChatThread: ${e.message}`)
+    throw new Error(e)
+  }
+}
+
+const chatThreadsResolver = async (_, { where }, ctx) => {
+  try {
+    logger.error(`${CHAT_THREAD_RESOLVER} getChatThreads`)
+    return getChatThreads(where)
+  } catch (e) {
+    logger.error(`${CHAT_THREAD_RESOLVER} getChatThreads: ${e.message}`)
+    throw new Error(e)
+  }
+}
+
 module.exports = {
   Query: {
-    chatThread: getChatThread,
-    chatThreads: getChatThreads,
+    chatThread: chatThreadResolver,
+    chatThreads: chatThreadsResolver,
   },
-
   ChatThread: {
     async messages(chatThread, _, ctx) {
       const { id } = chatThread

src/models/chatThread/index.js

 const model = require('./chatThread.model')
+const gqlLoader = require('../graphqlLoaderUtil')
+const chatThreadResolvers = require('./chatThread.resolvers')
 
 module.exports = {
   model,
   modelName: 'ChatThread',
+  typeDefs: gqlLoader('./chatThread.graphql'),
+  resolvers: chatThreadResolvers,
 }

src/models/graphqlLoaderUtil.js

+const fs = require('fs')
+const path = require('path')
+
+const loadGQLFile = type => {
+  const filePath = path.join(__dirname, type)
+  return fs.readFileSync(filePath, 'utf-8')
+}
+
+module.exports = loadGQLFile

src/models/identity/index.js

 const model = require('./identity.model')
+const gqlLoader = require('../graphqlLoaderUtil')
 
 const {
   identitiesBasedOnUserIdsLoader,
@@ -12,4 +13,5 @@ module.exports = {
     identitiesBasedOnUserIdsLoader,
     defaultIdentityBasedOnUserIdsLoader,
   },
+  typeDefs: gqlLoader('./identity.graphql'),
 }

src/models/team/index.js

 const model = require('./team.model')
+const gqlLoader = require('../graphqlLoaderUtil')
+const teamResolvers = require('./team.resolvers')
 
 module.exports = {
   model,
   modelName: 'Team',
+  typeDefs: gqlLoader('./team.graphql'),
+  resolvers: teamResolvers,
 }

src/models/team/team.resolvers.js

+const { logger } = require('../../index')
+
+const {
+  labels: { TEAM_RESOLVER },
+} = require('./constants')
+
 const {
   getTeam,
   getTeams,
@@ -6,21 +12,101 @@ const {
   updateTeamMembership,
   addTeamMember,
   removeTeamMember,
-  deleteTeam,
+  // deleteTeam,
 } = require('./team.controller')
 
+const teamResolver = async (_, { id }, ctx) => {
+  try {
+    logger.error(`${TEAM_RESOLVER} team`)
+    return getTeam(id)
+  } catch (e) {
+    logger.error(`${TEAM_RESOLVER} team: ${e.message}`)
+    throw new Error(e)
+  }
+}
+
+const teamsResolver = async (_, { where }, ctx) => {
+  try {
+    logger.error(`${TEAM_RESOLVER} teams`)
+    return getTeams(where)
+  } catch (e) {
+    logger.error(`${TEAM_RESOLVER} teams: ${e.message}`)
+    throw new Error(e)
+  }
+}
+
+const getGlobalTeamsResolver = async (_, { where }, ctx) => {
+  try {
+    logger.error(`${TEAM_RESOLVER} getGlobalTeams`)
+    return getGlobalTeams()
+  } catch (e) {
+    logger.error(`${TEAM_RESOLVER} getGlobalTeams: ${e.message}`)
+    throw new Error(e)
+  }
+}
+
+const getObjectTeamsResolver = async (_, { objectId, objectType }, ctx) => {
+  try {
+    logger.error(`${TEAM_RESOLVER} getObjectTeams`)
+    return getObjectTeams(objectId, objectType)
+  } catch (e) {
+    logger.error(`${TEAM_RESOLVER} getObjectTeams: ${e.message}`)
+    throw new Error(e)
+  }
+}
+
+const updateTeamMembershipResolver = async (_, { teamId, members }, ctx) => {
+  try {
+    logger.error(`${TEAM_RESOLVER} updateTeamMembership`)
+    return updateTeamMembership(teamId, members)
+  } catch (e) {
+    logger.error(`${TEAM_RESOLVER} updateTeamMembership: ${e.message}`)
+    throw new Error(e)
+  }
+}
+
+const addTeamMemberResolver = async (_, { teamId, userId }, ctx) => {
+  try {
+    logger.error(`${TEAM_RESOLVER} addTeamMember`)
+    return addTeamMember(teamId, userId)
+  } catch (e) {
+    logger.error(`${TEAM_RESOLVER} addTeamMember: ${e.message}`)
+    throw new Error(e)
+  }
+}
+
+const removeTeamMemberResolver = async (_, { teamId, userId }, ctx) => {
+  try {
+    logger.error(`${TEAM_RESOLVER} removeTeamMember`)
+    return removeTeamMember(teamId, userId)
+  } catch (e) {
+    logger.error(`${TEAM_RESOLVER} removeTeamMember: ${e.message}`)
+    throw new Error(e)
+  }
+}
+
+// const deleteTeamResolver = async (_, { id }, ctx) => {
+//   try {
+//     logger.error(`${TEAM_RESOLVER} deleteTeam`)
+//     return deleteTeam(id)
+//   } catch (e) {
+//     logger.error(`${TEAM_RESOLVER} deleteTeam: ${e.message}`)
+//     throw new Error(e)
+//   }
+// }
+
 module.exports = {
   Query: {
-    team: getTeam,
-    teams: getTeams,
-    getGlobalTeams,
-    getObjectTeams,
+    team: teamResolver,
+    teams: teamsResolver,
+    getGlobalTeams: getGlobalTeamsResolver,
+    getObjectTeams: getObjectTeamsResolver,
   },
   Mutation: {
-    updateTeamMembership,
-    addTeamMember,
-    removeTeamMember,
-    deleteTeam,
+    updateTeamMembership: updateTeamMembershipResolver,
+    addTeamMember: addTeamMemberResolver,
+    removeTeamMember: removeTeamMemberResolver,
+    // deleteTeam:deleteTeamResolver,
   },
   Team: {
     async members(team, _, ctx) {

src/models/teamMember/index.js

 const model = require('./teamMember.model')
+const gqlLoader = require('../graphqlLoaderUtil')
+const teamMemberResolvers = require('./teamMember.resolvers')
 
 const { teamMembersBasedOnTeamIdsLoader } = require('./teamMember.loaders')
 
@@ -8,4 +10,6 @@ module.exports = {
   modelLoaders: {
     teamMembersBasedOnTeamIdsLoader,
   },
+  typeDefs: gqlLoader('./teamMember.graphql'),
+  resolvers: teamMemberResolvers,
 }

src/models/user/index.js

 const model = require('./user.model')
+const gqlLoader = require('../graphqlLoaderUtil')
 const { usersBasedOnTeamMemberIdsLoader } = require('./user.loaders')
+const userResolvers = require('./user.resolvers')
 
 module.exports = {
   model,
@@ -7,4 +9,6 @@ module.exports = {
   modelLoaders: {
     usersBasedOnTeamMemberIdsLoader,
   },
+  typeDefs: gqlLoader('./user.graphql'),
+  resolvers: userResolvers,
 }

src/models/user/user.controller.js

@@ -485,7 +485,11 @@ const resendVerificationEmail = async (token, options = {}) => {
   }
 }
 
-const resendVerificationEmailFromLogin = async (username, options = {}) => {
+const resendVerificationEmailFromLogin = async (
+  username,
+  password,
+  options = {},
+) => {
   try {
     const { trx } = options
     logger.info(
@@ -499,6 +503,11 @@ const resendVerificationEmailFromLogin = async (username, options = {}) => {
             `${USER_CONTROLLER} resendVerificationEmailFromLogin: no user with username ${username} found`,
           )
 
+        if (!user.isPasswordValid(password)) {
+          throw new Error(
+            `${USER_CONTROLLER} resendVerificationEmailFromLogin: wrong credentials`,
+          )
+        }
         const identity = await Identity.findOne(
           {
             isDefault: true,

src/models/user/user.graphql

 scalar DateTime
 
+# find a better place to inject that
+input PageInput {
+  pageSize: Int!
+  pageNumber: Int!
+}
+#
 type User {
   id: ID!
   created: DateTime!
@@ -51,6 +57,7 @@ input UpdateInput {
 }
 
 input UpdatePasswordInput {
+  id: ID!
   currentPassword: String!
   newPassword: String!
 }
@@ -63,11 +70,11 @@ extend type Query {
 
 extend type Mutation {
   activateUser(id: ID!): User!
-  activateUsers(id: [ID!]!): [User!]!
+  activateUsers(ids: [ID!]!): [User!]!
   deleteUser(id: ID!): ID!
-  deleteUsers(id: [ID!]!): [ID!]!
+  deleteUsers(ids: [ID!]!): [ID!]!
   deactivateUser(id: ID!): User!
-  deactivateUsers(id: [ID!]!): [User!]!
+  deactivateUsers(ids: [ID!]!): [User!]!
   updateUser(id: ID, input: UpdateInput!): User!
   login(input: LoginInput!): LoginResult!
   signUp(input: SignUpInput!): ID!

src/models/user/user.resolvers.js

+const { logger } = require('../../index')
+
+const {
+  labels: { USER_RESOLVER },
+} = require('./constants')
+
 const {
   getUser,
   getUsers,
@@ -20,29 +26,227 @@ const {
   getDisplayName,
 } = require('./user.controller')
 
+const userResolver = async (_, { id }, ctx) => {
+  try {
+    logger.error(`${USER_RESOLVER} user`)
+    return getUser(id)
+  } catch (e) {
+    logger.error(`${USER_RESOLVER} user: ${e.message}`)
+    throw new Error(e)
+  }
+}
+
+const usersResolver = async (_, args, ctx) => {
+  try {
+    logger.error(`${USER_RESOLVER} users`)
+    return getUsers()
+  } catch (e) {
+    logger.error(`${USER_RESOLVER} users: ${e.message}`)
+    throw new Error(e)
+  }
+}
+
+const currentUserResolver = async (_, __, ctx) => {
+  try {
+    const { user: userId } = ctx
+    logger.error(`${USER_RESOLVER} currentUser`)
+    if (!userId) return null
+    return getUser(userId)
+  } catch (e) {
+    logger.error(`${USER_RESOLVER} currentUser: ${e.message}`)
+    throw new Error(e)
+  }
+}
+
+const activateUserResolver = async (_, { id }, ctx) => {
+  try {
+    logger.error(`${USER_RESOLVER} activateUser`)
+    return activateUser(id)
+  } catch (e) {
+    logger.error(`${USER_RESOLVER} activateUser: ${e.message}`)
+    throw new Error(e)
+  }
+}
+
+const activateUsersResolver = async (_, { ids }, ctx) => {
+  try {
+    logger.error(`${USER_RESOLVER} activateUsers`)
+    return activateUsers(ids)
+  } catch (e) {
+    logger.error(`${USER_RESOLVER} activateUsers: ${e.message}`)
+    throw new Error(e)
+  }
+}
+
+const deleteUserResolver = async (_, { id }, ctx) => {
+  try {
+    logger.error(`${USER_RESOLVER} deleteUser`)
+    return deleteUser(id)
+  } catch (e) {
+    logger.error(`${USER_RESOLVER} deleteUser: ${e.message}`)
+    throw new Error(e)
+  }
+}
+
+const deleteUsersResolver = async (_, { ids }, ctx) => {
+  try {
+    logger.error(`${USER_RESOLVER} deleteUsers`)
+    return deleteUsers(ids)
+  } catch (e) {
+    logger.error(`${USER_RESOLVER} deleteUsers: ${e.message}`)
+    throw new Error(e)
+  }
+}
+
+const deactivateUserResolver = async (_, { id }, ctx) => {
+  try {
+    logger.error(`${USER_RESOLVER} deactivateUser`)
+    return deactivateUser(id)
+  } catch (e) {
+    logger.error(`${USER_RESOLVER} deactivateUser: ${e.message}`)
+    throw new Error(e)
+  }
+}
+
+const deactivateUsersResolver = async (_, { ids }, ctx) => {
+  try {
+    logger.error(`${USER_RESOLVER} deactivateUsers`)
+    return deactivateUsers(ids)
+  } catch (e) {
+    logger.error(`${USER_RESOLVER} deactivateUsers: ${e.message}`)
+    throw new Error(e)
+  }
+}
+
+const updateUserResolver = async (_, { id, input }, ctx) => {
+  try {
+    logger.error(`${USER_RESOLVER} updateUser`)
+    return updateUser(id, input)
+  } catch (e) {
+    logger.error(`${USER_RESOLVER} updateUser: ${e.message}`)
+    throw new Error(e)
+  }
+}
+
+const loginResolver = async (_, { email, username, password }, ctx) => {
+  try {
+    logger.error(`${USER_RESOLVER} login`)
+    return login(email, username, password)
+  } catch (e) {
+    logger.error(`${USER_RESOLVER} login: ${e.message}`)
+    throw new Error(e)
+  }
+}
+
+const signUpResolver = async (_, { input }, ctx) => {
+  try {
+    logger.error(`${USER_RESOLVER} signUp`)
+    return signUp(input)
+  } catch (e) {
+    logger.error(`${USER_RESOLVER} signUp: ${e.message}`)
+    throw new Error(e)
+  }
+}
+
+const setDefaultIdentityResolver = async (_, { userId, identityId }, ctx) => {
+  try {
+    logger.error(`${USER_RESOLVER} setDefaultIdentity`)
+    return setDefaultIdentity(userId, identityId)
+  } catch (e) {
+    logger.error(`${USER_RESOLVER} setDefaultIdentity: ${e.message}`)
+    throw new Error(e)
+  }
+}
+
+const verifyEmailResolver = async (_, { token }, ctx) => {
+  try {
+    logger.error(`${USER_RESOLVER} verifyEmail`)
+    return verifyEmail(token)
+  } catch (e) {
+    logger.error(`${USER_RESOLVER} verifyEmail: ${e.message}`)
+    throw new Error(e)
+  }
+}
+
+const resendVerificationEmailResolver = async (_, { token }, ctx) => {
+  try {
+    logger.error(`${USER_RESOLVER} resendVerificationEmail`)
+    return resendVerificationEmail(token)
+  } catch (e) {
+    logger.error(`${USER_RESOLVER} resendVerificationEmail: ${e.message}`)
+    throw new Error(e)
+  }
+}
+
+const resendVerificationEmailFromLoginResolver = async (
+  _,
+  { username, password },
+  ctx,
+) => {
+  try {
+    logger.error(`${USER_RESOLVER} resendVerificationEmailFromLogin`)
+    return resendVerificationEmailFromLogin(username, password)
+  } catch (e) {
+    logger.error(
+      `${USER_RESOLVER} resendVerificationEmailFromLogin: ${e.message}`,
+    )
+    throw new Error(e)
+  }
+}
+
+const updatePasswordResolver = async (_, { input }, ctx) => {
+  try {
+    logger.error(`${USER_RESOLVER} updatePassword`)
+    return updatePassword(input)
+  } catch (e) {
+    logger.error(`${USER_RESOLVER} updatePassword: ${e.message}`)
+    throw new Error(e)
+  }
+}
+
+const sendPasswordResetEmailResolver = async (_, { email }, ctx) => {
+  try {
+    logger.error(`${USER_RESOLVER} sendPasswordResetEmail`)
+    return sendPasswordResetEmail(email)
+  } catch (e) {
+    logger.error(`${USER_RESOLVER} sendPasswordResetEmail: ${e.message}`)
+    throw new Error(e)
+  }
+}
+
+const resetPasswordResolver = async (_, { token, password }, ctx) => {
+  try {
+    logger.error(`${USER_RESOLVER} resetPassword`)
+    return resetPassword(token, password)
+  } catch (e) {
+    logger.error(`${USER_RESOLVER} resetPassword: ${e.message}`)
+    throw new Error(e)
+  }
+}
+
 module.exports = {
   Query: {
-    user: getUser,
-    users: getUsers,
-    currentUser: getUser,
+    user: userResolver,
+    users: usersResolver,
+    currentUser: currentUserResolver,
   },
   Mutation: {
-    activateUser,
-    activateUsers,
-    deleteUser,
-    deleteUsers,
-    deactivateUser,
-    deactivateUsers,
-    updateUser,
-    login,
-    signUp,
-    setDefaultIdentity,
-    verifyEmail,
-    resendVerificationEmail,
-    resendVerificationEmailFromLogin,
-    updatePassword,
-    sendPasswordResetEmail,
-    resetPassword,
+    activateUser: activateUserResolver,
+    activateUsers: activateUsersResolver,
+    deleteUser: deleteUserResolver,
+    deleteUsers: deleteUsersResolver,
+    deactivateUser: deactivateUserResolver,
+    deactivateUsers: deactivateUsersResolver,
+    updateUser: updateUserResolver,
+    login: loginResolver,
+    signUp: signUpResolver,
+    setDefaultIdentity: setDefaultIdentityResolver,
+    verifyEmail: verifyEmailResolver,
+    resendVerificationEmail: resendVerificationEmailResolver,
+    resendVerificationEmailFromLogin: resendVerificationEmailFromLoginResolver,
+    updatePassword: updatePasswordResolver,
+    sendPasswordResetEmail: sendPasswordResetEmailResolver,
+    resetPassword: resetPasswordResolver,
   },
   User: {
     async identities(user, _, ctx) {