cache watch data

Author: danieloprado

src/rxjs-operators/cache.ts

@@ -27,16 +27,15 @@ class CacheOperator<T> implements rxjs.Operator<T, T> {
   ) { }
 
   public call(subscriber: rxjs.Subscriber<any>, source: rxjs.Observable<any>): rxjs.Subscription {
-    if (this.options.refresh) {
-      return source.pipe(
-        rxjsOperators.tap(data => cacheService.saveData(this.key, data, this.options))
-      ).subscribe(subscriber);
-    }
+    const start = this.options.refresh ?
+      cacheService.removeData(this.key) : rxjs.of(true);
 
     let currentCache: ICache;
-    return cacheService.getData(this.key).pipe(
+    return start.pipe(
+      rxjsOperators.switchMap(() => cacheService.watchData(this.key)),
       rxjsOperators.switchMap(cache => {
         currentCache = cache;
+
         if (cache && !cacheService.isExpirated(cache)) {
           return rxjs.of(cache.data);
         }
@@ -51,7 +50,7 @@ class CacheOperator<T> implements rxjs.Operator<T, T> {
 
         logService.breadcrumb('Cache Set', 'manual', data);
         return cacheService.saveData(this.key, data, this.options).pipe(
-          rxjsOperators.map(() => data)
+          rxjsOperators.filter(() => false)
         );
       })
     ).subscribe(subscriber);

src/services/cache.ts

@@ -6,31 +6,56 @@ import { ICache } from '../interfaces/cache';
 import storageService, { StorageService } from './storage';
 
 export class CacheService {
+  private change$ = new rxjs.Subject<{ key: string, value: ICache }>();
   private memory: { [key: string]: ICache };
 
   constructor(private storageService: StorageService) {
     this.memory = {};
   }
 
-  public getData(key: string): rxjs.Observable<ICache> {
+  public getData<T = any>(key: string): rxjs.Observable<ICache<T>> {
     if (this.memory[key]) return rxjs.of(this.memory[key]);
     return this.storageService.get('app-cache-' + key);
   }
 
-  public saveData<T>(key: string, data: T, options: { persist: boolean, expirationMinutes: number }): rxjs.Observable<ICache<T>> {
+  public watchData<T>(key: string): rxjs.Observable<ICache<T>> {
+    return this.getData<T>(key).pipe(
+      rxjsOperators.concat(this.change$.pipe(
+        rxjsOperators.filter(data => data.key === key),
+        rxjsOperators.map(data => data.value)
+      )),
+      rxjsOperators.debounceTime(100)
+    );
+  }
+
+  public removeData(key: string) {
+    return this.storageService.set('app-cache-' + key, null).pipe(
+      rxjsOperators.tap(() => this.memory[key] = null),
+      rxjsOperators.tap(() => this.change$.next({ key, value: null }))
+    );
+  }
+
+  public saveData<T>(
+    key: string,
+    data: T,
+    options: { persist: boolean, expirationMinutes: number } = { persist: false, expirationMinutes: 5 }
+  ): rxjs.Observable<ICache<T>> {
     const cache: ICache<T> = {
       createdAt: new Date(),
       expirationDate: DateTime.local().plus({ minutes: options.expirationMinutes }).toJSDate(),
       data
     };
 
     if (options.persist) {
-      return this.storageService.set('app-cache-' + key, cache);
+      return this.storageService.set('app-cache-' + key, cache).pipe(
+        rxjsOperators.tap(() => this.change$.next({ key, value: cache }))
+      );
     }
 
     return rxjs.of(true).pipe(
       rxjsOperators.map(() => {
         this.memory[key] = cache;
+        this.change$.next({ key, value: cache });
         return cache;
       })
     );
@@ -46,7 +71,9 @@ export class CacheService {
   }
 
   public clear(): rxjs.Observable<void> {
-    return this.storageService.clear(/^app-cache-/gi);
+    return this.storageService.clear(/^app-cache-/gi).pipe(
+      rxjsOperators.tap(() => this.memory = {})
+    );
   }
 
 }