larapi 0.0.8 → 0.1.0

package/README.md

@@ -0,0 +1,77 @@
+# Laravel API Client
+## The simple package for authorization with token and data cache
+## Install
+```
+npm i larapi
+```
+
+### First step
+#### you can create instanse or use static methods for first configuration and for further use
+```js
+const api = new API({
+	host: 'https://my-host'
+});
+...
+API.setHost('https://my-host');
+```
+
+### Authorization
+#### token useds in the header Authorization: Bearer
+```js
+api.setToken('token');
+api.setUser({...object-user});
+```
+#### you can use method getUser or property user for get user object
+```js
+api.getUser();
+...
+api.user;
+```
+
+### Requests
+
+#### Get
+```js
+api.get({
+  path: '/test',
+  success: (e) => {
+    console.log(e)
+  }
+});
+```
+
+#### Post
+```js
+api.post({
+  path: '/test',
+  data: {
+    message: 'hello world'
+  }
+  success: (e) => {
+    console.log(e)
+  }
+});
+```
+
+### Cache
+
+#### for create simple cache use boolean true in the "cache" property
+```js
+const request = api.get({
+  path: '/test',
+  cache: true,
+  ...
+});
+```
+
+#### if you need clear current cache - use method "clearCache"
+```js
+request.clearCache();
+```
+#### or you can use method "updateCache" for update current cache data in the current request
+#### first argument in the method is object updated data, and last argument is key field for search in the current cache, if you need update all data use null
+```js
+request.updateCache({
+  message: 'update this string'
+}, null);
+```

package/lib/Core.d.ts

@@ -9,10 +9,11 @@ declare abstract class Core {
     constructor(context?: Core);
     addListener(event: TListenerEvents, callback: (data: any) => void): Event;
     protected getCache(key: string): TData | undefined;
+    protected isJsonString(str: string): boolean;
     setHost(host: string): void;
     protected setCache(key: string, data: TData, group?: string): void;
-    clearCacheGroup(group: string): void;
-    updateCacheGroup(group: string, fieldKey: string, data: TData): 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;

package/lib/Core.js

@@ -60,6 +60,15 @@ class Core {
             }
         }
     }
+    isJsonString(str) {
+        try {
+            JSON.parse(str);
+        }
+        catch (e) {
+            return false;
+        }
+        return true;
+    }
     setHost(host) {
         this.host = host;
     }
@@ -70,23 +79,52 @@ class Core {
             group: group
         };
     }
-    clearCacheGroup(group) {
-        for (const key in this.cache) {
-            if (this.cache[key].group === group) {
-                delete this.cache[key];
+    clearCacheGroup(group, data, fieldKey = 'id') {
+        if (data) {
+            const clear = (cacheData) => {
+                if ((fieldKey && (cacheData === null || cacheData === void 0 ? void 0 : cacheData[fieldKey]) === (data === null || data === void 0 ? void 0 : 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, fieldKey, data) {
+    updateCacheGroup(group, data, fieldKey = 'id') {
         const update = (cacheData) => {
-            if (cacheData[fieldKey] === data[fieldKey]) {
-                for (const fieldKey in cacheData) {
-                    if (fieldKey in data) {
-                        cacheData[fieldKey] = data[fieldKey];
+            const retData = cacheData;
+            for (const key of fieldKey.split('.')) {
+                cacheData = cacheData[key];
+            }
+            if ((fieldKey && cacheData[fieldKey] === data[fieldKey]) || fieldKey === null) {
+                for (const key in cacheData) {
+                    if (key in data) {
+                        cacheData[key] = data[key];
                     }
                 }
             }
-            return cacheData;
+            return retData;
         };
         for (const key in this.cache) {
             if (this.cache[key].group === group) {

package/lib/Http.d.ts

@@ -12,7 +12,7 @@ declare class Http extends Core {
     private encodeUrlParams;
     private cuteUndifinedParams;
     request(): this;
-    updateCache(fieldKey: string, data: TData): void;
-    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,14 +157,22 @@ class Http extends Core_1.default {
         }
         return this;
     }
-    updateCache(fieldKey, data) {
+    updateCache(data, fieldKey = 'id') {
         const cache = this.getCacheByIndex(this.cacheIndex);
         if (cache && cache.group) {
-            this.updateCacheGroup(cache.group, fieldKey, data);
+            this.updateCacheGroup(cache.group, data, fieldKey);
         }
     }
-    clearCache() {
-        this.deleteCache(this.cacheIndex);
+    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 clearCacheGroup: (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/types.d.ts

@@ -13,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.8",
+  "version": "0.1.0",
   "description": "API client for laravel",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",

package/src/Core.ts

@@ -45,6 +45,15 @@ 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;
 	}
@@ -57,25 +66,55 @@ abstract class Core {
 		};
 	}
 
-	public clearCacheGroup(group: string): void {
-		for(const key in this.cache) {
-			if (this.cache[key].group === group) {
-				delete this.cache[key];
+	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, fieldKey: string, data: TData): void {
+	public updateCacheGroup(group: string, data: TData, fieldKey: string | null = 'id'): void {
 
 		const update = (cacheData: any) => {
-			if (cacheData[fieldKey] === data[fieldKey]) {
-				for(const fieldKey in cacheData) {
-					if (fieldKey in data) {
-						cacheData[fieldKey] = data[fieldKey];
+			const retData = cacheData;
+			for(const key of fieldKey!.split('.')) {
+				cacheData = cacheData[key]
+			}
+			if ((fieldKey && cacheData[fieldKey] === data[fieldKey]) || fieldKey === null) {
+				for(const key in cacheData) {
+					if (key in data) {
+						cacheData[key] = data[key];
 					}
 				}
 			}
-			return cacheData;
+			return retData;
 		};
 
 		for(const key in this.cache) {

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,15 +172,22 @@ class Http extends Core {
 		return this
 	}
 
-	public updateCache(fieldKey: string, data: TData): void {
+	public updateCache(data: TData, fieldKey: string | null = 'id'): void {
 		const cache = this.getCacheByIndex(this.cacheIndex);
 		if (cache && cache.group) {
-			this.updateCacheGroup(cache.group, fieldKey, data);
+			this.updateCacheGroup(cache.group, data, fieldKey);
 		}
 	}
 
-	public clearCache(): void {
-		this.deleteCache(this.cacheIndex);
+	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/types.ts

@@ -18,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;