@rws-framework/client 2.15.5 → 2.16.0

package/builder/webpack/loaders/rws_fast_scss_loader.js

@@ -9,6 +9,7 @@ module.exports = async function(content) {
     const isDev = this._compiler.options.mode === 'development';    
     const saveFile = content.indexOf('@save') > -1; 
     const plugin = new RWSScssPlugin({
+        appRootDir: this.query?.appRootDir,
         rwsWorkspaceDir: this.query?.rwsWorkspaceDir
     }); 
     let fromTs = false;    

package/builder/webpack/loaders/rws_fast_ts_loader.js

@@ -61,6 +61,7 @@ module.exports = async function(content) {
     try { 
         if(tagName){                                   
             const [template, htmlFastImports, templateExists] = await LoadersHelper.getTemplate(filePath, this.addDependency, templateName, isDev);         
+
             const styles = await LoadersHelper.getStyles(filePath, this.query?.rwsWorkspaceDir, this.query?.appRootDir,this.addDependency, templateExists, stylesPath, isDev);  
 
             if(className){                
@@ -69,7 +70,7 @@ module.exports = async function(content) {
                 if(replacedViewDecoratorContent){
                     processedContent = `${template}\n${styles}\n${replacedViewDecoratorContent}`;
                 }                
-            }            
+            }
             
             processedContent = `${htmlFastImports ? htmlFastImports + '\n' : ''}${processedContent}`;
         }

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

@@ -63,12 +63,10 @@ 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, path.resolve(_MAIN_PACKAGE, 'node_modules'), executionDir) }  
+  aliases = { ...aliases, ...loadAliases(_packageDir, tsConfig,path.resolve(_MAIN_PACKAGE, 'node_modules'), executionDir) }  
 
   // #SECTION PLUGIN STARTING HOOKS
 
@@ -115,7 +113,7 @@ const RWSWebpackWrapper = async (appRoot, rwsFrontendConfig,  _packageDir) => {
   }
 
   // #SECTION RWS WEBPACK BUILD
-  const cfgExport = createWebpackConfig({
+  const cfgExport = await createWebpackConfig({
     executionDir,
     _packageDir,
     isDev,

package/builder/webpack/rws_scss_plugin.js

@@ -52,7 +52,7 @@ class RWSScssPlugin {
     scssPath = _scss_import.processImportPath(scssPath, this.getRWSWorkspaceDir(), this.getRWSRootDir(),path.dirname(scssPath))    
 
 
-    let scssCode = _scss_fs.getCodeFromFile(scssPath, this.getRWSWorkspaceDir());
+    let scssCode = _scss_fs.getCodeFromFile(scssPath, this.getRWSWorkspaceDir(), this.getRWSRootDir());
 
     return await _scss_compiler.compileScssCode(scssCode, path.dirname(scssPath), this.getRWSWorkspaceDir(), this.getRWSRootDir());
   }
@@ -70,7 +70,7 @@ class RWSScssPlugin {
   }
 
   getRWSRootDir() {
-    return this.rwsWorkspaceDir;
+    return this.appRootDir;
   }
 }
 

package/builder/webpack/scss/_import.js

@@ -13,9 +13,9 @@ function processImportPath(importPath, rwsWorkspaceDir, appRootDir, fileRootDir
     _scss_fs = _scss_fs_builder(this);
     const workspaceDir = this.getRWSWorkspaceDir ? this.getRWSWorkspaceDir() : rwsWorkspaceDir;
     const appRoot = this.getRWSWorkspaceDir ? this.getRWSRootDir() : appRootDir;
-
+  
     if (importPath.split('')[0] === '~') {
-        return fillSCSSExt(replaceWithNodeModules(importPath, appRootDir, null, true), noext);
+        return fillSCSSExt(replaceWithNodeModules(importPath, appRoot, null, true), noext);
     }
 
     if (importPath.indexOf('@rws-mixins') === 0) {
@@ -67,26 +67,6 @@ function underscorePath(path, noext = false) {
     return partSplit.join('/');
 }
 
-function fillSCSSExt(scssPath, noext = false) {
-    const underscoredPath = underscorePath(scssPath, noext);
-    if (!fs.existsSync(scssPath) && fs.existsSync(underscoredPath)) {
-        return underscoredPath;
-    }
-
-    if (noext) {
-        return scssPath;
-    }
-
-    if ((!fs.existsSync(scssPath) || (fs.existsSync(scssPath) && fs.statSync(scssPath).isDirectory())) && fs.existsSync(`${scssPath}.scss`)) {
-        return `${scssPath}.scss`;
-    }
-
-    if (fs.existsSync(`_${scssPath}.scss`)) {
-        return `${scssPath}.scss`;
-    }
-
-    return scssPath;
-}
 
 function fillSCSSExt(scssPath, noext = false) {
     const underscoredPath = underscorePath(scssPath, noext);
@@ -157,7 +137,8 @@ function detectImports(code) {
 
 function replaceWithNodeModules(input, appRootDir, fileDir = null, absolute = false, token = '~') {
     _scss_fs = _scss_fs_builder(this);
-    return input.replace(token, absolute ? `${path.resolve(appRootDir, 'node_modules')}/` : this.node_modules_dir(fileDir ? fileDir : appRootDir));
+   
+    return input.replace(token, absolute ? `${path.join(appRootDir, 'node_modules')}/` : this.node_modules_dir(fileDir ? fileDir : appRootDir));
 }
 
 function processImports(imports, fileRootDir, rwsWorkspaceDir, importStorage = {}, sub = false) {
@@ -184,8 +165,8 @@ function processImports(imports, fileRootDir, rwsWorkspaceDir, importStorage = {
         const appRoot = this.getRWSWorkspaceDir ? this.getRWSRootDir() : importData[4];
 
         let importPath = processImportPath(originalImportPath, workspaceDir, appRoot, fileRootDir);            
-
-        let replacedScssContent = getStorage(importPath, _scss_fs.getCodeFromFile(importPath, workspaceDir).replace(/\/\*[\s\S]*?\*\//g, ''));
+      
+        let replacedScssContent = getStorage(importPath, _scss_fs.getCodeFromFile(importPath, workspaceDir, appRoot).replace(/\/\*[\s\S]*?\*\//g, ''));
 
         const recursiveImports = extractScssImports(replacedScssContent, workspaceDir, appRoot, importPath)[0];
 

package/cfg/build_steps/vite/_build_config.ts

@@ -1,8 +1,8 @@
 import chalk from 'chalk';
 import { RWSConfigBuilder, rwsPath } from '@rws-framework/console';
-import { _DEFAULT_CONFIG } from '../../_default.cfg';
+// import { _DEFAULT_CONFIG } from '../../_default.cfg';
 
-import { IRWSPlugin } from '../../../src/types/IRWSPlugin';
+import { IPluginSpawnOption, IRWSPlugin, IStaticRWSPlugin } from '../../../src/types/IRWSPlugin';
 
 interface IRWSViteConfig {
   executionDir: string;
@@ -24,25 +24,23 @@ interface IRWSViteConfig {
   devDebug?: any,
   devRouteProxy?: any,
   tsConfigPath: string,
-  rwsPlugins?: {
-    [key: string]: IRWSPlugin
-  },
+  rwsPlugins?: IPluginSpawnOption<any>[],
   _packageDir?: string,
   BuildConfigurator: RWSConfigBuilder<any>
 }
 
-async function getBuildConfig(rwsFrontBuildConfig): Promise<IRWSViteConfig>
+async function getBuildConfig(rwsFrontBuildConfig: Partial<IRWSViteConfig>): Promise<IRWSViteConfig>
 {
-    const BuildConfigurator = new RWSConfigBuilder(rwsPath.findPackageDir(process.cwd()) + '/.rws.json', {..._DEFAULT_CONFIG, ...rwsFrontBuildConfig});
+    const BuildConfigurator = new RWSConfigBuilder(rwsPath.findPackageDir(process.cwd()) + '/.rws.json', {...rwsFrontBuildConfig});
     const _packageDir = rwsPath.findPackageDir(process.cwd());
 
     const executionDir = rwsPath.relativize(BuildConfigurator.get('executionDir') || rwsFrontBuildConfig.executionDir || process.cwd(), _packageDir);
     const isWatcher = process.argv.includes('--watch') || false;  
 
-    const isDev = isWatcher ? true : (BuildConfigurator.get('dev', rwsFrontBuildConfig.dev) || false);
-    const isHotReload = BuildConfigurator.get('hot', rwsFrontBuildConfig.hot);
-    const isReport = BuildConfigurator.get('report', rwsFrontBuildConfig.report);
-    const isParted = BuildConfigurator.get('parted', rwsFrontBuildConfig.parted || false);
+    const isDev = isWatcher ? true : (BuildConfigurator.get('dev', rwsFrontBuildConfig.isDev) || false);
+    const isHotReload = BuildConfigurator.get('isHotReload', rwsFrontBuildConfig.isHotReload);
+    const isReport = BuildConfigurator.get('isReport', rwsFrontBuildConfig.isReport);
+    const isParted = BuildConfigurator.get('isParted', rwsFrontBuildConfig.isParted || false);
 
     const partedPrefix = BuildConfigurator.get('partedPrefix', rwsFrontBuildConfig.partedPrefix);
     const partedDirUrlPrefix = BuildConfigurator.get('partedDirUrlPrefix', rwsFrontBuildConfig.partedDirUrlPrefix);
@@ -53,7 +51,7 @@ async function getBuildConfig(rwsFrontBuildConfig): Promise<IRWSViteConfig>
 
     const outputFileName = BuildConfigurator.get('outputFileName') || rwsFrontBuildConfig.outputFileName;
     const publicDir = BuildConfigurator.get('publicDir') || rwsFrontBuildConfig.publicDir;
-    const serviceWorkerPath = BuildConfigurator.get('serviceWorker') || rwsFrontBuildConfig.serviceWorker;
+    const serviceWorkerPath = BuildConfigurator.get('serviceWorkerPath') || rwsFrontBuildConfig.serviceWorkerPath;
 
     const publicIndex = BuildConfigurator.get('publicIndex') || rwsFrontBuildConfig.publicIndex;
 
@@ -68,14 +66,14 @@ async function getBuildConfig(rwsFrontBuildConfig): Promise<IRWSViteConfig>
 
     const tsConfigPath = rwsPath.relativize(BuildConfigurator.get('tsConfigPath') || rwsFrontBuildConfig.tsConfigPath, executionDir);
 
-    const rwsPlugins = {};
+    const rwsPlugins: IPluginSpawnOption<any>[] = [];
 
-    if(rwsFrontBuildConfig.rwsPlugins){
-        for(const pluginEntry of rwsFrontBuildConfig.rwsPlugins){
-          const pluginBuilder = (await import(`${pluginEntry}`)).default;      
-          rwsPlugins[pluginEntry] = new pluginBuilder(BuildConfigurator, rwsFrontBuildConfig);
-        }
-      }
+    // if(rwsFrontBuildConfig.rwsPlugins){
+    //     for(const pluginEntry of Object.values(rwsFrontBuildConfig.rwsPlugins)){
+    //       const pluginBuilder = (await import(`${pluginEntry}`)).default as IStaticRWSPlugin<any>;      
+    //       rwsPlugins[pluginEntry] = new pluginBuilder(BuildConfigurator, rwsFrontBuildConfig);
+    //     }
+    //   }
 
     return {
         executionDir,

package/cfg/build_steps/vite/index.ts

@@ -1,3 +1,3 @@
-import { createViteConfig } from './vite_config';
+import { getBuildConfig } from './_build_config';
 
-export { createViteConfig };
+export { getBuildConfig };

package/cfg/build_steps/webpack/_aliases.js

@@ -1,9 +1,22 @@
 const path = require('path');
 
-function loadAliases(packageDir, nodeModulesPath, srcDir){    
+function loadAliases(packageDir, tsConfig, nodeModulesPath, executionDir){  
+    
+    const tsPaths = {}
+
+    for(const aliasKey of Object.keys(tsConfig.config.compilerOptions.paths)){
+        const alias = tsConfig.config.compilerOptions.paths[aliasKey];
+        tsPaths[aliasKey] = path.resolve(executionDir, alias[0]);
+    }
+  
     return {        
-        '@rws-framework/foundation': path.resolve(packageDir, 'foundation', 'rws-foundation.js')
+        ...tsPaths,
+        '@rws-framework/foundation': path.resolve(packageDir, 'foundation', 'rws-foundation.js'),
+        '@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/_build_config.js

@@ -5,6 +5,7 @@ const { RWSConfigBuilder } = require('@rws-framework/console')
 const { rwsPath } = require('@rws-framework/console');
 const { _DEFAULT_CONFIG } = require('../../_default.cfg');
 
+
 async function getBuildConfig(rwsFrontBuildConfig, _packageDir){
     const BuildConfigurator = new RWSConfigBuilder(path.join(rwsPath.findPackageDir(process.cwd()), '.rws.json'), {..._DEFAULT_CONFIG, ...rwsFrontBuildConfig});
     const executionDir = rwsPath.relativize(BuildConfigurator.get('executionDir') || rwsFrontBuildConfig.executionDir || process.env.RWS_APP_ROOT || process.cwd(), _packageDir);
@@ -37,7 +38,7 @@ async function getBuildConfig(rwsFrontBuildConfig, _packageDir){
 
     const devRouteProxy = BuildConfigurator.get('devRouteProxy') || rwsFrontBuildConfig.devRouteProxy;
 
-    const tsConfig = BuildConfigurator.get('tsConfig') || rwsFrontBuildConfig.tsConfig;
+    const tsConfig = await (BuildConfigurator.get('tsConfig') || rwsFrontBuildConfig.tsConfig)(_packageDir, true, false);
 
     const rwsPlugins = {};
 

package/cfg/build_steps/webpack/_env_defines.js

@@ -10,8 +10,14 @@ function processEnvDefines(BuildConfigurator, config, devDebug) {
     const rwsDefines = BuildConfigurator.get('env') || config.env || null;
 
     if (rwsDefines) {
-        _rws_defines = { ..._rws_defines, ...rwsDefines }
+        const stringifiedDefines = Object.entries(rwsDefines).reduce((acc, [key, value]) => ({
+            ...acc,
+            [`process.env.${key}`]: JSON.stringify(value)
+        }), {});
+        _rws_defines = { ..._rws_defines, ...stringifiedDefines }
     }
+    
+    console.log({_rws_defines});
 
     return _rws_defines;
 }

package/cfg/build_steps/webpack/_info.js

@@ -17,7 +17,7 @@ module.exports = {
         plugins: rwsPlugins
         });
 
-        console.log(chalk.blue('\nTSCONFIG:'), util.inspect(tsConfig, {
+        console.log(chalk.blue('\nTSCONFIG:'), util.inspect(tsConfig.config, {
             depth: null,
             colors: true,
             maxArrayLength: null

package/cfg/build_steps/webpack/_loaders.js

@@ -10,12 +10,21 @@ const chalk = require('chalk');
 const { timingCounterStart, timingCounterStop } = require('./_timing');
 const { rwsRuntimeHelper, rwsPath } = require('@rws-framework/console');
 
-function getRWSLoaders(packageDir, executionDir, tsConfig, appRootDir, entrypoint) {
+function getRWSLoaders(packageDir, executionDir, tsConfigData, appRootDir, entrypoint) {
   const scssLoader = path.join(packageDir, 'builder/webpack/loaders/rws_fast_scss_loader.js');
   const tsLoader = path.join(packageDir, 'builder/webpack/loaders/rws_fast_ts_loader.js');
   const htmlLoader = path.join(packageDir, 'builder/webpack/loaders/rws_fast_html_loader.js');
 
+  const tsConfigPath = tsConfigData.path;
+
   const loaders = [
+    {
+      test: /\.json$/,
+      type: 'javascript/auto',
+      include: [
+        path.resolve(appRootDir, 'node_modules/entities/lib/maps')
+      ],
+    },
     {
       test: /\.html$/,
       use: [
@@ -30,14 +39,20 @@ function getRWSLoaders(packageDir, executionDir, tsConfig, appRootDir, entrypoin
         {
           loader: 'ts-loader',
           options: {
-            ...tsConfig,
-            configFile: false,
+            configFile: tsConfigPath, 
+            compilerOptions: {
+                emitDecoratorMetadata: true,
+                experimentalDecorators: true,
+                target: "ES2018",
+                module: "commonjs"
+            },            
             transpileOnly: false, 
             logLevel: "info",
             logInfoToStdOut: true,
             context: executionDir,
             errorFormatter: (message, colors) => {
-              const messageText = message.message || message;
+              console.log({message});
+              const messageText = typeof message === 'object' ? JSON.stringify(message, null, 2) : message;
               return `\nTS Error: ${messageText}\n`;
             },         
           }
@@ -51,20 +66,25 @@ function getRWSLoaders(packageDir, executionDir, tsConfig, appRootDir, entrypoin
         }
       ],
       include: [
-        path.resolve(executionDir, 'src'),
-        path.resolve(packageDir, 'src'),
-        path.resolve(packageDir, 'foundation', 'rws-foundation.d.ts')
+        ...tsConfigData.includes.map(item => item.abs()),
+        path.resolve(packageDir, 'foundation', 'rws-foundation.d.ts')            
       ],
-      exclude: [        
-        /node_modules\/(?!\@rws-framework\/[A-Z0-9a-z])/,
+      exclude: [
+        ...tsConfigData.excludes.map(item => item.abs()),
         /\.debug\.ts$/,
         /\.d\.ts$/        
-      ],
+      ]     
     },
     {
       test: /\.scss$/i,
       use: [
-        scssLoader,
+        {
+          loader: scssLoader,
+          options: {
+            rwsWorkspaceDir: executionDir,
+            appRootDir
+          }
+        },
       ],
     },
   ];
@@ -243,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

@@ -12,7 +12,7 @@ const _defaultOpts = {
   }
 }
 
-const externals = (pkgPath, declaredCodeBase, nodeModules, automatedChunks, externalOptions = _defaultOpts) => ({context, request}, callback) => {
+const externals = (declaredCodeBase, nodeModules, automatedChunks, externalOptions = _defaultOpts) => ({context, request}, callback) => {
     let theOptions = _defaultOpts;
 
     if(externalOptions !== null){      
@@ -21,24 +21,24 @@ const externals = (pkgPath, declaredCodeBase, nodeModules, automatedChunks, exte
 
     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/
+      /\@microsoft\/fast-foundation\/.*\/foundation-element/,      
     ]
 
     const frontendDirs = [
       codeBase,
-      pkgPath
+      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/cfg/build_steps/webpack/_webpack_config.js

@@ -1,7 +1,8 @@
 const { getRWSLoaders } = require('./_loaders');
 const path = require('path');
 
-function createWebpackConfig({
+
+async function createWebpackConfig({
     executionDir,
     _packageDir,
     isDev,
@@ -20,7 +21,8 @@ function createWebpackConfig({
     devExternalsVars,
     appRootDir,
     entrypoint
-}) {
+}) { 
+
     return {
         context: executionDir,
         entry: {
@@ -39,15 +41,19 @@ function createWebpackConfig({
             modules: modules_setup,
             alias: {
                 ...aliases
+            },
+            fallback: {                
+                fs: false,
+                path: false
             }
         },
         module: {
             rules: getRWSLoaders(_packageDir, executionDir, tsConfig, appRootDir, entrypoint),
         },
         plugins: WEBPACK_PLUGINS,
-        externals: rwsExternals(_packageDir, executionDir, modules_setup, automatedChunks, {
-            _vars: devExternalsVars
-        })      
+        // externals: rwsExternals(_packageDir, executionDir, modules_setup, automatedChunks, {
+        //     _vars: devExternalsVars
+        // })      
     }
 }
 

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "@rws-framework/client",
     "private": false,
-    "version": "2.15.5",
+    "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/config.ts

@@ -4,6 +4,7 @@ import { RWSClientInstance } from "../client";
 import { RWSPlugin, DefaultRWSPluginOptionsType } from "../plugins/_plugin";
 import RWSWindow, {loadRWSRichWindow } from '../types/RWSWindow';
 import deepmerge from 'deepmerge';
+import { IPluginSpawnOption } from "../types/IRWSPlugin";
 
 type RWSInfoType = { components: string[] };
 
@@ -72,15 +73,12 @@ function get(this: RWSClientInstance, key: string): any | null
     return null;
 }
 
-type PluginConstructor<T extends DefaultRWSPluginOptionsType> = new (options: T) => RWSPlugin<T>;
-type RWSPluginEntry<T extends DefaultRWSPluginOptionsType = DefaultRWSPluginOptionsType> = IStaticRWSPlugin<T>;
-
-function addPlugin<T  extends DefaultRWSPluginOptionsType>(this: RWSClientInstance, pluginEntry: RWSPluginEntry){
+function addPlugin<T  extends DefaultRWSPluginOptionsType>(this: RWSClientInstance, pluginEntry: IPluginSpawnOption<T>){
     const rwsWindow: RWSWindow = loadRWSRichWindow();
-    const pluginClass: PluginConstructor<T> = (Array.isArray(pluginEntry) ? pluginEntry[0] : pluginEntry) as unknown as PluginConstructor<T>;
+    const pluginClass: IStaticRWSPlugin<T> = pluginEntry.pluginEntry;
     const pluginOptions: T = (Array.isArray(pluginEntry) ? pluginEntry[1] : { enabled: true }) as T;
 
-    if(!Object.keys(rwsWindow.RWS.plugins).includes(pluginClass.name)){       
+    if(!Object.keys(rwsWindow.RWS.plugins).find(item => { item === pluginClass.name })){
         const pluginInstance: RWSPlugin<T> = new pluginClass(pluginOptions);
         this.plugins[pluginClass.name] = pluginInstance; 
         rwsWindow.RWS.plugins[pluginClass.name] = pluginInstance;

package/src/client.ts

@@ -1,4 +1,4 @@
-import IRWSConfig, { RWSPluginEntry } from './types/IRWSConfig';
+import IRWSConfig from './types/IRWSConfig';
 
 import RWSNotify from './types/RWSNotify';
 
@@ -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;
 
@@ -74,9 +66,9 @@ class RWSClient {
         }        
     }
 
-    addPlugin<T extends DefaultRWSPluginOptionsType>(pluginEntry: IStaticRWSPlugin)
+    addPlugin<T extends DefaultRWSPluginOptionsType>(pluginEntry: IStaticRWSPlugin<T>, options?: T)
     {        
-        this.config.plugins.push(pluginEntry);
+        this.config.plugins.push({pluginEntry, options});
     }
 
     async setup(config: IRWSConfig = {}): Promise<IRWSConfig> {
@@ -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/components/_container.ts

@@ -1,4 +1,4 @@
-import {DI, Container, Registration } from '../../foundation/rws-foundation';
+import {DI, Container, Registration, InterfaceSymbol, Key } from '../../foundation/rws-foundation';
 import {loadRWSRichWindow} from '../types/RWSWindow';
 
 export default () => {
@@ -13,4 +13,4 @@ export default () => {
     return richWindow.RWS.container;
 };
 
-export { DI, Container, Registration }
+export { DI, Container, Registration, InterfaceSymbol, Key }

package/src/index.ts

@@ -21,9 +21,8 @@ import { RWSPlugin } from './plugins/_plugin';
 
 import type { DefaultRWSPluginOptionsType } from './plugins/_plugin';
 
-import type { IRWSPlugin, IStaticRWSPlugin } from './types/IRWSPlugin';
+import type { IRWSPlugin, IStaticRWSPlugin, IPluginSpawnOption } from './types/IRWSPlugin';
 import RWSClient, { RWSClientInstance } from './client';
-import type  { RWSPluginEntry } from './types/IRWSConfig';
 import type IRWSUser from './types/IRWSUser';
 import RWSViewComponent from './components/_component';
 import type { IAssetShowOptions } from './components/_component';
@@ -31,24 +30,39 @@ 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,
 
     RWSPlugin,
-    RWSPluginEntry,
+    IPluginSpawnOption,
     IRWSPlugin, IStaticRWSPlugin,
-    DefaultRWSPluginOptionsType,
-    
-    NotifyUiType,
-    NotifyLogType,
-
+    DefaultRWSPluginOptionsType,    
     ApiServiceInstance,
     ApiService,    
     UtilsServiceInstance,    
@@ -64,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/plugins/_plugin.ts

@@ -3,62 +3,59 @@ import { Container } from "../components/_container";
 import RWSWindow, {loadRWSRichWindow } from '../types/RWSWindow';
 import IRWSUser from "../types/IRWSUser";
 import { RWSInfoType } from "../client/components";
-import { IRWSPlugin } from "../types/IRWSPlugin";
+import { IRWSPlugin, IStaticRWSPlugin } from "../types/IRWSPlugin";
 
-type DefaultRWSPluginOptionsType = { enabled: boolean };
-type PluginInfoType = { name: string }
+export type DefaultRWSPluginOptionsType = { enabled?: boolean };
+type PluginInfoType = { name: string };
 type PluginConstructor<T extends DefaultRWSPluginOptionsType> = new (options: T) => RWSPlugin<T>;
-abstract class RWSPlugin<PluginOptions extends DefaultRWSPluginOptionsType> implements IRWSPlugin{
+
+abstract class RWSPlugin<T extends DefaultRWSPluginOptionsType> extends IRWSPlugin<T> {
     protected isLoaded: boolean = false;
-    protected options: PluginOptions;
-    protected container: Container;    
-    protected window: RWSWindow;
+    protected options!: T;
+    protected container!: Container;    
+    protected window!: RWSWindow;
 
     static container: Container;    
     static window: RWSWindow;
 
-    constructor(options: PluginOptions = { enabled: false } as PluginOptions){
+    constructor(options: T = { enabled: true } as T) {
+        super();
         this.isLoaded = true;
         this.container = RWSPlugin.container;
         this.window = RWSPlugin.window;
         this.options = options;
     }
 
-    async onClientStart(): Promise<void>
-    {
-        
+    async onClientStart(): Promise<void> {
+        // Implementation
     }
 
-    async onPartedComponentsLoad(componentParts: RWSInfoType): Promise<void>
-    {
-        
+    async onPartedComponentsLoad(componentParts: RWSInfoType): Promise<void> {
+        // Implementation
     }
 
-    async onComponentsDeclare(): Promise<void>
-    {
-        
+    async onComponentsDeclare(): Promise<void> {
+        // Implementation
     }
 
-    async onSetUser(user: IRWSUser): Promise<void>{
-
+    async onSetUser(user: IRWSUser): Promise<void> {
+        // Implementation
     }
-
     
-    
-    static getPlugin<Plugin extends RWSPlugin<T>, T extends DefaultRWSPluginOptionsType = DefaultRWSPluginOptionsType>(pluginClass: PluginConstructor<T>): Plugin | null 
-    {
+    static getPlugin<P extends RWSPlugin<T>, T extends DefaultRWSPluginOptionsType = DefaultRWSPluginOptionsType>(
+        pluginClass: IStaticRWSPlugin<T>
+    ): P | null {
         const plugin = this.window.RWS.plugins[pluginClass.name];
-        return plugin ? plugin as Plugin : null;
+        return plugin ? plugin as P : null;
     }
 
-
-    static getAllPlugins(): RWSPlugin<DefaultRWSPluginOptionsType>[]
-    {
-        return Object.keys(this.window.RWS.plugins).map((key) => this.window.RWS.plugins[key]);
+    static getAllPlugins(): Array<RWSPlugin<DefaultRWSPluginOptionsType>> {
+        return Object.keys(this.window.RWS.plugins)
+            .map((key) => this.window.RWS.plugins[key]);
     }
 }
 
 RWSPlugin.window = loadRWSRichWindow();
 RWSPlugin.container = RWSContainer();
 
-export { RWSPlugin, DefaultRWSPluginOptionsType }
+export { RWSPlugin };

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/ConfigService.ts

@@ -68,15 +68,6 @@ class ConfigService extends TheService {
     public set<V extends keyof IRWSConfig>(key: V, value: IRWSConfig[V]){
         this.data[key] = value;
     }
-  
-    public async reloadConfig(cfgString: string): Promise<ConfigService> 
-    {
-        const module = await import(/* webpackIgnore: true */ cfgString);
-        const cfg: () => IRWSConfig = module.defaults;      
-        this.data = cfg();
-  
-        return this;
-    }
 
     async waitForConfig(tagName: string): Promise<boolean>
     {        

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/IRWSConfig.ts

@@ -1,10 +1,7 @@
 import RWSViewComponent from '../components/_component';
-import { RWSPlugin, DefaultRWSPluginOptionsType } from '../plugins/_plugin';
-import { IStaticRWSPlugin } from './IRWSPlugin';
+import { IPluginSpawnOption } from './IRWSPlugin';
 
 export type IFrontRoutes = Record<string, unknown>; 
-export type RWSPluginEntry<T extends DefaultRWSPluginOptionsType = DefaultRWSPluginOptionsType> = new (...args: any[]) => RWSPlugin<T>;
-
 export default interface IRWSConfig {
     [key: string]: any
     dev?: boolean
@@ -25,7 +22,7 @@ export default interface IRWSConfig {
     rwsDefines?: {[key: string]: any}
     partedFileDir?: string
     partedPrefix?: string
-    plugins?: IStaticRWSPlugin[]
+    plugins?: IPluginSpawnOption<any>[]
     routing_enabled?: boolean
     _noLoad?: boolean    
 }

package/src/types/IRWSPlugin.ts

@@ -1,19 +1,24 @@
-import { DefaultRWSPluginOptionsType } from "../plugins/_plugin";
+import { DefaultRWSPluginOptionsType, RWSPlugin } from "../plugins/_plugin";
 import IRWSUser from "./IRWSUser";
 import { Container } from "../components/_container";
 import RWSWindow from "./RWSWindow";
 import { RWSInfoType } from "../client/components";
 
+export abstract class IRWSPlugin<T extends DefaultRWSPluginOptionsType> {
+    abstract onClientStart(): Promise<void>;
+    abstract onPartedComponentsLoad(componentParts: RWSInfoType): Promise<void>;
+    abstract onComponentsDeclare(): Promise<void>;
+    abstract onSetUser(user: IRWSUser): Promise<void>;    
+    protected abstract options: T;
+    protected abstract container: Container;
+    protected abstract window: RWSWindow;
+}
 
-export interface IRWSPlugin {
-    onClientStart(): Promise<void>
-    onPartedComponentsLoad(componentParts: RWSInfoType): Promise<void>
-    onComponentsDeclare(): Promise<void>
-    onSetUser(user: IRWSUser): Promise<void>
+export interface IStaticRWSPlugin<T extends DefaultRWSPluginOptionsType> {    
+    new (options: T): RWSPlugin<T>;    
 }
 
-export interface IStaticRWSPlugin<PluginOptions extends DefaultRWSPluginOptionsType = DefaultRWSPluginOptionsType> {    
-    new (...args: any[]): IRWSPlugin;
-    container: Container;    
-    window: RWSWindow;
+export interface IPluginSpawnOption<T extends DefaultRWSPluginOptionsType = DefaultRWSPluginOptionsType> { 
+    pluginEntry: IStaticRWSPlugin<T>;
+    options?: T;
 }

package/src/types/IRWSResource.ts

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