ng-http-caching 18.0.2 → 20.0.1

package/index.d.ts

@@ -1,5 +1,320 @@
-/**
- * Generated bundle index. Do not edit.
- */
-/// <amd-module name="ng-http-caching" />
-export * from './public-api';
+import { HttpInterceptor, HttpRequest, HttpHandler, HttpEvent, HttpResponse, HttpContextToken, HttpContext, HttpHeaders } from '@angular/common/http';
+import { Observable } from 'rxjs';
+import * as i0 from '@angular/core';
+import { InjectionToken, ModuleWithProviders } from '@angular/core';
+import { Observable as Observable$1 } from 'rxjs/internal/Observable';
+
+declare class NgHttpCachingInterceptorService implements HttpInterceptor {
+    private readonly cacheService;
+    intercept(req: HttpRequest<any>, next: HttpHandler): Observable<HttpEvent<any>>;
+    /**
+     * Send http request (next handler)
+     */
+    sendRequest(req: HttpRequest<any>, next: HttpHandler): Observable<HttpEvent<any>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgHttpCachingInterceptorService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<NgHttpCachingInterceptorService>;
+}
+
+interface NgHttpCachingStorageInterface {
+    /**
+     * The number of cached entries.
+     */
+    readonly size: number;
+    /**
+     * Clear the cache.
+     */
+    clear(): void;
+    /**
+     * Delete the cache entry for the provided key.
+     */
+    delete(key: string): boolean;
+    /**
+     * The forEach() method executes a provided function once for each cache entry.
+     */
+    forEach<K = any, T = any>(callbackfn: (value: NgHttpCachingEntry<K, T>, key: string) => void): void;
+    /**
+     * Return the cache 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 cache entry for the provided key.
+     */
+    set<K = any, T = any>(key: string, value: NgHttpCachingEntry<K, T>): void;
+}
+
+type NgHttpCachingContext = Pick<NgHttpCachingConfig, 'getKey' | 'isCacheable' | 'isExpired' | 'isValid'>;
+declare const NG_HTTP_CACHING_CONTEXT: HttpContextToken<NgHttpCachingContext>;
+declare const withNgHttpCachingContext: (value: NgHttpCachingContext, context?: HttpContext) => HttpContext;
+declare const checkCacheHeaders: (headers: HttpHeaders) => boolean;
+interface NgHttpCachingEntry<K = any, T = any> {
+    /**
+     * URL
+     */
+    url: string;
+    /**
+     * HttpResponse
+     */
+    response: HttpResponse<T>;
+    /**
+     * HttpRequest
+     */
+    request: HttpRequest<K>;
+    /**
+     * Timestamp of add to cache time
+     */
+    addedTime: number;
+    /**
+     * Cache version
+     */
+    version: string;
+}
+declare const NG_HTTP_CACHING_CONFIG: InjectionToken<NgHttpCachingContext>;
+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"
+}
+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"
+}
+declare const NgHttpCachingHeadersList: NgHttpCachingHeaders[];
+declare const NG_HTTP_CACHING_SECOND_IN_MS = 1000;
+declare const NG_HTTP_CACHING_MINUTE_IN_MS: number;
+declare const NG_HTTP_CACHING_HOUR_IN_MS: number;
+declare const NG_HTTP_CACHING_DAY_IN_MS: number;
+declare const NG_HTTP_CACHING_WEEK_IN_MS: number;
+declare const NG_HTTP_CACHING_MONTH_IN_MS: number;
+declare const NG_HTTP_CACHING_YEAR_IN_MS: number;
+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 invalidated on every Angular upgrade.
+     */
+    version?: string;
+    /**
+     * If true response headers cache-control and expires are respected.
+     */
+    checkResponseHeaders?: boolean;
+    /**
+     * 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 | void;
+    /**
+     * 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 | void;
+    /**
+     * 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 | void;
+    /**
+     * If this function return `true` the cache entry is valid and can be stored, 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 | void;
+}
+interface NgHttpCachingDefaultConfig extends NgHttpCachingConfig {
+    store: NgHttpCachingStorageInterface;
+    lifetime: number;
+    allowedMethod: string[];
+    cacheStrategy: NgHttpCachingStrategy;
+    version: string;
+    checkResponseHeaders: boolean;
+}
+declare const NgHttpCachingConfigDefault: Readonly<NgHttpCachingDefaultConfig>;
+declare class NgHttpCachingService {
+    private readonly queue;
+    private readonly config;
+    private gcLock;
+    private devMode;
+    constructor();
+    /**
+     * Return the config
+     */
+    getConfig(): Readonly<NgHttpCachingConfig>;
+    /**
+     * Return the queue map
+     */
+    getQueue(): Readonly<Map<string, Observable$1<HttpEvent<any>>>>;
+    /**
+     * Return the cache store
+     */
+    getStore(): Readonly<NgHttpCachingStorageInterface>;
+    /**
+     * Return response from cache
+     */
+    getFromCache<K, T>(req: HttpRequest<K>): Readonly<HttpResponse<T>> | undefined;
+    /**
+     * Add response to cache
+     */
+    addToCache<K, T>(req: HttpRequest<K>, res: HttpResponse<T>): boolean;
+    /**
+     * Delete response from cache
+     */
+    deleteFromCache<K>(req: HttpRequest<K>): boolean;
+    /**
+     * Clear the cache
+     */
+    clearCache(): void;
+    /**
+     * Clear the cache by key
+     */
+    clearCacheByKey(key: string): boolean;
+    /**
+     * Clear the cache by keys
+     */
+    clearCacheByKeys(keys: Array<string>): number;
+    /**
+     * Clear the cache by regex
+     */
+    clearCacheByRegex<K, T>(regex: RegExp): number;
+    /**
+     * Clear the cache by TAG
+     */
+    clearCacheByTag<K, T>(tag: string): number;
+    /**
+     * Run garbage collector (delete expired cache entry)
+     */
+    runGc<K, T>(): boolean;
+    /**
+     * Return true if cache entry is expired
+     */
+    isExpired<K, T>(entry: NgHttpCachingEntry<K, T>): boolean;
+    /**
+     * Return true if cache entry is valid for store in the cache
+     * Default behaviour is whether the status code falls in the 2xx range and response headers cache-control and expires allow cache.
+     */
+    isValid<K, T>(entry: NgHttpCachingEntry<K, T>): boolean;
+    /**
+     * Return true if the request is cacheable
+     */
+    isCacheable<K>(req: HttpRequest<K>): boolean;
+    /**
+     * 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;
+    /**
+     * Return observable from cache
+     */
+    getFromQueue<K, T>(req: HttpRequest<K>): Observable$1<HttpEvent<T>> | undefined;
+    /**
+     * Add observable to cache
+     */
+    addToQueue<K, T>(req: HttpRequest<K>, obs: Observable$1<HttpEvent<T>>): void;
+    /**
+     * 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, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<NgHttpCachingService>;
+}
+
+declare class NgHttpCachingModule {
+    static forRoot(ngHttpCachingConfig?: NgHttpCachingConfig): ModuleWithProviders<NgHttpCachingModule>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgHttpCachingModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<NgHttpCachingModule, never, never, never>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<NgHttpCachingModule>;
+}
+
+declare function provideNgHttpCaching(ngHttpCachingConfig?: NgHttpCachingConfig): i0.EnvironmentProviders;
+
+declare class NgHttpCachingMemoryStorage extends Map<string, NgHttpCachingEntry<any, any>> implements NgHttpCachingStorageInterface {
+}
+
+interface NgHttpCachingStorageEntry {
+    url: string;
+    response: string;
+    request: string;
+    addedTime: number;
+    version: string;
+}
+declare const serializeRequest: (req: HttpRequest<any>) => string;
+declare const serializeResponse: (res: HttpResponse<any>) => string;
+declare const deserializeRequest: <T = any>(req: string) => HttpRequest<T>;
+declare const deserializeResponse: <T = any>(res: string) => HttpResponse<T>;
+declare class NgHttpCachingBrowserStorage implements NgHttpCachingStorageInterface {
+    private storage;
+    constructor(storage: Storage);
+    get size(): number;
+    clear(): void;
+    delete(key: string): boolean;
+    forEach(callbackfn: (value: NgHttpCachingEntry, key: string) => void): void;
+    get(key: string): Readonly<NgHttpCachingEntry> | undefined;
+    has(key: string): boolean;
+    set(key: string, value: NgHttpCachingEntry): void;
+    protected serialize(value: NgHttpCachingEntry): NgHttpCachingStorageEntry;
+    protected deserialize(value: NgHttpCachingStorageEntry): NgHttpCachingEntry;
+}
+
+declare class NgHttpCachingLocalStorage extends NgHttpCachingBrowserStorage {
+    constructor();
+}
+declare const withNgHttpCachingLocalStorage: () => NgHttpCachingLocalStorage;
+
+declare class NgHttpCachingSessionStorage extends NgHttpCachingBrowserStorage {
+    constructor();
+}
+declare const withNgHttpCachingSessionStorage: () => NgHttpCachingSessionStorage;
+
+export { NG_HTTP_CACHING_CONFIG, NG_HTTP_CACHING_CONTEXT, NG_HTTP_CACHING_DAY_IN_MS, NG_HTTP_CACHING_HOUR_IN_MS, NG_HTTP_CACHING_MINUTE_IN_MS, NG_HTTP_CACHING_MONTH_IN_MS, NG_HTTP_CACHING_SECOND_IN_MS, NG_HTTP_CACHING_WEEK_IN_MS, NG_HTTP_CACHING_YEAR_IN_MS, NgHttpCachingBrowserStorage, NgHttpCachingConfigDefault, NgHttpCachingHeaders, NgHttpCachingHeadersList, NgHttpCachingInterceptorService, NgHttpCachingLocalStorage, NgHttpCachingMemoryStorage, NgHttpCachingModule, NgHttpCachingService, NgHttpCachingSessionStorage, NgHttpCachingStrategy, checkCacheHeaders, deserializeRequest, deserializeResponse, provideNgHttpCaching, serializeRequest, serializeResponse, withNgHttpCachingContext, withNgHttpCachingLocalStorage, withNgHttpCachingSessionStorage };
+export type { NgHttpCachingConfig, NgHttpCachingContext, NgHttpCachingDefaultConfig, NgHttpCachingEntry, NgHttpCachingStorageEntry, NgHttpCachingStorageInterface };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ng-http-caching",
-  "version": "18.0.2",
+  "version": "20.0.1",
   "description": "Cache for HTTP requests in Angular application.",
   "repository": {
     "type": "git",
@@ -40,8 +40,6 @@
     },
     ".": {
       "types": "./index.d.ts",
-      "esm2022": "./esm2022/ng-http-caching.mjs",
-      "esm": "./esm2022/ng-http-caching.mjs",
       "default": "./fesm2022/ng-http-caching.mjs"
     }
   },

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

@@ -1,65 +0,0 @@
-import { HttpResponse } from '@angular/common/http';
-import { Injectable } from '@angular/core';
-import { asyncScheduler, of, scheduled } from 'rxjs';
-import { tap, finalize, shareReplay } from 'rxjs/operators';
-import { NgHttpCachingHeadersList } from './ng-http-caching.service';
-import * as i0 from "@angular/core";
-import * as i1 from "./ng-http-caching.service";
-export class NgHttpCachingInterceptorService {
-    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',cachedObservable);
-            return cachedObservable;
-        }
-        // Checked if there is cached response for this request
-        const cachedResponse = this.cacheService.getFromCache(req);
-        if (cachedResponse) {
-            // console.log('cachedResponse');
-            return scheduled(of(cachedResponse.clone()), asyncScheduler);
-        }
-        // 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);
-        }), shareReplay());
-        // add pending request to queue for cache parallel 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
-        NgHttpCachingHeadersList.forEach(ngHttpCachingHeaders => {
-            if (cloned.headers.has(ngHttpCachingHeaders)) {
-                cloned = cloned.clone({ headers: cloned.headers.delete(ngHttpCachingHeaders) });
-            }
-        });
-        return next.handle(cloned);
-    }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: NgHttpCachingInterceptorService, deps: [{ token: i1.NgHttpCachingService }], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: NgHttpCachingInterceptorService }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: NgHttpCachingInterceptorService, decorators: [{
-            type: Injectable
-        }], ctorParameters: () => [{ type: i1.NgHttpCachingService }] });
-//# sourceMappingURL=data:application/json;base64,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

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

@@ -1,44 +0,0 @@
-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,
-                },
-            ],
-        };
-    }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: NgHttpCachingModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
-    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "18.0.2", ngImport: i0, type: NgHttpCachingModule }); }
-    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: NgHttpCachingModule, providers: [
-            NgHttpCachingService,
-            NgHttpCachingInterceptorService,
-            {
-                provide: HTTP_INTERCEPTORS,
-                useClass: NgHttpCachingInterceptorService,
-                multi: true,
-            },
-        ] }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: NgHttpCachingModule, decorators: [{
-            type: NgModule,
-            args: [{
-                    providers: [
-                        NgHttpCachingService,
-                        NgHttpCachingInterceptorService,
-                        {
-                            provide: HTTP_INTERCEPTORS,
-                            useClass: NgHttpCachingInterceptorService,
-                            multi: true,
-                        },
-                    ]
-                }]
-        }] });
-//# sourceMappingURL=data:application/json;base64,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