$http: Allow interceptors per request

[jmendiara]

Scenario: an App is consuming several APIs. As the interceptor chain is global, the interceptors are applied to any request. But the interceptors may apply only to a request subset.

Problem: Requests are traversing interceptors they don't need to.

Proposal: Keep the current global interceptor chain as-is, and add a new config property with the per-request interceptors and merge it with the global chain.

[lgalfaso]

Well, it is not that simple as interceptors have an order... I think that what you are trying to do can be done without any change as follows:

• Invent a new configuration property name that will trigger the behavior you want
• Add an interceptor but that only do it's thing based on the configuration property (if this is a request interceptor, then you get the config as a parameter, if not, then use response.config)
• Make the call to $http using this config flag

Given that this is turning into help on how to use $http and not on an issue, then I am closing this. Feel free to use the forum to discuss this

[jmendiara]

Thanks @lgalfaso . More on this topic:
https://groups.google.com/forum/#!topic/angular/ToOHB2xGItI

[iangreenleaf]

I think this would be a useful improvement - not so much based on performance concerns, but for writing code that is simple and obvious. It's certainly possible to get the same behavior using the config toggle scheme @lgalfaso describes, but I don't think it results in code that's easy to understand. Here's an example:

myApp.factory("mySpecializedInterceptor", function($q) {
  return {
    response: function(response) {
      if (response.config.interceptors.indexOf("mySpecializedInterceptor") >= 0) {
        return manipulate(response);
      } else {
        return response;
      }
    },
    responseError: function(rejection) {
      if (rejection.config.interceptors.indexOf("mySpecializedInterceptor") >= 0) {
        return handle(rejection);
      } else {
        return $q.reject(rejection);
      }
    }
  };
});

myApp.factory("TheServiceThatUsesIt", function($http, User) {
  return {
    go: function() {
      return $http.get("/foo", {
        interceptors: ["mySpecializedInterceptor"]
      });
    }
  };
});

myApp.config(function($httpProvider, $provide) {
  return $httpProvider.interceptors.push("mySpecializedInterceptor");
});

The toggle statement is buried (and duplicated) inside the interceptor's logic itself. We have to write these extra useless else statements to pass it through any time the interceptor isn't wanted. And there's no indication at the point the interceptor is pushed onto the stack (near the bottom) that it might not be active most of the time.

I can see how changing this implementation might be a bit tricky, since right now the interceptors are tied tightly to the $httpProvider and aren't manipulable at all at runtime. But I'm not sure why that should be the case either. Most other capabilities of $http are available at runtime, including transformers.