解析云-删除属性（指针）

Question

My data model consist of 3 objects, two of them (the children) are linked to the parent using a pointer.

MyModel is the parent that has 2 properties: colors and goal. Both are pointers to other Objects.

When i delete the parent I want the children to be deleted as well, the caveat is that the pointer might be nil, so I'd need to check if there is something there before attempting deletion.

[I'm new to Javascript so maybe that's also part of the problem]

Parse.Cloud.beforeDelete("MyModel", function(request) {
    if request.has(request.object.colors) {
      color = request.object.colors;
      Parse.Object.destroyAll(color, {
              success: function() {},
              error: function(error) {
                console.error("Error deleting related color " + error.code + ": " + error.message);
              }
            });
    }

    if request.has(request.object.goal) {
      goal = request.object.goal;
      Parse.Object.destroyAll(goal, {
          success: function() {},
          error: function(error) {
            console.error("Error deleting related goal " + error.code + ": " + error.message);
          }
        });
  }
});

Answer 1

Lets break this into smaller functions and correct a couple problems in the OP code along the way. It's very helpful to reduce things to smaller, promise-returning functions keep the code modular and the concurrency manageable.

EDIT Generally, it's preferred to use pointers to relate objects. Here's a general purpose function to delete an object related via pointer:

function deleteRelatedPointer(myModel, pointerName) {
    var pointer = myModel.get(pointerName);
    if (pointer) {
        return pointer.fetch().then(function(relatedObject) {
            return relatedObject.destroy();
        });
    } else {
        return null;
    }
}

Some authors relate objects via a string column containing the id of the related object. Here's the equivalent function to delete an object related by id:

function deleteRelatedId(myModel, columnName, relatedClass) {
    var relatedId = myModel.get(columnName);
    if (relatedId) {
        var query = new Parse.Query(relatedClass);
        return query.get(relatedId).then(function(relatedObject) {
            return relatedObject.destroy();
        });
    } else {
        return null;
    }
}

Now, the beforeDelete method is easy to write and understand. (Assuming the relationships via pointers):

Parse.Cloud.beforeDelete("MyModel", function(request, response) {
    var myModel = request.object;
    deleteRelatedPointer(myModel, "colors").then(function() {
        return deleteRelatedPointer(myModel , "goal");
    }).then(function() {
        response.success();
    }, function(error) {
        response.error(error);
    });
}

The other important thing to notice is that the before hook takes a response object and is required to invoke success / error on that object after the related tasks are complete.

All of this hinges on promises, which are necessary and immensely useful. Read about parse's implementation of them here .