diff --git a/src/models/chatMessage/chatMessage.resolvers.js b/src/models/chatMessage/chatMessage.resolvers.js
index e69de29bb2d1d6434b8b29ae775ad8c2e48c5391..e506d5823780089bc234fbc3c7ec59293f7ee726 100644
--- a/src/models/chatMessage/chatMessage.resolvers.js
+++ b/src/models/chatMessage/chatMessage.resolvers.js
@@ -0,0 +1,50 @@
+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,
+  },
+}
diff --git a/src/models/chatMessage/index.js b/src/models/chatMessage/index.js
index c3600a43785b1d81e971b84c072bdfa01fddb85b..bbd90254897e03a9f1849ceabc8bbf3df37d3bf1 100644
--- a/src/models/chatMessage/index.js
+++ b/src/models/chatMessage/index.js
@@ -1,5 +1,7 @@
 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,
 }
diff --git a/src/models/chatThread/chatThread.resolvers.js b/src/models/chatThread/chatThread.resolvers.js
index 312895c5671fff74a6e6f8ed9cd4eb2844db9c84..3ba990d4339a3fe723fe587860e66a3e951904dd 100644
--- a/src/models/chatThread/chatThread.resolvers.js
+++ b/src/models/chatThread/chatThread.resolvers.js
@@ -1,11 +1,35 @@
+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
diff --git a/src/models/chatThread/index.js b/src/models/chatThread/index.js
index 848eecbb24a0cd669ee48b6819fe8f8060eb7926..be90459cad0da41536f7ef02068ef0c4db85aa08 100644
--- a/src/models/chatThread/index.js
+++ b/src/models/chatThread/index.js
@@ -1,6 +1,10 @@
 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,
 }
diff --git a/src/models/graphqlLoaderUtil.js b/src/models/graphqlLoaderUtil.js
new file mode 100644
index 0000000000000000000000000000000000000000..c94ffb58890e959001374277b138e34708d67d44
--- /dev/null
+++ b/src/models/graphqlLoaderUtil.js
@@ -0,0 +1,9 @@
+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
diff --git a/src/models/identity/index.js b/src/models/identity/index.js
index 834344c81a0857eed4a70c9fabf36f1e529b042f..6afe7b1be1804718b53416ecc4b56f6d889ae142 100644
--- a/src/models/identity/index.js
+++ b/src/models/identity/index.js
@@ -1,4 +1,5 @@
 const model = require('./identity.model')
+const gqlLoader = require('../graphqlLoaderUtil')
 
 const {
   identitiesBasedOnUserIdsLoader,
@@ -12,4 +13,5 @@ module.exports = {
     identitiesBasedOnUserIdsLoader,
     defaultIdentityBasedOnUserIdsLoader,
   },
+  typeDefs: gqlLoader('./identity.graphql'),
 }
diff --git a/src/models/team/index.js b/src/models/team/index.js
index f5e111e769ac354444f80c0c2d188ddf1b7a59de..0c21c758bec2dfc87db1a4dbea6a238590f5c04a 100644
--- a/src/models/team/index.js
+++ b/src/models/team/index.js
@@ -1,6 +1,10 @@
 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,
 }
diff --git a/src/models/team/team.resolvers.js b/src/models/team/team.resolvers.js
index 08db6ba0149e79db818cea024c15b27ef1b554c7..cfea1c1b49c0b019cbe337db2a434f01a0852e3f 100644
--- a/src/models/team/team.resolvers.js
+++ b/src/models/team/team.resolvers.js
@@ -1,3 +1,9 @@
+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) {
diff --git a/src/models/teamMember/index.js b/src/models/teamMember/index.js
index cc405b2f4b3b3a5d5c39288b2508dcc82c06ed0d..f3d88d0b309f0cc1dfc4e80a454372027fa024ab 100644
--- a/src/models/teamMember/index.js
+++ b/src/models/teamMember/index.js
@@ -1,4 +1,6 @@
 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,
 }
diff --git a/src/models/user/index.js b/src/models/user/index.js
index 531474c6442ce5bf2682edde245e76e73566a99b..93bfc670000e59a7a198725a465bd5a1bbaaa5b2 100644
--- a/src/models/user/index.js
+++ b/src/models/user/index.js
@@ -1,5 +1,7 @@
 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,
 }
diff --git a/src/models/user/user.controller.js b/src/models/user/user.controller.js
index 53da2c25f0785bd01b755ecd57f35b9ab90c868c..5bbab16157b7ea3dd40dabd25520d97de720fc1c 100644
--- a/src/models/user/user.controller.js
+++ b/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,
diff --git a/src/models/user/user.graphql b/src/models/user/user.graphql
index 8c7e16b101497fd8626f01a7d0f9e3c04a28d699..9b0b84cf7621a4deaa6e239d167977673c72f894 100644
--- a/src/models/user/user.graphql
+++ b/src/models/user/user.graphql
@@ -1,5 +1,11 @@
 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!
diff --git a/src/models/user/user.resolvers.js b/src/models/user/user.resolvers.js
index 22f082e613f29cb7118362c985d560ee3ffae764..03bd9ca6f2c0a2ed749e16c914c9298f9a1ad390 100644
--- a/src/models/user/user.resolvers.js
+++ b/src/models/user/user.resolvers.js
@@ -1,3 +1,9 @@
+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) {