@rws-framework/client 2.15.6 → 2.16.0

package/builder/webpack/rws.webpack.config.js

@@ -63,11 +63,9 @@ const RWSWebpackWrapper = async (appRoot, rwsFrontendConfig,  _packageDir) => {
   const WEBPACK_AFTER_ACTIONS = rwsFrontendConfig.actions || [];
   const WEBPACK_AFTER_ERROR_ACTIONS = rwsFrontendConfig.error_actions || [];
 
-  const modules_setup = [path.resolve(tools.findRootWorkspacePath(executionDir), 'node_modules')];
-
+  const modules_setup = [path.join(_packageDir, 'node_modules'), path.join(executionDir, 'node_modules'), path.join(tools.findRootWorkspacePath(appRoot), 'node_modules')];
   let optimConfig = null;
   let aliases = rwsFrontendConfig.aliases || {};
-
   aliases = { ...aliases, ...loadAliases(_packageDir, tsConfig,path.resolve(_MAIN_PACKAGE, 'node_modules'), executionDir) }  
 
   // #SECTION PLUGIN STARTING HOOKS

package/cfg/build_steps/webpack/_aliases.js

@@ -12,8 +12,11 @@ function loadAliases(packageDir, tsConfig, nodeModulesPath, executionDir){
     return {        
         ...tsPaths,
         '@rws-framework/foundation': path.resolve(packageDir, 'foundation', 'rws-foundation.js'),
-        '@rws-framework/foundation/*': path.resolve(packageDir, 'foundation', '*')
+        '@rws-framework/foundation/*': path.resolve(packageDir, 'foundation', '*'),
+        // 'entities/lib/maps/entities.json': path.resolve(nodeModulesPath, 'entities/lib/maps/entities.json'),
+        // 'entities/lib/maps/legacy.json': path.resolve(nodeModulesPath, 'entities/lib/maps/legacy.json'),
+        // 'entities/lib/maps/xml.json': path.resolve(nodeModulesPath, 'entities/lib/maps/xml.json')
     }
 }
 
-module.exports = { loadAliases }
+module.exports = { loadAliases }

package/cfg/build_steps/webpack/_loaders.js

@@ -18,6 +18,13 @@ function getRWSLoaders(packageDir, executionDir, tsConfigData, appRootDir, entry
   const tsConfigPath = tsConfigData.path;
 
   const loaders = [
+    {
+      test: /\.json$/,
+      type: 'javascript/auto',
+      include: [
+        path.resolve(appRootDir, 'node_modules/entities/lib/maps')
+      ],
+    },
     {
       test: /\.html$/,
       use: [
@@ -256,4 +263,4 @@ let rwsTemplate: any = T.html\`${templateContent}\`;
   return [template, htmlFastImports, templateExists];
 }
 
-module.exports = { getRWSLoaders, extractRWSViewArgs, getTemplate, getStyles }
+module.exports = { getRWSLoaders, extractRWSViewArgs, getTemplate, getStyles }

package/cfg/build_steps/webpack/_rws_externals.js

@@ -21,15 +21,13 @@ const externals = (declaredCodeBase, nodeModules, automatedChunks, externalOptio
 
     const codeBase = path.resolve(declaredCodeBase);        
 
-    const ignored = [
-      // /css-loader/,
+    const ignored = [      
       /tslib/,
       /reflect-metadata/, 
-      /\@microsoft\/fast-foundation\/.*/
+      /\@microsoft\/fast-foundation\/.*/,      
     ]
 
-    const enforced = [
-      /entities/,      
+    const enforced = [      
       /\@microsoft\/fast-foundation\/.*\/di/,
       /\@microsoft\/fast-foundation\/.*\/foundation-element/,      
     ]
@@ -39,6 +37,8 @@ const externals = (declaredCodeBase, nodeModules, automatedChunks, externalOptio
       path.resolve(__dirname,'..','..','..')
     ];        
 
+    console.log({frontendDirs})
+
     const inFrontendContext = frontendDirs.some(dir => context.startsWith(dir)) || 
         externalOptions._vars.frontendRequestContextCache.some(package => context.indexOf(package.request) > -1)
     

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "@rws-framework/client",
     "private": false,
-    "version": "2.15.6",
+    "version": "2.16.0",
     "main": "src/index.ts",
     "scripts": {
         "docs": "typedoc --tsconfig ./tsconfig.json"
@@ -32,6 +32,7 @@
         "@types/moment": "^2.13.0",
         "deepmerge": "^4.3.1",
         "dragula": "^3.7.3",
+        "entities": "6.0.0",
         "he": "^1.2.0",
         "json5": "^2.2.3",
         "lodash": "^4.17.21",
@@ -39,7 +40,7 @@
         "partial-json-parser": "^1.0.0",
         "reflect-metadata": "^0.2.2",
         "resolve-url-loader": "^5.0.0",
-        "sanitize-html": "^2.12.1",
+        "sanitize-html": "^2.14.0",
         "socket.io-client": "^4.7.2",
         "upload": "^1.3.2",
         "url-router": "^13.0.0",

package/src/client.ts

@@ -25,14 +25,6 @@ import ConfigHelper from './client/config';
 import { DefaultRWSPluginOptionsType, RWSPlugin } from './plugins/_plugin';
 import { IStaticRWSPlugin } from './types/IRWSPlugin'
 
-interface IHotModule extends NodeModule {
-    hot?: {
-        accept(dependencies: string[], callback?: (updatedDependencies: string[]) => void): void;
-        accept(dependency: string, callback?: () => void): void;
-        accept(errHandler?: (err: Error) => void): void;
-        dispose(callback: (data: any) => void): void;
-    }
-}
 
 type RWSEventListener = (event: CustomEvent) => void;
 
@@ -210,4 +202,4 @@ class RWSClient {
 }
 
 export default DI.createInterface<RWSClient>(x => x.singleton(RWSClient));
-export { IHotModule, RWSClient as RWSClientInstance };
+export {  RWSClient as RWSClientInstance };

package/src/index.ts

@@ -30,12 +30,31 @@ import type { IAssetShowOptions } from './components/_component';
 import RWSContainer from './components/_container';
 
 import type { RWSDecoratorOptions } from './components/_decorator';
+import type { IKDBTypeInfo, IKDBTypesResponse } from './types/IBackendCore';
 
 import {  RWSIgnore, RWSInject, RWSView } from './components/_decorator';
 
 import { declareRWSComponents } from './components';
 
 export default RWSClient;
+
+export type {
+    IKDBTypeInfo, IKDBTypesResponse,
+    NotifyUiType,
+    NotifyLogType,
+    IBackendRoute as IRWSBackendRoute,
+    RWSDecoratorOptions as IRWSDecoratorOptions,
+    IHTTProute as IRWSHttpRoute,
+    IPrefixedHTTProutes as IRWSPrefixedHTTProutes,    
+    IAssetShowOptions as IRWSAssetShowOptions,
+    IRWSConfig,
+    IRWSUser,
+    TagsProcessorType,
+    HTMLTagTransformerType,
+    HTMLTag,
+    HTMLAttributes
+}
+
 export { 
     RWSClient,
     RWSClientInstance,
@@ -43,11 +62,7 @@ export {
     RWSPlugin,
     IPluginSpawnOption,
     IRWSPlugin, IStaticRWSPlugin,
-    DefaultRWSPluginOptionsType,
-    
-    NotifyUiType,
-    NotifyLogType,
-
+    DefaultRWSPluginOptionsType,    
     ApiServiceInstance,
     ApiService,    
     UtilsServiceInstance,    
@@ -63,18 +78,7 @@ export {
     ServiceWorkerService,
 
     RWSNotify,
-    IBackendRoute as IRWSBackendRoute,
-    RWSDecoratorOptions as IRWSDecoratorOptions,
-    IHTTProute as IRWSHttpRoute,
-    IPrefixedHTTProutes as IRWSPrefixedHTTProutes,    
-    IAssetShowOptions as IRWSAssetShowOptions,
-    IRWSConfig,
-    IRWSUser,
-    TagsProcessorType,
-    HTMLTagTransformerType,
-    HTMLTag,
-    HTMLAttributes,
-         
+
     RWSView,
     sanitizedAttr,
     RWSIgnore,

package/src/services/ApiService.ts

@@ -1,3 +1,4 @@
+import { IKDBTypesResponse } from '../types/IBackendCore';
 import TheService from './_service';
 
 //@4DI
@@ -5,6 +6,8 @@ import ConfigService, { ConfigServiceInstance } from './ConfigService';
 
 import { upload, UploadResponse } from 'upload';
 
+import { backend } from './_api/backend';
+import { calls } from './_api/calls';
 
 interface RequestOptions {
     method?: string;
@@ -19,182 +22,49 @@ interface IAPIOptions {
     }, 
 }
 
-interface IHTTProute {
+interface IHTTProute<P = {[key: string]: any}> {
     name: string;
-    path: string;    
+    path: string;  
+    method: string;
+    noParams?: boolean;
+    options?: any;
+    plugins?: P
 }
 
-
-interface IPrefixedHTTProutes {
+interface IPrefixedHTTProutes<P = {[key: string]: any}> {
     prefix: string;
-    routes: IHTTProute[];
+    controllerName: string;
+    exportAutoRoutes?: boolean,
+    routes: IHTTProute<P>[];
 }
 
+
 type IBackendRoute = IHTTProute | IPrefixedHTTProutes;
 
 
-const _DEFAULT_CONTENT_TYPE = 'application/json';
 
 class ApiService extends TheService {
     static _DEFAULT: boolean = true;
     private token?: string;    
 
-    constructor(@ConfigService private config: ConfigServiceInstance) {
+    constructor(@ConfigService public config: ConfigServiceInstance) {
         super();        
     }
 
-    private addHeader(headers: Headers | [string, string][] | {[key: string]: string}, key: string, val: string)
-    {
-        if (headers instanceof Headers) {
-            headers.append(key, val);
-        } else if (Array.isArray(headers)) {
-            headers.push([key, val]);
-        } else {
-            headers[key] = val;
-        }
-    }
-
-    // Function to get headers
-    private getHeaders(optHeaders: HeadersInit = {}): HeadersInit {
-        const headers: HeadersInit = { ...optHeaders };                
-
-        if (!('Content-Type' in headers)) {
-            this.addHeader(headers, 'Content-Type', _DEFAULT_CONTENT_TYPE);
-        }            
- 
-        if (this.token) {
-            this.addHeader(headers, 'Authorization', `Bearer ${this.token}`);            
-        }        
-
-        if((headers as any)['Content-Type']){
-            this.addHeader(headers, 'Accept', '*/*');
-        }else{
-            this.addHeader(headers, 'Accept', (headers as any)['Content-Type']);
-        }
-
-        return headers;
-    }
-
     public setToken(token: string)
     {
         this.token = token;
     }
 
-    public async pureGet(url: string, options: IAPIOptions = {}): Promise<string> {
-        try {
-            const response = await fetch(url, {
-                headers: this.getHeaders(options.headers),
-            });
-            return await response.text();
-        } catch (error) {
-            console.error('GET request failed:', error);
-            throw error;
-        }
-    }
+    
 
     public async isGetTargetReachable(url: string, options: IAPIOptions = {}): Promise<boolean> {
         try {    
-            return !!(await this.pureGet(url, options));
+            return !!(await calls.pureGet(url, options, this.token));
         } catch (error) {
             return false;
         }
-    }
-
-    public async get<T>(url: string, options: IAPIOptions = {}): Promise<T> {
-        try {
-            const response = await fetch(url, {
-                headers: this.getHeaders(options.headers),
-            });
-            return await response.json();
-        } catch (error) {
-            console.error('GET request failed:', error);
-            throw error;
-        }
-    }
-    
-    public async post<T, P extends object = object>(url: string, payload?: P, options: IAPIOptions = {}): Promise<T> {
-        try {
-            const response = await fetch(url, {
-                method: 'POST',
-                headers: this.getHeaders(options.headers),
-                body: payload ? JSON.stringify(payload) : null,
-            });
-            return await response.json();
-        } catch (error) {
-            console.error('POST request failed:', error);
-            throw error;
-        }
-    }
-    
-    public async put<T, P extends object = object>(url: string, payload?: P, options: IAPIOptions = {}): Promise<T> {
-        try {
-            const response = await fetch(url, {
-                method: 'PUT',
-                headers: this.getHeaders(options.headers),
-                body: payload ? JSON.stringify(payload) : null,
-            });
-            return await response.json();
-        } catch (error) {
-            console.error('PUT request failed:', error);
-            throw error;
-        }
-    }
-    
-    public async delete<T>(url: string, options: IAPIOptions = {}): Promise<T> {
-        try {
-            const response = await fetch(url, {
-                method: 'DELETE',
-                headers: this.getHeaders(options.headers),
-            });
-            return await response.json();
-        } catch (error) {
-            console.error('DELETE request failed:', error);
-            throw error;
-        }
-    }
-
-    private getBackendUrl(routeName: string, params: {[key: string]: string} = {})
-    {
-       
-
-        const routesPackage = this.config.get('backendRoutes');
-
-        let routes: IHTTProute[] = [];       
-
-        routesPackage.forEach((item: IBackendRoute) => {
-            // Check if item is an instance of IPrefixedHTTProutes
-            if ('prefix' in item && 'routes' in item && Array.isArray(item.routes)) {
-                // Handle the case where item is of type IPrefixedHTTProutes
-                routes = [...routes, ...item.routes.map((subRouteItem: IHTTProute): IHTTProute => {
-                    const subRoute: IHTTProute = {
-                        path: item.prefix + subRouteItem.path,
-                        name: subRouteItem.name
-                    };
-            
-                    return subRoute;
-                })];
-            } else {
-                // Handle the case where item is of type IHTTProute
-                routes.push(item as IHTTProute);
-            }          
-        });        
-
-        const route = routes.find((item: IHTTProute) => item.name === routeName);        
-
-        if(!route){
-            throw new Error(`Backend route '${routeName}' does not exist.`);
-        }
-
-        let apiPath = route.path;
-
-        Object.keys(params).forEach((paramKey: string) => {
-            const paramValue = params[paramKey];
-
-            apiPath = apiPath.replace(`:${paramKey}`, paramValue);
-        });
-
-        return `${this.config.get('backendUrl')}${this.config.get('apiPrefix') || ''}${apiPath}`;
-    }
+    }    
 
     async uploadFile(url: string, file: File, onProgress: (progress: number) => void, payload: any = {}): Promise<UploadResponse>
     {
@@ -212,32 +82,25 @@ class ApiService extends TheService {
         );
     }
 
+    public pureGet = calls.pureGet;
+    public get = calls.get;
+    public post = calls.post;
+    public put = calls.put;
+    public delete = calls.delete;
+
     public back = {
-        get: <T>(routeName: string, options?: IAPIOptions): Promise<T> => this.get(this.getBackendUrl(routeName, options?.routeParams), options),
-        post: <T, P extends object = object>(routeName: string, payload?: P, options?: IAPIOptions): Promise<T> => this.post(this.getBackendUrl(routeName, options?.routeParams), payload, options),
-        put: <T, P extends object = object>(routeName: string, payload: P, options?: IAPIOptions): Promise<T> => this.put(this.getBackendUrl(routeName, options?.routeParams), payload, options),
-        delete: <T>(routeName: string, options?: IAPIOptions): Promise<T> => this.delete(this.getBackendUrl(routeName, options?.routeParams), options),
-        uploadFile: (routeName: string, file: File, onProgress: (progress: number) => void, options: IAPIOptions = {}, payload: any = {}): Promise<UploadResponse> => this.uploadFile(this.getBackendUrl(routeName, options?.routeParams), file, onProgress, payload),
+        get: <T>(routeName: string, options?: IAPIOptions): Promise<T> => calls.get(backend.getBackendUrl.bind(this)(routeName, options?.routeParams), options, this.token),
+        post: <T, P extends object = object>(routeName: string, payload?: P, options?: IAPIOptions): Promise<T> => calls.post(backend.getBackendUrl.bind(this)(routeName, options?.routeParams), payload, options, this.token),
+        put: <T, P extends object = object>(routeName: string, payload: P, options?: IAPIOptions): Promise<T> => calls.put(backend.getBackendUrl.bind(this)(routeName, options?.routeParams), payload, options, this.token),
+        delete: <T>(routeName: string, options?: IAPIOptions): Promise<T> => calls.delete(backend.getBackendUrl.bind(this)(routeName, options?.routeParams), options, this.token),
+        uploadFile: (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),
     };
 
-    connectToAmplify()
+    async getResource(resourceName: string): Promise<IKDBTypesResponse>
     {        
-        // "use client"       
-        // const client = generateClient<Schema>() // use this Data client for CRUDL requests
-        
-
-        // /*== STEP 3 ===============================================================
-        // Fetch records from the database and use them in your frontend component.
-        // (THIS SNIPPET WILL ONLY WORK IN THE FRONTEND CODE FILE.)
-        // =========================================================================*/
-
-        // /* For example, in a React component, you can use this snippet in your
-        // function's RETURN statement */
-        // // const { data: todos } = client.models.Todo.list()
-
-        // // return <ul>{todos.map(todo => <li key={todo.id}>{todo.content}</li>)}</ul>
+        return calls.get(`${this.config.get('backendUrl')}${this.config.get('apiPrefix') || ''}/api/rws/resource/${resourceName}`)
     }
 }
 
 export default ApiService.getSingleton();
-export { IBackendRoute, RequestOptions, ApiService as ApiServiceInstance, IHTTProute, IPrefixedHTTProutes };
+export { IBackendRoute, RequestOptions, ApiService as ApiServiceInstance, IHTTProute, IPrefixedHTTProutes, IAPIOptions };

package/src/services/_api/backend.ts

@@ -0,0 +1,88 @@
+import { ApiServiceInstance, IBackendRoute, IHTTProute } from "../ApiService";
+import { ConfigServiceInstance } from "../ConfigService";
+
+export const backend = {
+    getBackendUrl(this: ApiServiceInstance, routeName: string, params: {[key: string]: string} = {})
+    {       
+        const config = this.config;
+        const routesPackage = config.get('backendRoutes');
+
+        let routes: IHTTProute[] = [];       
+
+        routesPackage.forEach((item: IBackendRoute) => {
+            // Check if item is an instance of IPrefixedHTTProutes
+            if ('prefix' in item && 'routes' in item && Array.isArray(item.routes)) {
+                // Handle the case where item is of type IPrefixedHTTProutes
+                if(item.exportAutoRoutes){
+                    item.routes = [...item.routes, 
+                        {
+                            name: `list`,
+                            path: '/',
+                            method: 'GET'
+                        },
+                        {
+                            name: `create`,
+                            path: '/',
+                            method: 'POST'
+                        },
+                        {
+                            name: `show`,
+                            path: '/:id',
+                            method: 'GET'
+                        },                      
+                        {
+                            name: `update`,
+                            path: '/:id',
+                            method: 'PUT'
+                        },
+                        {
+                            name: `delete`,
+                            path: '/:id',
+                            method: 'DELETE'
+                        },
+                    ];
+                }
+
+                routes = [...routes, ...item.routes.map((subRouteItem: IHTTProute): IHTTProute => {
+                    const subRoute: IHTTProute = {
+                        path: item.prefix + subRouteItem.path,
+                        name: backend.checkPrefixedRouteName(subRouteItem.name, item.controllerName),
+                        method: subRouteItem.method || 'GET'
+                    };
+            
+                    return subRoute;
+                })];
+
+                console.log({routes});
+            } else {
+                // Handle the case where item is of type IHTTProute
+                routes.push(item as IHTTProute);
+            }          
+        });        
+
+        const route = routes.find((item: IHTTProute) => item.name === routeName);        
+
+        if(!route){
+            throw new Error(`Backend route '${routeName}' does not exist.`);
+        }
+
+        let apiPath = route.path;
+
+        Object.keys(params).forEach((paramKey: string) => {
+            const paramValue = params[paramKey];
+
+            apiPath = apiPath.replace(`:${paramKey}`, paramValue);
+        });
+
+        return `${config.get('backendUrl')}${config.get('apiPrefix') || ''}${apiPath}`;
+    },
+    checkPrefixedRouteName(routeName: string, prefixName: string){
+        let finalRoute = routeName;
+
+        if(routeName.indexOf(prefixName) === -1){
+            finalRoute = `${prefixName}:${routeName}`;
+        }
+
+        return finalRoute;
+    }
+}

package/src/services/_api/calls.ts

@@ -0,0 +1,95 @@
+import { IAPIOptions } from "../ApiService";
+
+const _DEFAULT_CONTENT_TYPE = 'application/json';
+
+export const calls = {
+    addHeader(headers: Headers | [string, string][] | {[key: string]: string}, key: string, val: string)
+    {
+        if (headers instanceof Headers) {
+            headers.append(key, val);
+        } else if (Array.isArray(headers)) {
+            headers.push([key, val]);
+        } else {
+            headers[key] = val;
+        }
+    },
+    getHeaders(token: string = null, optHeaders: HeadersInit = {}): HeadersInit {
+        const headers: HeadersInit = { ...optHeaders };                
+
+        if (!('Content-Type' in headers)) {
+            this.addHeader(headers, 'Content-Type', _DEFAULT_CONTENT_TYPE);
+        }            
+ 
+        if (token) {
+            this.addHeader(headers, 'Authorization', `Bearer ${token}`);            
+        }        
+
+        if((headers as any)['Content-Type']){
+            this.addHeader(headers, 'Accept', '*/*');
+        }else{
+            this.addHeader(headers, 'Accept', (headers as any)['Content-Type']);
+        }
+
+        return headers;
+    },
+    async pureGet(url: string, options: IAPIOptions = {}, token: string = null): Promise<string> {
+        try {
+            const response = await fetch(url, {
+                headers: this.getHeaders(token, options.headers),
+            });
+            return await response.text();
+        } catch (error) {
+            console.error('GET request failed:', error);
+            throw error;
+        }
+    },
+    async get<T>(url: string, options: IAPIOptions = {}, token: string = null): Promise<T> {
+        try {
+            const response = await fetch(url, {
+                headers: this.getHeaders(token, options.headers),
+            });
+            return await response.json();
+        } catch (error) {
+            console.error('GET request failed:', error);
+            throw error;
+        }
+    },    
+    async post<T, P extends object = object>(url: string, payload?: P, options: IAPIOptions = {}, token: string = null): Promise<T> {
+        try {
+            const response = await fetch(url, {
+                method: 'POST',
+                headers: this.getHeaders(token, options.headers),
+                body: payload ? JSON.stringify(payload) : null,
+            });
+            return await response.json();
+        } catch (error) {
+            console.error('POST request failed:', error);
+            throw error;
+        }
+    },    
+    async put<T, P extends object = object>(url: string, payload?: P, options: IAPIOptions = {}, token: string = null): Promise<T> {
+        try {
+            const response = await fetch(url, {
+                method: 'PUT',
+                headers: this.getHeaders(token, options.headers),
+                body: payload ? JSON.stringify(payload) : null,
+            });
+            return await response.json();
+        } catch (error) {
+            console.error('PUT request failed:', error);
+            throw error;
+        }
+    },    
+    async delete<T>(url: string, options: IAPIOptions = {}, token: string = null): Promise<T> {
+        try {
+            const response = await fetch(url, {
+                method: 'DELETE',
+                headers: this.getHeaders(token, options.headers),
+            });
+            return await response.json();
+        } catch (error) {
+            console.error('DELETE request failed:', error);
+            throw error;
+        }
+    }
+}

package/src/types/IBackendCore.ts

@@ -0,0 +1,12 @@
+export interface IKDBTypeInfo {
+    fieldName: string;
+    type: string;
+    boundModel?: string
+}
+
+export interface IKDBTypesResponse {
+    success: boolean;
+    data: {
+        types: IKDBTypeInfo[];
+    };
+}

package/src/types/IRWSResource.ts

@@ -0,0 +1,5 @@
+export interface IRWSResourceQuery {
+    fieldName: string,
+    type: String,
+    boundModel: string
+}