refactor to use caching interceptor

src/app/http-interceptors/caching.interceptor.spec.ts

@@ -0,0 +1,16 @@
+import { TestBed } from '@angular/core/testing';
+
+import { CachingInterceptor } from './caching.interceptor';
+
+describe('CachingInterceptor', () => {
+  beforeEach(() => TestBed.configureTestingModule({
+    providers: [
+      CachingInterceptor
+      ]
+  }));
+
+  it('should be created', () => {
+    const interceptor: CachingInterceptor = TestBed.inject(CachingInterceptor);
+    expect(interceptor).toBeTruthy();
+  });
+});

src/app/http-interceptors/caching.interceptor.ts

@@ -0,0 +1,58 @@
+import { Injectable } from '@angular/core';
+import {
+  HttpRequest,
+  HttpHandler,
+  HttpEvent,
+  HttpInterceptor,
+  HttpHeaders,
+  HttpResponse
+} from '@angular/common/http';
+import { Observable, of } from 'rxjs';
+import { tap } from 'rxjs/operators';
+import { RequestCacheService } from '../request-cache.service'
+
+@Injectable()
+export class CachingInterceptor implements HttpInterceptor {
+  constructor(private cache: RequestCacheService) { }
+
+  intercept(req: HttpRequest<any>, next: HttpHandler) {
+    // continue if not cachable.
+    if (!isCachable(req)) { return next.handle(req); }
+
+    const cachedResponse = this.cache.get(req);
+    return cachedResponse ?
+      of(cachedResponse) : sendRequest(req, next, this.cache);
+  }
+}
+
+/** Is this request cachable? */
+function isCachable(req: HttpRequest<any>) {
+  // Only GET requests are cachable
+  return req.method === 'GET';
+  /*
+  return req.method === 'GET' &&
+    -1 < req.url.indexOf("url");
+    */
+}
+
+/**
+ * Get server response observable by sending request to `next()`.
+ * Will add the response to the cache on the way out.
+ */
+function sendRequest(
+  req: HttpRequest<any>,
+  next: HttpHandler,
+  cache: RequestCacheService): Observable<HttpEvent<any>> {
+
+  // No headers allowed in npm search request
+  const noHeaderReq = req.clone({ headers: new HttpHeaders() });
+
+  return next.handle(noHeaderReq).pipe(
+    tap(event => {
+      // There may be other events besides the response.
+      if (event instanceof HttpResponse) {
+        // cache.put(req, event); // Update the cache.
+      }
+    })
+  );
+}

src/app/http-interceptors/csrf-intercepor.ts

@@ -1,29 +0,0 @@
-import { Injectable } from '@angular/core';
-import { deviceID } from '../api-utils';
-import {
-    HttpInterceptor, HttpHandler, HttpRequest, HttpHeaders
-} from '@angular/common/http';
-
-import { CookieService } from '../cookie.service';
-
-
-@Injectable()
-export class CSRFInterceptor implements HttpInterceptor {
-
-    constructor(private cookieService: CookieService) { }
-
-    intercept(req: HttpRequest<any>, next: HttpHandler) {
-        const dID: String = deviceID();
-        const csrfCookie = 'CSRF-Token-' + dID
-
-        // Clone the request and replace the original headers with
-        // cloned headers, updated with the CSRF information.
-        const csrfReq = req.clone({
-            headers: req.headers.set('X-CSRF-Token-' + dID,
-                this.cookieService.getCookie(csrfCookie))
-        });
-
-        // send cloned request with header to the next handler.
-        return next.handle(csrfReq);
-    }
-}

src/app/http-interceptors/csrf.interceptor.spec.ts

@@ -0,0 +1,16 @@
+import { TestBed } from '@angular/core/testing';
+
+import { CSRFInterceptor } from './csrf.interceptor';
+
+describe('CsrfInterceptor', () => {
+  beforeEach(() => TestBed.configureTestingModule({
+    providers: [
+      CSRFInterceptor
+    ]
+  }));
+
+  it('should be created', () => {
+    const interceptor: CSRFInterceptor = TestBed.inject(CSRFInterceptor);
+    expect(interceptor).toBeTruthy();
+  });
+});

src/app/http-interceptors/csrf.interceptor.ts

@@ -0,0 +1,29 @@
+import { Injectable } from '@angular/core';
+import { deviceID } from '../api-utils';
+import {
+  HttpInterceptor, HttpHandler, HttpRequest, HttpHeaders
+} from '@angular/common/http';
+
+import { CookieService } from '../cookie.service';
+
+
+@Injectable()
+export class CSRFInterceptor implements HttpInterceptor {
+
+  constructor(private cookieService: CookieService) { }
+
+  intercept(req: HttpRequest<any>, next: HttpHandler) {
+    const dID: String = deviceID();
+    const csrfCookie = 'CSRF-Token-' + dID
+
+    // Clone the request and replace the original headers with
+    // cloned headers, updated with the CSRF information.
+    const csrfReq = req.clone({
+      headers: req.headers.set('X-CSRF-Token-' + dID,
+        this.cookieService.getCookie(csrfCookie))
+    });
+
+    // send cloned request with header to the next handler.
+    return next.handle(csrfReq);
+  }
+}

src/app/http-interceptors/index.ts

@@ -1,8 +1,12 @@
 /* "Barrel" of Http Interceptors */
 import { HTTP_INTERCEPTORS } from '@angular/common/http';
-import { CSRFInterceptor } from './csrf-intercepor';
+
+import { CSRFInterceptor } from './csrf.interceptor';
+import { CachingInterceptor } from './caching.interceptor';
 
 /** Http interceptor providers in outside-in order */
 export const httpInterceptorProviders = [
+    { provide: HTTP_INTERCEPTORS, useClass: CachingInterceptor, multi: true },
+    // CSRFInterceptor needs to be last 
     { provide: HTTP_INTERCEPTORS, useClass: CSRFInterceptor, multi: true },
 ];