Dojo using deferred functions to get data in ajax callback function

Devdar, you are making heavy wether out of something quite simple. In particular, you don't need to loop through an object to access one of its properties, and the variable hasErrors is not really necessary.

Your code should simplify to something like this :

function PostInformation() {
    var $containers = $("#container1, #container2");
    var Employee = {
        //data
    };
    return dojo.xhrPost({
        url: 'hello',
        content: Employee
    }).then(function(data) {
        data = JSON.parse(data);
        var formErrors = data.formErrors;
        if(formErrors.errors) {
            $containers.each(function(i, c) {
                $(c).children().each(function(wid) {
                    var val = formErrors[wid.id],
                        myWidget;
                    if(val) {
                        myWidget = dijit.byId(wid.id);
                        myWidget.validator = function() {
                            this.set("invalidMessage", val);
                        };
                        myWidget._hasBeenBlurred = true;
                        myWidget.validate();
                    }
                });
            });
            //Send an enhanced error object down the "error" route 
            throw $.extend(formErrors, {
                'message': 'PostInformation(): validation failure'
            });
        }
        //Send the data object down the "success" route 
        return data;
    });
};

PostInformation().then(function(data) {
    console.log('PostInformation(): everything went OK');
    //access/process `data` here if necessary
    //and/or just display a nice "success" message to the user
}, function(err) {
    console.error(err.message);
});

Barring mistakes on my part, this code should do everything you want and more. As with your own code, it processes the server's JSON response and returns a Promise, but that's where the similarity stops.

In your code, you seek to return a Promise which is eventually resolved with a boolean to indicate whether or not errors were detected. Whilst this will (if correctly written) meet your immediate needs, it is not the best Promise logic.

In my code, the Promise is resolved only if validation succeeds and rejected if validation fails for whatever reason. Not only is this logically correct behaviour for a Promise (success goes down the success route, and errors go down the error route) but as a bonus should (see note below) also allow you to pass more information to whetever function(s) eventually handle errors. I choose to pass the whole formErrors object enhanced with an error message, thus providing a great deal of freedom in the error handler to display/log/etc as much or as little as is appropriate, and with virtually no assumption inside PostInformation() as to what will happen subsequently. You currently believe that you will only read and act on the boolean formErrors.errors but it could be beneficial to pass as much error data as possible thus allowing yourself the freedom to change your mind at a later date without needing to change anything in PostInformation().

In this regard you can think of PostInformation() as an agent of the server-side service; and like that service, it can be written with incomplete knowledge (or maybe no knowledge at all) of how the (promise of) data/errors it delivers will be used by "consumer code".

NOTE: I have to admit that I'm not 100% familiar with Dojo's Promises, so I'm not sure that a JS plain object can be thrown in the way I indicate. I have found evidence but not proof that it can. For that reason, I am cautious above in saying "your code should simplify to something like this" Anyway, that issue aside, the principle of sending success down the success route and errors down the error route should still apply.

I think this is more of an issue with design of the function then.

Since the xHR call is asynchronous, the postInformation shouldn't really return anything unless it's the Deferred object itself. An alternative option is to have postInformation do some sort of event publishing (dojo/topic), that other functions will subscribe to and know how to handle said events.