@angular/common
Version:
Angular - commonly needed directives and services
130 lines • 28.7 kB
JavaScript
/**
* @license
* Copyright Google LLC All Rights Reserved.
*
* Use of this source code is governed by an MIT-style license that can be
* found in the LICENSE file at https://angular.io/license
*/
import { isPlatformServer } from '@angular/common';
import { EnvironmentInjector, inject, Injectable, InjectionToken, PLATFORM_ID, runInInjectionContext, ɵConsole as Console, ɵformatRuntimeError as formatRuntimeError, ɵPendingTasks as PendingTasks } from '@angular/core';
import { finalize } from 'rxjs/operators';
import { HttpBackend, HttpHandler } from './backend';
import { FetchBackend } from './fetch';
import * as i0 from "@angular/core";
import * as i1 from "./backend";
function interceptorChainEndFn(req, finalHandlerFn) {
return finalHandlerFn(req);
}
/**
* Constructs a `ChainedInterceptorFn` which adapts a legacy `HttpInterceptor` to the
* `ChainedInterceptorFn` interface.
*/
function adaptLegacyInterceptorToChain(chainTailFn, interceptor) {
return (initialRequest, finalHandlerFn) => interceptor.intercept(initialRequest, {
handle: (downstreamRequest) => chainTailFn(downstreamRequest, finalHandlerFn),
});
}
/**
* Constructs a `ChainedInterceptorFn` which wraps and invokes a functional interceptor in the given
* injector.
*/
function chainedInterceptorFn(chainTailFn, interceptorFn, injector) {
// clang-format off
return (initialRequest, finalHandlerFn) => runInInjectionContext(injector, () => interceptorFn(initialRequest, downstreamRequest => chainTailFn(downstreamRequest, finalHandlerFn)));
// clang-format on
}
/**
* A multi-provider token that represents the array of registered
* `HttpInterceptor` objects.
*
* @publicApi
*/
export const HTTP_INTERCEPTORS = new InjectionToken(ngDevMode ? 'HTTP_INTERCEPTORS' : '');
/**
* A multi-provided token of `HttpInterceptorFn`s.
*/
export const HTTP_INTERCEPTOR_FNS = new InjectionToken(ngDevMode ? 'HTTP_INTERCEPTOR_FNS' : '');
/**
* A multi-provided token of `HttpInterceptorFn`s that are only set in root.
*/
export const HTTP_ROOT_INTERCEPTOR_FNS = new InjectionToken(ngDevMode ? 'HTTP_ROOT_INTERCEPTOR_FNS' : '');
/**
* A provider to set a global primary http backend. If set, it will override the default one
*/
export const PRIMARY_HTTP_BACKEND = new InjectionToken(ngDevMode ? 'PRIMARY_HTTP_BACKEND' : '');
/**
* Creates an `HttpInterceptorFn` which lazily initializes an interceptor chain from the legacy
* class-based interceptors and runs the request through it.
*/
export function legacyInterceptorFnFactory() {
let chain = null;
return (req, handler) => {
if (chain === null) {
const interceptors = inject(HTTP_INTERCEPTORS, { optional: true }) ?? [];
// Note: interceptors are wrapped right-to-left so that final execution order is
// left-to-right. That is, if `interceptors` is the array `[a, b, c]`, we want to
// produce a chain that is conceptually `c(b(a(end)))`, which we build from the inside
// out.
chain = interceptors.reduceRight(adaptLegacyInterceptorToChain, interceptorChainEndFn);
}
const pendingTasks = inject(PendingTasks);
const taskId = pendingTasks.add();
return chain(req, handler).pipe(finalize(() => pendingTasks.remove(taskId)));
};
}
let fetchBackendWarningDisplayed = false;
/** Internal function to reset the flag in tests */
export function resetFetchBackendWarningFlag() {
fetchBackendWarningDisplayed = false;
}
export class HttpInterceptorHandler extends HttpHandler {
constructor(backend, injector) {
super();
this.backend = backend;
this.injector = injector;
this.chain = null;
this.pendingTasks = inject(PendingTasks);
// Check if there is a preferred HTTP backend configured and use it if that's the case.
// This is needed to enable `FetchBackend` globally for all HttpClient's when `withFetch`
// is used.
const primaryHttpBackend = inject(PRIMARY_HTTP_BACKEND, { optional: true });
this.backend = primaryHttpBackend ?? backend;
// We strongly recommend using fetch backend for HTTP calls when SSR is used
// for an application. The logic below checks if that's the case and produces
// a warning otherwise.
if ((typeof ngDevMode === 'undefined' || ngDevMode) && !fetchBackendWarningDisplayed) {
const isServer = isPlatformServer(injector.get(PLATFORM_ID));
if (isServer && !(this.backend instanceof FetchBackend)) {
fetchBackendWarningDisplayed = true;
injector.get(Console).warn(formatRuntimeError(2801 /* RuntimeErrorCode.NOT_USING_FETCH_BACKEND_IN_SSR */, 'Angular detected that `HttpClient` is not configured ' +
'to use `fetch` APIs. It\'s strongly recommended to ' +
'enable `fetch` for applications that use Server-Side Rendering ' +
'for better performance and compatibility. ' +
'To enable `fetch`, add the `withFetch()` to the `provideHttpClient()` ' +
'call at the root of the application.'));
}
}
}
handle(initialRequest) {
if (this.chain === null) {
const dedupedInterceptorFns = Array.from(new Set([
...this.injector.get(HTTP_INTERCEPTOR_FNS),
...this.injector.get(HTTP_ROOT_INTERCEPTOR_FNS, []),
]));
// Note: interceptors are wrapped right-to-left so that final execution order is
// left-to-right. That is, if `dedupedInterceptorFns` is the array `[a, b, c]`, we want to
// produce a chain that is conceptually `c(b(a(end)))`, which we build from the inside
// out.
this.chain = dedupedInterceptorFns.reduceRight((nextSequencedFn, interceptorFn) => chainedInterceptorFn(nextSequencedFn, interceptorFn, this.injector), interceptorChainEndFn);
}
const taskId = this.pendingTasks.add();
return this.chain(initialRequest, downstreamRequest => this.backend.handle(downstreamRequest))
.pipe(finalize(() => this.pendingTasks.remove(taskId)));
}
static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.1.1", ngImport: i0, type: HttpInterceptorHandler, deps: [{ token: i1.HttpBackend }, { token: i0.EnvironmentInjector }], target: i0.ɵɵFactoryTarget.Injectable }); }
static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.1.1", ngImport: i0, type: HttpInterceptorHandler }); }
}
i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.1.1", ngImport: i0, type: HttpInterceptorHandler, decorators: [{
type: Injectable
}], ctorParameters: () => [{ type: i1.HttpBackend }, { type: i0.EnvironmentInjector }] });
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"interceptor.js","sourceRoot":"","sources":["../../../../../../../packages/common/http/src/interceptor.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\nimport {isPlatformServer} from '@angular/common';\nimport {EnvironmentInjector, inject, Injectable, InjectionToken, PLATFORM_ID, runInInjectionContext, ɵConsole as Console, ɵformatRuntimeError as formatRuntimeError, ɵPendingTasks as PendingTasks} from '@angular/core';\nimport {Observable} from 'rxjs';\nimport {finalize} from 'rxjs/operators';\n\nimport {HttpBackend, HttpHandler} from './backend';\nimport {RuntimeErrorCode} from './errors';\nimport {FetchBackend} from './fetch';\nimport {HttpRequest} from './request';\nimport {HttpEvent} from './response';\n\n/**\n * Intercepts and handles an `HttpRequest` or `HttpResponse`.\n *\n * Most interceptors transform the outgoing request before passing it to the\n * next interceptor in the chain, by calling `next.handle(transformedReq)`.\n * An interceptor may transform the\n * response event stream as well, by applying additional RxJS operators on the stream\n * returned by `next.handle()`.\n *\n * More rarely, an interceptor may handle the request entirely,\n * and compose a new event stream instead of invoking `next.handle()`. This is an\n * acceptable behavior, but keep in mind that further interceptors will be skipped entirely.\n *\n * It is also rare but valid for an interceptor to return multiple responses on the\n * event stream for a single request.\n *\n * @publicApi\n *\n * @see [HTTP Guide](guide/http-intercept-requests-and-responses)\n * @see {@link HttpInterceptorFn}\n *\n * @usageNotes\n *\n * To use the same instance of `HttpInterceptors` for the entire app, import the `HttpClientModule`\n * only in your `AppModule`, and add the interceptors to the root application injector.\n * If you import `HttpClientModule` multiple times across different modules (for example, in lazy\n * loading modules), each import creates a new copy of the `HttpClientModule`, which overwrites the\n * interceptors provided in the root module.\n */\nexport interface HttpInterceptor {\n  /**\n   * Identifies and handles a given HTTP request.\n   * @param req The outgoing request object to handle.\n   * @param next The next interceptor in the chain, or the backend\n   * if no interceptors remain in the chain.\n   * @returns An observable of the event stream.\n   */\n  intercept(req: HttpRequest<any>, next: HttpHandler): Observable<HttpEvent<any>>;\n}\n\n/**\n * Represents the next interceptor in an interceptor chain, or the real backend if there are no\n * further interceptors.\n *\n * Most interceptors will delegate to this function, and either modify the outgoing request or the\n * response when it arrives. Within the scope of the current request, however, this function may be\n * called any number of times, for any number of downstream requests. Such downstream requests need\n * not be to the same URL or even the same origin as the current request. It is also valid to not\n * call the downstream handler at all, and process the current request entirely within the\n * interceptor.\n *\n * This function should only be called within the scope of the request that's currently being\n * intercepted. Once that request is complete, this downstream handler function should not be\n * called.\n *\n * @publicApi\n *\n * @see [HTTP Guide](guide/http-intercept-requests-and-responses)\n */\nexport type HttpHandlerFn = (req: HttpRequest<unknown>) => Observable<HttpEvent<unknown>>;\n\n/**\n * An interceptor for HTTP requests made via `HttpClient`.\n *\n * `HttpInterceptorFn`s are middleware functions which `HttpClient` calls when a request is made.\n * These functions have the opportunity to modify the outgoing request or any response that comes\n * back, as well as block, redirect, or otherwise change the request or response semantics.\n *\n * An `HttpHandlerFn` representing the next interceptor (or the backend which will make a real HTTP\n * request) is provided. Most interceptors will delegate to this function, but that is not required\n * (see `HttpHandlerFn` for more details).\n *\n * `HttpInterceptorFn`s are executed in an [injection context](/guide/dependency-injection-context).\n * They have access to `inject()` via the `EnvironmentInjector` from which they were configured.\n *\n * @see [HTTP Guide](guide/http-intercept-requests-and-responses)\n * @see {@link withInterceptors}\n *\n * @usageNotes\n * Here is a noop interceptor that passes the request through without modifying it:\n * ```typescript\n * export const noopInterceptor: HttpInterceptorFn = (req: HttpRequest<unknown>, next:\n * HttpHandlerFn) => {\n *   return next(modifiedReq);\n * };\n * ```\n *\n * If you want to alter a request, clone it first and modify the clone before passing it to the\n * `next()` handler function.\n *\n * Here is a basic interceptor that adds a bearer token to the headers\n * ```typescript\n * export const authenticationInterceptor: HttpInterceptorFn = (req: HttpRequest<unknown>, next:\n * HttpHandlerFn) => {\n *    const userToken = 'MY_TOKEN'; const modifiedReq = req.clone({\n *      headers: req.headers.set('Authorization', `Bearer ${userToken}`),\n *    });\n *\n *    return next(modifiedReq);\n * };\n * ```\n */\nexport type HttpInterceptorFn = (req: HttpRequest<unknown>, next: HttpHandlerFn) =>\n    Observable<HttpEvent<unknown>>;\n\n/**\n * Function which invokes an HTTP interceptor chain.\n *\n * Each interceptor in the interceptor chain is turned into a `ChainedInterceptorFn` which closes\n * over the rest of the chain (represented by another `ChainedInterceptorFn`). The last such\n * function in the chain will instead delegate to the `finalHandlerFn`, which is passed down when\n * the chain is invoked.\n *\n * This pattern allows for a chain of many interceptors to be composed and wrapped in a single\n * `HttpInterceptorFn`, which is a useful abstraction for including different kinds of interceptors\n * (e.g. legacy class-based interceptors) in the same chain.\n */\ntype ChainedInterceptorFn<RequestT> = (req: HttpRequest<RequestT>, finalHandlerFn: HttpHandlerFn) =>\n    Observable<HttpEvent<RequestT>>;\n\nfunction interceptorChainEndFn(\n    req: HttpRequest<any>, finalHandlerFn: HttpHandlerFn): Observable<HttpEvent<any>> {\n  return finalHandlerFn(req);\n}\n\n/**\n * Constructs a `ChainedInterceptorFn` which adapts a legacy `HttpInterceptor` to the\n * `ChainedInterceptorFn` interface.\n */\nfunction adaptLegacyInterceptorToChain(\n    chainTailFn: ChainedInterceptorFn<any>,\n    interceptor: HttpInterceptor): ChainedInterceptorFn<any> {\n  return (initialRequest, finalHandlerFn) => interceptor.intercept(initialRequest, {\n    handle: (downstreamRequest) => chainTailFn(downstreamRequest, finalHandlerFn),\n  });\n}\n\n/**\n * Constructs a `ChainedInterceptorFn` which wraps and invokes a functional interceptor in the given\n * injector.\n */\nfunction chainedInterceptorFn(\n    chainTailFn: ChainedInterceptorFn<unknown>, interceptorFn: HttpInterceptorFn,\n    injector: EnvironmentInjector): ChainedInterceptorFn<unknown> {\n  // clang-format off\n  return (initialRequest, finalHandlerFn) => runInInjectionContext(injector, () =>\n    interceptorFn(\n      initialRequest,\n      downstreamRequest => chainTailFn(downstreamRequest, finalHandlerFn)\n    )\n  );\n  // clang-format on\n}\n\n/**\n * A multi-provider token that represents the array of registered\n * `HttpInterceptor` objects.\n *\n * @publicApi\n */\nexport const HTTP_INTERCEPTORS =\n    new InjectionToken<readonly HttpInterceptor[]>(ngDevMode ? 'HTTP_INTERCEPTORS' : '');\n\n/**\n * A multi-provided token of `HttpInterceptorFn`s.\n */\nexport const HTTP_INTERCEPTOR_FNS =\n    new InjectionToken<readonly HttpInterceptorFn[]>(ngDevMode ? 'HTTP_INTERCEPTOR_FNS' : '');\n\n/**\n * A multi-provided token of `HttpInterceptorFn`s that are only set in root.\n */\nexport const HTTP_ROOT_INTERCEPTOR_FNS =\n    new InjectionToken<readonly HttpInterceptorFn[]>(ngDevMode ? 'HTTP_ROOT_INTERCEPTOR_FNS' : '');\n\n/**\n * A provider to set a global primary http backend. If set, it will override the default one\n */\nexport const PRIMARY_HTTP_BACKEND =\n    new InjectionToken<HttpBackend>(ngDevMode ? 'PRIMARY_HTTP_BACKEND' : '');\n\n\n/**\n * Creates an `HttpInterceptorFn` which lazily initializes an interceptor chain from the legacy\n * class-based interceptors and runs the request through it.\n */\nexport function legacyInterceptorFnFactory(): HttpInterceptorFn {\n  let chain: ChainedInterceptorFn<any>|null = null;\n\n  return (req, handler) => {\n    if (chain === null) {\n      const interceptors = inject(HTTP_INTERCEPTORS, {optional: true}) ?? [];\n      // Note: interceptors are wrapped right-to-left so that final execution order is\n      // left-to-right. That is, if `interceptors` is the array `[a, b, c]`, we want to\n      // produce a chain that is conceptually `c(b(a(end)))`, which we build from the inside\n      // out.\n      chain = interceptors.reduceRight(\n          adaptLegacyInterceptorToChain, interceptorChainEndFn as ChainedInterceptorFn<any>);\n    }\n\n    const pendingTasks = inject(PendingTasks);\n    const taskId = pendingTasks.add();\n    return chain(req, handler).pipe(finalize(() => pendingTasks.remove(taskId)));\n  };\n}\n\nlet fetchBackendWarningDisplayed = false;\n\n/** Internal function to reset the flag in tests */\nexport function resetFetchBackendWarningFlag() {\n  fetchBackendWarningDisplayed = false;\n}\n\n@Injectable()\nexport class HttpInterceptorHandler extends HttpHandler {\n  private chain: ChainedInterceptorFn<unknown>|null = null;\n  private readonly pendingTasks = inject(PendingTasks);\n\n  constructor(private backend: HttpBackend, private injector: EnvironmentInjector) {\n    super();\n\n    // Check if there is a preferred HTTP backend configured and use it if that's the case.\n    // This is needed to enable `FetchBackend` globally for all HttpClient's when `withFetch`\n    // is used.\n    const primaryHttpBackend = inject(PRIMARY_HTTP_BACKEND, {optional: true});\n    this.backend = primaryHttpBackend ?? backend;\n\n    // We strongly recommend using fetch backend for HTTP calls when SSR is used\n    // for an application. The logic below checks if that's the case and produces\n    // a warning otherwise.\n    if ((typeof ngDevMode === 'undefined' || ngDevMode) && !fetchBackendWarningDisplayed) {\n      const isServer = isPlatformServer(injector.get(PLATFORM_ID));\n      if (isServer && !(this.backend instanceof FetchBackend)) {\n        fetchBackendWarningDisplayed = true;\n        injector.get(Console).warn(formatRuntimeError(\n            RuntimeErrorCode.NOT_USING_FETCH_BACKEND_IN_SSR,\n            'Angular detected that `HttpClient` is not configured ' +\n                'to use `fetch` APIs. It\\'s strongly recommended to ' +\n                'enable `fetch` for applications that use Server-Side Rendering ' +\n                'for better performance and compatibility. ' +\n                'To enable `fetch`, add the `withFetch()` to the `provideHttpClient()` ' +\n                'call at the root of the application.'));\n      }\n    }\n  }\n\n  override handle(initialRequest: HttpRequest<any>): Observable<HttpEvent<any>> {\n    if (this.chain === null) {\n      const dedupedInterceptorFns = Array.from(new Set([\n        ...this.injector.get(HTTP_INTERCEPTOR_FNS),\n        ...this.injector.get(HTTP_ROOT_INTERCEPTOR_FNS, []),\n      ]));\n\n      // Note: interceptors are wrapped right-to-left so that final execution order is\n      // left-to-right. That is, if `dedupedInterceptorFns` is the array `[a, b, c]`, we want to\n      // produce a chain that is conceptually `c(b(a(end)))`, which we build from the inside\n      // out.\n      this.chain = dedupedInterceptorFns.reduceRight(\n          (nextSequencedFn, interceptorFn) =>\n              chainedInterceptorFn(nextSequencedFn, interceptorFn, this.injector),\n          interceptorChainEndFn as ChainedInterceptorFn<unknown>);\n    }\n\n    const taskId = this.pendingTasks.add();\n    return this.chain(initialRequest, downstreamRequest => this.backend.handle(downstreamRequest))\n        .pipe(finalize(() => this.pendingTasks.remove(taskId)));\n  }\n}\n"]}