Mongoose count in array of schemas

The problem is that the result of your first find is a array of users, it are the complete documents. you can only use an array of values for the $in find operator.

change it to:

User.find({type: 'psycologist'}).exec(function (err, users) {
    if(err){
        callback(new Error("Something went wrong"), null);
    }else{
        var MyUserIdArray = users.map(function(x) { return x._id} );
        Message.count({userFrom: { "$in" : MyUserIdArray} }).exec(function (err, counter) {
            if(err){
                callback(new Error("Something went wrong."), null);
            }else{
                console.log(counter); //displays 0
                callback(null, counter);
            }
        });
    }
});

A much better way would involve using the aggregation framework to run a pipeline that uses the $lookup operator to do a "left join" on the messages collection from the users collection.

Consider running the following aggregation pipeline:

Users.aggregate([
    { "$match": { "type": "psycologist"} },
    {
        "$lookup": {
            "from": "messages",
            "localField": "_id",
            "foreignField": "userFrom",
            "as": "messagesFrom"
        }
    },  
    { 
        "$project": {
            "messages": { "$size": "$messagesFrom" }            
        }
    },
    {
        "$group": {
            "_id": null,
            "counter": { "$sum": "$messages" }
        }
    }
]).exec(function(err, result) {
    if(err){
        callback(new Error("Something went wrong."), null);
    }else{
        console.log(JSON.stringify(result, null, 4)); 
        callback(null, result[0].counter);
    }
});

In the above aggregation operation, the first step is the $match operator which filters the document stream to allow only matching documents to pass unmodified into the next pipeline stage and can take as its parameters MongoDB query syntax. This is similar to MongoDB Collection's find() method and SQL's WHERE clause and the filter { "$match": { "type": "psycologist"} } is just the same as

User.find({type: 'psycologist'})

In the next pipeline, the filtered documents are then passed to the $lookup operator which performs a left outer join to the messages collection in the same database to filter in documents from the "joined" collection for processing. The "as" option is the name of the new array field to add to the input documents. The new array field contains the matching documents from the "from" collection.

You would then need to get the length of this array as it indicates the number of messages per user. This is made possible in the next pipeline using the $project operator which reshapes each document in the stream, include, exclude or rename fields, inject computed fields, create sub-document fields, using mathematical expressions, dates, strings and/or logical (comparison, boolean, control) expressions.

In this case you use the $size operator which returns the number of elements in the array thus you get the number of messages per user.

The final pipeline step is the $group which summarize all the documents. This groups input documents by a specified identifier expression and applies the accumulator expression(s). But in this instance, you specify an _id value of null to calculate accumulated values for all the input documents as a whole. You aggregate all the messages count using the $sum accumulator operator applied on the messages field (computed from the previous pipeline) thus you get the total number of messages from for a particular user type.

Try

User.find({type: 'psycologist'}, {_id: 1}).exec(function (err, users) {
    if(err){
        callback(new Error("Something went wrong"), null);
    }else{
        var ids = users.map(function(user){
           return user._id;
        })
        Message.count({userFrom: { "$in" : ids } }).exec(function (err, counter) {
            if(err){
                callback(new Error("Something went wrong."), null);
            }else{
                console.log(counter); //displays 0
                callback(null, counter);
            }
        });
    }
});