Project managers, board members, auto-update after reconnection, refactoring

server/api/controllers/access-tokens/create.js

@@ -37,8 +37,8 @@ module.exports = {
     },
   },
 
-  async fn(inputs, exits) {
-    const user = await sails.helpers.getUserByEmailOrUsername(inputs.emailOrUsername);
+  async fn(inputs) {
+    const user = await sails.helpers.users.getOneByEmailOrUsername(inputs.emailOrUsername);
 
     if (!user) {
       throw Errors.INVALID_EMAIL_OR_USERNAME;
@@ -48,8 +48,8 @@ module.exports = {
       throw Errors.INVALID_PASSWORD;
     }
 
-    return exits.success({
-      item: sails.helpers.signToken(user.id),
-    });
+    return {
+      item: sails.helpers.utils.signToken(user.id),
+    };
   },
 };

server/api/controllers/actions/index.js

@@ -23,32 +23,36 @@ module.exports = {
     },
   },
 
-  async fn(inputs, exits) {
+  async fn(inputs) {
     const { currentUser } = this.req;
 
-    const { project } = await sails.helpers
-      .getCardToProjectPath(inputs.cardId)
+    const { card, project } = await sails.helpers.cards
+      .getProjectPath(inputs.cardId)
       .intercept('pathNotFound', () => Errors.CARD_NOT_FOUND);
 
-    const isUserMemberForProject = await sails.helpers.isUserMemberForProject(
-      project.id,
-      currentUser.id,
-    );
+    const isBoardMember = await sails.helpers.users.isBoardMember(currentUser.id, card.boardId);
 
-    if (!isUserMemberForProject) {
-      throw Errors.CARD_NOT_FOUND; // Forbidden
+    if (!isBoardMember) {
+      const isProjectManager = await sails.helpers.users.isProjectManager(
+        currentUser.id,
+        project.id,
+      );
+
+      if (!isProjectManager) {
+        throw Errors.BOARD_NOT_FOUND; // Forbidden
+      }
     }
 
-    const actions = await sails.helpers.getActionsForCard(inputs.cardId, inputs.beforeId);
+    const actions = await sails.helpers.cards.getActions(card.id, inputs.beforeId);
 
-    const userIds = sails.helpers.mapRecords(actions, 'userId', true);
-    const users = await sails.helpers.getUsers(userIds, true);
+    const userIds = sails.helpers.utils.mapRecords(actions, 'userId', true);
+    const users = await sails.helpers.users.getMany(userIds, true);
 
-    return exits.success({
+    return {
       items: actions,
       included: {
         users,
       },
-    });
+    };
   },
 };

server/api/controllers/attachments/create.js

@@ -29,46 +29,45 @@ module.exports = {
   async fn(inputs, exits) {
     const { currentUser } = this.req;
 
-    const { card, project } = await sails.helpers
-      .getCardToProjectPath(inputs.cardId)
+    const { card } = await sails.helpers.cards
+      .getProjectPath(inputs.cardId)
       .intercept('pathNotFound', () => Errors.CARD_NOT_FOUND);
 
-    const isUserMemberForProject = await sails.helpers.isUserMemberForProject(
-      project.id,
-      currentUser.id,
-    );
+    const isBoardMember = await sails.helpers.users.isBoardMember(currentUser.id, card.boardId);
 
-    if (!isUserMemberForProject) {
+    if (!isBoardMember) {
       throw Errors.CARD_NOT_FOUND; // Forbidden
     }
 
-    this.req.file('file').upload(sails.helpers.createAttachmentReceiver(), async (error, files) => {
-      if (error) {
-        return exits.uploadError(error.message);
-      }
+    this.req
+      .file('file')
+      .upload(sails.helpers.utils.createAttachmentReceiver(), async (error, files) => {
+        if (error) {
+          return exits.uploadError(error.message);
+        }
 
-      if (files.length === 0) {
-        return exits.uploadError('No file was uploaded');
-      }
+        if (files.length === 0) {
+          return exits.uploadError('No file was uploaded');
+        }
 
-      const file = files[0];
+        const file = files[0];
 
-      const attachment = await sails.helpers.createAttachment(
-        card,
-        currentUser,
-        {
-          dirname: file.extra.dirname,
-          filename: file.filename,
-          isImage: file.extra.isImage,
-          name: file.extra.name,
-        },
-        inputs.requestId,
-        this.req,
-      );
+        const attachment = await sails.helpers.attachments.createOne(
+          {
+            dirname: file.extra.dirname,
+            filename: file.filename,
+            isImage: file.extra.isImage,
+            name: file.extra.name,
+          },
+          currentUser,
+          card,
+          inputs.requestId,
+          this.req,
+        );
 
-      return exits.success({
-        item: attachment.toJSON(),
+        return exits.success({
+          item: attachment.toJSON(),
+        });
       });
-    });
   },
 };

server/api/controllers/attachments/delete.js

@@ -19,33 +19,30 @@ module.exports = {
     },
   },
 
-  async fn(inputs, exits) {
+  async fn(inputs) {
     const { currentUser } = this.req;
 
-    const attachmentToProjectPath = await sails.helpers
-      .getAttachmentToProjectPath(inputs.id)
+    const path = await sails.helpers.attachments
+      .getProjectPath(inputs.id)
       .intercept('pathNotFound', () => Errors.ATTACHMENT_NOT_FOUND);
 
-    let { attachment } = attachmentToProjectPath;
-    const { card, board, project } = attachmentToProjectPath;
+    let { attachment } = path;
+    const { card, board } = path;
 
-    const isUserMemberForProject = await sails.helpers.isUserMemberForProject(
-      project.id,
-      currentUser.id,
-    );
+    const isBoardMember = await sails.helpers.users.isBoardMember(currentUser.id, board.id);
 
-    if (!isUserMemberForProject) {
+    if (!isBoardMember) {
       throw Errors.ATTACHMENT_NOT_FOUND; // Forbidden
     }
 
-    attachment = await sails.helpers.deleteAttachment(attachment, card, board, this.req);
+    attachment = await sails.helpers.attachments.deleteOne(attachment, board, card, this.req);
 
     if (!attachment) {
       throw Errors.ATTACHMENT_NOT_FOUND;
     }
 
-    return exits.success({
+    return {
       item: attachment,
-    });
+    };
   },
 };

server/api/controllers/attachments/update.js

@@ -23,34 +23,31 @@ module.exports = {
     },
   },
 
-  async fn(inputs, exits) {
+  async fn(inputs) {
     const { currentUser } = this.req;
 
-    const attachmentToProjectPath = await sails.helpers
-      .getAttachmentToProjectPath(inputs.id)
+    const path = await sails.helpers.attachments
+      .getProjectPath(inputs.id)
       .intercept('pathNotFound', () => Errors.ATTACHMENT_NOT_FOUND);
 
-    let { attachment } = attachmentToProjectPath;
-    const { board, project } = attachmentToProjectPath;
+    let { attachment } = path;
+    const { board } = path;
 
-    const isUserMemberForProject = await sails.helpers.isUserMemberForProject(
-      project.id,
-      currentUser.id,
-    );
+    const isBoardMember = await sails.helpers.users.isBoardMember(currentUser.id, board.id);
 
-    if (!isUserMemberForProject) {
+    if (!isBoardMember) {
       throw Errors.ATTACHMENT_NOT_FOUND; // Forbidden
     }
 
     const values = _.pick(inputs, ['name']);
-    attachment = await sails.helpers.updateAttachment(attachment, values, board, this.req);
+    attachment = await sails.helpers.attachments.updateOne(attachment, values, board, this.req);
 
     if (!attachment) {
       throw Errors.ATTACHMENT_NOT_FOUND;
     }
 
-    return exits.success({
+    return {
       item: attachment,
-    });
+    };
   },
 };

server/api/controllers/board-memberships/create.js

@@ -0,0 +1,69 @@
+const Errors = {
+  BOARD_NOT_FOUND: {
+    boardNotFound: 'Board not found',
+  },
+  USER_NOT_FOUND: {
+    userNotFound: 'User not found',
+  },
+  USER_ALREADY_BOARD_MEMBER: {
+    userAlreadyBoardMember: 'User already board member',
+  },
+};
+
+module.exports = {
+  inputs: {
+    boardId: {
+      type: 'string',
+      regex: /^[0-9]+$/,
+      required: true,
+    },
+    userId: {
+      type: 'string',
+      regex: /^[0-9]+$/,
+      required: true,
+    },
+  },
+
+  exits: {
+    boardNotFound: {
+      responseType: 'notFound',
+    },
+    userNotFound: {
+      responseType: 'notFound',
+    },
+    userAlreadyBoardMember: {
+      responseType: 'conflict',
+    },
+  },
+
+  async fn(inputs) {
+    const { currentUser } = this.req;
+
+    const { board } = await sails.helpers.boards
+      .getProjectPath(inputs.boardId)
+      .intercept('pathNotFound', () => Errors.BOARD_NOT_FOUND);
+
+    const isProjectManager = await sails.helpers.users.isProjectManager(
+      currentUser.id,
+      board.projectId,
+    );
+
+    if (!isProjectManager) {
+      throw Errors.BOARD_NOT_FOUND; // Forbidden
+    }
+
+    const user = await sails.helpers.users.getOne(inputs.userId);
+
+    if (!user) {
+      throw Error.USER_NOT_FOUND;
+    }
+
+    const boardMembership = await sails.helpers.boardMemberships
+      .createOne(user, board, this.req)
+      .intercept('userAlreadyBoardMember', () => Errors.USER_ALREADY_BOARD_MEMBER);
+
+    return {
+      item: boardMembership,
+    };
+  },
+};

server/api/controllers/board-memberships/delete.js

@@ -0,0 +1,57 @@
+const Errors = {
+  BOARD_MEMBERSHIP_NOT_FOUND: {
+    boardMembershipNotFound: 'Board membership not found',
+  },
+};
+
+module.exports = {
+  inputs: {
+    id: {
+      type: 'string',
+      regex: /^[0-9]+$/,
+      required: true,
+    },
+  },
+
+  exits: {
+    boardMembershipNotFound: {
+      responseType: 'notFound',
+    },
+  },
+
+  async fn(inputs) {
+    const { currentUser } = this.req;
+
+    const path = await sails.helpers.boardMemberships
+      .getProjectPath(inputs.id)
+      .intercept('pathNotFound', () => Errors.BOARD_MEMBERSHIP_NOT_FOUND);
+
+    let { boardMembership } = path;
+    const { project } = path;
+
+    if (boardMembership.userId !== currentUser.id) {
+      const isProjectManager = await sails.helpers.users.isProjectManager(
+        currentUser.id,
+        project.id,
+      );
+
+      if (!isProjectManager) {
+        throw Errors.BOARD_MEMBERSHIP_NOT_FOUND;
+      }
+    }
+
+    boardMembership = await sails.helpers.boardMemberships.deleteOne(
+      boardMembership,
+      project,
+      this.req,
+    );
+
+    if (!boardMembership) {
+      throw Errors.BOARD_MEMBERSHIP_NOT_FOUND;
+    }
+
+    return {
+      item: boardMembership,
+    };
+  },
+};

server/api/controllers/boards/create.js

@@ -13,7 +13,7 @@ module.exports = {
     },
     type: {
       type: 'string',
-      isIn: Board.TYPES,
+      isIn: Object.values(Board.Types),
       required: true,
     },
     position: {
@@ -32,29 +32,42 @@ module.exports = {
     },
   },
 
-  async fn(inputs, exits) {
+  async fn(inputs) {
     // TODO: allow over HTTP without subscription
     if (!this.req.isSocket) {
       return this.res.badRequest();
     }
 
+    const { currentUser } = this.req;
+
     const project = await Project.findOne(inputs.projectId);
 
     if (!project) {
       throw Errors.PROJECT_NOT_FOUND;
     }
 
+    const isProjectManager = await sails.helpers.users.isProjectManager(currentUser.id, project.id);
+
+    if (!isProjectManager) {
+      throw Errors.PROJECT_NOT_FOUND; // Forbidden
+    }
+
     const values = _.pick(inputs, ['type', 'position', 'name']);
-    const board = await sails.helpers.createBoard(project, values, this.req);
+
+    const { board, boardMembership } = await sails.helpers.boards.createOne(
+      values,
+      currentUser,
+      project,
+      this.req,
+    );
 
     sails.sockets.join(this.req, `board:${board.id}`); // TODO: only when subscription needed
 
-    return exits.success({
+    return {
       item: board,
       included: {
-        lists: [],
-        labels: [],
+        boardMemberships: [boardMembership],
       },
-    });
+    };
   },
 };

server/api/controllers/boards/delete.js

@@ -19,21 +19,32 @@ module.exports = {
     },
   },
 
-  async fn(inputs, exits) {
-    let board = await Board.findOne(inputs.id);
+  async fn(inputs) {
+    let { board } = await sails.helpers.boards
+      .getProjectPath(inputs.id)
+      .intercept('pathNotFound', () => Errors.BOARD_NOT_FOUND);
 
     if (!board) {
       throw Errors.BOARD_NOT_FOUND;
     }
 
-    board = await sails.helpers.deleteBoard(board, this.req);
+    const isProjectManager = await sails.helpers.users.isProjectManager(
+      currentUser.id,
+      board.projectId,
+    );
+
+    if (!isProjectManager) {
+      throw Errors.BOARD_NOT_FOUND; // Forbidden
+    }
+
+    board = await sails.helpers.boards.deleteOne(board, this.req);
 
     if (!board) {
       throw Errors.BOARD_NOT_FOUND;
     }
 
-    return exits.success({
+    return {
       item: board,
-    });
+    };
   },
 };

server/api/controllers/boards/show.js

@@ -19,7 +19,7 @@ module.exports = {
     },
   },
 
-  async fn(inputs, exits) {
+  async fn(inputs) {
     // TODO: allow over HTTP without subscription
     if (!this.req.isSocket) {
       return this.res.badRequest();
@@ -27,35 +27,43 @@ module.exports = {
 
     const { currentUser } = this.req;
 
-    const { board, project } = await sails.helpers
-      .getBoardToProjectPath(inputs.id)
+    const { board, project } = await sails.helpers.boards
+      .getProjectPath(inputs.id)
       .intercept('pathNotFound', () => Errors.BOARD_NOT_FOUND);
 
-    const isUserMemberForProject = await sails.helpers.isUserMemberForProject(
-      project.id,
-      currentUser.id,
-    );
+    const isBoardMember = await sails.helpers.users.isBoardMember(currentUser.id, board.id);
 
-    if (!isUserMemberForProject) {
-      throw Errors.BOARD_NOT_FOUND; // Forbidden
+    if (!isBoardMember) {
+      const isProjectManager = await sails.helpers.users.isProjectManager(
+        currentUser.id,
+        project.id,
+      );
+
+      if (!isProjectManager) {
+        throw Errors.BOARD_NOT_FOUND; // Forbidden
+      }
     }
 
-    const labels = await sails.helpers.getLabelsForBoard(board.id);
-    const lists = await sails.helpers.getListsForBoard(board.id);
+    const boardMemberships = await sails.helpers.boards.getBoardMemberships(board.id);
 
-    const cards = await sails.helpers.getCardsForBoard(board);
-    const cardIds = sails.helpers.mapRecords(cards);
+    const userIds = sails.helpers.utils.mapRecords(boardMemberships, 'userId');
+    const users = await sails.helpers.users.getMany(userIds);
 
-    const cardSubscriptions = await sails.helpers.getSubscriptionsByUserForCard(
-      cardIds,
-      currentUser.id,
-    );
+    const labels = await sails.helpers.boards.getLabels(board.id);
+    const lists = await sails.helpers.boards.getLists(board.id);
 
-    const cardMemberships = await sails.helpers.getMembershipsForCard(cardIds);
-    const cardLabels = await sails.helpers.getCardLabelsForCard(cardIds);
+    const cards = await sails.helpers.boards.getCards(board);
+    const cardIds = sails.helpers.utils.mapRecords(cards);
 
-    const tasks = await sails.helpers.getTasksForCard(cardIds);
-    const attachments = await sails.helpers.getAttachmentsForCard(cardIds);
+    const cardSubscriptions = await sails.helpers.cardSubscriptions.getMany({
+      cardId: cardIds,
+      userId: currentUser.id,
+    });
+
+    const cardMemberships = await sails.helpers.cards.getCardMemberships(cardIds);
+    const cardLabels = await sails.helpers.cards.getCardLabels(cardIds);
+    const tasks = await sails.helpers.cards.getTasks(cardIds);
+    const attachments = await sails.helpers.cards.getAttachments(cardIds);
 
     const isSubscribedByCardId = cardSubscriptions.reduce(
       (result, cardSubscription) => ({
@@ -65,16 +73,17 @@ module.exports = {
       {},
     );
 
-    cards.map((card) => ({
-      ...card,
-      isSubscribed: isSubscribedByCardId[card.id] || false,
-    }));
+    cards.forEach((card) => {
+      card.isSubscribed = isSubscribedByCardId[card.id] || false; // eslint-disable-line no-param-reassign
+    });
 
     sails.sockets.join(this.req, `board:${board.id}`); // TODO: only when subscription needed
 
-    return exits.success({
+    return {
       item: board,
       included: {
+        users,
+        boardMemberships,
         labels,
         lists,
         cards,
@@ -82,7 +91,8 @@ module.exports = {
         cardLabels,
         tasks,
         attachments,
+        projects: [project],
       },
-    });
+    };
   },
 };

server/api/controllers/boards/update.js

@@ -26,22 +26,35 @@ module.exports = {
     },
   },
 
-  async fn(inputs, exits) {
-    let board = await Board.findOne(inputs.id);
+  async fn(inputs) {
+    const { currentUser } = this.req;
+
+    let { board } = await sails.helpers.boards
+      .getProjectPath(inputs.id)
+      .intercept('pathNotFound', () => Errors.BOARD_NOT_FOUND);
 
     if (!board) {
       throw Errors.BOARD_NOT_FOUND;
     }
 
+    const isProjectManager = await sails.helpers.users.isProjectManager(
+      currentUser.id,
+      board.projectId,
+    );
+
+    if (!isProjectManager) {
+      throw Errors.BOARD_NOT_FOUND; // Forbidden
+    }
+
     const values = _.pick(inputs, ['position', 'name']);
-    board = await sails.helpers.updateBoard(board, values, this.req);
+    board = await sails.helpers.boards.updateOne(board, values, this.req);
 
     if (!board) {
       throw Errors.BOARD_NOT_FOUND;
     }
 
-    return exits.success({
+    return {
       item: board,
-    });
+    };
   },
 };

server/api/controllers/card-labels/create.js

@@ -36,19 +36,16 @@ module.exports = {
     },
   },
 
-  async fn(inputs, exits) {
+  async fn(inputs) {
     const { currentUser } = this.req;
 
-    const { card, project } = await sails.helpers
-      .getCardToProjectPath(inputs.cardId)
+    const { card } = await sails.helpers.cards
+      .getProjectPath(inputs.cardId)
       .intercept('pathNotFound', () => Errors.CARD_NOT_FOUND);
 
-    const isUserMemberForProject = await sails.helpers.isUserMemberForProject(
-      project.id,
-      currentUser.id,
-    );
+    const isBoardMember = await sails.helpers.users.isBoardMember(currentUser.id, card.boardId);
 
-    if (!isUserMemberForProject) {
+    if (!isBoardMember) {
       throw Errors.CARD_NOT_FOUND; // Forbidden
     }
 
@@ -61,12 +58,12 @@ module.exports = {
       throw Errors.LABEL_NOT_FOUND;
     }
 
-    const cardLabel = await sails.helpers
-      .createCardLabel(card, label, this.req)
+    const cardLabel = await sails.helpers.cardLabels
+      .createOne(label, card, this.req)
       .intercept('labelAlreadyInCard', () => Errors.LABEL_ALREADY_IN_CARD);
 
-    return exits.success({
+    return {
       item: cardLabel,
-    });
+    };
   },
 };

server/api/controllers/card-labels/delete.js

@@ -30,19 +30,16 @@ module.exports = {
     },
   },
 
-  async fn(inputs, exits) {
+  async fn(inputs) {
     const { currentUser } = this.req;
 
-    const { board, project } = await sails.helpers
-      .getCardToProjectPath(inputs.cardId)
+    const { board } = await sails.helpers.cards
+      .getProjectPath(inputs.cardId)
       .intercept('pathNotFound', () => Errors.CARD_NOT_FOUND);
 
-    const isUserMemberForProject = await sails.helpers.isUserMemberForProject(
-      project.id,
-      currentUser.id,
-    );
+    const isBoardMember = await sails.helpers.users.isBoardMember(currentUser.id, board.id);
 
-    if (!isUserMemberForProject) {
+    if (!isBoardMember) {
       throw Errors.CARD_NOT_FOUND; // Forbidden
     }
 
@@ -55,14 +52,14 @@ module.exports = {
       throw Errors.LABEL_NOT_IN_CARD;
     }
 
-    cardLabel = await sails.helpers.deleteCardLabel(cardLabel, board, this.req);
+    cardLabel = await sails.helpers.cardLabels.deleteOne(cardLabel, board, this.req);
 
     if (!cardLabel) {
       throw Errors.LABEL_NOT_IN_CARD;
     }
 
-    return exits.success({
+    return {
       item: cardLabel,
-    });
+    };
   },
 };

server/api/controllers/card-memberships/create.js

@@ -36,34 +36,31 @@ module.exports = {
     },
   },
 
-  async fn(inputs, exits) {
+  async fn(inputs) {
     const { currentUser } = this.req;
 
-    const { card, project } = await sails.helpers
-      .getCardToProjectPath(inputs.cardId)
+    const { card } = await sails.helpers.cards
+      .getProjectPath(inputs.cardId)
       .intercept('pathNotFound', () => Errors.CARD_NOT_FOUND);
 
-    let isUserMemberForProject = await sails.helpers.isUserMemberForProject(
-      project.id,
-      currentUser.id,
-    );
+    let isBoardMember = await sails.helpers.users.isBoardMember(currentUser.id, card.boardId);
 
-    if (!isUserMemberForProject) {
+    if (!isBoardMember) {
       throw Errors.CARD_NOT_FOUND; // Forbidden
     }
 
-    isUserMemberForProject = await sails.helpers.isUserMemberForProject(project.id, inputs.userId);
+    isBoardMember = await sails.helpers.users.isBoardMember(inputs.userId, card.boardId);
 
-    if (!isUserMemberForProject) {
+    if (!isBoardMember) {
       throw Errors.USER_NOT_FOUND;
     }
 
-    const cardMembership = await sails.helpers
-      .createCardMembership(card, inputs.userId, this.req)
+    const cardMembership = await sails.helpers.cardMemberships
+      .createOne(inputs.userId, card, this.req)
       .intercept('userAlreadyCardMember', () => Errors.USER_ALREADY_CARD_MEMBER);
 
-    return exits.success({
+    return {
       item: cardMembership,
-    });
+    };
   },
 };

server/api/controllers/card-memberships/delete.js

@@ -30,19 +30,16 @@ module.exports = {
     },
   },
 
-  async fn(inputs, exits) {
+  async fn(inputs) {
     const { currentUser } = this.req;
 
-    const { board, project } = await sails.helpers
-      .getCardToProjectPath(inputs.cardId)
+    const { board } = await sails.helpers.cards
+      .getProjectPath(inputs.cardId)
       .intercept('pathNotFound', () => Errors.CARD_NOT_FOUND);
 
-    const isUserMemberForProject = await sails.helpers.isUserMemberForProject(
-      project.id,
-      currentUser.id,
-    );
+    const isBoardMember = await sails.helpers.users.isBoardMember(currentUser.id, board.id);
 
-    if (!isUserMemberForProject) {
+    if (!isBoardMember) {
       throw Errors.CARD_NOT_FOUND; // Forbidden
     }
 
@@ -55,14 +52,14 @@ module.exports = {
       throw Errors.USER_NOT_CARD_MEMBER;
     }
 
-    cardMembership = await sails.helpers.deleteCardMembership(cardMembership, board, this.req);
+    cardMembership = await sails.helpers.cardMemberships.deleteOne(cardMembership, board, this.req);
 
     if (!cardMembership) {
       throw Errors.USER_NOT_CARD_MEMBER;
     }
 
-    return exits.success({
+    return {
       item: cardMembership,
-    });
+    };
   },
 };

server/api/controllers/cards/create.js

@@ -81,20 +81,17 @@ module.exports = {
     },
   },
 
-  async fn(inputs, exits) {
+  async fn(inputs) {
     const { currentUser } = this.req;
 
-    const { board, project } = await sails.helpers
-      .getBoardToProjectPath(inputs.boardId)
+    const { board } = await sails.helpers.boards
+      .getProjectPath(inputs.boardId)
       .intercept('pathNotFound', () => Errors.BOARD_NOT_FOUND);
 
-    const isUserMemberForProject = await sails.helpers.isUserMemberForProject(
-      project.id,
-      currentUser.id,
-    );
+    const isBoardMember = await sails.helpers.users.isBoardMember(currentUser.id, board.id);
 
-    if (!isUserMemberForProject) {
-      throw Errors.LIST_NOT_FOUND; // Forbidden
+    if (!isBoardMember) {
+      throw Errors.BOARD_NOT_FOUND; // Forbidden
     }
 
     let list;
@@ -111,19 +108,13 @@ module.exports = {
 
     const values = _.pick(inputs, ['position', 'name', 'description', 'dueDate', 'timer']);
 
-    const card = await sails.helpers
-      .createCard(board, list, values, currentUser, this.req)
+    const card = await sails.helpers.cards
+      .createOne(values, currentUser, board, list, this.req)
       .intercept('listMustBePresent', () => Errors.LIST_MUST_BE_PRESENT)
       .intercept('positionMustBeInValues', () => Errors.POSITION_MUST_BE_PRESENT);
 
-    return exits.success({
+    return {
       item: card,
-      included: {
-        cardMemberships: [],
-        cardLabels: [],
-        tasks: [],
-        attachments: [],
-      },
-    });
+    };
   },
 };

server/api/controllers/cards/delete.js

@@ -19,33 +19,27 @@ module.exports = {
     },
   },
 
-  async fn(inputs, exits) {
+  async fn(inputs) {
     const { currentUser } = this.req;
 
-    const cardToProjectPath = await sails.helpers
-      .getCardToProjectPath(inputs.id)
+    let { card } = await sails.helpers.cards
+      .getProjectPath(inputs.id)
       .intercept('pathNotFound', () => Errors.CARD_NOT_FOUND);
 
-    let { card } = cardToProjectPath;
-    const { project } = cardToProjectPath;
+    const isBoardMember = await sails.helpers.users.isBoardMember(currentUser.id, card.boardId);
 
-    const isUserMemberForProject = await sails.helpers.isUserMemberForProject(
-      project.id,
-      currentUser.id,
-    );
-
-    if (!isUserMemberForProject) {
+    if (!isBoardMember) {
       throw Errors.CARD_NOT_FOUND; // Forbidden
     }
 
-    card = await sails.helpers.deleteCard(card, this.req);
+    card = await sails.helpers.cards.deleteOne(card, this.req);
 
     if (!card) {
       throw Errors.CARD_NOT_FOUND;
     }
 
-    return exits.success({
+    return {
       item: card,
-    });
+    };
   },
 };

server/api/controllers/cards/index.js

@@ -26,32 +26,23 @@ module.exports = {
   async fn(inputs, exits) {
     const { currentUser } = this.req;
 
-    const { board, project } = await sails.helpers
-      .getBoardToProjectPath(inputs.boardId)
+    const { board } = await sails.helpers.boards
+      .getProjectPath(inputs.boardId)
       .intercept('pathNotFound', () => Errors.BOARD_NOT_FOUND);
 
-    const isUserMemberForProject = await sails.helpers.isUserMemberForProject(
-      project.id,
-      currentUser.id,
-    );
+    const isBoardMember = await sails.helpers.users.isBoardMember(currentUser.id, board.id);
 
-    if (!isUserMemberForProject) {
+    if (!isBoardMember) {
       throw Errors.BOARD_NOT_FOUND; // Forbidden
     }
 
-    const cards = await sails.helpers.getCardsForBoard(board, inputs.beforeId);
-    const cardIds = sails.helpers.mapRecords(cards);
+    const cards = await sails.helpers.boards.getCards(board, inputs.beforeId);
+    const cardIds = sails.helpers.utils.mapRecords(cards);
 
-    const cardSubscriptions = await sails.helpers.getSubscriptionsByUserForCard(
-      cardIds,
-      currentUser.id,
-    );
-
-    const cardMemberships = await sails.helpers.getMembershipsForCard(cardIds);
-    const cardLabels = await sails.helpers.getCardLabelsForCard(cardIds);
-
-    const tasks = await sails.helpers.getTasksForCard(cardIds);
-    const attachments = await sails.helpers.getAttachmentsForCard(cardIds);
+    const cardSubscriptions = await sails.helpers.cardSubscriptions.getMany({
+      cardId: cardIds,
+      userId: currentUser.id,
+    });
 
     const isSubscribedByCardId = cardSubscriptions.reduce(
       (result, cardSubscription) => ({
@@ -61,10 +52,14 @@ module.exports = {
       {},
     );
 
-    cards.map((card) => ({
-      ...card,
-      isSubscribed: isSubscribedByCardId[card.id] || false,
-    }));
+    cards.forEach((card) => {
+      card.isSubscribed = isSubscribedByCardId[card.id] || false; // eslint-disable-line no-param-reassign
+    });
+
+    const cardMemberships = await sails.helpers.cards.getCardMemberships(cardIds);
+    const cardLabels = await sails.helpers.cards.getCardLabels(cardIds);
+    const tasks = await sails.helpers.cards.getTasks(cardIds);
+    const attachments = await sails.helpers.cards.getAttachments(cardIds);
 
     return exits.success({
       items: cards,

server/api/controllers/cards/show.js

@@ -19,24 +19,41 @@ module.exports = {
     },
   },
 
-  async fn(inputs, exits) {
+  async fn(inputs) {
     const { currentUser } = this.req;
 
-    const { card, project } = await sails.helpers
-      .getCardToProjectPath(inputs.id)
+    const { card, project } = await sails.helpers.cards
+      .getProjectPath(inputs.id)
       .intercept('pathNotFound', () => Errors.CARD_NOT_FOUND);
 
-    const isUserMemberForProject = await sails.helpers.isUserMemberForProject(
-      project.id,
-      currentUser.id,
-    );
+    const isBoardMember = await sails.helpers.users.isBoardMember(currentUser.id, card.boardId);
 
-    if (!isUserMemberForProject) {
-      throw Errors.CARD_NOT_FOUND; // Forbidden
+    if (!isBoardMember) {
+      const isProjectManager = await sails.helpers.users.isProjectManager(
+        currentUser.id,
+        project.id,
+      );
+
+      if (!isProjectManager) {
+        throw Errors.CARD_NOT_FOUND; // Forbidden
+      }
     }
 
-    return exits.success({
+    card.isSubscribed = await sails.helpers.users.isCardSubscriber(currentUser.id, card.id);
+
+    const cardMemberships = await sails.helpers.cards.getCardMemberships(card.id);
+    const cardLabels = await sails.helpers.cards.getCardLabels(card.id);
+    const tasks = await sails.helpers.cards.getTasks(card.id);
+    const attachments = await sails.helpers.cards.getAttachments(card.id);
+
+    return {
       item: card,
-    });
+      included: {
+        cardMemberships,
+        cardLabels,
+        tasks,
+        attachments,
+      },
+    };
   },
 };

server/api/controllers/cards/update.js

@@ -100,49 +100,43 @@ module.exports = {
     },
   },
 
-  async fn(inputs, exits) {
+  async fn(inputs) {
     const { currentUser } = this.req;
 
-    const cardToProjectPath = await sails.helpers
-      .getCardToProjectPath(inputs.id)
+    const path = await sails.helpers.cards
+      .getProjectPath(inputs.id)
       .intercept('pathNotFound', () => Errors.CARD_NOT_FOUND);
 
-    let { card, project } = cardToProjectPath;
-    const { list, board } = cardToProjectPath;
+    let { card } = path;
+    const { list, board } = path;
 
-    let isUserMemberForProject = await sails.helpers.isUserMemberForProject(
-      project.id,
-      currentUser.id,
-    );
+    let isBoardMember = await sails.helpers.users.isBoardMember(currentUser.id, board.id);
 
-    if (!isUserMemberForProject) {
+    if (!isBoardMember) {
       throw Errors.CARD_NOT_FOUND; // Forbidden
     }
 
-    let toBoard;
+    let nextBoard;
     if (!_.isUndefined(inputs.boardId)) {
-      ({ board: toBoard, project } = await sails.helpers
-        .getBoardToProjectPath(inputs.boardId)
+      ({ board: nextBoard } = await sails.helpers.boards
+        .getProjectPath(inputs.boardId)
         .intercept('pathNotFound', () => Errors.BOARD_NOT_FOUND));
 
-      isUserMemberForProject = await sails.helpers.isUserMemberForProject(
-        project.id,
-        currentUser.id,
-      );
+      isBoardMember = await sails.helpers.users.isBoardMember(currentUser.id, nextBoard.id);
 
-      if (!isUserMemberForProject) {
+      if (!isBoardMember) {
         throw Errors.BOARD_NOT_FOUND; // Forbidden
       }
     }
 
-    let toList;
+    let nextList;
     if (!_.isUndefined(inputs.listId)) {
-      toList = await List.findOne({
+      nextList = await List.findOne({
         id: inputs.listId,
-        boardId: (toBoard || board).id,
+        boardId: (nextBoard || board).id,
       });
 
-      if (!toList) {
+      if (!nextList) {
         throw Errors.LIST_NOT_FOUND; // Forbidden
       }
     }
@@ -157,17 +151,17 @@ module.exports = {
       'isSubscribed',
     ]);
 
-    card = await sails.helpers
-      .updateCard(card, toBoard, toList, values, board, list, currentUser, this.req)
-      .intercept('toListMustBePresent', () => Errors.LIST_MUST_BE_PRESENT)
+    card = await sails.helpers.cards
+      .updateOne(card, values, nextBoard, nextList, currentUser, board, list, this.req)
+      .intercept('nextListMustBePresent', () => Errors.LIST_MUST_BE_PRESENT)
       .intercept('positionMustBeInValues', () => Errors.POSITION_MUST_BE_PRESENT);
 
     if (!card) {
       throw Errors.CARD_NOT_FOUND;
     }
 
-    return exits.success({
+    return {
       item: card,
-    });
+    };
   },
 };

server/api/controllers/comment-actions/create.js

@@ -23,31 +23,28 @@ module.exports = {
     },
   },
 
-  async fn(inputs, exits) {
+  async fn(inputs) {
     const { currentUser } = this.req;
 
-    const { card, project } = await sails.helpers
-      .getCardToProjectPath(inputs.cardId)
+    const { card } = await sails.helpers.cards
+      .getProjectPath(inputs.cardId)
       .intercept('pathNotFound', () => Errors.CARD_NOT_FOUND);
 
-    const isUserMemberForProject = await sails.helpers.isUserMemberForProject(
-      project.id,
-      currentUser.id,
-    );
+    const isBoardMember = await sails.helpers.users.isBoardMember(currentUser.id, card.boardId);
 
-    if (!isUserMemberForProject) {
+    if (!isBoardMember) {
       throw Errors.CARD_NOT_FOUND; // Forbidden
     }
 
     const values = {
-      type: 'commentCard',
+      type: Action.Types.COMMENT_CARD,
       data: _.pick(inputs, ['text']),
     };
 
-    const action = await sails.helpers.createAction(card, currentUser, values, this.req);
+    const action = await sails.helpers.actions.createOne(values, currentUser, card, this.req);
 
-    return exits.success({
+    return {
       item: action,
-    });
+    };
   },
 };

server/api/controllers/comment-actions/delete.js

@@ -19,42 +19,41 @@ module.exports = {
     },
   },
 
-  async fn(inputs, exits) {
+  async fn(inputs) {
     const { currentUser } = this.req;
 
-    const criteria = {
-      id: inputs.id,
-      type: 'commentCard',
-    };
-
-    if (!currentUser.isAdmin) {
-      criteria.userId = currentUser.id;
-    }
-
-    const actionToProjectPath = await sails.helpers
-      .getActionToProjectPath(criteria)
+    const path = await sails.helpers.actions
+      .getProjectPath({
+        id: inputs.id,
+        type: Action.Types.COMMENT_CARD,
+      })
       .intercept('pathNotFound', () => Errors.COMMENT_ACTION_NOT_FOUND);
 
-    let { action } = actionToProjectPath;
-    const { board, project } = actionToProjectPath;
+    let { action } = path;
+    const { board, project } = path;
 
-    const isUserMemberForProject = await sails.helpers.isUserMemberForProject(
-      project.id,
-      currentUser.id,
-    );
+    const isProjectManager = await sails.helpers.users.isProjectManager(currentUser.id, project.id);
 
-    if (!isUserMemberForProject) {
-      throw Errors.COMMENT_ACTION_NOT_FOUND; // Forbidden
+    if (!isProjectManager) {
+      if (action.userId !== currentUser.id) {
+        throw Errors.COMMENT_ACTION_NOT_FOUND; // Forbidden
+      }
+
+      const isBoardMember = await sails.helpers.users.isBoardMember(currentUser.id, board.id);
+
+      if (!isBoardMember) {
+        throw Errors.COMMENT_ACTION_NOT_FOUND; // Forbidden
+      }
     }
 
-    action = await sails.helpers.deleteAction(action, board, this.req);
+    action = await sails.helpers.actions.deleteOne(action, board, this.req);
 
     if (!action) {
       throw Errors.COMMENT_ACTION_NOT_FOUND;
     }
 
-    return exits.success({
+    return {
       item: action,
-    });
+    };
   },
 };

server/api/controllers/comment-actions/update.js

@@ -23,41 +23,45 @@ module.exports = {
     },
   },
 
-  async fn(inputs, exits) {
+  async fn(inputs) {
     const { currentUser } = this.req;
 
-    const actionToProjectPath = await sails.helpers
-      .getActionToProjectPath({
+    const path = await sails.helpers.actions
+      .getProjectPath({
         id: inputs.id,
-        type: 'commentCard',
-        userId: currentUser.id,
+        type: Action.Types.COMMENT_CARD,
       })
       .intercept('pathNotFound', () => Errors.COMMENT_ACTION_NOT_FOUND);
 
-    let { action } = actionToProjectPath;
-    const { board, project } = actionToProjectPath;
+    let { action } = path;
+    const { board, project } = path;
 
-    const isUserMemberForProject = await sails.helpers.isUserMemberForProject(
-      project.id,
-      currentUser.id,
-    );
+    const isProjectManager = await sails.helpers.users.isProjectManager(currentUser.id, project.id);
 
-    if (!isUserMemberForProject) {
-      throw Errors.COMMENT_ACTION_NOT_FOUND; // Forbidden
+    if (!isProjectManager) {
+      if (action.userId !== currentUser.id) {
+        throw Errors.COMMENT_ACTION_NOT_FOUND; // Forbidden
+      }
+
+      const isBoardMember = await sails.helpers.users.isBoardMember(currentUser.id, board.id);
+
+      if (!isBoardMember) {
+        throw Errors.COMMENT_ACTION_NOT_FOUND; // Forbidden
+      }
     }
 
     const values = {
       data: _.pick(inputs, ['text']),
     };
 
-    action = await sails.helpers.updateAction(action, values, board, this.req);
+    action = await sails.helpers.actions.updateOne(action, values, board, this.req);
 
     if (!action) {
       throw Errors.COMMENT_ACTION_NOT_FOUND;
     }
 
-    return exits.success({
+    return {
       item: action,
-    });
+    };
   },
 };

server/api/controllers/labels/create.js

@@ -29,27 +29,24 @@ module.exports = {
     },
   },
 
-  async fn(inputs, exits) {
+  async fn(inputs) {
     const { currentUser } = this.req;
 
-    const { board, project } = await sails.helpers
-      .getBoardToProjectPath(inputs.boardId)
+    const { board } = await sails.helpers.boards
+      .getProjectPath(inputs.boardId)
       .intercept('pathNotFound', () => Errors.BOARD_NOT_FOUND);
 
-    const isUserMemberForProject = await sails.helpers.isUserMemberForProject(
-      project.id,
-      currentUser.id,
-    );
+    const isBoardMember = await sails.helpers.users.isBoardMember(currentUser.id, board.id);
 
-    if (!isUserMemberForProject) {
+    if (!isBoardMember) {
       throw Errors.BOARD_NOT_FOUND; // Forbidden
     }
 
     const values = _.pick(inputs, ['name', 'color']);
-    const label = await sails.helpers.createLabel(board, values, this.req);
+    const label = await sails.helpers.labels.createOne(values, board, this.req);
 
-    return exits.success({
+    return {
       item: label,
-    });
+    };
   },
 };

server/api/controllers/labels/delete.js

@@ -19,33 +19,27 @@ module.exports = {
     },
   },
 
-  async fn(inputs, exits) {
+  async fn(inputs) {
     const { currentUser } = this.req;
 
-    const labelToProjectPath = await sails.helpers
-      .getLabelToProjectPath(inputs.id)
+    let { label } = await sails.helpers.labels
+      .getProjectPath(inputs.id)
       .intercept('pathNotFound', () => Errors.LABEL_NOT_FOUND);
 
-    let { label } = labelToProjectPath;
-    const { project } = labelToProjectPath;
+    const isBoardMember = await sails.helpers.users.isBoardMember(currentUser.id, label.boardId);
 
-    const isUserMemberForProject = await sails.helpers.isUserMemberForProject(
-      project.id,
-      currentUser.id,
-    );
-
-    if (!isUserMemberForProject) {
+    if (!isBoardMember) {
       throw Errors.LABEL_NOT_FOUND; // Forbidden
     }
 
-    label = await sails.helpers.deleteLabel(label, this.req);
+    label = await sails.helpers.labels.deleteOne(label, this.req);
 
     if (!label) {
       throw Errors.LABEL_NOT_FOUND;
     }
 
-    return exits.success({
+    return {
       item: label,
-    });
+    };
   },
 };

server/api/controllers/labels/update.js

@@ -29,30 +29,24 @@ module.exports = {
     },
   },
 
-  async fn(inputs, exits) {
+  async fn(inputs) {
     const { currentUser } = this.req;
 
-    const labelToProjectPath = await sails.helpers
-      .getLabelToProjectPath(inputs.id)
+    let { label } = await sails.helpers.labels
+      .getProjectPath(inputs.id)
       .intercept('pathNotFound', () => Errors.LABEL_NOT_FOUND);
 
-    let { label } = labelToProjectPath;
-    const { project } = labelToProjectPath;
+    const isBoardMember = await sails.helpers.users.isBoardMember(currentUser.id, label.boardId);
 
-    const isUserMemberForProject = await sails.helpers.isUserMemberForProject(
-      project.id,
-      currentUser.id,
-    );
-
-    if (!isUserMemberForProject) {
+    if (!isBoardMember) {
       throw Errors.LABEL_NOT_FOUND; // Forbidden
     }
 
     const values = _.pick(inputs, ['name', 'color']);
-    label = await sails.helpers.updateLabel(label, values, this.req);
+    label = await sails.helpers.labels.updateOne(label, values, this.req);
 
-    return exits.success({
+    return {
       item: label,
-    });
+    };
   },
 };

server/api/controllers/lists/create.js

@@ -27,27 +27,24 @@ module.exports = {
     },
   },
 
-  async fn(inputs, exits) {
+  async fn(inputs) {
     const { currentUser } = this.req;
 
-    const { board, project } = await sails.helpers
-      .getBoardToProjectPath(inputs.boardId)
+    const { board } = await sails.helpers.boards
+      .getProjectPath(inputs.boardId)
       .intercept('pathNotFound', () => Errors.BOARD_NOT_FOUND);
 
-    const isUserMemberForProject = await sails.helpers.isUserMemberForProject(
-      project.id,
-      currentUser.id,
-    );
+    const isBoardMember = await sails.helpers.users.isBoardMember(currentUser.id, board.id);
 
-    if (!isUserMemberForProject) {
+    if (!isBoardMember) {
       throw Errors.BOARD_NOT_FOUND; // Forbidden
     }
 
     const values = _.pick(inputs, ['position', 'name']);
-    const list = await sails.helpers.createList(board, values, this.req);
+    const list = await sails.helpers.lists.createOne(values, board, this.req);
 
-    return exits.success({
+    return {
       item: list,
-    });
+    };
   },
 };

server/api/controllers/lists/delete.js

@@ -19,33 +19,27 @@ module.exports = {
     },
   },
 
-  async fn(inputs, exits) {
+  async fn(inputs) {
     const { currentUser } = this.req;
 
-    const listToProjectPath = await sails.helpers
-      .getListToProjectPath(inputs.id)
+    let { list } = await sails.helpers.lists
+      .getProjectPath(inputs.id)
       .intercept('pathNotFound', () => Errors.LIST_NOT_FOUND);
 
-    let { list } = listToProjectPath;
-    const { project } = listToProjectPath;
+    const isBoardMember = await sails.helpers.users.isBoardMember(currentUser.id, list.boardId);
 
-    const isUserMemberForProject = await sails.helpers.isUserMemberForProject(
-      project.id,
-      currentUser.id,
-    );
-
-    if (!isUserMemberForProject) {
+    if (!isBoardMember) {
       throw Errors.LIST_NOT_FOUND; // Forbidden
     }
 
-    list = await sails.helpers.deleteList(list, this.req);
+    list = await sails.helpers.lists.deleteOne(list, this.req);
 
     if (!list) {
       throw Errors.LIST_NOT_FOUND;
     }
 
-    return exits.success({
+    return {
       item: list,
-    });
+    };
   },
 };

server/api/controllers/lists/update.js

@@ -26,34 +26,28 @@ module.exports = {
     },
   },
 
-  async fn(inputs, exits) {
+  async fn(inputs) {
     const { currentUser } = this.req;
 
-    const listToProjectPath = await sails.helpers
-      .getListToProjectPath(inputs.id)
+    let { list } = await sails.helpers.lists
+      .getProjectPath(inputs.id)
       .intercept('pathNotFound', () => Errors.LIST_NOT_FOUND);
 
-    let { list } = listToProjectPath;
-    const { project } = listToProjectPath;
+    const isBoardMember = await sails.helpers.users.isBoardMember(currentUser.id, list.boardId);
 
-    const isUserMemberForProject = await sails.helpers.isUserMemberForProject(
-      project.id,
-      currentUser.id,
-    );
-
-    if (!isUserMemberForProject) {
+    if (!isBoardMember) {
       throw Errors.LIST_NOT_FOUND; // Forbidden
     }
 
     const values = _.pick(inputs, ['position', 'name']);
-    list = await sails.helpers.updateList(list, values, this.req);
+    list = await sails.helpers.lists.updateOne(list, values, this.req);
 
     if (!list) {
       throw Errors.LIST_NOT_FOUND;
     }
 
-    return exits.success({
+    return {
       item: list,
-    });
+    };
   },
 };

server/api/controllers/notifications/index.js

@@ -1,25 +1,25 @@
 module.exports = {
-  async fn(inputs, exits) {
+  async fn() {
     const { currentUser } = this.req;
 
-    const notifications = await sails.helpers.getNotificationsForUser(currentUser.id);
+    const notifications = await sails.helpers.users.getNotifications(currentUser.id);
 
-    const actionIds = sails.helpers.mapRecords(notifications, 'actionId');
-    const actions = await sails.helpers.getActions(actionIds);
+    const actionIds = sails.helpers.utils.mapRecords(notifications, 'actionId');
+    const actions = await sails.helpers.actions.getMany(actionIds);
 
-    const cardIds = sails.helpers.mapRecords(notifications, 'cardId');
-    const cards = await sails.helpers.getCards(cardIds);
+    const userIds = sails.helpers.utils.mapRecords(actions, 'userId', true);
+    const users = await sails.helpers.users.getMany(userIds, true);
 
-    const userIds = sails.helpers.mapRecords(actions, 'userId', true);
-    const users = await sails.helpers.getUsers(userIds);
+    const cardIds = sails.helpers.utils.mapRecords(notifications, 'cardId');
+    const cards = await sails.helpers.cards.getMany(cardIds);
 
-    return exits.success({
+    return {
       items: notifications,
       included: {
         users,
         cards,
         actions,
       },
-    });
+    };
   },
 };

server/api/controllers/notifications/show.js

@@ -0,0 +1,48 @@
+const Errors = {
+  NOTIFICATION_NOT_FOUND: {
+    notificationNotFound: 'Notification not found',
+  },
+};
+
+module.exports = {
+  inputs: {
+    id: {
+      type: 'string',
+      regex: /^[0-9]+$/,
+      required: true,
+    },
+  },
+
+  exits: {
+    notificationNotFound: {
+      responseType: 'notFound',
+    },
+  },
+
+  async fn(inputs) {
+    const { currentUser } = this.req;
+
+    const notification = await Notification.findOne({
+      id: inputs.id,
+      isRead: false,
+      userId: currentUser.id,
+    });
+
+    if (!notification) {
+      throw Errors.NOTIFICATION_NOT_FOUND;
+    }
+
+    const action = await Action.findOne(notification.actionId);
+    const user = await sails.helpers.users.getOne(action.userId, true);
+    const card = await Card.findOne(notification.cardId);
+
+    return {
+      item: notification,
+      included: {
+        users: [user],
+        cards: [card],
+        actions: [action],
+      },
+    };
+  },
+};

server/api/controllers/notifications/update.js

@@ -10,20 +10,20 @@ module.exports = {
     },
   },
 
-  async fn(inputs, exits) {
+  async fn(inputs) {
     const { currentUser } = this.req;
 
     const values = _.pick(inputs, ['isRead']);
 
-    const notifications = await sails.helpers.updateNotificationsForUser(
+    const notifications = await sails.helpers.notifications.updateMany(
       inputs.ids.split(','),
-      currentUser,
       values,
+      currentUser,
       this.req,
     );
 
-    return exits.success({
+    return {
       items: notifications,
-    });
+    };
   },
 };

server/api/controllers/project-managers/create.js

@@ -5,8 +5,8 @@ const Errors = {
   USER_NOT_FOUND: {
     userNotFound: 'User not found',
   },
-  USER_ALREADY_PROJECT_MEMBER: {
-    userAlreadyProjectMember: 'User already project member',
+  USER_ALREADY_PROJECT_MANAGER: {
+    userAlreadyProjectManager: 'User already project manager',
   },
 };
 
@@ -31,33 +31,38 @@ module.exports = {
     userNotFound: {
       responseType: 'notFound',
     },
-    userAlreadyProjectMember: {
+    userAlreadyProjectManager: {
       responseType: 'conflict',
     },
   },
 
-  async fn(inputs, exits) {
+  async fn(inputs) {
+    const { currentUser } = this.req;
+
     const project = await Project.findOne(inputs.projectId);
 
     if (!project) {
       throw Errors.PROJECT_NOT_FOUND;
     }
 
-    const user = await sails.helpers.getUser(inputs.userId);
+    const isProjectManager = await sails.helpers.users.isProjectManager(currentUser.id, project.id);
+
+    if (!isProjectManager) {
+      throw Errors.PROJECT_NOT_FOUND; // Forbidden
+    }
+
+    const user = await sails.helpers.users.getOne(inputs.userId);
 
     if (!user) {
       throw Error.USER_NOT_FOUND;
     }
 
-    const projectMembership = await sails.helpers
-      .createProjectMembership(project, user, this.req)
-      .intercept('userAlreadyProjectMember', () => Errors.USER_ALREADY_PROJECT_MEMBER);
+    const projectManager = await sails.helpers.projectManagers
+      .createOne(user, project, this.req)
+      .intercept('userAlreadyProjectManager', () => Errors.USER_ALREADY_PROJECT_MANAGER);
 
-    return exits.success({
-      item: projectMembership,
-      included: {
-        users: [user],
-      },
-    });
+    return {
+      item: projectManager,
+    };
   },
 };

server/api/controllers/project-managers/delete.js

@@ -0,0 +1,51 @@
+const Errors = {
+  PROJECT_MANAGER_NOT_FOUND: {
+    projectManagerNotFound: 'Project manager not found',
+  },
+};
+
+module.exports = {
+  inputs: {
+    id: {
+      type: 'string',
+      regex: /^[0-9]+$/,
+      required: true,
+    },
+  },
+
+  exits: {
+    projectManagerNotFound: {
+      responseType: 'notFound',
+    },
+  },
+
+  async fn(inputs) {
+    const { currentUser } = this.req;
+
+    let projectManager = await ProjectManager.findOne(inputs.id);
+
+    if (!projectManager) {
+      throw Errors.PROJECT_MANAGER_NOT_FOUND;
+    }
+
+    const isProjectManager = await sails.helpers.users.isProjectManager(
+      currentUser.id,
+      projectManager.projectId,
+    );
+
+    if (!isProjectManager) {
+      throw Errors.PROJECT_MANAGER_NOT_FOUND; // Forbidden
+    }
+
+    // TODO: check if the last one
+    projectManager = await sails.helpers.projectManagers.deleteOne(projectManager, this.req);
+
+    if (!projectManager) {
+      throw Errors.PROJECT_MANAGER_NOT_FOUND;
+    }
+
+    return {
+      item: projectManager,
+    };
+  },
+};

server/api/controllers/project-memberships/delete.js

@@ -1,39 +0,0 @@
-const Errors = {
-  PROJECT_MEMBERSHIP_NOT_FOUND: {
-    projectMembershipNotFound: 'Project membership not found',
-  },
-};
-
-module.exports = {
-  inputs: {
-    id: {
-      type: 'string',
-      regex: /^[0-9]+$/,
-      required: true,
-    },
-  },
-
-  exits: {
-    projectMembershipNotFound: {
-      responseType: 'notFound',
-    },
-  },
-
-  async fn(inputs, exits) {
-    let projectMembership = await ProjectMembership.findOne(inputs.id);
-
-    if (!projectMembership) {
-      throw Errors.PROJECT_MEMBERSHIP_NOT_FOUND;
-    }
-
-    projectMembership = await sails.helpers.deleteProjectMembership(projectMembership, this.req);
-
-    if (!projectMembership) {
-      throw Errors.PROJECT_MEMBERSHIP_NOT_FOUND;
-    }
-
-    return exits.success({
-      item: projectMembership,
-    });
-  },
-};

server/api/controllers/projects/create.js

@@ -6,25 +6,22 @@ module.exports = {
     },
   },
 
-  async fn(inputs, exits) {
+  async fn(inputs) {
     const { currentUser } = this.req;
 
     const values = _.pick(inputs, ['name']);
 
-    const { project, projectMembership } = await sails.helpers.createProject(
-      currentUser,
+    const { project, projectManager } = await sails.helpers.projects.createOne(
       values,
+      currentUser,
       this.req,
-      true,
     );
 
-    return exits.success({
+    return {
       item: project,
       included: {
-        users: [currentUser],
-        projectMemberships: [projectMembership],
-        boards: [],
+        projectManagers: [projectManager],
       },
-    });
+    };
   },
 };

server/api/controllers/projects/delete.js

@@ -19,21 +19,29 @@ module.exports = {
     },
   },
 
-  async fn(inputs, exits) {
+  async fn(inputs) {
+    const { currentUser } = this.req;
+
     let project = await Project.findOne(inputs.id);
 
     if (!project) {
       throw Errors.PROJECT_NOT_FOUND;
     }
 
-    project = await sails.helpers.deleteProject(project, this.req);
+    const isProjectManager = await sails.helpers.users.isProjectManager(currentUser.id, project.id);
+
+    if (!isProjectManager) {
+      throw Errors.PROJECT_NOT_FOUND; // Forbidden
+    }
+
+    project = await sails.helpers.projects.deleteOne(project, this.req);
 
     if (!project) {
       throw Errors.PROJECT_NOT_FOUND;
     }
 
-    return exits.success({
+    return {
       item: project,
-    });
+    };
   },
 };

server/api/controllers/projects/index.js

@@ -1,25 +1,44 @@
 module.exports = {
-  async fn(inputs, exits) {
+  async fn() {
     const { currentUser } = this.req;
 
-    const projectIds = await sails.helpers.getMembershipProjectIdsForUser(currentUser.id);
-    const projects = await sails.helpers.getProjects(projectIds);
+    const managerProjectIds = await sails.helpers.users.getManagerProjectIds(currentUser.id);
 
-    const { userIds, projectMemberships } = await sails.helpers.getMembershipUserIdsForProject(
-      projectIds,
+    const boardMemberships = await sails.helpers.users.getBoardMemberships(currentUser.id);
+    const membershipBoardIds = await sails.helpers.utils.mapRecords(boardMemberships, 'boardId');
+
+    const membershipBoards = await sails.helpers.boards.getMany({
+      id: membershipBoardIds,
+      projectId: {
+        '!=': managerProjectIds,
+      },
+    });
+
+    const membershipProjectIds = sails.helpers.utils.mapRecords(
+      membershipBoards,
+      'projectId',
       true,
     );
 
-    const users = await sails.helpers.getUsers(userIds);
-    const boards = await sails.helpers.getBoardsForProject(projectIds);
+    const projectIds = [...managerProjectIds, ...membershipProjectIds];
+    const projects = await sails.helpers.projects.getMany(projectIds);
 
-    return exits.success({
+    const projectManagers = await sails.helpers.projects.getProjectManagers(projectIds);
+
+    const userIds = sails.helpers.utils.mapRecords(projectManagers, 'userId', true);
+    const users = await sails.helpers.users.getMany(userIds);
+
+    const managerBoards = await sails.helpers.projects.getBoards(managerProjectIds);
+    const boards = [...managerBoards, ...membershipBoards];
+
+    return {
       items: projects,
       included: {
         users,
-        projectMemberships,
+        projectManagers,
         boards,
+        boardMemberships,
       },
-    });
+    };
   },
 };

server/api/controllers/projects/show.js

@@ -0,0 +1,65 @@
+const Errors = {
+  PROJECT_NOT_FOUND: {
+    projectNotFound: 'Project not found',
+  },
+};
+
+module.exports = {
+  inputs: {
+    id: {
+      type: 'string',
+      regex: /^[0-9]+$/,
+      required: true,
+    },
+  },
+
+  exits: {
+    projectNotFound: {
+      responseType: 'notFound',
+    },
+  },
+
+  async fn(inputs) {
+    const { currentUser } = this.req;
+
+    const project = await Project.findOne(inputs.id);
+
+    if (!project) {
+      throw Errors.PROJECT_NOT_FOUND;
+    }
+
+    let boards = await sails.helpers.projects.getBoards(project.id);
+    let boardIds = sails.helpers.utils.mapRecords(boards);
+
+    const boardMemberships = await sails.helpers.boardMemberships.getMany({
+      boardId: boardIds,
+      userId: currentUser.id,
+    });
+
+    const isProjectManager = await sails.helpers.users.isProjectManager(currentUser.id, project.id);
+
+    if (!isProjectManager) {
+      if (boardMemberships.length === 0) {
+        throw Errors.PROJECT_NOT_FOUND; // Forbidden
+      }
+
+      boardIds = sails.helpers.utils.mapRecords(boardMemberships, 'boardId');
+      boards = boards.filter((board) => boardIds.includes(board.id));
+    }
+
+    const projectManagers = await sails.helpers.projects.getProjectManagers(project.id);
+
+    const userIds = sails.helpers.utils.mapRecords(projectManagers, 'userId');
+    const users = await sails.helpers.users.getMany(userIds);
+
+    return {
+      item: project,
+      included: {
+        users,
+        projectManagers,
+        boards,
+        boardMemberships,
+      },
+    };
+  },
+};

server/api/controllers/projects/update-background-image.js

@@ -23,15 +23,23 @@ module.exports = {
   },
 
   async fn(inputs, exits) {
+    const { currentUser } = this.req;
+
     let project = await Project.findOne(inputs.id);
 
     if (!project) {
       throw Errors.PROJECT_NOT_FOUND;
     }
 
+    const isProjectManager = await sails.helpers.users.isProjectManager(currentUser.id, project.id);
+
+    if (!isProjectManager) {
+      throw Errors.PROJECT_NOT_FOUND; // Forbidden
+    }
+
     this.req
       .file('file')
-      .upload(sails.helpers.createProjectBackgroundImageReceiver(), async (error, files) => {
+      .upload(sails.helpers.utils.createProjectBackgroundImageReceiver(), async (error, files) => {
         if (error) {
           return exits.uploadError(error.message);
         }
@@ -40,7 +48,7 @@ module.exports = {
           return exits.uploadError('No file was uploaded');
         }
 
-        project = await sails.helpers.updateProject(
+        project = await sails.helpers.projects.updateOne(
           project,
           {
             backgroundImageDirname: files[0].extra.dirname,

server/api/controllers/projects/update.js

@@ -26,19 +26,19 @@ module.exports = {
           return false;
         }
 
-        if (!Project.BACKGROUND_TYPES.includes(value.type)) {
+        if (!Object.values(Project.BackgroundTypes).includes(value.type)) {
           return false;
         }
 
         if (
-          value.type === 'gradient' &&
+          value.type === Project.BackgroundTypes.GRADIENT &&
           _.size(value) === 2 &&
           Project.BACKGROUND_GRADIENTS.includes(value.name)
         ) {
           return true;
         }
 
-        if (value.type === 'image' && _.size(value) === 1) {
+        if (value.type === Project.BackgroundTypes.IMAGE && _.size(value) === 1) {
           return true;
         }
 
@@ -57,22 +57,30 @@ module.exports = {
     },
   },
 
-  async fn(inputs, exits) {
+  async fn(inputs) {
+    const { currentUser } = this.req;
+
     let project = await Project.findOne(inputs.id);
 
     if (!project) {
       throw Errors.PROJECT_NOT_FOUND;
     }
 
+    const isProjectManager = await sails.helpers.users.isProjectManager(currentUser.id, project.id);
+
+    if (!isProjectManager) {
+      throw Errors.PROJECT_NOT_FOUND; // Forbidden
+    }
+
     const values = _.pick(inputs, ['name', 'background', 'backgroundImage']);
-    project = await sails.helpers.updateProject(project, values, this.req);
+    project = await sails.helpers.projects.updateOne(project, values, this.req);
 
     if (!project) {
       throw Errors.PROJECT_NOT_FOUND;
     }
 
-    return exits.success({
+    return {
       item: project,
-    });
+    };
   },
 };

server/api/controllers/tasks/create.js

@@ -26,27 +26,24 @@ module.exports = {
     },
   },
 
-  async fn(inputs, exits) {
+  async fn(inputs) {
     const { currentUser } = this.req;
 
-    const { card, project } = await sails.helpers
-      .getCardToProjectPath(inputs.cardId)
+    const { card } = await sails.helpers.cards
+      .getProjectPath(inputs.cardId)
       .intercept('pathNotFound', () => Errors.CARD_NOT_FOUND);
 
-    const isUserMemberForProject = await sails.helpers.isUserMemberForProject(
-      project.id,
-      currentUser.id,
-    );
+    const isBoardMember = await sails.helpers.users.isBoardMember(currentUser.id, card.boardId);
 
-    if (!isUserMemberForProject) {
+    if (!isBoardMember) {
       throw Errors.CARD_NOT_FOUND; // Forbidden
     }
 
     const values = _.pick(inputs, ['name', 'isCompleted']);
-    const task = await sails.helpers.createTask(card, values, this.req);
+    const task = await sails.helpers.tasks.createOne(values, card, this.req);
 
-    return exits.success({
+    return {
       item: task,
-    });
+    };
   },
 };

server/api/controllers/tasks/delete.js

@@ -19,33 +19,30 @@ module.exports = {
     },
   },
 
-  async fn(inputs, exits) {
+  async fn(inputs) {
     const { currentUser } = this.req;
 
-    const taskToProjectPath = await sails.helpers
-      .getTaskToProjectPath(inputs.id)
+    const path = await sails.helpers.tasks
+      .getProjectPath(inputs.id)
       .intercept('pathNotFound', () => Errors.TASK_NOT_FOUND);
 
-    let { task } = taskToProjectPath;
-    const { board, project } = taskToProjectPath;
+    let { task } = path;
+    const { board } = path;
 
-    const isUserMemberForProject = await sails.helpers.isUserMemberForProject(
-      project.id,
-      currentUser.id,
-    );
+    const isBoardMember = await sails.helpers.users.isBoardMember(currentUser.id, board.id);
 
-    if (!isUserMemberForProject) {
+    if (!isBoardMember) {
       throw Errors.TASK_NOT_FOUND; // Forbidden
     }
 
-    task = await sails.helpers.deleteTask(task, board, this.req);
+    task = await sails.helpers.tasks.deleteOne(task, board, this.req);
 
     if (!task) {
       throw Errors.TASK_NOT_FOUND;
     }
 
-    return exits.success({
+    return {
       item: task,
-    });
+    };
   },
 };

server/api/controllers/tasks/update.js

@@ -26,34 +26,31 @@ module.exports = {
     },
   },
 
-  async fn(inputs, exits) {
+  async fn(inputs) {
     const { currentUser } = this.req;
 
-    const taskToProjectPath = await sails.helpers
-      .getTaskToProjectPath(inputs.id)
+    const path = await sails.helpers.tasks
+      .getProjectPath(inputs.id)
       .intercept('pathNotFound', () => Errors.TASK_NOT_FOUND);
 
-    let { task } = taskToProjectPath;
-    const { board, project } = taskToProjectPath;
+    let { task } = path;
+    const { board } = path;
 
-    const isUserMemberForProject = await sails.helpers.isUserMemberForProject(
-      project.id,
-      currentUser.id,
-    );
+    const isBoardMember = await sails.helpers.users.isBoardMember(currentUser.id, board.id);
 
-    if (!isUserMemberForProject) {
+    if (!isBoardMember) {
       throw Errors.TASK_NOT_FOUND; // Forbidden
     }
 
     const values = _.pick(inputs, ['name', 'isCompleted']);
-    task = await sails.helpers.updateTask(task, values, board, this.req);
+    task = await sails.helpers.tasks.updateOne(task, values, board, this.req);
 
     if (!task) {
       throw Errors.TASK_NOT_FOUND;
     }
 
-    return exits.success({
+    return {
       item: task,
-    });
+    };
   },
 };

server/api/controllers/users/create.js

@@ -54,7 +54,7 @@ module.exports = {
     },
   },
 
-  async fn(inputs, exits) {
+  async fn(inputs) {
     const values = _.pick(inputs, [
       'email',
       'password',
@@ -65,13 +65,13 @@ module.exports = {
       'subscribeToOwnCards',
     ]);
 
-    const user = await sails.helpers
-      .createUser(values, this.req)
+    const user = await sails.helpers.users
+      .createOne(values, this.req)
       .intercept('emailAlreadyInUse', () => Errors.EMAIL_ALREADY_IN_USE)
       .intercept('usernameAlreadyInUse', () => Errors.USERNAME_ALREADY_IN_USE);
 
-    return exits.success({
+    return {
       item: user,
-    });
+    };
   },
 };

server/api/controllers/users/delete.js

@@ -19,21 +19,21 @@ module.exports = {
     },
   },
 
-  async fn(inputs, exits) {
-    let user = await sails.helpers.getUser(inputs.id);
+  async fn(inputs) {
+    let user = await sails.helpers.users.getOne(inputs.id);
 
     if (!user) {
       throw Errors.USER_NOT_FOUND;
     }
 
-    user = await sails.helpers.deleteUser(user, this.req);
+    user = await sails.helpers.users.deleteOne(user, this.req);
 
     if (!user) {
       throw Errors.USER_NOT_FOUND;
     }
 
-    return exits.success({
+    return {
       item: user,
-    });
+    };
   },
 };

server/api/controllers/users/index.js

@@ -1,9 +1,9 @@
 module.exports = {
-  async fn(inputs, exits) {
-    const users = await sails.helpers.getUsers();
+  async fn() {
+    const users = await sails.helpers.users.getMany();
 
-    return exits.success({
+    return {
       items: users,
-    });
+    };
   },
 };

server/api/controllers/users/show.js

@@ -1,16 +1,44 @@
-module.exports = {
-  async fn(inputs, exits) {
-    // TODO: allow over HTTP without subscription
-    if (!this.req.isSocket) {
-      return this.res.badRequest();
-    }
-
-    const { currentUser } = this.req;
-
-    sails.sockets.join(this.req, `user:${currentUser.id}`); // TODO: only when subscription needed
-
-    return exits.success({
-      item: currentUser,
-    });
+const Errors = {
+  USER_NOT_FOUND: {
+    userNotFound: 'User not found',
+  },
+};
+
+const CURRENT_USER_ID = 'me';
+
+module.exports = {
+  inputs: {
+    id: {
+      type: 'string',
+      regex: /^[0-9]+|me$/,
+      required: true,
+    },
+  },
+
+  exits: {
+    boardNotFound: {
+      responseType: 'notFound',
+    },
+  },
+
+  async fn(inputs) {
+    let user;
+    if (inputs.id === CURRENT_USER_ID) {
+      ({ currentUser: user } = this.req);
+
+      if (this.req.isSocket) {
+        sails.sockets.join(this.req, `user:${user.id}`); // TODO: only when subscription needed
+      }
+    } else {
+      user = await sails.helpers.users.getOne(inputs.id);
+
+      if (!user) {
+        throw Errors.USER_NOT_FOUND;
+      }
+    }
+
+    return {
+      item: user,
+    };
   },
 };

server/api/controllers/users/update-avatar.js

@@ -27,7 +27,7 @@ module.exports = {
 
     let user;
     if (currentUser.isAdmin) {
-      user = await sails.helpers.getUser(inputs.id);
+      user = await sails.helpers.users.getOne(inputs.id);
 
       if (!user) {
         throw Errors.USER_NOT_FOUND;
@@ -38,30 +38,32 @@ module.exports = {
       user = currentUser;
     }
 
-    this.req.file('file').upload(sails.helpers.createUserAvatarReceiver(), async (error, files) => {
-      if (error) {
-        return exits.uploadError(error.message);
-      }
+    this.req
+      .file('file')
+      .upload(sails.helpers.utils.createUserAvatarReceiver(), async (error, files) => {
+        if (error) {
+          return exits.uploadError(error.message);
+        }
 
-      if (files.length === 0) {
-        return exits.uploadError('No file was uploaded');
-      }
+        if (files.length === 0) {
+          return exits.uploadError('No file was uploaded');
+        }
 
-      user = await sails.helpers.updateUser(
-        user,
-        {
-          avatarDirname: files[0].extra.dirname,
-        },
-        this.req,
-      );
+        user = await sails.helpers.users.updateOne(
+          user,
+          {
+            avatarDirname: files[0].extra.dirname,
+          },
+          this.req,
+        );
 
-      if (!user) {
-        throw Errors.USER_NOT_FOUND;
-      }
+        if (!user) {
+          throw Errors.USER_NOT_FOUND;
+        }
 
-      return exits.success({
-        item: user.toJSON(),
+        return exits.success({
+          item: user.toJSON(),
+        });
       });
-    });
   },
 };

server/api/controllers/users/update-email.js

@@ -42,7 +42,7 @@ module.exports = {
     },
   },
 
-  async fn(inputs, exits) {
+  async fn(inputs) {
     const { currentUser } = this.req;
 
     if (inputs.id === currentUser.id) {
@@ -53,7 +53,7 @@ module.exports = {
       throw Errors.USER_NOT_FOUND; // Forbidden
     }
 
-    let user = await sails.helpers.getUser(inputs.id);
+    let user = await sails.helpers.users.getOne(inputs.id);
 
     if (!user) {
       throw Errors.USER_NOT_FOUND;
@@ -68,16 +68,16 @@ module.exports = {
 
     const values = _.pick(inputs, ['email']);
 
-    user = await sails.helpers
-      .updateUser(user, values, this.req)
+    user = await sails.helpers.users
+      .update(user, values, this.req)
       .intercept('emailAlreadyInUse', () => Errors.EMAIL_ALREADY_IN_USE);
 
     if (!user) {
       throw Errors.USER_NOT_FOUND;
     }
 
-    return exits.success({
+    return {
       item: user,
-    });
+    };
   },
 };

server/api/controllers/users/update-password.js

@@ -35,7 +35,7 @@ module.exports = {
     },
   },
 
-  async fn(inputs, exits) {
+  async fn(inputs) {
     const { currentUser } = this.req;
 
     if (inputs.id === currentUser.id) {
@@ -46,7 +46,7 @@ module.exports = {
       throw Errors.USER_NOT_FOUND; // Forbidden
     }
 
-    let user = await sails.helpers.getUser(inputs.id);
+    let user = await sails.helpers.users.getOne(inputs.id);
 
     if (!user) {
       throw Errors.USER_NOT_FOUND;
@@ -60,14 +60,14 @@ module.exports = {
     }
 
     const values = _.pick(inputs, ['password']);
-    user = await sails.helpers.updateUser(user, values, this.req);
+    user = await sails.helpers.users.updateOne(user, values, this.req);
 
     if (!user) {
       throw Errors.USER_NOT_FOUND;
     }
 
-    return exits.success({
+    return {
       item: user,
-    });
+    };
   },
 };

server/api/controllers/users/update-username.js

@@ -44,7 +44,7 @@ module.exports = {
     },
   },
 
-  async fn(inputs, exits) {
+  async fn(inputs) {
     const { currentUser } = this.req;
 
     if (inputs.id === currentUser.id) {
@@ -55,7 +55,7 @@ module.exports = {
       throw Errors.USER_NOT_FOUND; // Forbidden
     }
 
-    let user = await sails.helpers.getUser(inputs.id);
+    let user = await sails.helpers.users.getOne(inputs.id);
 
     if (!user) {
       throw Errors.USER_NOT_FOUND;
@@ -70,16 +70,16 @@ module.exports = {
 
     const values = _.pick(inputs, ['username']);
 
-    user = await sails.helpers
-      .updateUser(user, values, this.req)
+    user = await sails.helpers.users
+      .update(user, values, this.req)
       .intercept('usernameAlreadyInUse', () => Errors.USERNAME_ALREADY_IN_USE);
 
     if (!user) {
       throw Errors.USER_NOT_FOUND;
     }
 
-    return exits.success({
+    return {
       item: user,
-    });
+    };
   },
 };

server/api/controllers/users/update.js

@@ -43,7 +43,7 @@ module.exports = {
     },
   },
 
-  async fn(inputs, exits) {
+  async fn(inputs) {
     const { currentUser } = this.req;
 
     if (!currentUser.isAdmin) {
@@ -54,7 +54,7 @@ module.exports = {
       delete inputs.isAdmin; // eslint-disable-line no-param-reassign
     }
 
-    let user = await sails.helpers.getUser(inputs.id);
+    let user = await sails.helpers.users.getOne(inputs.id);
 
     if (!user) {
       throw Errors.USER_NOT_FOUND;
@@ -69,14 +69,14 @@ module.exports = {
       'subscribeToOwnCards',
     ]);
 
-    user = await sails.helpers.updateUser(user, values, this.req);
+    user = await sails.helpers.users.updateOne(user, values, this.req);
 
     if (!user) {
       throw Errors.USER_NOT_FOUND;
     }
 
-    return exits.success({
+    return {
       item: user,
-    });
+    };
   },
 };