Backbone.js with XML response - parse function not called before parse error

2
votes

I'm using Backbone.js to structure an application that usually communicates with web services via JSON.

One web service will return JSON on success or XML in an error (clever, huh?). I need to parse this XML response to determine the error, but Backbone's JSON-centric thinking is causing me problems.

I have a collection that includes a parse function. The parse function is always called when the service returns JSON, and in this case I simply return the response object. However, when the service returns XML my fetch call's error callback function is called, and passed an error object with arguments[1] of parseerror. Further digging shows there was an unexpected < character.

Why is my parse function not being called to parse the XML before a parseerror is thrown? Furthermore - why, in the successful JSON calls, is it passed a JavaScript object (indicating that the JSON string has already been parsed)? Isn't the parse function supposed to do the parsing?

Relevant code below, any suggestions much appreciated.

var myCollection = Backbone.Collection.extend({

initialize : function() {
    ...
},

fetch: function(options) {

    var options = {data: {...}, error: this.onFetchError};

    Backbone.Collection.prototype.fetch.call(this, options);
},

onFetchError: function(arg1, arg2, arg3) {

    debugger
},

parse: function(response) {

    debugger
    if(typeof response === 'object') {
        return response;
    }
}
});

return myCollection;
2
xmlajaxparsingbackbone.js
The parseerror is probably coming from jQuery or the XMLHttpRequest, not from backbone. Is the response being returned with an appropriate Content-Type, such as application/xml? And is the returned XML well-formed? - Brian Reischl
@breischl Thanks for the input, everything looks good on that side - Content-Type is application/xml and w3schools.com/xml/xml_validator.asp told me the XML was well-formed - tomfumb
Is it possible that someone, somewhere is setting the jQuery dataType option on the request? Possibly it's being done in a $.ajaxSetup() or $.ajaxStart() call? If that's not it, I guess try setting breakpoints in the Backbone success and error functions and see if that yields more information. - Brian Reischl

2 Answers

7
votes

The documentation is vague about this. Model.fetch([options]) uses Backbone.sync. The docs for sync say that you can use "all other jQuery request options", meaning anything supported by jQuery.ajax.

So to get the response as raw text, you could do:

this.fetch({ dataType: 'text' });

Then in your parse function, you can deal with the response however you want.

Side note: I figured this out when trying to get a model to fetch XML, and tested with that dataType.

3
votes

If you look at the default fetch:

fetch: function(options) {
  options = options ? _.clone(options) : {};
  var model = this;
  var success = options.success;
  options.success = function(resp, status, xhr) {

    //-->parse only invoked on success     
    if (!model.set(model.parse(resp, xhr), options)) return false;
    if (success) success(model, resp);
  };

  //-->parse not invoked on error
  options.error = Backbone.wrapError(options.error, model, options);
  return (this.sync || Backbone.sync).call(this, 'read', this, options);
}

You see that parse will never get called on an error condition. However, wrapError (shown below) will give you the original response:

Backbone.wrapError = function(onError, originalModel, options) {
  return function(model, resp) {
    resp = model === originalModel ? resp : model;
    if (onError) {
      onError(originalModel, resp, options);
    } else {
      originalModel.trigger('error', originalModel, resp, options);
    }
  };
};

So your arg2 will have the response and conceivably, you could pass that to your parse function.