ng-http-caching 15.0.3 → 15.2.2

package/lib/ng-http-caching.service.d.ts

@@ -4,21 +4,55 @@ import { Observable } from 'rxjs/internal/Observable';
 import { NgHttpCachingStorageInterface } from './storage/ng-http-caching-storage.interface';
 import * as i0 from "@angular/core";
 export interface NgHttpCachingEntry<K = any, T = any> {
+    /**
+     * URL
+     */
     url: string;
+    /**
+     * HttpResponse
+     */
     response: HttpResponse<T>;
+    /**
+     * HttpRequest
+     */
     request: HttpRequest<K>;
+    /**
+     * Timestam of add to cache time
+     */
     addedTime: number;
+    /**
+     * Cache version
+     */
     version: string;
 }
 export declare const NG_HTTP_CACHING_CONFIG: InjectionToken<NgHttpCachingConfig>;
 export declare enum NgHttpCachingStrategy {
+    /**
+     * All request are cacheable if HTTP method is into `allowedMethod`
+     */
     ALLOW_ALL = "ALLOW_ALL",
+    /**
+     * Only the request with `X-NG-HTTP-CACHING-ALLOW-CACHE` header are cacheable if HTTP method is into `allowedMethod`
+     */
     DISALLOW_ALL = "DISALLOW_ALL"
 }
 export declare enum NgHttpCachingHeaders {
+    /**
+     * Request is cacheable if HTTP method is into `allowedMethod`
+     */
     ALLOW_CACHE = "X-NG-HTTP-CACHING-ALLOW-CACHE",
+    /**
+     * Request isn't cacheable
+     */
     DISALLOW_CACHE = "X-NG-HTTP-CACHING-DISALLOW-CACHE",
+    /**
+     * Specific cache lifetime for the request
+     */
     LIFETIME = "X-NG-HTTP-CACHING-LIFETIME",
+    /**
+     * You can tag multiple request by adding this header with the same tag and
+     * using `NgHttpCachingService.clearCacheByTag(tag: string)` for delete all the tagged request
+     */
     TAG = "X-NG-HTTP-CACHING-TAG"
 }
 export declare const NgHttpCachingHeadersList: NgHttpCachingHeaders[];
@@ -30,14 +64,54 @@ export declare const NG_HTTP_CACHING_WEEK_IN_MS: number;
 export declare const NG_HTTP_CACHING_MONTH_IN_MS: number;
 export declare const NG_HTTP_CACHING_YEAR_IN_MS: number;
 export interface NgHttpCachingConfig {
+    /**
+     * Set the cache store. You can implement your custom store by implement the `NgHttpCachingStorageInterface` interface, eg.:
+     */
     store?: NgHttpCachingStorageInterface;
+    /**
+     * Number of millisecond that a response is stored in the cache.
+     * You can set specific "lifetime" for each request by add the header `X-NG-HTTP-CACHING-LIFETIME` (see example below).
+     */
     lifetime?: number;
+    /**
+     * Array of allowed HTTP methods to cache.
+     * You can allow multiple methods, eg.: `['GET', 'POST', 'PUT', 'DELETE', 'HEAD']` or
+     * allow all methods by: `['ALL']`. If `allowedMethod` is an empty array (`[]`), no response are cached.
+     * *Warning!* `NgHttpCaching` use the full url (url with query parameters) as unique key for the cached response,
+     * this is correct for the `GET` request but is _potentially_ wrong for other type of request (eg. `POST`, `PUT`).
+     * You can set a different "key" by customizing the `getKey` config method (see `getKey` section).
+     */
     allowedMethod?: string[];
+    /**
+     * 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`;
+     */
     cacheStrategy?: NgHttpCachingStrategy;
+    /**
+     * Cache version. When you have a breaking change, change the version, and it'll delete the current cache automatically.
+     * The default value is Angular major version (eg. 13), in this way, the cache is invalitaded on every Angular upgrade.
+     */
     version?: string;
+    /**
+     * 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.
+     */
     isExpired?: <K, T>(entry: NgHttpCachingEntry<K, T>) => boolean | undefined;
+    /**
+     * If this function return `true` the request is cacheable, if return `false` isn't cacheable.
+     * If the result is `undefined`, the normal behaviour is provided.
+     */
     isCacheable?: <K>(req: HttpRequest<K>) => boolean | undefined;
+    /**
+     * This function return the unique key (`string`) for store the response into the cache.
+     * If the result is `undefined`, the normal behaviour is provided.
+     */
     getKey?: <K>(req: HttpRequest<K>) => string | undefined;
+    /**
+     * If this function return `true` the cache entry is valid and can be strored, if return `false` isn't valid.
+     * If the result is `undefined`, the normal behaviour is provided.
+     */
     isValid?: <K, T>(entry: NgHttpCachingEntry<K, T>) => boolean | undefined;
 }
 export interface NgHttpCachingDefaultConfig extends NgHttpCachingConfig {
@@ -47,28 +121,29 @@ export interface NgHttpCachingDefaultConfig extends NgHttpCachingConfig {
     cacheStrategy: NgHttpCachingStrategy;
     version: string;
 }
-export declare const NgHttpCachingConfigDefault: NgHttpCachingDefaultConfig;
+export declare const NgHttpCachingConfigDefault: Readonly<NgHttpCachingDefaultConfig>;
 export declare class NgHttpCachingService {
-    private queue;
-    private config;
+    private readonly queue;
+    private readonly config;
     private gcLock;
-    constructor(config: NgHttpCachingConfig);
+    private devMode;
+    constructor(config: Readonly<NgHttpCachingConfig>);
     /**
      * Return the config
      */
-    getConfig(): NgHttpCachingConfig;
+    getConfig(): Readonly<NgHttpCachingConfig>;
     /**
      * Return the queue map
      */
-    getQueue(): Map<string, Observable<HttpEvent<any>>>;
+    getQueue(): Readonly<Map<string, Observable<HttpEvent<any>>>>;
     /**
      * Return the cache store
      */
-    getStore(): NgHttpCachingStorageInterface;
+    getStore(): Readonly<NgHttpCachingStorageInterface>;
     /**
      * Return response from cache
      */
-    getFromCache<K, T>(req: HttpRequest<K>): HttpResponse<T> | undefined;
+    getFromCache<K, T>(req: HttpRequest<K>): Readonly<HttpResponse<T>> | undefined;
     /**
      * Add response to cache
      */
@@ -110,7 +185,9 @@ export declare class NgHttpCachingService {
      */
     isCacheable<K>(req: HttpRequest<K>): boolean;
     /**
-     * Return the cache key
+     * Return the cache key.
+     * Default key is http method plus url with query parameters, eg.:
+     * `GET@https://github.com/nigrosimone/ng-http-caching`
      */
     getKey<K>(req: HttpRequest<K>): string;
     /**
@@ -125,6 +202,12 @@ export declare class NgHttpCachingService {
      * Delete observable from cache
      */
     deleteFromQueue<K>(req: HttpRequest<K>): boolean;
+    /**
+     * Recursively Object.freeze simple Javascript structures consisting of plain objects, arrays, and primitives.
+     * Make the data immutable.
+     * @returns immutable object
+     */
+    private deepFreeze;
     static ɵfac: i0.ɵɵFactoryDeclaration<NgHttpCachingService, [{ optional: true; }]>;
     static ɵprov: i0.ɵɵInjectableDeclaration<NgHttpCachingService>;
 }

package/lib/storage/ng-http-caching-browser-storage.d.ts

@@ -1,10 +1,10 @@
 import { NgHttpCachingStorageInterface } from './ng-http-caching-storage.interface';
 import { NgHttpCachingEntry } from '../ng-http-caching.service';
 import { HttpRequest, HttpResponse } from '@angular/common/http';
-export declare function serializeRequest(req: HttpRequest<any>): string;
-export declare function serializeResponse(res: HttpResponse<any>): string;
-export declare function deserializeRequest<T = any>(req: string): HttpRequest<T>;
-export declare function deserializeResponse<T = any>(res: string): HttpResponse<T>;
+export declare const serializeRequest: (req: HttpRequest<any>) => string;
+export declare const serializeResponse: (res: HttpResponse<any>) => string;
+export declare const deserializeRequest: <T = any>(req: string) => HttpRequest<T>;
+export declare const deserializeResponse: <T = any>(res: string) => HttpResponse<T>;
 export declare class NgHttpCachingBrowserStorage implements NgHttpCachingStorageInterface {
     private storage;
     constructor(storage: Storage);
@@ -12,7 +12,7 @@ export declare class NgHttpCachingBrowserStorage implements NgHttpCachingStorage
     clear(): void;
     delete(key: string): boolean;
     forEach(callbackfn: (value: NgHttpCachingEntry, key: string) => void): void;
-    get(key: string): NgHttpCachingEntry | undefined;
+    get(key: string): Readonly<NgHttpCachingEntry> | undefined;
     has(key: string): boolean;
     set(key: string, value: NgHttpCachingEntry): void;
 }

package/lib/storage/ng-http-caching-memory-storage.d.ts

@@ -6,7 +6,7 @@ export declare class NgHttpCachingMemoryStorage implements NgHttpCachingStorageI
     clear(): void;
     delete(key: string): boolean;
     forEach<K, T>(callbackfn: (value: NgHttpCachingEntry<K, T>, key: string) => void): void;
-    get<K, T>(key: string): NgHttpCachingEntry<K, T> | undefined;
+    get<K, T>(key: string): Readonly<NgHttpCachingEntry<K, T>> | undefined;
     has(key: string): boolean;
     set<K, T>(key: string, value: NgHttpCachingEntry<K, T>): void;
 }

package/lib/storage/ng-http-caching-storage.interface.d.ts

@@ -1,10 +1,31 @@
 import { NgHttpCachingEntry } from '../ng-http-caching.service';
 export interface NgHttpCachingStorageInterface {
+    /**
+     * The number of cached entries.
+     */
     readonly size: number;
+    /**
+     * Clear the cache.
+     */
     clear(): void;
+    /**
+     * Delete the chache entry for the provided key.
+     */
     delete(key: string): boolean;
+    /**
+     * The forEach() method executes a provided function once for each chache entry.
+     */
     forEach<K = any, T = any>(callbackfn: (value: NgHttpCachingEntry<K, T>, key: string) => void): void;
-    get<K = any, T = any>(key: string): NgHttpCachingEntry<K, T> | undefined;
+    /**
+     * Return the chache entry for the provided key.
+     */
+    get<K = any, T = any>(key: string): Readonly<NgHttpCachingEntry<K, T>> | undefined;
+    /**
+     * Return true if the cache entry exists the provided key.
+     */
     has(key: string): boolean;
+    /**
+     * Set the chache entry for the provided key.
+     */
     set<K = any, T = any>(key: string, value: NgHttpCachingEntry<K, T>): void;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ng-http-caching",
-  "version": "15.0.3",
+  "version": "15.2.2",
   "description": "Cache for HTTP requests in Angular application.",
   "repository": {
     "type": "git",