It's actually quite easy to override the promise behaviour of the jqXHR object in a prefilter. You just need to use the promise method of a new Deferred object with the jqXHR object itself as the target objet parameter:

$.ajaxPrefilter(function( options, originalOptions, jqXHR ) {
    var originalPromise = jqXHR.promise(),
        newDefer = $.Deferred(function( defer ) {
            defer.promise( jqXHR );
            jqXHR.success = defer.done;
            jqXHR.error = defer.fail;
            // Need a little bit more work to handle complete
        });
    originalPromise.done(function() {
        newDefer.resolve( /* whatever */ );
    });
});

Callbacks are not attached after prefilters are called so they will be attached to your new deferred this way. The jqXHR object hasn't been given to any external code yet (the beforeSend callback is called AFTER prefilters) so it's 100% safe.

Thanks. That's pretty ugly, though.

Replying to [comment:2 anonymous]:

Thanks. That's pretty ugly, though.

Well, let's see:

• You don't have to know about the internals of the transport layer
• You don't have to worry about the dataType conversion layer
• You don't need to worry about another prefilter doing something similar (everything will still work as intended)

I'd say it's pretty neat in its simplicity. You could even do it using pipe:

jqXHR.pipe( function() {
   // Handle success and eventually redirect
}, function() {
   // Handle error and eventually redirect
} ).promise( jqXHR );
// Aliases
jqXHR.success = jqXHR.done;
jqXHR.error = jqXHR.fail;

Of course, you still have to handle complete if you really need to but that's not that much of an hassle, is it?

The API could make that process a whole lot less retarded by vending a reference to the internal "done" method, but that would involve actual thought in place of snark on your part, so I shant be holding my breath.

Giving access to the internal "done" method (whatever you exactly mean by that) is insufficient and dangerous. A key in the design of Deferreds is to ensure no-one will bork your Deferreds to death. The fact that Deferreds methods are "detachable" (lexically bound) allows a lot of flexibility without the need to compromise the Deferred's internal state by having the Deferred's guts wide opened. Please, stop obsessing about your immediate problem and just ponder this for a mere second.

No, really, stop being mad at me/the screen/the world right now, re-read the paragraph above and do think about it.

I know it's always difficult to understand that cutting corners for every specific edge-case is NOT good design. Making so said edge-case can be solved using a reasonable amount of code without compromising everyone else's code (at least not that easily, I know we're still in JavaScript) is the ultimate goal.

Now bring on the insults!