ng-http-caching 1.0.13 → 13.0.1

package/README.md

@@ -1,8 +1,8 @@
-# NgHttpCaching [![Build Status](https://travis-ci.org/nigrosimone/ng-http-caching.svg?branch=master)](https://travis-ci.com/github/nigrosimone/ng-http-caching) [![Coverage Status](https://coveralls.io/repos/github/nigrosimone/ng-http-caching/badge.svg?branch=master)](https://coveralls.io/github/nigrosimone/ng-http-caching?branch=master)
+# NgHttpCaching [![Build Status](https://travis-ci.org/nigrosimone/ng-http-caching.svg?branch=master)](https://travis-ci.com/github/nigrosimone/ng-http-caching) [![Coverage Status](https://coveralls.io/repos/github/nigrosimone/ng-http-caching/badge.svg?branch=master)](https://coveralls.io/github/nigrosimone/ng-http-caching?branch=master) [![NPM version](https://img.shields.io/npm/v/ng-http-caching.svg)](https://www.npmjs.com/package/ng-http-caching)
 
 Cache for HTTP requests in Angular application.
 
-# Description
+## Description
 
 Sometime there is a need to cache the HTTP requests so that browser doesn’t have to hit server to fetch same data when same service is invoked serially or in parallel. `NgHttpCaching` intercept all request are made, try to retrieve a cached instance of the response and then return the cached response or send the request to the backend. Once the operation has completed cache the response.
 
@@ -14,10 +14,11 @@ See the [stackblitz demo](https://stackblitz.com/edit/demo-ng-http-caching?file=
 ✅ Handles simultaneous/parallel requests<br>
 ✅ Automatic garbage collector of cache<br>
 ✅ More than 90% unit tested<br>
+✅ Custom cache storage<br>
 
-# Get Started
+## Get Started
 
-*Step 1*: intall `ng-http-caching`
+*Step 1*: install `ng-http-caching`
 
 ```bash
 npm i ng-http-caching
@@ -62,7 +63,7 @@ import { NgHttpCachingModule, NgHttpCachingConfig } from 'ng-http-caching';
 
 // your config...
 const ngHttpCachingConfig: NgHttpCachingConfig = {
-  lifetime: 1000 * 10; // cache expire after 10 seconds
+  lifetime: 1000 * 10 // cache expire after 10 seconds
 };
 
 @NgModule({
@@ -80,7 +81,7 @@ const ngHttpCachingConfig: NgHttpCachingConfig = {
 export class AppModule { }
 ```
 
-### Config
+## Config
 
 This is all the configuration interface, see below for the detail of each config.
 
@@ -90,6 +91,7 @@ export interface NgHttpCachingConfig {
   lifetime?: number;
   allowedMethod?: string[];
   cacheStrategy?: NgHttpCachingStrategy;
+  store?: NgHttpCachingStorageInterface;
   isExpired?: (entry: NgHttpCachingEntry) => boolean | undefined;
   isValid?: (entry: NgHttpCachingEntry) => boolean | undefined;
   isCacheable?: (req: HttpRequest<any>) => boolean | undefined;
@@ -114,6 +116,21 @@ Set the cache strategy, possible strategies are:
 - `NgHttpCachingStrategy.ALLOW_ALL`: All request are cacheable if HTTP method is into `allowedMethod`;
 - `NgHttpCachingStrategy.DISALLOW_ALL`: Only the request with `X-NG-HTTP-CACHING-ALLOW-CACHE` header are cacheable if HTTP method is into `allowedMethod`;
 
+### store (class of NgHttpCachingStorageInterface - default: NgHttpCachingMemoryStorage)
+Set the cache store. You can imlement your custom store by implement the `NgHttpCachingStorageInterface` interface, eg.:
+
+```ts
+import { NgHttpCachingConfig, NgHttpCachingStorageInterface } from 'ng-http-caching';
+
+class MyCustomStore implements NgHttpCachingStorageInterface {
+  // ... your logic
+}
+
+const ngHttpCachingConfig: NgHttpCachingConfig = {
+  store: new MyCustomStore(),
+};
+```
+
 ### isExpired (function - default see NgHttpCachingService.isExpired());
 If this function return `true` the request is expired and a new request is send to backend, if return `false` isn't expired. 
 If the result is `undefined`, the normal behaviour is provided.
@@ -198,7 +215,176 @@ const ngHttpCachingConfig: NgHttpCachingConfig = {
 };
 ```
 
-## Example: exclude specific request from cache
+## Headers
+
+`NgHttpCaching` use some custom headers for customize the caching behaviour.
+The supported headers are exported from the enum `NgHttpCachingHeaders`:
+
+```ts
+export enum NgHttpCachingHeaders {
+  ALLOW_CACHE = 'X-NG-HTTP-CACHING-ALLOW-CACHE',
+  DISALLOW_CACHE = 'X-NG-HTTP-CACHING-DISALLOW-CACHE',
+  LIFETIME = 'X-NG-HTTP-CACHING-LIFETIME',
+  TAG = 'X-NG-HTTP-CACHING-TAG',
+}
+```
+
+All those headers are removed before send the request to the backend.
+
+### X-NG-HTTP-CACHING-ALLOW-CACHE (string: any value);
+
+If you have choose the `DISALLOW_ALL` cache strategy, you can mark specific request as cacheable by adding the header `X-NG-HTTP-CACHING-ALLOW-CACHE`, eg.:
+
+```ts
+this.http.get('https://my-json-server.typicode.com/typicode/demo/db', {
+  headers: {
+    [NgHttpCachingHeaders.ALLOW_ALL]: '1',
+  }
+}).subscribe(e => console.log);
+```
+
+### X-NG-HTTP-CACHING-DISALLOW-CACHE (string: any value);
+
+You can disallow specific request by add the header `X-NG-HTTP-CACHING-DISALLOW-CACHE`, eg.:
+
+```ts
+this.http.get('https://my-json-server.typicode.com/typicode/demo/db', {
+  headers: { 
+    [NgHttpCachingHeaders.DISALLOW_CACHE]: '1',
+  }
+}).subscribe(e => console.log);
+```
+
+### X-NG-HTTP-CACHING-LIFETIME (string: number of millisecond);
+
+You can set specific lifetime for request by add the header `X-NG-HTTP-CACHING-LIFETIME` with a string value as the number of millisecond, eg.:
+
+```ts
+this.http.get('https://my-json-server.typicode.com/typicode/demo/db', {
+  headers: {
+    [NgHttpCachingHeaders.LIFETIME]: (1000 * 60 * 60 * 24 * 365).toString(), // one year
+  }
+}).subscribe(e => console.log);
+```
+
+### X-NG-HTTP-CACHING-TAG (string: tag name);
+
+You can tag multiple request by adding special header `X-NG-HTTP-CACHING-TAG` with the same tag and 
+using `NgHttpCachingService.clearCacheByTag(tag: string)` for delete all the tagged request. Eg.:
+
+```ts
+this.http.get('https://my-json-server.typicode.com/typicode/demo/db?id=1', {
+  headers: {
+    [NgHttpCachingHeaders.TAG]: 'foo',
+  }
+}).subscribe(e => console.log);
+```
+
+## Cache service
+
+You can inject into your component the `NgHttpCachingService` that expose some utils methods:
+
+```ts
+export class NgHttpCachingService {
+
+  /**
+   * Return the config
+   */
+  getConfig(): NgHttpCachingConfig;
+
+  /**
+   * Return the queue map
+   */
+  getQueue(): Map<string, Observable<HttpEvent<any>>>;
+
+  /**
+   * Return the cache store
+   */
+  getStore(): NgHttpCachingStorageInterface;
+
+  /**
+   * Return response from cache
+   */
+  getFromCache(req: HttpRequest<any>): HttpResponse<any> | undefined;
+
+  /**
+   * Add response to cache
+   */
+  addToCache(req: HttpRequest<any>, res: HttpResponse<any>): boolean;
+
+  /**
+   * Delete response from cache
+   */
+  deleteFromCache(req: HttpRequest<any>): boolean;
+
+  /**
+   * Clear the cache
+   */
+  clearCache(): void;
+
+  /**
+   * Clear the cache by key
+   */
+  clearCacheByKey(key: string): boolean;
+
+  /**
+   * Clear the cache by regex
+   */
+  clearCacheByRegex(regex: RegExp): void;
+
+  /**
+   * Clear the cache by TAG
+   */
+  clearCacheByTag(tag: string): void;
+
+  /**
+   * Run garbage collector (delete expired cache entry)
+   */
+  runGc(): void;
+
+  /**
+   * Return true if cache entry is expired
+   */
+  isExpired(entry: NgHttpCachingEntry): boolean;
+
+  /**
+   * Return true if cache entry is valid for store in the cache
+   */
+  isValid(entry: NgHttpCachingEntry): boolean;
+
+  /**
+   * Return true if the request is cacheable
+   */
+  isCacheable(req: HttpRequest<any>): boolean;
+
+  /**
+   * Return the cache key
+   */
+  getKey(req: HttpRequest<any>): string;
+
+  /**
+   * Return observable from cache
+   */
+  getFromQueue(req: HttpRequest<any>): Observable<HttpEvent<any>> | undefined;
+
+  /**
+   * Add observable to cache
+   */
+  addToQueue(req: HttpRequest<any>, obs: Observable<HttpEvent<any>>): void;
+
+  /**
+   * Delete observable from cache
+   */
+  deleteFromQueue(req: HttpRequest<any>): boolean;
+
+}
+```
+
+## Examples
+
+Below there are some examples of use case.
+
+### Example: exclude specific request from cache
 
 You can disallow specific request by add the header `X-NG-HTTP-CACHING-DISALLOW-CACHE`, eg.:
 
@@ -228,7 +414,7 @@ export class AppComponent implements OnInit {
 }
 ```
 
-## Example: set specific lifetime for request
+### Example: set specific lifetime for request
 
 You can set specific lifetime for request by add the header `X-NG-HTTP-CACHING-LIFETIME` with a string value as the number of millisecond, eg.:
 
@@ -258,7 +444,7 @@ export class AppComponent implements OnInit {
 }
 ```
 
-## Example: mark specific request as cacheable (if cache strategy is DISALLOW_ALL)
+### Example: mark specific request as cacheable (if cache strategy is DISALLOW_ALL)
 
 If you have choose the `DISALLOW_ALL` cache strategy, you can mark specific request as cacheable by adding the header `X-NG-HTTP-CACHING-ALLOW-CACHE`, eg.:
 
@@ -288,7 +474,7 @@ export class AppComponent implements OnInit {
 }
 ```
 
-## Example: clear/flush all the cache
+### Example: clear/flush all the cache
 
 If user switch the account (logout/login) or the application language, maybe ca be necessary clear all the cache, eg.:
 
@@ -312,7 +498,7 @@ export class AppComponent {
 }
 ```
 
-## Example: clear/flush specific cache entry
+### Example: clear/flush specific cache entry
 
 If you want delete some cache entry, eg.:
 
@@ -336,7 +522,7 @@ export class AppComponent {
 }
 ```
 
-## Example: clear/flush specific cache entry by RegEx
+### Example: clear/flush specific cache entry by RegEx
 
 If you want delete some cache entry by RegEx, eg.:
 
@@ -360,10 +546,11 @@ export class AppComponent {
 }
 ```
 
-## Example: TAG request and clear/flush specific cache entry by TAG
+### Example: TAG request and clear/flush specific cache entry by TAG
 
-You can tag multiple request by adding special header `'X-NG-HTTP-CACHING-TAG'` with the same tag and 
-using `NgHttpCachingService.clearCacheByTag(tag: syting)` for delete all the tagged request. Eg.:
+You can tag multiple request by adding special header `X-NG-HTTP-CACHING-TAG` with the same tag and 
+using `NgHttpCachingService.clearCacheByTag(tag: 
+)` for delete all the tagged request. Eg.:
 
 ```ts
 import { Component, OnInit } from '@angular/core';
@@ -402,4 +589,29 @@ export class AppComponent {
     this.ngHttpCachingService.clearCacheByTag('foo');
   }
 }
-```
+```
+
+## Alternatives
+
+Aren't you satisfied? there are some valid alternatives:
+
+ - [@ngneat/cashew](https://www.npmjs.com/package/@ngneat/cashew)
+ - [p3x-angular-http-cache-interceptor](https://www.npmjs.com/package/p3x-angular-http-cache-interceptor)
+ - [@d4h/angular-http-cache](https://www.npmjs.com/package/@d4h/angular-http-cache)
+
+
+## Support
+
+This is an open-source project. Star this [repository](https://github.com/nigrosimone/ng-http-caching), if you like it, or even [donate](https://www.paypal.com/paypalme/snwp). Thank you so much!
+
+## My other libraries
+
+I have published some other Angular libraries, take a look:
+
+ - [NgSimpleState: Simple state management in Angular with only Services and RxJS](https://www.npmjs.com/package/ng-simple-state)
+ - [NgPortal: Component property connection in Angular application](https://www.npmjs.com/package/ng-portal)
+ - [NgHttpCaching: Cache for HTTP requests in Angular application](https://www.npmjs.com/package/ng-http-caching)
+ - [NgGenericPipe: Generic pipe for Angular application](https://www.npmjs.com/package/ng-generic-pipe)
+ - [NgLet: Structural directive for sharing data as local variable into html component template](https://www.npmjs.com/package/ng-let)
+ - [NgLock: Angular decorator for lock a function and user interface while a task running](https://www.npmjs.com/package/ng-lock)
+ - [NgCondition: An alternative to `*ngIf; else` directive for simplify conditions into HTML template for Angular application](https://www.npmjs.com/package/ng-condition)

package/esm2020/lib/ng-http-caching-interceptor.service.mjs

@@ -0,0 +1,66 @@
+import { HttpResponse } from '@angular/common/http';
+import { Injectable } from '@angular/core';
+import { of } from 'rxjs';
+import { tap, finalize, share } from 'rxjs/operators';
+import { NgHttpCachingHeaders } from './ng-http-caching.service';
+import * as i0 from "@angular/core";
+import * as i1 from "./ng-http-caching.service";
+export class NgHttpCachingInterceptorService {
+    // eslint-disable-next-line no-unused-vars
+    constructor(cacheService) {
+        this.cacheService = cacheService;
+    }
+    intercept(req, next) {
+        // run garbage collector
+        this.cacheService.runGc();
+        // Don't cache if it's not cacheable
+        if (!this.cacheService.isCacheable(req)) {
+            return this.sendRequest(req, next);
+        }
+        // Checked if there is pending response for this request
+        const cachedObservable = this.cacheService.getFromQueue(req);
+        if (cachedObservable) {
+            // console.log('cachedObservable', req);
+            return cachedObservable;
+        }
+        // Checked if there is cached response for this request
+        const cachedResponse = this.cacheService.getFromCache(req);
+        if (cachedResponse) {
+            // console.log('cachedResponse', req);
+            return of(cachedResponse.clone());
+        }
+        // If the request of going through for first time
+        // then let the request proceed and cache the response
+        // console.log('sendRequest', req);
+        const shared = this.sendRequest(req, next).pipe(tap(event => {
+            if (event instanceof HttpResponse) {
+                this.cacheService.addToCache(req, event.clone());
+            }
+        }), finalize(() => {
+            // delete pending request
+            this.cacheService.deleteFromQueue(req);
+        }), share());
+        // add pending request to queue for cache parallell request
+        this.cacheService.addToQueue(req, shared);
+        return shared;
+    }
+    /**
+     * Send http request (next handler)
+     */
+    sendRequest(req, next) {
+        let cloned = req.clone();
+        // trim custom headers before send request
+        Object.values(NgHttpCachingHeaders).forEach(ngHttpCachingHeaders => {
+            if (cloned.headers.has(ngHttpCachingHeaders)) {
+                cloned = cloned.clone({ headers: cloned.headers.delete(ngHttpCachingHeaders) });
+            }
+        });
+        return next.handle(cloned);
+    }
+}
+NgHttpCachingInterceptorService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.3", ngImport: i0, type: NgHttpCachingInterceptorService, deps: [{ token: i1.NgHttpCachingService }], target: i0.ɵɵFactoryTarget.Injectable });
+NgHttpCachingInterceptorService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.0.3", ngImport: i0, type: NgHttpCachingInterceptorService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.3", ngImport: i0, type: NgHttpCachingInterceptorService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.NgHttpCachingService }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/ng-http-caching.module.mjs

@@ -0,0 +1,45 @@
+import { NgModule } from '@angular/core';
+import { HTTP_INTERCEPTORS } from '@angular/common/http';
+import { NG_HTTP_CACHING_CONFIG, NgHttpCachingService, } from './ng-http-caching.service';
+import { NgHttpCachingInterceptorService } from './ng-http-caching-interceptor.service';
+import * as i0 from "@angular/core";
+export class NgHttpCachingModule {
+    static forRoot(ngHttpCachingConfig) {
+        return {
+            ngModule: NgHttpCachingModule,
+            providers: [
+                {
+                    provide: NG_HTTP_CACHING_CONFIG,
+                    useValue: ngHttpCachingConfig,
+                },
+            ],
+        };
+    }
+}
+NgHttpCachingModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.3", ngImport: i0, type: NgHttpCachingModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+NgHttpCachingModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "13.0.3", ngImport: i0, type: NgHttpCachingModule });
+NgHttpCachingModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "13.0.3", ngImport: i0, type: NgHttpCachingModule, providers: [
+        NgHttpCachingService,
+        {
+            provide: HTTP_INTERCEPTORS,
+            useClass: NgHttpCachingInterceptorService,
+            multi: true,
+        },
+    ], imports: [[]] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.3", ngImport: i0, type: NgHttpCachingModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [],
+                    imports: [],
+                    providers: [
+                        NgHttpCachingService,
+                        {
+                            provide: HTTP_INTERCEPTORS,
+                            useClass: NgHttpCachingInterceptorService,
+                            multi: true,
+                        },
+                    ],
+                    exports: [],
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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