promise error/exception handling design

Question

I want to create a function that performs async operation and returns a promise. The action is:

• downloading external content via AJAX
• if the content can't be downloaded (e.g. invalid URL) -> reject
• if the content was downloaded successfully, but I can't parse it -> reject
• otherwise (content was downloaded and parsed successfully) -> resolve

The code I've got now is pretty sttraightforward:

function fetch(hash){
  return $.ajax({
    method: "GET",
    url: baseURL + "/gists/" + hash
  }).then(function(response) {
    return JSON.parse(response.files['schema.json'].content);
  });
}

it's just a jQuery AJAX call that fetches data from github gist. Currently:

• when the AJAX can't be resolved -> promise gets rejected - OK
• when the AJAX was resolved and content was parsed correctly -> promise gets resolved - OK
• however, if the AJAX was resolved, but the content was invalid, the JSON.parse line throws an error and the promise doesn't get rejected and it should - FAIL

The question is - what is the right design to do that? I could wrap entire thing with a Deferred and handle it manually, but I think there might be an easier solution. Should I do a try-catch? Or something else?

Answer 1

I could wrap entire thing with a Deferred and handle it manually

That sounds like the deferred antipattern. Don't wrap anything that already uses promises.

I think there might be an easier solution. Should I do a try-catch?

Yes:

.then(function(response) {
  try {
    return JSON.parse(response.files['schema.json'].content);
  } catch (e) {
    return $.Deferred().reject(e);
  }
})

See also Throwing an Error in jQuery's Deferred object.

Or something else?

Actually your original code does work in any reasonable promise implementation, where exceptions become rejections implicitly. It's just jQuery's fail. You might simply want to dodge jQuery's then implementation.

Answer 2

As has already been described, jQuery 1.x and 2.x promises are not compliant with the promise spec and .then() handlers in those version are not "throw-safe". With a proper promise, the exception will be automatically turned into a rejection.

Bergi has already shown how to manually catch the exception and manually turn it into a rejection in jQuery. But, you could also cast the jQuery promise into a real promise and then get that throw-safe behavior for free. Here's one way to do that:

function fetch(hash){
  return Promise.resolve($.ajax({
    method: "GET",
    url: baseURL + "/gists/" + hash
  })).then(function(response) {
    return JSON.parse(response.files['schema.json'].content);
  });
}

Or, perhaps even better, make a new version of $.ajax() that returns a standard promise and then use that:

$.ajaxStd = function() {
    return Promise.resolve($.ajax.apply($, arguments));
}

function fetch(hash){
  return $.ajaxStd({
    method: "GET",
    url: baseURL + "/gists/" + hash
  }).then(function(response) {
    return JSON.parse(response.files['schema.json'].content);
  });
}

Both of these options mean that your fetch() function now returns a standard promise, not a jQuery promise so it won't have some of the jQuery specific things on it like .abort(), but it will have standards-compliant promise behavior.

Answer 3

As you clearly mentioned, $.ajax fails only for one of your other cases, hence you can easily handle that case alone using some custom validation. You could possibly include the parse in a try catch block