Vulcan/packages/vulcan-core/lib/modules/default_mutations.js

/*

Default mutations

*/

import { newMutation, editMutation, removeMutation, Utils } from 'meteor/vulcan:lib';
import Users from 'meteor/vulcan:users';

export const getDefaultMutations = (collectionName, options = {}) => ({

  // mutation for inserting a new document

  new: {
    
    name: `${collectionName}New`,
    
    // check function called on a user to see if they can perform the operation
    check(user, document) {
      if (options.newCheck) {
        return options.newCheck(user, document);
      }
      // if user is not logged in, disallow operation
      if (!user) return false;
      // else, check if they can perform "foo.new" operation (e.g. "movies.new")
      return Users.canDo(user, `${collectionName.toLowerCase()}.new`);
    },
    
    async mutation(root, {document}, context) {
      
      const collection = context[collectionName];

      // check if current user can pass check function; else throw error
      Utils.performCheck(this.check, context.currentUser, document);

      // pass document to boilerplate newMutation function
      return await newMutation({
        collection,
        document: document, 
        currentUser: context.currentUser,
        validate: true,
        context,
      });
    },

  },

  // mutation for editing a specific document

  edit: {
    
    name: `${collectionName}Edit`,
    
    // check function called on a user and document to see if they can perform the operation
    check(user, document) {
      if (options.editCheck) {
        return options.editCheck(user);
      }

      if (!user || !document) return false;
      // check if user owns the document being edited. 
      // if they do, check if they can perform "foo.edit.own" action
      // if they don't, check if they can perform "foo.edit.all" action
      return Users.owns(user, document) ? Users.canDo(user, `${collectionName.toLowerCase()}.edit.own`) : Users.canDo(user, `${collectionName.toLowerCase()}.edit.all`);
    },

    async mutation(root, {documentId, set, unset}, context) {

      const collection = context[collectionName];

      // get entire unmodified document from database
      const document = collection.findOne(documentId);

      // check if user can perform operation; if not throw error
      Utils.performCheck(this.check, context.currentUser, document);

      // call editMutation boilerplate function
      return await editMutation({
        collection, 
        documentId: documentId, 
        set: set, 
        unset: unset, 
        currentUser: context.currentUser,
        validate: true,
        context,
      });
    },

  },
  
  // mutation for removing a specific document (same checks as edit mutation)

  remove: {

    name: `${collectionName}Remove`,
    
    check(user, document) {
      if (options.removeCheck) {
        return options.removeCheck(user);
      }
      
      if (!user || !document) return false;
      return Users.owns(user, document) ? Users.canDo(user, `${collectionName.toLowerCase()}.remove.own`) : Users.canDo(user, `${collectionName.toLowerCase()}.remove.all`);
    },
    
    async mutation(root, {documentId}, context) {

      const collection = context[collectionName];

      const document = collection.findOne(documentId);
      Utils.performCheck(this.check, context.currentUser, document, context);

      return await removeMutation({
        collection, 
        documentId: documentId, 
        currentUser: context.currentUser,
        validate: true,
        context,
      });
    },

  },

});