@angular/common
Version:
Angular - commonly needed directives and services
142 lines • 18.5 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 { APP_BOOTSTRAP_LISTENER, ApplicationRef, inject, InjectionToken, makeStateKey, TransferState, ɵENABLED_SSR_FEATURES as ENABLED_SSR_FEATURES, ɵInitialRenderPendingTasks as InitialRenderPendingTasks } from '@angular/core';
import { of } from 'rxjs';
import { first, tap } from 'rxjs/operators';
import { HttpHeaders } from './headers';
import { HTTP_ROOT_INTERCEPTOR_FNS } from './interceptor';
import { HttpResponse } from './response';
const CACHE_STATE = new InjectionToken(ngDevMode ? 'HTTP_TRANSFER_STATE_CACHE_STATE' : '');
/**
* A list of allowed HTTP methods to cache.
*/
const ALLOWED_METHODS = ['GET', 'HEAD'];
export function transferCacheInterceptorFn(req, next) {
const { isCacheActive } = inject(CACHE_STATE);
// Stop using the cache if the application has stabilized, indicating initial rendering
// is complete.
if (!isCacheActive || !ALLOWED_METHODS.includes(req.method)) {
// Cache is no longer active or method is not HEAD or GET.
// Pass the request through.
return next(req);
}
const transferState = inject(TransferState);
const storeKey = makeCacheKey(req);
const response = transferState.get(storeKey, null);
if (response) {
// Request found in cache. Respond using it.
let body = response.body;
switch (response.responseType) {
case 'arraybuffer':
body = new TextEncoder().encode(response.body).buffer;
break;
case 'blob':
body = new Blob([response.body]);
break;
}
return of(new HttpResponse({
body,
headers: new HttpHeaders(response.headers),
status: response.status,
statusText: response.statusText,
url: response.url,
}));
}
// Request not found in cache. Make the request and cache it.
return next(req).pipe(tap((event) => {
if (event instanceof HttpResponse) {
transferState.set(storeKey, {
body: event.body,
headers: getHeadersMap(event.headers),
status: event.status,
statusText: event.statusText,
url: event.url || '',
responseType: req.responseType,
});
}
}));
}
function getHeadersMap(headers) {
const headersMap = {};
for (const key of headers.keys()) {
const values = headers.getAll(key);
if (values !== null) {
headersMap[key] = values;
}
}
return headersMap;
}
function makeCacheKey(request) {
// make the params encoded same as a url so it's easy to identify
const { params, method, responseType, url } = request;
const encodedParams = params.keys().sort().map((k) => `${k}=${params.getAll(k)}`).join('&');
const key = method + '.' + responseType + '.' + url + '?' + encodedParams;
const hash = generateHash(key);
return makeStateKey(hash);
}
/**
* A method that returns a hash representation of a string using a variant of DJB2 hash
* algorithm.
*
* This is the same hashing logic that is used to generate component ids.
*/
function generateHash(value) {
let hash = 0;
for (const char of value) {
hash = Math.imul(31, hash) + char.charCodeAt(0) << 0;
}
// Force positive number hash.
// 2147483647 = equivalent of Integer.MAX_VALUE.
hash += 2147483647 + 1;
return hash.toString();
}
/**
* Returns the DI providers needed to enable HTTP transfer cache.
*
* By default, when using server rendering, requests are performed twice: once on the server and
* other one on the browser.
*
* When these providers are added, requests performed on the server are cached and reused during the
* bootstrapping of the application in the browser thus avoiding duplicate requests and reducing
* load time.
*
*/
export function withHttpTransferCache() {
return [
{
provide: CACHE_STATE,
useFactory: () => {
inject(ENABLED_SSR_FEATURES).add('httpcache');
return { isCacheActive: true };
}
},
{
provide: HTTP_ROOT_INTERCEPTOR_FNS,
useValue: transferCacheInterceptorFn,
multi: true,
deps: [TransferState, CACHE_STATE]
},
{
provide: APP_BOOTSTRAP_LISTENER,
multi: true,
useFactory: () => {
const appRef = inject(ApplicationRef);
const cacheState = inject(CACHE_STATE);
const pendingTasks = inject(InitialRenderPendingTasks);
return () => {
const isStablePromise = appRef.isStable.pipe(first((isStable) => isStable)).toPromise();
isStablePromise.then(() => pendingTasks.whenAllTasksComplete).then(() => {
cacheState.isCacheActive = false;
});
};
},
deps: [ApplicationRef, CACHE_STATE, InitialRenderPendingTasks]
}
];
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"transfer_cache.js","sourceRoot":"","sources":["../../../../../../../packages/common/http/src/transfer_cache.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAC,sBAAsB,EAAE,cAAc,EAAE,MAAM,EAAE,cAAc,EAAE,YAAY,EAAsB,aAAa,EAAE,qBAAqB,IAAI,oBAAoB,EAAE,0BAA0B,IAAI,yBAAyB,EAAC,MAAM,eAAe,CAAC;AACtP,OAAO,EAAa,EAAE,EAAC,MAAM,MAAM,CAAC;AACpC,OAAO,EAAC,KAAK,EAAE,GAAG,EAAC,MAAM,gBAAgB,CAAC;AAE1C,OAAO,EAAC,WAAW,EAAC,MAAM,WAAW,CAAC;AACtC,OAAO,EAAC,yBAAyB,EAAgB,MAAM,eAAe,CAAC;AAEvE,OAAO,EAAY,YAAY,EAAC,MAAM,YAAY,CAAC;AAWnD,MAAM,WAAW,GAAG,IAAI,cAAc,CAClC,SAAS,CAAC,CAAC,CAAC,iCAAiC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC;AAExD;;GAEG;AACH,MAAM,eAAe,GAAG,CAAC,KAAK,EAAE,MAAM,CAAC,CAAC;AAExC,MAAM,UAAU,0BAA0B,CACtC,GAAyB,EAAE,IAAmB;IAChD,MAAM,EAAC,aAAa,EAAC,GAAG,MAAM,CAAC,WAAW,CAAC,CAAC;IAE5C,uFAAuF;IACvF,eAAe;IACf,IAAI,CAAC,aAAa,IAAI,CAAC,eAAe,CAAC,QAAQ,CAAC,GAAG,CAAC,MAAM,CAAC,EAAE;QAC3D,0DAA0D;QAC1D,4BAA4B;QAC5B,OAAO,IAAI,CAAC,GAAG,CAAC,CAAC;KAClB;IAED,MAAM,aAAa,GAAG,MAAM,CAAC,aAAa,CAAC,CAAC;IAC5C,MAAM,QAAQ,GAAG,YAAY,CAAC,GAAG,CAAC,CAAC;IACnC,MAAM,QAAQ,GAAG,aAAa,CAAC,GAAG,CAAC,QAAQ,EAAE,IAAI,CAAC,CAAC;IAEnD,IAAI,QAAQ,EAAE;QACZ,4CAA4C;QAC5C,IAAI,IAAI,GAAsC,QAAQ,CAAC,IAAI,CAAC;QAE5D,QAAQ,QAAQ,CAAC,YAAY,EAAE;YAC7B,KAAK,aAAa;gBAChB,IAAI,GAAG,IAAI,WAAW,EAAE,CAAC,MAAM,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,MAAM,CAAC;gBACtD,MAAM;YACR,KAAK,MAAM;gBACT,IAAI,GAAG,IAAI,IAAI,CAAC,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,CAAC;gBACjC,MAAM;SACT;QAED,OAAO,EAAE,CACL,IAAI,YAAY,CAAC;YACf,IAAI;YACJ,OAAO,EAAE,IAAI,WAAW,CAAC,QAAQ,CAAC,OAAO,CAAC;YAC1C,MAAM,EAAE,QAAQ,CAAC,MAAM;YACvB,UAAU,EAAE,QAAQ,CAAC,UAAU;YAC/B,GAAG,EAAE,QAAQ,CAAC,GAAG;SAClB,CAAC,CACL,CAAC;KACH;IAED,6DAA6D;IAC7D,OAAO,IAAI,CAAC,GAAG,CAAC,CAAC,IAAI,CACjB,GAAG,CAAC,CAAC,KAAyB,EAAE,EAAE;QAChC,IAAI,KAAK,YAAY,YAAY,EAAE;YACjC,aAAa,CAAC,GAAG,CAAuB,QAAQ,EAAE;gBAChD,IAAI,EAAE,KAAK,CAAC,IAAI;gBAChB,OAAO,EAAE,aAAa,CAAC,KAAK,CAAC,OAAO,CAAC;gBACrC,MAAM,EAAE,KAAK,CAAC,MAAM;gBACpB,UAAU,EAAE,KAAK,CAAC,UAAU;gBAC5B,GAAG,EAAE,KAAK,CAAC,GAAG,IAAI,EAAE;gBACpB,YAAY,EAAE,GAAG,CAAC,YAAY;aAC/B,CAAC,CAAC;SACJ;IACH,CAAC,CAAC,CACL,CAAC;AACJ,CAAC;AAED,SAAS,aAAa,CAAC,OAAoB;IACzC,MAAM,UAAU,GAA6B,EAAE,CAAC;IAEhD,KAAK,MAAM,GAAG,IAAI,OAAO,CAAC,IAAI,EAAE,EAAE;QAChC,MAAM,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;QACnC,IAAI,MAAM,KAAK,IAAI,EAAE;YACnB,UAAU,CAAC,GAAG,CAAC,GAAG,MAAM,CAAC;SAC1B;KACF;IAED,OAAO,UAAU,CAAC;AACpB,CAAC;AAED,SAAS,YAAY,CAAC,OAAyB;IAC7C,iEAAiE;IACjE,MAAM,EAAC,MAAM,EAAE,MAAM,EAAE,YAAY,EAAE,GAAG,EAAC,GAAG,OAAO,CAAC;IACpD,MAAM,aAAa,GAAG,MAAM,CAAC,IAAI,EAAE,CAAC,IAAI,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,GAAG,CAAC,IAAI,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;IAC5F,MAAM,GAAG,GAAG,MAAM,GAAG,GAAG,GAAG,YAAY,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,aAAa,CAAC;IAE1E,MAAM,IAAI,GAAG,YAAY,CAAC,GAAG,CAAC,CAAC;IAE/B,OAAO,YAAY,CAAC,IAAI,CAAC,CAAC;AAC5B,CAAC;AAED;;;;;GAKG;AACH,SAAS,YAAY,CAAC,KAAa;IACjC,IAAI,IAAI,GAAG,CAAC,CAAC;IAEb,KAAK,MAAM,IAAI,IAAI,KAAK,EAAE;QACxB,IAAI,GAAG,IAAI,CAAC,IAAI,CAAC,EAAE,EAAE,IAAI,CAAC,GAAG,IAAI,CAAC,UAAU,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC;KACtD;IAED,8BAA8B;IAC9B,gDAAgD;IAChD,IAAI,IAAI,UAAU,GAAG,CAAC,CAAC;IAEvB,OAAO,IAAI,CAAC,QAAQ,EAAE,CAAC;AACzB,CAAC;AAED;;;;;;;;;;GAUG;AACH,MAAM,UAAU,qBAAqB;IACnC,OAAO;QACL;YACE,OAAO,EAAE,WAAW;YACpB,UAAU,EAAE,GAAG,EAAE;gBACf,MAAM,CAAC,oBAAoB,CAAC,CAAC,GAAG,CAAC,WAAW,CAAC,CAAC;gBAC9C,OAAO,EAAC,aAAa,EAAE,IAAI,EAAC,CAAC;YAC/B,CAAC;SACF;QACD;YACE,OAAO,EAAE,yBAAyB;YAClC,QAAQ,EAAE,0BAA0B;YACpC,KAAK,EAAE,IAAI;YACX,IAAI,EAAE,CAAC,aAAa,EAAE,WAAW,CAAC;SACnC;QACD;YACE,OAAO,EAAE,sBAAsB;YAC/B,KAAK,EAAE,IAAI;YACX,UAAU,EAAE,GAAG,EAAE;gBACf,MAAM,MAAM,GAAG,MAAM,CAAC,cAAc,CAAC,CAAC;gBACtC,MAAM,UAAU,GAAG,MAAM,CAAC,WAAW,CAAC,CAAC;gBACvC,MAAM,YAAY,GAAG,MAAM,CAAC,yBAAyB,CAAC,CAAC;gBAEvD,OAAO,GAAG,EAAE;oBACV,MAAM,eAAe,GAAG,MAAM,CAAC,QAAQ,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,QAAQ,EAAE,EAAE,CAAC,QAAQ,CAAC,CAAC,CAAC,SAAS,EAAE,CAAC;oBACxF,eAAe,CAAC,IAAI,CAAC,GAAG,EAAE,CAAC,YAAY,CAAC,oBAAoB,CAAC,CAAC,IAAI,CAAC,GAAG,EAAE;wBACtE,UAAU,CAAC,aAAa,GAAG,KAAK,CAAC;oBACnC,CAAC,CAAC,CAAC;gBACL,CAAC,CAAC;YACJ,CAAC;YACD,IAAI,EAAE,CAAC,cAAc,EAAE,WAAW,EAAE,yBAAyB,CAAC;SAC/D;KACF,CAAC;AACJ,CAAC","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 {APP_BOOTSTRAP_LISTENER, ApplicationRef, inject, InjectionToken, makeStateKey, Provider, StateKey, TransferState, ɵENABLED_SSR_FEATURES as ENABLED_SSR_FEATURES, ɵInitialRenderPendingTasks as InitialRenderPendingTasks} from '@angular/core';\nimport {Observable, of} from 'rxjs';\nimport {first, tap} from 'rxjs/operators';\n\nimport {HttpHeaders} from './headers';\nimport {HTTP_ROOT_INTERCEPTOR_FNS, HttpHandlerFn} from './interceptor';\nimport {HttpRequest} from './request';\nimport {HttpEvent, HttpResponse} from './response';\n\ninterface TransferHttpResponse {\n  body: any;\n  headers: Record<string, string[]>;\n  status?: number;\n  statusText?: string;\n  url?: string;\n  responseType?: HttpRequest<unknown>['responseType'];\n}\n\nconst CACHE_STATE = new InjectionToken<{isCacheActive: boolean}>(\n    ngDevMode ? 'HTTP_TRANSFER_STATE_CACHE_STATE' : '');\n\n/**\n * A list of allowed HTTP methods to cache.\n */\nconst ALLOWED_METHODS = ['GET', 'HEAD'];\n\nexport function transferCacheInterceptorFn(\n    req: HttpRequest<unknown>, next: HttpHandlerFn): Observable<HttpEvent<unknown>> {\n  const {isCacheActive} = inject(CACHE_STATE);\n\n  // Stop using the cache if the application has stabilized, indicating initial rendering\n  // is complete.\n  if (!isCacheActive || !ALLOWED_METHODS.includes(req.method)) {\n    // Cache is no longer active or method is not HEAD or GET.\n    // Pass the request through.\n    return next(req);\n  }\n\n  const transferState = inject(TransferState);\n  const storeKey = makeCacheKey(req);\n  const response = transferState.get(storeKey, null);\n\n  if (response) {\n    // Request found in cache. Respond using it.\n    let body: ArrayBuffer|Blob|string|undefined = response.body;\n\n    switch (response.responseType) {\n      case 'arraybuffer':\n        body = new TextEncoder().encode(response.body).buffer;\n        break;\n      case 'blob':\n        body = new Blob([response.body]);\n        break;\n    }\n\n    return of(\n        new HttpResponse({\n          body,\n          headers: new HttpHeaders(response.headers),\n          status: response.status,\n          statusText: response.statusText,\n          url: response.url,\n        }),\n    );\n  }\n\n  // Request not found in cache. Make the request and cache it.\n  return next(req).pipe(\n      tap((event: HttpEvent<unknown>) => {\n        if (event instanceof HttpResponse) {\n          transferState.set<TransferHttpResponse>(storeKey, {\n            body: event.body,\n            headers: getHeadersMap(event.headers),\n            status: event.status,\n            statusText: event.statusText,\n            url: event.url || '',\n            responseType: req.responseType,\n          });\n        }\n      }),\n  );\n}\n\nfunction getHeadersMap(headers: HttpHeaders): Record<string, string[]> {\n  const headersMap: Record<string, string[]> = {};\n\n  for (const key of headers.keys()) {\n    const values = headers.getAll(key);\n    if (values !== null) {\n      headersMap[key] = values;\n    }\n  }\n\n  return headersMap;\n}\n\nfunction makeCacheKey(request: HttpRequest<any>): StateKey<TransferHttpResponse> {\n  // make the params encoded same as a url so it's easy to identify\n  const {params, method, responseType, url} = request;\n  const encodedParams = params.keys().sort().map((k) => `${k}=${params.getAll(k)}`).join('&');\n  const key = method + '.' + responseType + '.' + url + '?' + encodedParams;\n\n  const hash = generateHash(key);\n\n  return makeStateKey(hash);\n}\n\n/**\n * A method that returns a hash representation of a string using a variant of DJB2 hash\n * algorithm.\n *\n * This is the same hashing logic that is used to generate component ids.\n */\nfunction generateHash(value: string): string {\n  let hash = 0;\n\n  for (const char of value) {\n    hash = Math.imul(31, hash) + char.charCodeAt(0) << 0;\n  }\n\n  // Force positive number hash.\n  // 2147483647 = equivalent of Integer.MAX_VALUE.\n  hash += 2147483647 + 1;\n\n  return hash.toString();\n}\n\n/**\n * Returns the DI providers needed to enable HTTP transfer cache.\n *\n * By default, when using server rendering, requests are performed twice: once on the server and\n * other one on the browser.\n *\n * When these providers are added, requests performed on the server are cached and reused during the\n * bootstrapping of the application in the browser thus avoiding duplicate requests and reducing\n * load time.\n *\n */\nexport function withHttpTransferCache(): Provider[] {\n  return [\n    {\n      provide: CACHE_STATE,\n      useFactory: () => {\n        inject(ENABLED_SSR_FEATURES).add('httpcache');\n        return {isCacheActive: true};\n      }\n    },\n    {\n      provide: HTTP_ROOT_INTERCEPTOR_FNS,\n      useValue: transferCacheInterceptorFn,\n      multi: true,\n      deps: [TransferState, CACHE_STATE]\n    },\n    {\n      provide: APP_BOOTSTRAP_LISTENER,\n      multi: true,\n      useFactory: () => {\n        const appRef = inject(ApplicationRef);\n        const cacheState = inject(CACHE_STATE);\n        const pendingTasks = inject(InitialRenderPendingTasks);\n\n        return () => {\n          const isStablePromise = appRef.isStable.pipe(first((isStable) => isStable)).toPromise();\n          isStablePromise.then(() => pendingTasks.whenAllTasksComplete).then(() => {\n            cacheState.isCacheActive = false;\n          });\n        };\n      },\n      deps: [ApplicationRef, CACHE_STATE, InitialRenderPendingTasks]\n    }\n  ];\n}\n"]}