bower-composite/composite.js at master · angular-hu/bower-composite · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
/**
 * angular-hu-composite v1.1.0
 * https://github.com/angular-hu/angular-hu
 * (c) 2015 Telefónica I+D - http://www.tid.es
 * @license MIT
 */
(function(angular) {
  'use strict';

  angular.module('httpu.composite', [])
    .factory('huComposite', huComposite);

  /**
   * Makes a composite pattern for interceptors, allowing to use a flag
   * to apply a set of interceptors for a determinate request
   *
   * @param {Object} $q
   * @param {Object} $injector
   * @returns {Function} The factory function
   */
  function huComposite($q, $injector) {
    return function huCompositeFactory(interceptorFactories, options) {
      var toBackend = [],
        fromBackend = [],
        configuration = angular.extend({
          flag: null,
          backend: null
        }, options);

      var interceptor = {
        request: requestInterceptor,
        requestError: requestErrorInterceptor,
        response: responseInterceptor,
        responseError: responseErrorInterceptor
      };

      initChains();

      return interceptor;

      /////////////////////////////////

      function requestInterceptor(config) {
        if (appliesChain(config)) {
          return applyInterceptorChain($q.when(config), toBackend);
        }
        return config;
      }

      function requestErrorInterceptor(rejection) {
        if (appliesChain(rejection)) {
          return applyInterceptorChain($q.reject(rejection), toBackend);
        }
        return $q.reject(rejection);
      }

      function responseInterceptor(response) {
        if (response && appliesChain(response.config)) {
          return applyInterceptorChain($q.when(response), fromBackend);
        }
        return response;
      }

      function responseErrorInterceptor(rejection) {
        if (rejection && appliesChain(rejection.config)) {
          return applyInterceptorChain($q.reject(rejection), fromBackend);
        }
        return $q.reject(rejection);
      }

      /**
       * Initializes the toBackend and fromBackend Chains with the provided
       * interceptor factories
       */
      function initChains() {
        angular.forEach(interceptorFactories, function iterator(interceptorFactory) {
          //support for 'string' or annotated factories
          var currentInterceptor = angular.isString(interceptorFactory) ?
            $injector.get(interceptorFactory) :
            $injector.invoke(interceptorFactory);

          if (currentInterceptor.request || currentInterceptor.requestError) {
            toBackend.push({
              resolve: currentInterceptor.request,
              reject: currentInterceptor.requestError
            });
          }
          if (currentInterceptor.response || currentInterceptor.responseError) {
            fromBackend.unshift({
              resolve: currentInterceptor.response,
              reject: currentInterceptor.responseError
            });
          }
        });
      }

      /**
       * Checks if a config flag is in the request
       * @param {Object} config
       * @returns {boolean}
       */
      function appliesChain(config) {
        return (!configuration.flag && !configuration.backend) ||
          (config && angular.isDefined(config[configuration.flag])) ||
          (config && configuration.backend && configuration.backend.test(config.url));
      }
    };
  }
  huComposite.$inject = ['$q', '$injector'];

  function applyInterceptorChain(promise, chain) {
    angular.forEach(chain, function iterator(obj) {
      promise = promise.then(obj.resolve, obj.reject);
    });
    return promise;
  }

})(window.angular);