larapi 0.0.7 → 0.0.8

package/lib/Core.d.ts

@@ -1,5 +1,5 @@
 import { Events, Event } from 'easy-event-emitter';
-import { TData, TGroupsData, TListenerEvents } from './types';
+import { TCacheBody, TData, TGroupsData, TListenerEvents } from './types';
 declare abstract class Core {
     private cache;
     initData: TGroupsData;
@@ -8,11 +8,13 @@ declare abstract class Core {
     token: string;
     constructor(context?: Core);
     addListener(event: TListenerEvents, callback: (data: any) => void): Event;
-    protected getCache(request: string): TData | undefined;
+    protected getCache(key: string): TData | undefined;
     setHost(host: string): void;
-    protected setCache(request: string, data: TData, group?: string): void;
-    deleteCacheGroup(group: string): void;
-    protected deleteCache(request: string): void;
+    protected setCache(key: string, data: TData, group?: string): void;
+    clearCacheGroup(group: string): void;
+    updateCacheGroup(group: string, fieldKey: string, data: TData): void;
+    protected getCacheByIndex(index: string): TCacheBody;
+    protected deleteCache(key: string): void;
     setInitData(data: TGroupsData): void;
 }
 export default Core;

package/lib/Core.js

@@ -3,8 +3,6 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-//@ts-ignore
-const md5_1 = __importDefault(require("md5"));
 const easy_event_emitter_1 = __importDefault(require("easy-event-emitter"));
 class Core {
     constructor(context) {
@@ -46,14 +44,13 @@ class Core {
         this.setHost = this.setHost.bind(this);
         this.addListener = this.addListener.bind(this);
         this.setInitData = this.setInitData.bind(this);
-        this.deleteCacheGroup = this.deleteCacheGroup.bind(this);
+        this.clearCacheGroup = this.clearCacheGroup.bind(this);
         Object.assign(this, context);
     }
     addListener(event, callback) {
         return this.events.addListener(event, callback);
     }
-    getCache(request) {
-        const key = (0, md5_1.default)(request);
+    getCache(key) {
         if (this.cache[key]) {
             if ((new Date()).getTime() <= (this.cache[key].time + 3600000000)) {
                 return this.cache[key].data;
@@ -66,29 +63,53 @@ class Core {
     setHost(host) {
         this.host = host;
     }
-    setCache(request, data, group) {
-        this.cache[(0, md5_1.default)(request)] = {
+    setCache(key, data, group) {
+        this.cache[key] = {
             time: (new Date()).getTime(),
             data: data,
             group: group
         };
     }
-    deleteCacheGroup(group) {
+    clearCacheGroup(group) {
         for (const key in this.cache) {
             if (this.cache[key].group === group) {
                 delete this.cache[key];
             }
         }
     }
-    deleteCache(request) {
-        const keyCache = (0, md5_1.default)(request);
-        if (!this.cache[keyCache])
+    updateCacheGroup(group, fieldKey, data) {
+        const update = (cacheData) => {
+            if (cacheData[fieldKey] === data[fieldKey]) {
+                for (const fieldKey in cacheData) {
+                    if (fieldKey in data) {
+                        cacheData[fieldKey] = data[fieldKey];
+                    }
+                }
+            }
+            return cacheData;
+        };
+        for (const key in this.cache) {
+            if (this.cache[key].group === group) {
+                if (Array.isArray(this.cache[key].data)) {
+                    this.cache[key].data = Object.values(this.cache[key].data).map(update);
+                }
+                else {
+                    this.cache[key].data = update(this.cache[key].data);
+                }
+            }
+        }
+    }
+    getCacheByIndex(index) {
+        return this.cache[index];
+    }
+    deleteCache(key) {
+        if (!this.cache[key])
             return;
-        const group = this.cache[keyCache].group;
+        const group = this.cache[key].group;
         if (group) {
-            this.deleteCacheGroup(group);
+            this.clearCacheGroup(group);
         }
-        delete this.cache[keyCache];
+        delete this.cache[key];
     }
     setInitData(data) {
         this.initData = data;

package/lib/Http.d.ts

@@ -1,5 +1,5 @@
 import Core from "./Core";
-import { TMethod, TParams } from "./types";
+import { TMethod, TParams, TData } from "./types";
 declare class Http extends Core {
     private cacheIndex;
     method: TMethod;
@@ -12,6 +12,7 @@ declare class Http extends Core {
     private encodeUrlParams;
     private cuteUndifinedParams;
     request(): this;
+    updateCache(fieldKey: string, data: TData): void;
     clearCache(): void;
 }
 export default Http;

package/lib/Http.js

@@ -151,6 +151,12 @@ class Http extends Core_1.default {
         }
         return this;
     }
+    updateCache(fieldKey, data) {
+        const cache = this.getCacheByIndex(this.cacheIndex);
+        if (cache && cache.group) {
+            this.updateCacheGroup(cache.group, fieldKey, data);
+        }
+    }
     clearCache() {
         this.deleteCache(this.cacheIndex);
     }

package/lib/index.d.ts

@@ -34,7 +34,7 @@ declare class API extends Core {
     static setToken: (token: string) => void;
     static addListener: (event: import("./types").TListenerEvents, callback: (data: any) => void) => import("easy-event-emitter").Event;
     static setInitData: (data: import("./types").TGroupsData) => void;
-    static deleteCacheGroup: (group: string) => void;
+    static clearCacheGroup: (group: string) => void;
     static getToken: () => string;
     static getUid: () => number;
     static getUser: () => TUser;

package/lib/index.js

@@ -162,11 +162,11 @@ Object.defineProperty(API, "setInitData", {
     writable: true,
     value: _a.instance.setInitData
 });
-Object.defineProperty(API, "deleteCacheGroup", {
+Object.defineProperty(API, "clearCacheGroup", {
     enumerable: true,
     configurable: true,
     writable: true,
-    value: _a.instance.deleteCacheGroup
+    value: _a.instance.clearCacheGroup
 });
 Object.defineProperty(API, "getToken", {
     enumerable: true,

package/lib/types.d.ts

@@ -1,5 +1,10 @@
+export type TCacheBody = {
+    data: any;
+    group?: string;
+    time: number;
+};
 export type TCache = {
-    [index: string]: any;
+    [index: string]: TCacheBody;
 };
 export type TData = {
     [index: string]: any;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "larapi",
-  "version": "0.0.7",
+  "version": "0.0.8",
   "description": "API client for laravel",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",

package/src/Core.ts

@@ -1,12 +1,10 @@
-//@ts-ignore
-import md5 from 'md5';
 import EventEmitter,{
 	Events,
 	Event
 } from 'easy-event-emitter';
-// import ApiRequest from './ApiRequest';
 import {
 	TCache,
+	TCacheBody,
 	TData,
 	TGroupsData,
 	TListenerEvents
@@ -29,7 +27,7 @@ abstract class Core {
 		this.setHost = this.setHost.bind(this);
 		this.addListener = this.addListener.bind(this);
 		this.setInitData = this.setInitData.bind(this);
-		this.deleteCacheGroup = this.deleteCacheGroup.bind(this);
+		this.clearCacheGroup = this.clearCacheGroup.bind(this);
 		Object.assign(this, context);
 	}
 
@@ -37,8 +35,7 @@ abstract class Core {
 		return this.events.addListener(event, callback);
 	}
 
-	protected getCache(request: string): TData | undefined {
-		const key = md5(request);
+	protected getCache(key: string): TData | undefined {
 		if (this.cache[key]) {
 			if ((new Date()).getTime() <= (this.cache[key].time + 3600000000)) {
 				return this.cache[key].data;
@@ -52,15 +49,15 @@ abstract class Core {
 		this.host = host;
 	}
 
-	protected setCache(request: string, data: TData, group?: string): void {
-		this.cache[md5(request)] = {
+	protected setCache(key: string, data: TData, group?: string): void {
+		this.cache[key] = {
 			time: (new Date()).getTime(),
 			data: data,
 			group: group
 		};
 	}
 
-	public deleteCacheGroup(group: string): void {
+	public clearCacheGroup(group: string): void {
 		for(const key in this.cache) {
 			if (this.cache[key].group === group) {
 				delete this.cache[key];
@@ -68,16 +65,43 @@ abstract class Core {
 		}
 	}
 
-	protected deleteCache(request: string): void {
-		const keyCache = md5(request);
-		if (!this.cache[keyCache])
+	public updateCacheGroup(group: string, fieldKey: string, data: TData): void {
+
+		const update = (cacheData: any) => {
+			if (cacheData[fieldKey] === data[fieldKey]) {
+				for(const fieldKey in cacheData) {
+					if (fieldKey in data) {
+						cacheData[fieldKey] = data[fieldKey];
+					}
+				}
+			}
+			return cacheData;
+		};
+
+		for(const key in this.cache) {
+			if (this.cache[key].group === group) {
+				if (Array.isArray(this.cache[key].data)) {
+					this.cache[key].data = Object.values(this.cache[key].data).map(update);
+				}else{
+					this.cache[key].data = update(this.cache[key].data);
+				}
+			}
+		}
+	}
+
+	protected getCacheByIndex(index: string): TCacheBody {
+		return this.cache[index];
+	}
+
+	protected deleteCache(key: string): void {
+		if (!this.cache[key])
 			return;
 
-		const group = this.cache[keyCache].group;
+		const group = this.cache[key].group;
 		if (group) {
-			this.deleteCacheGroup(group);
+			this.clearCacheGroup(group);
 		}
-		delete this.cache[keyCache];
+		delete this.cache[key];
 	}
 
 	public setInitData(data: TGroupsData): void {

package/src/Http.ts

@@ -160,7 +160,14 @@ class Http extends Core {
 		return this
 	}
 
-	public clearCache() {
+	public updateCache(fieldKey: string, data: TData): void {
+		const cache = this.getCacheByIndex(this.cacheIndex);
+		if (cache && cache.group) {
+			this.updateCacheGroup(cache.group, fieldKey, data);
+		}
+	}
+
+	public clearCache(): void {
 		this.deleteCache(this.cacheIndex);
 	}
 }

package/src/index.ts

@@ -116,7 +116,7 @@ class API extends Core {
 	public static setToken = this.instance.setToken;
 	public static addListener = this.instance.addListener;
 	public static setInitData = this.instance.setInitData;
-	public static deleteCacheGroup = this.instance.deleteCacheGroup;
+	public static clearCacheGroup = this.instance.clearCacheGroup;
 	public static getToken = this.instance.getToken;
 	public static getUid = this.instance.getUid;
 	public static getUser = this.instance.getUser;

package/src/types.ts

@@ -1,5 +1,11 @@
+export type TCacheBody = {
+	data: any;
+	group?: string;
+	time: number;
+}
+
 export type TCache = {
-	[index: string]: any;
+	[index: string]: TCacheBody;
 }
 
 export type TData = {