store with promises, and separated from cache memory

Author: pablorsk

CHANGELOG.md

@@ -1,8 +1,17 @@
+# 0.7.x
+
+- Interfaces are in `ng.jsonapi` now
+- Resources can be extended for personalized classes
+
 # 0.6.x
 
 ## Localstorage cache
 
 - Save on localstore all data. When you request a resource or collection, first check memory. If its empty, read from store. If is empty, get the data from back-end.
+- HttpStorage deprecated: jsons were saved as sent by the server, now we save json with logic (saving ids and resources separately).
+
+## No more declaration file .d.ts
+
 - typings and index.d.ts removed. We only use `import`
 
 # 0.5.x

src/library/interfaces/cache.d.ts

@@ -1,20 +1,6 @@
 import { ICollection, IResource } from '../interfaces';
 
 export interface ICache {
-    resources: Object;
-
-    isCollectionExist(url: string): boolean;
-    isCollectionLive(url: string, ttl: number): boolean;
-    getOrCreateCollection(url: string): ICollection;
-    getCollectionFromStorePromise(url:string, collection: ICollection): ng.IPromise<ICollection>;
     setCollection(url: string, collection: ICollection): void;
-    clearAllCollections(): boolean;
-
-    isResourceLive(id: string, ttl: number): boolean;
-    getOrCreateResource(type: string, id: string, use_store?: boolean): IResource;
-    getResource(id: string): IResource;
-    getResourceFromStore(resource: IResource): void;
     setResource(resource: IResource): void;
-
-    removeResource(id: string): void;
 }

src/library/interfaces/cachememory.d.ts

@@ -0,0 +1,18 @@
+import { ICollection, IResource } from '../interfaces';
+import { ICache } from '../interfaces/cache.d';
+
+export interface ICacheMemory extends ICache {
+    resources: { [id: string]: IResource };
+
+    getResource(id: string): IResource;
+    getOrCreateCollection(url: string): ICollection;
+    isCollectionExist(url: string): boolean;
+    isCollectionLive(url: string, ttl: number): boolean;
+    clearAllCollections(): boolean;
+
+    isResourceLive(id: string, ttl: number): boolean;
+    getOrCreateResource(type: string, id: string): IResource;
+    getResource(id: string): IResource;
+
+    removeResource(id: string): void;
+}

src/library/interfaces/cachestore.d.ts

@@ -0,0 +1,7 @@
+import { ICollection, IResource } from '../interfaces';
+import { ICache } from '../interfaces/cache.d';
+
+export interface ICacheStore extends ICache {
+    getResource(resource: IResource): ng.IPromise<object>;
+    getCollectionFromStorePromise(url:string, collection: ICollection): ng.IPromise<ICollection>;
+}

src/library/interfaces/collection.d.ts

@@ -6,7 +6,7 @@ export interface ICollection extends Array<IResource> {
     $length: number;
     $toArray: Array<IResource>;
     $is_loading: boolean;
-    $source: 'new' | 'memory' | 'store' | 'server' | 'httpstorage';
+    $source: 'new' | 'memory' | 'store' | 'server';
     $cache_last_update: number;
     data: Array<IDataResource>; // this need disapear is for datacollection
     page: IPage;

src/library/interfaces/index.d.ts

@@ -6,7 +6,8 @@ export * from './service.d'
 export * from './resource.d'
 export * from './relationship.d'
 export * from './relationships.d'
-export * from './cache.d'
+export * from './cachestore.d'
+export * from './cachememory.d'
 export * from './params-collection.d'
 export * from './params-resource.d'
 export * from './resources-by-id.d'

src/library/interfaces/service.d.ts

@@ -1,4 +1,4 @@
-import { ISchema, IResource, ICollection, IParamsCollection, ICache, IParamsResource } from './index';
+import { ISchema, IResource, ICollection, ICacheMemory, ICacheStore, IParamsCollection, IParamsResource } from './index';
 
 export interface IService {
     type: string;
@@ -12,5 +12,6 @@ export interface IService {
     getService<T extends IService> ():T;
     clearCacheMemory? (): boolean;
     new?<T extends IResource>(): T;
-    cachememory: ICache;
+    cachememory: ICacheMemory;
+    cachestore: ICacheStore;
 }

src/library/resource.ts

@@ -163,6 +163,7 @@ export class Resource extends ParentResourceService implements IResource {
                     angular.forEach(tempororay_collection, (resource_value: IResource, key: string) => {
                         let res = Converter.getService(resource_value.type).cachememory.resources[resource_value.id];
                         Converter.getService(resource_value.type).cachememory.setResource(resource_value);
+                        Converter.getService(resource_value.type).cachestore.setResource(resource_value);
                         res.id = res.id + 'x';
                     });
 

src/library/service.ts

@@ -8,12 +8,15 @@ import { UrlParamsBuilder } from './services/url-params-builder';
 import { Converter } from './services/converter';
 import { LocalFilter } from './services/localfilter';
 import { CacheMemory } from './services/cachememory';
+import { CacheStore } from './services/cachestore';
 
-import { IService, ISchema, IResource, ICollection, IExecParams, ICache, IParamsCollection, IParamsResource } from './interfaces';
+import { IService, ISchema, IResource, ICollection, IExecParams, ICacheStore, ICacheMemory,
+    IParamsCollection, IParamsResource } from './interfaces';
 
 export class Service extends ParentResourceService implements IService {
     public schema: ISchema;
-    public cachememory: ICache;
+    public cachememory: ICacheMemory;
+    public cachestore: ICacheStore;
     public type: string;
 
     private path: string;   // without slashes
@@ -29,6 +32,7 @@ export class Service extends ParentResourceService implements IService {
         }
         // only when service is registered, not cloned object
         this.cachememory = new CacheMemory();
+        this.cachestore = new CacheStore();
         this.schema = angular.extend({}, Base.Schema, this.schema);
         return Core.me._register(this);
     }
@@ -78,8 +82,8 @@ export class Service extends ParentResourceService implements IService {
         path.applyParams(this, params);
         path.appendPath(id);
 
-        // cache
-        let resource = this.getService().cachememory.getOrCreateResource(this.type, id, true);
+        // CACHEMEMORY
+        let resource = this.getService().cachememory.getOrCreateResource(this.type, id);
         resource.is_loading = true;
         // exit if ttl is not expired
         let temporal_ttl = params.ttl || 0; // this.schema.ttl
@@ -95,22 +99,39 @@ export class Service extends ParentResourceService implements IService {
             return resource;
         }
 
+        // CACHESTORE
+        this.getService().cachestore.getResource(resource)
+        .then(
+            success => {
+                if (Base.isObjectLive(temporal_ttl, resource.lastupdate)) {
+                    this.runFc(fc_success, { data: success});
+                } else {
+                    this.getGetFromServer(path, fc_success, fc_error, resource);
+                }
+            },
+            error => {
+                this.getGetFromServer(path, fc_success, fc_error, resource);
+            }
+        );
+
+        return resource;
+    }
 
+    private getGetFromServer(path, fc_success, fc_error, resource: IResource) {
         Core.injectedServices.JsonapiHttp
         .get(path.get())
         .then(
             success => {
                 Converter.build(success.data, resource);
                 resource.is_loading = false;
                 this.getService().cachememory.setResource(resource);
+                this.getService().cachestore.setResource(resource);
                 this.runFc(fc_success, success);
             },
             error => {
                 this.runFc(fc_error, error);
             }
         );
-
-        return resource;
     }
 
     private _all(params: IParamsCollection, fc_success, fc_error): ICollection {
@@ -136,6 +157,15 @@ export class Service extends ParentResourceService implements IService {
         // if we remove this, dont work the same .all on same time (ej: <component /><component /><component />)
         let tempororay_collection = this.getService().cachememory.getOrCreateCollection(path.getForCache());
 
+        // creamos otra colleción si luego será filtrada
+        let localfilter = new LocalFilter(params.localfilter);
+        let cached_collection: ICollection;
+        if (params.localfilter && Object.keys(params.localfilter).length > 0) {
+             cached_collection = Base.newCollection();
+        } else {
+             cached_collection = tempororay_collection;
+        }
+
         // MEMORY_CACHE
         let temporal_ttl = params.ttl || this.schema.ttl;
         if (temporal_ttl >= 0 && this.getService().cachememory.isCollectionExist(path.getForCache())) {
@@ -148,8 +178,7 @@ export class Service extends ParentResourceService implements IService {
             }
 
             // fill collection and localfilter
-            let localfilter = new LocalFilter();
-            tempororay_collection = localfilter.filterCollection(tempororay_collection, params.localfilter);
+            localfilter.filterCollection(tempororay_collection, cached_collection);
 
             // exit if ttl is not expired
             if (this.getService().cachememory.isCollectionLive(path.getForCache(), temporal_ttl)) {
@@ -160,71 +189,36 @@ export class Service extends ParentResourceService implements IService {
                 deferred.promise.then(fc_success => {
                     this.runFc(fc_success, 'cachememory');
                 });
-                return tempororay_collection;
+            } else {
+                this.getAllFromServer(path, params, fc_success, fc_error, tempororay_collection, cached_collection);
             }
         } else {
             // STORE
-            this.getService().cachememory.getCollectionFromStorePromise(path.getForCache(), tempororay_collection)
+            this.getService().cachestore.getCollectionFromStorePromise(path.getForCache(), tempororay_collection)
             .then(
                 success => {
                     tempororay_collection.$source = 'store';
                     tempororay_collection.$is_loading = false;
 
                     // localfilter getted data
-                    let localfilter = new LocalFilter();
-                    tempororay_collection = localfilter.filterCollection(tempororay_collection, params.localfilter);
+                    localfilter.filterCollection(tempororay_collection, cached_collection);
 
-                    if (temporal_ttl >= 0 && Date.now() <= (tempororay_collection.$cache_last_update + temporal_ttl * 1000)) {
+                    if (Base.isObjectLive(temporal_ttl, tempororay_collection.$cache_last_update)) {
                         this.runFc(fc_success, { data: success});
                     } else {
-                        this.getAllFromHttpStorage(path, params, fc_success, fc_error, tempororay_collection);
+                        this.getAllFromServer(path, params, fc_success, fc_error, tempororay_collection, cached_collection);
                     }
                 },
                 error => {
-                    this.getAllFromHttpStorage(path, params, fc_success, fc_error, tempororay_collection);
+                    this.getAllFromServer(path, params, fc_success, fc_error, tempororay_collection, cached_collection);
                 }
             );
         }
 
-        return tempororay_collection;
-    }
-
-    /**
-    @deprecated
-    **/
-    private getAllFromHttpStorage(path, params, fc_success, fc_error, tempororay_collection: ICollection) {
-        // SERVER REQUEST
-        tempororay_collection['$is_loading'] = true;
-
-        // STORAGE_CACHE
-        Core.injectedServices.JsonapiHttpStorage
-        .get(path.getForCache(), params.storage_ttl)
-        .then(
-            success => {
-                tempororay_collection.$source = 'httpstorage';
-                tempororay_collection.$is_loading = false;
-                Converter.build(success, tempororay_collection);
-
-                // localfilter getted data
-                let localfilter = new LocalFilter();
-                tempororay_collection = localfilter.filterCollection(tempororay_collection, params.localfilter);
-
-                this.runFc(fc_success, { data: success});
-
-                var deferred = Core.injectedServices.$q.defer();
-                deferred.resolve(fc_success);
-                deferred.promise.then(fc_success => {
-                    this.runFc(fc_success, 'httpstorage');
-                });
-                return tempororay_collection;
-            },
-            error => {
-                this.getAllFromServer(path, params, fc_success, fc_error, tempororay_collection);
-            }
-        );
+        return cached_collection;
     }
 
-    private getAllFromServer(path, params, fc_success, fc_error, tempororay_collection: ICollection) {
+    private getAllFromServer(path, params, fc_success, fc_error, tempororay_collection: ICollection, cached_collection: ICollection) {
         // SERVER REQUEST
         Core.injectedServices.JsonapiHttp
         .get(path.get())
@@ -236,14 +230,11 @@ export class Service extends ParentResourceService implements IService {
                 Converter.build(success.data, tempororay_collection);
 
                 this.getService().cachememory.setCollection(path.getForCache(), tempororay_collection);
-
-                if (params.storage_ttl > 0) {
-                    Core.injectedServices.JsonapiHttpStorage.save(path.getForCache(), success.data);
-                }
+                this.getService().cachestore.setCollection(path.getForCache(), tempororay_collection);
 
                 // localfilter getted data
-                let localfilter = new LocalFilter();
-                tempororay_collection = localfilter.filterCollection(tempororay_collection, params.localfilter);
+                let localfilter = new LocalFilter(params.localfilter);
+                localfilter.filterCollection(tempororay_collection, cached_collection);
 
                 // trying to define smartfiltertype
                 if (this.smartfiltertype === 'undefined') {

src/library/services/base.ts

@@ -4,7 +4,6 @@ import { Page } from './page';
 export class Base {
     static Params: IParamsCollection | IParamsResource = {
         id: '',
-        storage_ttl: 0,
         include: []
     };
 
@@ -39,4 +38,8 @@ export class Base {
             'page': { value: new Page(), enumerable: false, writable: true  }
         });
     }
+
+    static isObjectLive(ttl: number, last_update: number) {
+        return (ttl >= 0 && Date.now() <= (last_update + ttl * 1000));
+    }
 }