@rws-framework/client 2.21.5 → 2.22.1

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "@rws-framework/client",
     "private": false,
-    "version": "2.21.5",
+    "version": "2.22.1",
     "main": "src/index.ts",
     "scripts": {
         "docs": "typedoc --tsconfig ./tsconfig.json"

package/src/services/ApiService.ts

@@ -1,4 +1,4 @@
-import { IKDBTypesResponse } from '../../../components/src/types/IBackendCore';
+import { ITypesResponse } from '../../../components/src/types/IBackendCore';
 import TheService from './_service';
 
 //@4DI
@@ -20,11 +20,14 @@ interface IAPIOptions {
     routeParams?: {
         [key: string]: string
     }, 
+    queryParams?: {
+        [key: string]: string
+    }
 }
 
 interface IHTTProute<P = {[key: string]: any}> {
     name: string;
-    path: string;  
+    path: string | string[];  
     method: string;
     noParams?: boolean;
     options?: any;
@@ -89,16 +92,16 @@ class ApiService extends TheService {
     public delete = calls.delete;
 
     public back = {
-        get: async <T>(routeName: string, options?: IAPIOptions, token?: string): Promise<T> => calls.get.bind(this)(backend.getBackendUrl.bind(this)(routeName, options?.routeParams), options) as Promise<T>,
-        post: async <T, P extends object = object>(routeName: string, payload?: P, options?: IAPIOptions): Promise<T> => calls.post.bind(this)(backend.getBackendUrl.bind(this)(routeName, options?.routeParams), payload, options) as Promise<T>,
-        put: async <T, P extends object = object>(routeName: string, payload: P, options?: IAPIOptions): Promise<T> => calls.put.bind(this)(backend.getBackendUrl.bind(this)(routeName, options?.routeParams), payload, options) as Promise<T>,
-        delete: async <T>(routeName: string, options?: IAPIOptions): Promise<T> => calls.delete.bind(this)(backend.getBackendUrl.bind(this)(routeName, options?.routeParams), options) as Promise<T>,
+        get: async <T>(routeName: string, options?: IAPIOptions, token?: string): Promise<T> => calls.get.bind(this)(backend.getBackendUrl.bind(this)(routeName, options?.routeParams, options?.queryParams), options) as Promise<T>,
+        post: async <T, P extends object = object>(routeName: string, payload?: P, options?: IAPIOptions): Promise<T> => calls.post.bind(this)(backend.getBackendUrl.bind(this)(routeName, options?.routeParams, options?.queryParams), payload, options) as Promise<T>,
+        put: async <T, P extends object = object>(routeName: string, payload: P, options?: IAPIOptions): Promise<T> => calls.put.bind(this)(backend.getBackendUrl.bind(this)(routeName, options?.routeParams, options?.queryParams), payload, options) as Promise<T>,
+        delete: async <T>(routeName: string, options?: IAPIOptions): Promise<T> => calls.delete.bind(this)(backend.getBackendUrl.bind(this)(routeName, options?.routeParams, options?.queryParams), options) as Promise<T>,
         uploadFile: async (routeName: string, file: File, onProgress: (progress: number) => void, options: IAPIOptions = {}, payload: any = {}): Promise<UploadResponse> => this.uploadFile(backend.getBackendUrl.bind(this)(routeName, options?.routeParams), file, onProgress, payload),
     };
 
-    async getResource(resourceName: string): Promise<IKDBTypesResponse>
+    async getResource(resourceName: string): Promise<ITypesResponse>
     {        
-        return calls.get.bind(this)(`${this.config.get('backendUrl')}${this.config.get('apiPrefix') || ''}/api/rws/resource/${resourceName}`) as Promise<IKDBTypesResponse>
+        return calls.get.bind(this)(`${this.config.get('backendUrl')}${this.config.get('apiPrefix') || ''}/api/rws/resource/${resourceName}`) as Promise<ITypesResponse>
     }
 }
 

package/src/services/_api/backend.ts

@@ -2,7 +2,7 @@ import { ApiServiceInstance, IBackendRoute, IHTTProute } from "../ApiService";
 import { ConfigServiceInstance } from "../ConfigService";
 
 export const backend = {
-    getBackendUrl(this: ApiServiceInstance, routeName: string, params: {[key: string]: string} = {}): string
+    getBackendUrl(this: ApiServiceInstance, routeName: string, params: {[key: string]: string} = {}, queryParams: {[key: string]: string} = {}): string
     {       
         const config = this.config;
         const routesPackage = config.get('backendRoutes');
@@ -43,13 +43,12 @@ export const backend = {
                     ];
                 }
 
-                routes = [...routes, ...item.routes.map((subRouteItem: IHTTProute): IHTTProute => {
+                    routes = [...routes, ...item.routes.map((subRouteItem: IHTTProute): IHTTProute => {
                     const subRoute: IHTTProute = {
-                        path: item.prefix + subRouteItem.path,
+                        path: Array.isArray(subRouteItem.path) ? subRouteItem.path.map(subPath => item.prefix + subPath) : item.prefix + subRouteItem.path,
                         name: backend.checkPrefixedRouteName(subRouteItem.name, item.controllerName),
                         method: subRouteItem.method || 'GET'
-                    };
-            
+                    };            
                     return subRoute;
                 })];
 
@@ -65,15 +64,48 @@ export const backend = {
             throw new Error(`Backend route '${routeName}' does not exist.`);
         }
 
-        let apiPath = route.path;
+        let apiPath: string | string[] = route.path;        
+
+        if(Array.isArray(apiPath)){
+            const paramsLength = Object.keys(params).length;
+            if(paramsLength > 0){               
+                for(const searchedPath of apiPath){
+                    let foundParams = 0;
+                    for(const p of Object.keys(params)){
+                        if(searchedPath.indexOf(`:${p}`) !== -1){
+                            foundParams++;
+                        }
+                    }
+
+                    if(foundParams === paramsLength){
+                        apiPath = searchedPath;
+                        break;
+                    }
+                }
+            }else{
+                for(const searchedPath of apiPath){
+                    if(!searchedPath.includes(':')){
+                        apiPath = searchedPath;
+                        break;
+                    }
+                }
+            }
+        }
 
         Object.keys(params).forEach((paramKey: string) => {
             const paramValue = params[paramKey];
 
-            apiPath = apiPath.replace(`:${paramKey}`, paramValue);
-        });
+            apiPath = (apiPath as string).replace(`:${paramKey}`, paramValue);
+        });        
+
+        let finalUrl = `${config.get('backendUrl')}${config.get('apiPrefix') || ''}${apiPath}`;
+
+        if(Object.keys(queryParams).length > 0){
+            const queryString = new URLSearchParams(queryParams).toString();
+            finalUrl += `?${queryString}`;
+        }
 
-        return `${config.get('backendUrl')}${config.get('apiPrefix') || ''}${apiPath}`;
+        return finalUrl;
     },
     checkPrefixedRouteName(routeName: string, prefixName: string){
         let finalRoute = routeName;