larapi 0.0.7 → 0.0.9

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,14 @@ 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;
+    protected isJsonString(str: string): boolean;
     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, data?: TData, fieldKey?: string | null): void;
+    updateCacheGroup(group: string, data: TData, fieldKey?: string | null): 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;
@@ -63,32 +60,90 @@ class Core {
             }
         }
     }
+    isJsonString(str) {
+        try {
+            JSON.parse(str);
+        }
+        catch (e) {
+            return false;
+        }
+        return true;
+    }
     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, data, fieldKey = 'id') {
+        if (data) {
+            const clear = (cacheData) => {
+                if ((fieldKey && cacheData[fieldKey] === data[fieldKey]) || fieldKey === null) {
+                    for (const key in cacheData) {
+                        if (key in data) {
+                            return false;
+                        }
+                    }
+                }
+                return true;
+            };
+            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).filter(clear);
+                    }
+                    else {
+                        if (!clear(this.cache[key].data))
+                            delete this.cache[key];
+                    }
+                }
+            }
+        }
+        else {
+            for (const key in this.cache) {
+                if (this.cache[key].group === group) {
+                    delete this.cache[key];
+                }
+            }
+        }
+    }
+    updateCacheGroup(group, data, fieldKey = 'id') {
+        const update = (cacheData) => {
+            if ((fieldKey && cacheData[fieldKey] === data[fieldKey]) || fieldKey === null) {
+                for (const key in cacheData) {
+                    if (key in data) {
+                        cacheData[key] = data[key];
+                    }
+                }
+            }
+            return cacheData;
+        };
         for (const key in this.cache) {
             if (this.cache[key].group === group) {
-                delete this.cache[key];
+                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);
+                }
             }
         }
     }
-    deleteCache(request) {
-        const keyCache = (0, md5_1.default)(request);
-        if (!this.cache[keyCache])
+    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;
-    clearCache(): void;
+    updateCache(data: TData, fieldKey?: string | null): void;
+    clearCache(data?: TData, fieldKey?: string | null): void;
 }
 export default Http;

package/lib/Http.js

@@ -40,6 +40,12 @@ class Http extends Core_1.default {
     success(...args) {
         if (typeof this.params.success === 'function')
             this.params.success(...args);
+        if (this.params.cacheUpdate && this.params.data) {
+            this.updateCacheGroup(typeof this.params.cacheUpdate === 'string' ? this.params.cacheUpdate : this.params.cacheUpdate.group, this.params.data, typeof this.params.cacheUpdate === 'string' ? undefined : this.params.cacheUpdate.fieldKey);
+        }
+        if (this.params.cacheClear && this.params.data) {
+            this.clearCacheGroup(typeof this.params.cacheClear === 'string' ? this.params.cacheClear : this.params.cacheClear.group, this.params.data, typeof this.params.cacheClear === 'string' ? undefined : this.params.cacheClear.fieldKey);
+        }
     }
     //Заголовки от 400 до 499
     fail(...args) {
@@ -127,7 +133,7 @@ class Http extends Core_1.default {
                     if (xhr.readyState !== 4) {
                         return;
                     }
-                    const result = xhr.responseText ? JSON.parse(xhr.responseText) : {};
+                    const result = this.isJsonString(xhr.responseText) ? JSON.parse(xhr.responseText) : {};
                     if (xhr.status >= 200 && xhr.status <= 299) {
                         if (this.params.cache) {
                             this.setCache(this.cacheIndex, result, (typeof this.params.cache === 'boolean' ? undefined : this.params.cache));
@@ -151,8 +157,22 @@ class Http extends Core_1.default {
         }
         return this;
     }
-    clearCache() {
-        this.deleteCache(this.cacheIndex);
+    updateCache(data, fieldKey = 'id') {
+        const cache = this.getCacheByIndex(this.cacheIndex);
+        if (cache && cache.group) {
+            this.updateCacheGroup(cache.group, data, fieldKey);
+        }
+    }
+    clearCache(data, fieldKey = 'id') {
+        if (data) {
+            const cache = this.getCacheByIndex(this.cacheIndex);
+            if (cache && cache.group) {
+                this.clearCacheGroup(cache.group, data, fieldKey);
+            }
+        }
+        else {
+            this.deleteCache(this.cacheIndex);
+        }
     }
 }
 exports.default = Http;

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, data?: import("./types").TData | undefined, fieldKey?: string | null) => 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;
@@ -8,10 +13,16 @@ export type TGroupsData = {
     [index: string]: TData;
 };
 export type TMethod = 'GET' | 'POST';
+export type TCacheControll = string | {
+    group: string;
+    fieldKey: string;
+};
 export type TParams = {
     path: string;
     data?: TData;
     cache?: string | boolean;
+    cacheUpdate?: TCacheControll;
+    cacheClear?: TCacheControll;
     globalName?: string;
     success?: (...args: any) => void;
     error?: (...args: any) => void;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "larapi",
-  "version": "0.0.7",
+  "version": "0.0.9",
   "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;
@@ -48,36 +45,97 @@ abstract class Core {
 		}
 	}
 
+	protected isJsonString(str: string) {
+		try {
+			JSON.parse(str);
+		} catch (e) {
+			return false;
+		}
+		return true;
+	}
+
 	public setHost(host: string): void {
 		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, data?: TData, fieldKey: string | null = 'id'): void {
+		if (data) {
+
+			const clear = (cacheData: any) => {
+				if ((fieldKey && cacheData[fieldKey] === data[fieldKey]) || fieldKey === null) {
+					for(const key in cacheData) {
+						if (key in data) {
+							return false
+						}
+					}
+				}
+				return true;
+			};
+
+			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).filter(clear);
+					}else{
+						if (!clear(this.cache[key].data))
+							delete this.cache[key];
+					}
+				}
+			}
+		}else{
+			for(const key in this.cache) {
+				if (this.cache[key].group === group) {
+					delete this.cache[key];
+				}
+			}
+		}
+	}
+
+	public updateCacheGroup(group: string, data: TData, fieldKey: string | null = 'id'): void {
+
+		const update = (cacheData: any) => {
+			if ((fieldKey && cacheData[fieldKey] === data[fieldKey]) || fieldKey === null) {
+				for(const key in cacheData) {
+					if (key in data) {
+						cacheData[key] = data[key];
+					}
+				}
+			}
+			return cacheData;
+		};
+
 		for(const key in this.cache) {
 			if (this.cache[key].group === group) {
-				delete this.cache[key];
+				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 deleteCache(request: string): void {
-		const keyCache = md5(request);
-		if (!this.cache[keyCache])
+	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

@@ -30,6 +30,18 @@ class Http extends Core {
 	private success(...args: any) {
 		if (typeof this.params.success === 'function')
 			this.params.success(...args);
+		if (this.params.cacheUpdate && this.params.data) {
+			this.updateCacheGroup(
+				typeof this.params.cacheUpdate === 'string' ? this.params.cacheUpdate : this.params.cacheUpdate.group,
+				this.params.data,
+				typeof this.params.cacheUpdate === 'string' ? undefined : this.params.cacheUpdate.fieldKey);
+		}
+		if (this.params.cacheClear && this.params.data) {
+			this.clearCacheGroup(
+				typeof this.params.cacheClear === 'string' ? this.params.cacheClear : this.params.cacheClear.group,
+				this.params.data,
+				typeof this.params.cacheClear === 'string' ? undefined : this.params.cacheClear.fieldKey);
+		}
 	}
 
 	//Заголовки от 400 до 499
@@ -135,7 +147,7 @@ class Http extends Core {
 						return;
 					}
 					
-					const result = xhr.responseText ? JSON.parse(xhr.responseText) : {};
+					const result = this.isJsonString(xhr.responseText) ? JSON.parse(xhr.responseText) : {};
 	
 					if (xhr.status >= 200 && xhr.status <= 299) {
 						if (this.params.cache) {
@@ -160,8 +172,22 @@ class Http extends Core {
 		return this
 	}
 
-	public clearCache() {
-		this.deleteCache(this.cacheIndex);
+	public updateCache(data: TData, fieldKey: string | null = 'id'): void {
+		const cache = this.getCacheByIndex(this.cacheIndex);
+		if (cache && cache.group) {
+			this.updateCacheGroup(cache.group, data, fieldKey);
+		}
+	}
+
+	public clearCache(data?: TData, fieldKey: string | null = 'id'): void {
+		if (data) {
+			const cache = this.getCacheByIndex(this.cacheIndex);
+			if (cache && cache.group) {
+				this.clearCacheGroup(cache.group, data, fieldKey);
+			}
+		}else{
+			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 = {
@@ -12,10 +18,17 @@ export type TGroupsData = {
 
 export type TMethod = 'GET' | 'POST';
 
+export type TCacheControll = string | {
+	group: string;
+	fieldKey: string;
+};
+
 export type TParams = {
 	path: string;
 	data?: TData;
 	cache?: string | boolean;
+	cacheUpdate?: TCacheControll;
+	cacheClear?: TCacheControll;
 	globalName?: string;
 	success?: (...args: any) => void;
 	error?: (...args: any) => void;