larapi 0.2.13 → 0.2.15

package/lib/Http.d.ts

@@ -1,16 +1,18 @@
 import Core from "./Core";
+import Queue from './Queue';
 import { Event, Events } from "easy-event-emitter";
-import type { TMethod, TParams, TData, TRequestParams, TListenerEvents, TRequestProgress } from "./types";
-declare class Http extends Core {
+import type { TMethod, TParams, TData, TRequestParams, TListenerEvents, TRequestProgress, TResponseData } from "./types";
+declare class Http<D extends TResponseData = TResponseData, PATH = any, DATA extends ((...args: any) => any) = any> extends Core {
     private cacheIndex;
     currentCache?: TData;
     currentEvents: Events;
     requestParams: TRequestParams;
     method: TMethod;
-    params: TParams;
+    params: TParams<PATH, DATA>;
     path: string;
+    queue: Queue<D>;
     queueName: string;
-    constructor(method: TMethod, params: TParams, context?: Core);
+    constructor(method: TMethod, params: TParams<PATH, DATA>, context?: Core);
     private initRequest;
     private initCache;
     private initQueue;

package/lib/Queue.d.ts

@@ -1,15 +1,13 @@
 import Http from "./Http";
-declare class Queue {
-    private static instance;
+import type { TResponseData } from "./types";
+declare class Queue<D extends TResponseData = TResponseData> {
+    private static _Queue;
     private queue;
-    constructor();
+    http: Http<D>;
+    constructor(http: Http<D>);
     has(request: string): boolean;
-    get(request: string): Http | undefined;
+    get(request: string): Http<TResponseData, any, any> | undefined;
     clear(request: string): void;
-    push(request: string, instance: Http): boolean;
-    static has: (request: string) => boolean;
-    static get: (request: string) => Http | undefined;
-    static clear: (request: string) => void;
-    static push: (request: string, instance: Http) => boolean;
+    push(request: string): boolean;
 }
 export default Queue;

package/lib/index.d.ts

@@ -1,50 +1,44 @@
 import Core from "./Core";
-import type { TMethod, TParams, TListenerEvents } from "./types";
+import type { TUser, TConfig, TMethod, TParams, TResponseData, TListenerEvents } from "./types";
 import type { Event } from "easy-event-emitter";
 import Http from "./Http";
-type TUser = {
-    id: number;
-    [index: string]: any;
-};
-type TConfig = {
-    host: string;
-};
 /** Laravel API Client */
-declare class API<USER extends TUser = TUser> extends Core {
+declare class API<D extends TResponseData = TResponseData, U extends TUser = TUser, S extends D['success'] = D['success']> extends Core {
     private static instance;
     private _user;
     token?: string;
     constructor(config: TConfig);
-    http(method: TMethod, params: TParams): Http;
-    get(params: TParams): Http;
-    head(params: TParams): Http;
-    post(params: TParams): Http;
-    put(params: TParams): Http;
-    patch(params: TParams): Http;
-    delete(params: TParams): Http;
-    options(params: TParams): Http;
-    connect(params: TParams): Http;
-    trace(params: TParams): Http;
+    http<PATH extends keyof S, DATA extends S[PATH]>(method: TMethod, params: TParams<PATH, DATA>): Http<D, PATH, DATA>;
+    get<PATH extends keyof S, DATA extends S[PATH]>(params: TParams<PATH, DATA, 'GET'>): Http<D, PATH, DATA>;
+    head<PATH extends keyof S, DATA extends S[PATH]>(params: TParams<PATH, DATA>): Http<D, PATH, DATA>;
+    post<PATH extends keyof S, DATA extends S[PATH]>(params: TParams<PATH, DATA>): Http<D, PATH, DATA>;
+    put<PATH extends keyof S, DATA extends S[PATH]>(params: TParams<PATH, DATA>): Http<D, PATH, DATA>;
+    patch<PATH extends keyof S, DATA extends S[PATH]>(params: TParams<PATH, DATA>): Http<D, PATH, DATA>;
+    delete<PATH extends keyof S, DATA extends S[PATH]>(params: TParams<PATH, DATA>): Http<D, PATH, DATA>;
+    options<PATH extends keyof S, DATA extends S[PATH]>(params: TParams<PATH, DATA>): Http<D, PATH, DATA>;
+    connect<PATH extends keyof S, DATA extends S[PATH]>(params: TParams<PATH, DATA>): Http<D, PATH, DATA>;
+    trace<PATH extends keyof S, DATA extends S[PATH]>(params: TParams<PATH, DATA>): Http<D, PATH, DATA>;
     addListener(event: TListenerEvents, callback: (data: any) => void): Event;
     setToken(token: string): Promise<void>;
     getToken(): string | undefined;
     getUid(): number;
-    getUser(): USER;
+    getUser(): U;
     get uid(): number;
-    get user(): USER;
-    setUser(user: USER): Promise<void>;
-    updateUser(user: USER): void;
+    get user(): U;
+    setUser(user: U): Promise<void>;
+    updateUser(user: U): void;
     logout(): Promise<void>;
-    static http: (method: TMethod, params: TParams) => Http;
-    static get: (params: TParams) => Http;
-    static head: (params: TParams) => Http;
-    static post: (params: TParams) => Http;
-    static put: (params: TParams) => Http;
-    static patch: (params: TParams) => Http;
-    static delete: (params: TParams) => Http;
-    static options: (params: TParams) => Http;
-    static connect: (params: TParams) => Http;
-    static trace: (params: TParams) => Http;
+    static http: <PATH extends string | number, DATA extends import("./types").TData[PATH]>(method: TMethod, params: TParams<PATH, DATA>) => Http<TResponseData, PATH, DATA>;
+    static get: <PATH extends string | number, DATA extends import("./types").TData[PATH]>(params: TParams<PATH, DATA, "GET">) => Http<TResponseData, PATH, DATA>;
+    static head: <PATH extends string | number, DATA extends import("./types").TData[PATH]>(params: TParams<PATH, DATA>) => Http<TResponseData, PATH, DATA>;
+    static post: <PATH extends string | number, DATA extends import("./types").TData[PATH]>(params: TParams<PATH, DATA>) => Http<TResponseData, PATH, DATA>;
+    static put: <PATH extends string | number, DATA extends import("./types").TData[PATH]>(params: TParams<PATH, DATA>) => Http<TResponseData, PATH, DATA>;
+    static patch: <PATH extends string | number, DATA extends import("./types").TData[PATH]>(params: TParams<PATH, DATA>) => Http<TResponseData, PATH, DATA>;
+    static delete: <PATH extends string | number, DATA extends import("./types").TData[PATH]>(params: TParams<PATH, DATA>) => Http<TResponseData, PATH, DATA>;
+    static options: <PATH extends string | number, DATA extends import("./types").TData[PATH]>(params: TParams<PATH, DATA>) => Http<TResponseData, PATH, DATA>;
+    static connect: <PATH extends string | number, DATA extends import("./types").TData[PATH]>(params: TParams<PATH, DATA>) => Http<TResponseData, PATH, DATA>;
+    static trace: <PATH extends string | number, DATA extends import("./types").TData[PATH]>(params: TParams<PATH, DATA>) => Http<TResponseData, PATH, DATA>;
+    static setConfig: (config: TConfig) => void;
     static setHost: (host: string) => void;
     static setUser: (user: TUser) => Promise<void>;
     static updateUser: (user: TUser) => void;
@@ -65,5 +59,9 @@ declare class API<USER extends TUser = TUser> extends Core {
      */
     static deleteCacheGroup: (groups: string | string[], data?: import("./types").TData | undefined, fieldKey?: string | null) => void;
 }
-export type { Event };
+export type { 
+/**
+ * @deprecated The type should not be used
+ */
+Event, Event as EventListener, TResponseData };
 export default API;

package/lib/types.d.ts

@@ -3,11 +3,18 @@ export type TCacheBody = {
     group?: string;
     time: number;
 };
+export type TUser = {
+    id: number;
+    [index: string]: any;
+};
 export type TCache = {
     [index: string]: TCacheBody;
 };
+export type TError = {
+    message?: string;
+};
 export type TData = {
-    [index: string]: any;
+    [index: string]: any | ((...args: any) => any);
 };
 export type TGroupsData = {
     [index: string]: TData;
@@ -22,18 +29,39 @@ export type TRequestProgress = {
     total: number;
     loaded: number;
 };
-export type TParams = {
-    path: string;
-    data?: TData;
+export type TCoreRviverObject = {
+    and?: {
+        [index: string]: string[];
+    };
+    or?: {
+        [index: string]: string[];
+    };
+};
+export type TConfigDataReviver = {
+    [index: string]: (value: any) => any;
+};
+export type TConfig = {
+    host: string;
+    reviver?: (this: any, key: string, value: any) => any;
+    dataReviver?: TConfigDataReviver;
+};
+export type TResponseData = {
+    success: TData;
+    error?: TError;
+    fail?: TError;
+};
+export type TParams<P = string | keyof TResponseData['success'], D extends ((...args: any) => any) = TResponseData['success']['?'] | ((...args: any) => any), M extends TMethod = TMethod, E extends TError = TError, F extends TError = TError> = {
+    path: P;
+    data?: Parameters<D>[0];
     cache?: string | boolean;
     cacheUpdate?: TCacheControll | TCacheControll[];
     cacheClear?: TCacheControll | TCacheControll[];
     globalName?: string;
     queueThrottling?: boolean;
-    success?: (data: any) => void;
-    error?: (data: any) => void;
-    fail?: (data: any) => void;
-    complete?: (data: any) => void;
+    success?: (data: ReturnType<D>) => void;
+    error?: (error: E) => void;
+    fail?: (fail: F) => void;
+    complete?: (complete: any) => void;
     progress?: (progress: TRequestProgress) => void;
 };
 export type TRequestParams = {

package/package.json

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

package/src/Core.ts

@@ -2,25 +2,30 @@ import EventEmitter,{
 	Events
 } from 'easy-event-emitter';
 import type {
+	TConfig,
 	TCache,
 	TCacheBody,
 	TData,
-	TGroupsData
+	TGroupsData,
+	TCoreRviverObject
 } from './types';
 
 abstract class Core {
 	private cache: TCache;
 		initData: TGroupsData;
-	protected events: Events;
-		host: string;
+	protected readonly events: Events;
+		config: TConfig;
 		
 
 	constructor(context?: Core) {
 		this.events = new EventEmitter();
-		this.host = 'http://127.0.0.1/';
+		this.config = {
+			host: 'http://127.0.0.1/'
+		};
 		this.cache = {};
 		this.initData = {};
 
+		this.setConfig = this.setConfig.bind(this);
 		this.setHost = this.setHost.bind(this);
 		this.setInitData = this.setInitData.bind(this);
 		this.triggerByCacheGroup = this.triggerByCacheGroup.bind(this);
@@ -28,7 +33,7 @@ abstract class Core {
 		this.updateCacheGroup = this.updateCacheGroup.bind(this);
 		if (context) {
 			Object.assign(this, {
-				host: context?.host,
+				config: context?.config,
 				events: context?.events,
 				cache: context?.cache,
 				initData: context?.initData
@@ -36,6 +41,10 @@ abstract class Core {
 		}
 	}
 
+	protected setConfig(config: TConfig) {
+		this.config = config;
+	}
+
 	protected getCache(key: string): TData | undefined {
 		if (this.cache[key]) {
 			if ((new Date()).getTime() <= (this.cache[key].time + 3600000000)) {
@@ -55,8 +64,55 @@ abstract class Core {
 		return true;
 	}
 
+	protected jsonParse(str: string) {
+		if (typeof this.config.reviver === 'function') {
+			return JSON.parse(str, this.config.reviver);
+		}
+
+		if (this.config.dataReviver) {
+			const replace = this.config.dataReviver;
+			const dataKeys = Object.keys(replace);
+			const ifKeys: TCoreRviverObject = {};
+
+			dataKeys.forEach((key) => {
+				const and = key.split('&');
+				if (and.length > 1) {
+					ifKeys.and = ifKeys.and ?? {};
+					if (key in ifKeys.and) {
+						ifKeys.and[key].push(...and);
+					}else{
+						ifKeys.and[key] = and;
+					}
+				}
+			});
+
+			const data = JSON.parse(str, (key, value) => {
+				if ((key in replace && typeof replace[key] === 'function')) {
+					return replace[key](value);
+				}
+				return value;
+			});
+			
+			if (ifKeys.and && data) {
+				const dataKeys = Object.keys(data);
+
+				if (ifKeys.and) {
+					for (const [key, keys] of Object.entries(ifKeys.and)) {
+						if (keys.length === dataKeys.length && keys.every((key) => dataKeys.includes(key))) {
+							return replace[key](data);
+						}
+					}
+				}
+			}
+
+			return data;
+		}
+		
+		return JSON.parse(str);
+	}
+
 	public setHost(host: string): void {
-		this.host = host;
+		this.config.host = host;
 	}
 
 	protected setCache(key: string, data: TData, group?: string): void {

package/src/Http.ts

@@ -12,27 +12,30 @@ import type {
 	TRequestParams,
 	TListenerEvents,
 	TCacheControll,
-	TRequestProgress
+	TRequestProgress,
+	TResponseData
 } from "./types";
 
-class Http extends Core {
+class Http<D extends TResponseData = TResponseData, PATH = any, DATA extends ((...args: any) => any) = any> extends Core {
 	private cacheIndex: string;
 		currentCache?: TData;
 		currentEvents: Events
 		requestParams: TRequestParams;
 		method: TMethod;
-		params: TParams;
+		params: TParams<PATH, DATA>;
 		path: string;
+		queue: Queue<D>;
 		queueName: string;
 
-	constructor(method: TMethod, params: TParams, context?: Core) {
+	constructor(method: TMethod, params: TParams<PATH, DATA>, context?: Core) {
 		super(context);
 		this.currentEvents = new EventEmitter();
+		this.queue = new Queue<D>(this);
 		this.cacheIndex = '';
 		this.queueName = '';
 		this.method = method;
 		this.params = params;
-		this.path = this.params.path;
+		this.path = this.params.path as string;
 		this.requestParams = {
 			method: this.method
 		};
@@ -62,7 +65,7 @@ class Http extends Core {
 
 		if ((['GET', 'HEAD'] as TMethod[]).includes(this.method)) {
 			if (this.params.data)
-				this.path = this.params.path + '?' + this.encodeUrlParams(this.params.data);
+				this.path = (this.params.path as string) + '?' + this.encodeUrlParams(this.params.data);
 
 			if (this.method === 'HEAD') {
 				this.requestParams.withoutResponse = true;
@@ -189,12 +192,12 @@ class Http extends Core {
 	}
 
 	public request(): this {
-		if (typeof XMLHttpRequest === 'undefined' || this.currentCache || Queue.push(this.queueName, this)) return this;
+		if (typeof XMLHttpRequest === 'undefined' || this.currentCache || this.queue.push(this.queueName)) return this;
 		
 		try {
 			const xhr = new XMLHttpRequest();
 			
-			xhr.open(this.method, this.host + this.path, true);
+			xhr.open(this.method, this.config.host + this.path, true);
 			for(const header in this.requestParams.headers) {
 				xhr.setRequestHeader(header, this.requestParams.headers[header]);
 			}
@@ -226,7 +229,7 @@ class Http extends Core {
 			xhr.onreadystatechange = () => {
 				if (xhr.readyState !== 4) return;
 				
-				const result = (!this.requestParams.withoutResponse && this.isJsonString(xhr.responseText)) ? JSON.parse(xhr.responseText) : {};
+				const result = (!this.requestParams.withoutResponse && this.isJsonString(xhr.responseText)) ? this.jsonParse(xhr.responseText) : {};
 
 				if (xhr.status >= 200 && xhr.status <= 299) {
 					if (this.params.cache) {
@@ -242,7 +245,7 @@ class Http extends Core {
 					console.warn(result);
 				}
 				this.complete(result);
-				Queue.clear(this.queueName);
+				this.queue.clear(this.queueName);
 			}
 			xhr.send(this.requestParams.body);
 		}catch(e) {

package/src/Queue.ts

@@ -1,14 +1,17 @@
 import Http from "./Http";
+import type { TResponseData } from "./types";
 
 type TQueue = {
 	[index: string]: Http;
 };
 
-class Queue {
-	private static instance = new Queue;
-	private queue: TQueue = {};
+class Queue<D extends TResponseData = TResponseData> {
+	private static _Queue: TQueue = {};
+	private queue = Queue._Queue;
+		http: Http<D>;
 
-	constructor() {
+	constructor(http: Http<D>) {
+		this.http = http;
 		this.has = this.has.bind(this);
 		this.get = this.get.bind(this);
 		this.clear = this.clear.bind(this);
@@ -29,23 +32,18 @@ class Queue {
 		}
 	}
 
-	public push(request: string, instance: Http): boolean {
+	public push(request: string): boolean {
 		const refInstance = this.get(request);
 		if (!refInstance) {
-			this.queue[request] = instance;
+			(this.queue[request] as any) = this.http;
 		}else{
-			refInstance?.addListener('api-request-success', instance.success);
-			refInstance?.addListener('api-request-error', instance.error);
-			refInstance?.addListener('api-request-fail', instance.fail);
-			refInstance?.addListener('api-request-complete', instance.complete);
+			refInstance?.addListener('api-request-success', this.http.success);
+			refInstance?.addListener('api-request-error', this.http.error);
+			refInstance?.addListener('api-request-fail', this.http.fail);
+			refInstance?.addListener('api-request-complete', this.http.complete);
 		}
 		return refInstance instanceof Http;
 	}
-
-	public static has = this.instance.has;
-	public static get = this.instance.get;
-	public static clear = this.instance.clear;
-	public static push = this.instance.push;
 }
 
 export default Queue;

package/src/index.ts

@@ -1,7 +1,10 @@
 import Core from "./Core";
 import type {
+	TUser,
+	TConfig,
 	TMethod,
 	TParams,
+	TResponseData,
 	TListenerEvents
 } from "./types";
 import type {
@@ -9,27 +12,19 @@ import type {
 } from "easy-event-emitter";
 import Http from "./Http";
 
-type TUser = {
-	id: number;
-	[index: string]: any;
-};
-
-type TConfig = {
-	host: string;
-};
 
 /** Laravel API Client */
-class API<USER extends TUser = TUser> extends Core {
+class API<D extends TResponseData = TResponseData, U extends TUser = TUser, S extends D['success'] = D['success']> extends Core {
 	private static instance = new API({
 		host: ''
 	});
-	private _user: USER;
+	private _user: U;
 		token?: string;
 
 	constructor(config: TConfig) {
 		super();
-		this.setHost(config.host);
-		this._user = {} as USER;
+		this.setConfig(config);
+		this._user = {} as U;
 
 		this.setToken = this.setToken.bind(this);
 		this.setUser = this.setUser.bind(this);
@@ -51,47 +46,47 @@ class API<USER extends TUser = TUser> extends Core {
 		this.addListener = this.addListener.bind(this);
 	}
 
-	public http(method: TMethod, params: TParams): Http {
-		const http = new Http(method, params, this);
+	public http<PATH extends keyof S, DATA extends S[PATH]>(method: TMethod, params: TParams<PATH, DATA>) {
+		const http = new Http<D, PATH, DATA>(method, params, this);
 		if (this.token) {
 			http.addHeader('Authorization', 'Bearer ' + this.token);
 		}
 		return http;
 	}
 
-	public get(params: TParams): Http {
+	public get<PATH extends keyof S, DATA extends S[PATH]>(params: TParams<PATH, DATA, 'GET'>) {
 		return this.http('GET', params).request();
 	}
 
-	public head(params: TParams): Http {
+	public head<PATH extends keyof S, DATA extends S[PATH]>(params: TParams<PATH, DATA>) {
 		return this.http('HEAD', params).request();
 	}
 
-	public post(params: TParams): Http {
+	public post<PATH extends keyof S, DATA extends S[PATH]>(params: TParams<PATH, DATA>) {
 		return this.http('POST', params).request();
 	}
 
-	public put(params: TParams): Http {
+	public put<PATH extends keyof S, DATA extends S[PATH]>(params: TParams<PATH, DATA>) {
 		return this.http('PUT', params).request();
 	}
 
-	public patch(params: TParams): Http {
+	public patch<PATH extends keyof S, DATA extends S[PATH]>(params: TParams<PATH, DATA>) {
 		return this.http('PATCH', params).request();
 	}
 
-	public delete(params: TParams): Http {
+	public delete<PATH extends keyof S, DATA extends S[PATH]>(params: TParams<PATH, DATA>) {
 		return this.http('DELETE', params).request();
 	}
 
-	public options(params: TParams): Http {
+	public options<PATH extends keyof S, DATA extends S[PATH]>(params: TParams<PATH, DATA>) {
 		return this.http('OPTIONS', params).request();
 	}
 
-	public connect(params: TParams): Http {
+	public connect<PATH extends keyof S, DATA extends S[PATH]>(params: TParams<PATH, DATA>) {
 		return this.http('CONNECT', params).request();
 	}
 
-	public trace(params: TParams): Http {
+	public trace<PATH extends keyof S, DATA extends S[PATH]>(params: TParams<PATH, DATA>) {
 		return this.http('TRACE', params).request();
 	}
 
@@ -111,7 +106,7 @@ class API<USER extends TUser = TUser> extends Core {
 		return (typeof this._user === 'object' && 'id' in this._user) ? Number(this._user.id) : 0;
 	}
 
-	public getUser(): USER {
+	public getUser(): U {
 		return this._user;
 	}
 
@@ -119,16 +114,16 @@ class API<USER extends TUser = TUser> extends Core {
 		return this.getUid();
 	}
 
-	public get user(): USER {
+	public get user(): U {
 		return this.getUser();
 	}
 
-	public async setUser(user: USER) {
+	public async setUser(user: U) {
 		this._user = user;
 		this.events.emit('login', user);
 	}
 
-	public updateUser(user: USER) {
+	public updateUser(user: U) {
 		const updatedUser = {...this.user, ...user};
 		this.setUser(updatedUser);
 		this.events.emit('user-update', updatedUser);
@@ -136,7 +131,7 @@ class API<USER extends TUser = TUser> extends Core {
 
 	public async logout() {
 		const user = this.user;
-		this.setUser({} as USER);
+		this.setUser({} as U);
 		this.setToken('');
 		this.events.emit('logout', user);
 	}
@@ -151,6 +146,7 @@ class API<USER extends TUser = TUser> extends Core {
 	public static options = this.instance.options;
 	public static connect = this.instance.connect;
 	public static trace = this.instance.trace;
+	public static setConfig = this.instance.setConfig;
 	public static setHost = this.instance.setHost;
 	public static setUser = this.instance.setUser;
 	public static updateUser = this.instance.updateUser;
@@ -175,6 +171,11 @@ class API<USER extends TUser = TUser> extends Core {
 
 (globalThis as any).apiSetInitData = API.setInitData;
 export type {
-	Event
+	/**
+	 * @deprecated The type should not be used
+	 */
+	Event,
+	Event as EventListener,
+	TResponseData
 };
 export default API;