Cloud code - "Execution timed out" during saveAll call in afterSave

Question

Situation

• I have a messaging Android app providing following feature(s)
  • to send message direct message to one selected recipient
  • to create public announcement that all users using the app receive (except author)
  • each user sees on his phone a list of messages he got
  • each message is either unread, read, or deleted
• I use Parse.com as back-end

Current implementation

On Android client

1. When there is a new message, a new messageRequest of the MessageRequest class is created
2. If the message should be direct, the messageRequest has type 0, otherwise type 1
3. If the message is direct, there is recipient stored in the messageRequest object
4. The messageRequest object is stored to parse.com

On parse.com back-end

In the afterSave of the MessageRequest it is checked if the message is direct or public and based on that

• in case of direct message - one new message object of the Message class is created and saved
• in case of public announcement - for each user except author, a new message object is created and added to a list of messages, then the list is saved

In both cases, the data like content, type, etc. are copied from messageRequest object into the newly created message object(s).

The reason for creating separate message for each user is that each user can have it in another status (unread, read, deleted).

The status column representing the unread, read, deleted status is set (by unread) for the message object.

Problem

When I call the ParseObject.saveAll method in the afterSave of MessageRequest, I get the Execution timed out - Request timed out error

I think the cause is that there are some limits on time in which the request must complete in cloud code. In my case, I'm creating ca 100 Messages for 1 MessageRequest

This doesn't seem so much to me, but maybe I'm wrong.

Source code

var generateAnnouncement = function(messageRequest, recipients) {

    var messageList = [];

    for (var i = 0; i < recipients.length; i++) {
        var msg = new Message();
        msg.set("type", 1);
        msg.set("author", messageRequest.get("author"));
        msg.set("content", messageRequest.get("content"));
        msg.set("recipient", recipients[i]);
        msg.set("status", 0)

        messageList.push(msg);
    }

    Parse.Object.saveAll(messageList).then(function(list) {
    }, function(error) {
        console.error(error.message);
    });

}

Parse.Cloud.afterSave("MessageRequest", function(request) {
    var mr = request.object;
    var type = mr.get("type");

    if (type == 0) {
        generateDirectMessage(mr);
    } else {
        var query = new Parse.Query(Parse.User);
        query.notEqualTo("objectId", mr.get("author").id);
        query.find().then(function(allUsersExceptAuthor) {
            generateAnnouncement(mr, allUsersExceptAuthor);
        }, function(error) {
            console.error(error.message);
        });
    }
});

How would you suggest to solve this?

Additional thoughts

• My only other idea how to solve this is to have only one Message object, and two columns called e.g. viewedBy and deletedFor which would contain lists of users that already viewed the message or have delete the message for them.

• In this case, I'm not very sure about the performance of the queries

• Also, I know, many of you think Why isn't he using table for splitting the M:N relation between the MessageRequest(which could be actually called Message in that case) and User?

• My answer is that I had this solution, but it was harder to work with it in the Android code, more pointers, more includes in queries, etc.
• Moreover, I would have to create the same amount of objects representing status for each user in the on parse.com back-end anyway, so I think the problem with Execution time out would be the same in the end

Update - mockup representing user's "Inbox"

In the "inbox" user sees both direct messages and public announcements. They are sorted by chronological order.

Update #2 - using arrays to identify who viewed and who marked as deleted

• I have just one Message object, via type I identify if it is direct or public
• Two array columns were added
  • viewedBy - containing users that already viewed the message
  • deletedFor - containing users that marked the message as deleted for them

Then my query for all messages not deleted by currently logged in user looks like this

//direct messages for me
ParseQuery<Message> queryDirect = ParseQuery.getQuery(Message.class);
queryDirect.whereEqualTo("type", 0);
queryDirect.whereEqualTo("recipient", ParseUser.getCurrentUser());

//public announcements
ParseQuery<Message> queryAnnouncements = ParseQuery.getQuery(Message.class);
queryAnnouncements.whereEqualTo("type", 1);

//I want both direct and public
List<ParseQuery<Message>> queries = new ArrayList<ParseQuery<Message>>();
queries.add(queryDirect);
queries.add(queryAnnouncements);

ParseQuery<Message> queryMessages = ParseQuery.or(queries);
//... but only those which I haven't deleted for myself
queryMessages.whereNotEqualTo("deletedFor", ParseUser.getCurrentUser());
//puting them in correct order
queryMessages.addDescendingOrder("createdAt");
//and attaching the author ParseUser object (to get e.g. his name or URL to photo)
queryMessages.include("author");
queryMessages.findInBackground(new FindCallback<Message>() {/*DO SOMETHING HERE*/});

Answer 1

I would suggest changing your schema to better support public messages.

You should have a single copy of the public message, as there's no changing the message itself.

You should then store just the status for each user if it is anything other than "unread". This would be another table.

When a MessageRequest comes in with type 1, create a new PublicMessage, don't create any status rows as everyone will use the default status of "unread". This makes your afterSave handler work cleanly as it is always creating just one new object, either a Message or a PublicMessage.

As each user reads the message or deletes it, create new PublicMessageStatus row for that user with the correct status.

When showing public messages to a user, you will do two queries:

1. Query for PublicMessage, probably with some date range
2. Query for PublicMessageStatus with a filter on user matching the current user and matchesQuery('publicMessage', publicMessageQuery) constraint using a clone of the first query

Client side you'll then need to combine the two to hide/remove those with status "deleted" and mark those with status "read" accordingly.

Update based on feedback

You could choose instead to use a single Message class for public/private messages, and a MessageStatus class to handle status.

Public vs Private would be based on the Message.recipient being empty or not.

To get all messages for the current user:

// JavaScript sample since you haven't specified a language
// assumes Underscore library available

var Message = Parse.Object.extend('Message');
var MessageStatus = Parse.Object.extend('MessageStatus');

var publicMessageQuery = new Parse.Query(Message);
publicMessageQuery.doesNotExist('recipient');
publicMessageQuery.notEqualTo('author', currentUser);

var privateMessageQuery = new Parse.Query(Message);
privateMessageQuery.equalTo('recipient', currentUser);

var messagesQuery = new Parse.Query.or(publicMessageQuery, privateMessageQuery);
messagesQuery.descending('createdAt');
// set any other filters to apply to both queries

var messages = [];
messageQuery.find().then(function(results) {
    messages = _(results).map(function (message) {
        return { message: message, status: 'unread', messageId: message.objectId };
    });
    var statusQuery = new Parse.Query(MessageStatus);
    statusQuery.containedIn('message', results);
    statusQuery.equalTo('user', currentUser);
    // process status in order so last applies
    statusQuery.ascending('createdAt');
    return
}).then(function(results) {
    _(results).each(function (messageStatus) {
        var messageId = messageStatus.get('message').objectId;
        _(messages).findWhere({ messageId: messageId }).status = messageStatus.get('status');
    });
});

// optionally filter messages that are deleted
messages = _(messages).filter(function(message) { return message.status !== 'deleted'; });

// feed messages array to UI...