@lcap/nasl 3.7.0-alpha.1 → 3.7.0-beta.1

package/src/generator/genBundleFiles.ts

@@ -1,6 +1,7 @@
 import * as JSON5 from 'json5';
 import * as UglifyJS from 'uglify-js-export';
 import * as utils from '../utils';
+import { config as globalConfig } from '../config'
 
 import { genBreakpoints, clearBreakpoints } from '../breakpoint';
 
@@ -32,9 +33,11 @@ interface Config {
   tenantType: any;
   tenantLevel: any;
   appid: string;
+  isExport?:string;
   devDnsAddr: string;
   miniEnable: boolean;
   isPreviewFe?: boolean;
+  previewVersion?: string;
 }
 
 // 将metaData转成字符串
@@ -93,6 +96,9 @@ export function genBundleFiles(app: App, frontend: Frontend, config: Config) {
   const fnLowcodeDomain = config?.envLcpDomain?.[config?.env]?.lcpDomain || config?.lowcodeDomain;
   const modules: (Module | Connector)[] = [];
   const views: View[] = [];
+
+  const STATIC_URL = config.isExport ? '' : config.STATIC_URL;
+
   app.dependencies && modules.push(...app.dependencies);
   app.interfaceDependencies && modules.push(...app.interfaceDependencies);
   frontend.views && views.push(...frontend.views);
@@ -104,28 +110,31 @@ export function genBundleFiles(app: App, frontend: Frontend, config: Config) {
     [name: string]: RawOptions;
   } = {};
 
-  config?.debug && genBreakpoints(app);
-
-  utils.traverse(
-    (current) => {
-      if (current.node.toVueOptions) componentMap[current.node.id] = current.node.toVueOptions();
-    },
-    {
-      node: {
-        children: views,
-      } as View,
-    }
-  );
-
   // 需要放在清除断点节点之前
   let compRegStr = '';
-  businessComponents.forEach((businessComponent) => {
-    const vueOptions = businessComponent.toVueOptions();
-    const component = compileComponent(vueOptions);
-    compRegStr += `window.Vue.component('bs-${businessComponent.name}', ${genComponetCode(component)},\n);`;
-  });
 
-  config?.debug && clearBreakpoints(app);
+  try {
+    config?.debug && genBreakpoints(app);
+
+    utils.traverse(
+      (current) => {
+        if (current.node.toVueOptions) componentMap[current.node.id] = current.node.toVueOptions();
+      },
+      {
+        node: {
+          children: views,
+        } as View,
+      }
+    );
+
+    businessComponents.forEach((businessComponent) => {
+      const vueOptions = businessComponent.toVueOptions();
+      const component = compileComponent(vueOptions);
+      compRegStr += `window.Vue.component('bs-${businessComponent.name}', ${genComponetCode(component)},\n);`;
+    });
+  } finally {
+    config?.debug && clearBreakpoints(app);
+  }
 
   /**
    * vue.config.js page options
@@ -353,7 +362,7 @@ export function genBundleFiles(app: App, frontend: Frontend, config: Config) {
   const metaData = genMetaData(app, frontend, config);
   const metaDataStr = stringifyMetaData(metaData);
 
-  const assetsInfo = app.genAllAssetsInfo(config.STATIC_URL, frontend.type);
+  const assetsInfo = app.genAllAssetsInfo(STATIC_URL, frontend.type);
   const customNames = JSON5.stringify(assetsInfo.custom.names);
 
 
@@ -362,7 +371,8 @@ export function genBundleFiles(app: App, frontend: Frontend, config: Config) {
   if (frontend.globalScaleEnabled) {
     content += `{
             // 如果是顶层页面，才使用iframe缩放，否则会死循环
-            if(window.parent === window){
+            // 如果不是登录页面，才使用iframe缩放，否则会拒绝连接
+            if(window.parent === window && location.pathname !== '/login'){
                 // 顶层页面里有个iframe，用来缩放页面
                 document.body.innerHTML = '<iframe src="' + location.href + '"></iframe>';
                 const iframe = document.querySelector('iframe');
@@ -384,6 +394,8 @@ export function genBundleFiles(app: App, frontend: Frontend, config: Config) {
                         marginRight = (scale - 1)/scale * 100 + '%';
                         // 由于 marginBottom 的百分比也是基于宽度的，因此需要乘以 windowHeight / windowWidth
                         marginBottom = (scale - 1)/scale * windowHeight / windowWidth * 100 + '%';
+                        // 消除白边，暂时没有找到原因，临时处理 bugid: 2765692131244288
+                        marginBottom = 'calc(' + marginBottom + ' - 10px)';
                     }
                     iframe.style.marginRight = marginRight;
                     iframe.style.marginBottom = marginBottom;
@@ -615,17 +627,29 @@ export function genBundleFiles(app: App, frontend: Frontend, config: Config) {
          `;
     content += str;
   }
-  const baseUrl = `${config.USER_STATIC_URL}/${config.tenant}/${app.id}/${config.env}`;
-  let bundleMinPath = `${baseUrl}/${config.isPreviewFe?'mockBundle':'bundle'}.${genHash(content)}.min.js`;
-  if (frontend.basePath) {
-    bundleMinPath = `${baseUrl}${frontend.basePath}/${config.isPreviewFe?'mockBundle':'bundle'}.${genHash(content)}.min.js`;
+  const getBundleFileName =()=>{
+    if(config.isPreviewFe && config.previewVersion){
+      return `mockBundle-${config.previewVersion}`
+    }else {
+      return 'bundle'
+    }
+  }
+  let baseUrl = `${config.STATIC_URL}/${config.tenant}/${app.id}/${config.env}`;
+  let { basePath } = frontend;
+
+  if((config.isExport)as any){
+      baseUrl = '';
+      // basePath = '';
   }
+
+  let bundleMinPath = `${baseUrl}${basePath || ''}/${getBundleFileName()}.${genHash(content)}.min.js`;
+
   const otherJsList = (frontend as any)?.appletsConfig?.enable ? ['//res.wx.qq.com/open/js/jweixin-1.3.2.js'] : [];
 
   const microAppIntegration = integrateMicroApp(frontend);
 
   if (config?.debug) {
-    otherJsList.push(`${config.STATIC_URL}/packages/@lcap/breakpoint-client@1.0.0/dist/index.js?time=${Date.now()}`);
+    otherJsList.push(`${STATIC_URL}/packages/@lcap/breakpoint-client@1.0.0/dist/index.js?time=${Date.now()}`);
   }
   let jsAssetsList = assetsInfo.basic.js.concat(assetsInfo.custom.js, otherJsList).concat([bundleMinPath])
   // if(!config.isPreviewFe){
@@ -634,18 +658,94 @@ export function genBundleFiles(app: App, frontend: Frontend, config: Config) {
   let cssAssetsList = assetsInfo.basic.css.concat(assetsInfo.custom.css)
   if(config.isPreviewFe){
     const changeToRelativePath =(str:any)=>{
-      let pathname = new URL(`http:${str}`).pathname
+      const {pathname} = new URL(`http:${str}`)
       return `${ pathname.split('/').filter(v=>v).slice(1).join('/')}`
     }
     jsAssetsList = jsAssetsList.map(changeToRelativePath)
     cssAssetsList = cssAssetsList.map(changeToRelativePath)
   }
+
+  // 导出源码才处理
+  if (config.isExport) {
+    // 以`${STATIC_URL}/packages`开头的正则
+    const prefixPackagesReg = new RegExp(`^${STATIC_URL}/packages/`);
+    const prefixHostReg = new RegExp(`^${STATIC_URL}`);
+
+    jsAssetsList = (jsAssetsList || []).map(url => {
+      // packages下的需要下载
+      if (prefixPackagesReg.test(url)) {
+        // 去除`?`及后面的内容
+        // eslint-disable-next-line prefer-destructuring
+        const noQueryUrl = url.split('?')[0];
+        const path = noQueryUrl.replace(prefixHostReg, '');
+        const dir = path.split('/').slice(0, -1).join('/');
+
+        globalConfig.frontendPackagesResource.push({
+          path: dir, // 下载后存放的路径
+          isDir: true,
+          url: `${config.STATIC_URL}${dir}`,
+        });
+
+        const noHostUrl = url.replace(prefixHostReg, '');
+        return `${noHostUrl}`;
+      }
+
+      const prefixBasePathReg = new RegExp(`${bundleMinPath}`);
+      if (prefixBasePathReg.test(url)) {
+        // bundle.js
+        return `${url}`;
+      }
+
+      return url;
+    });
+
+    cssAssetsList = (cssAssetsList || []).map(url => {
+      // 去除`?`及后面的内容
+      // eslint-disable-next-line prefer-destructuring
+      const noQueryUrl = url.split('?')[0];
+
+      if (prefixPackagesReg.test(noQueryUrl)) {
+        const path = noQueryUrl.replace(prefixHostReg, '');
+        const dir = path.split('/').slice(0, -1).join('/');
+
+        if (!globalConfig.frontendPackagesResource.some(item => item.path === dir)) {
+          globalConfig.frontendPackagesResource.push({
+            path: dir, // 下载后存放的路径
+            isDir: true,
+            url: `${config.STATIC_URL}${dir}`,
+          });
+        }
+
+        const noHostUrl = url.replace(prefixHostReg, '');
+        return `${noHostUrl}`;
+      }
+
+      return url;
+    });
+  }
+
     let loadAssets = `
       const loadAssets = () => {
       LazyLoad.js(${JSON5.stringify(jsAssetsList)});
       LazyLoad.css(${JSON5.stringify(cssAssetsList)});
     }`
-    let loadMockAssets = `
+
+    // 导出源码才处理
+    if (config.isExport) {
+      loadAssets = `const loadJSWrap = (arr)=>{
+      LazyLoad.js(arr.map(url => (window.UIBasePath || '') + url));
+    }
+    const loadCSSWrap = (arr)=>{
+      LazyLoad.css(arr.map(url => (window.UIBasePath || '') + url));
+    }
+    const loadAssets = () => {
+      loadJSWrap(${JSON5.stringify(jsAssetsList)});
+      loadCSSWrap(${JSON5.stringify(cssAssetsList)});
+    }`
+    }
+
+
+    const loadMockAssets = `
     const loadJSWrap = (arr)=>{
       LazyLoad.js(arr.map(url=>window.assetsDomain + url));
     }
@@ -679,7 +779,7 @@ export function genBundleFiles(app: App, frontend: Frontend, config: Config) {
       content: minifyObj.code,
     },
     {
-      name: frontend.basePath ? `${baseUrl}${frontend.basePath}/client.js` : `${baseUrl}/client.js`,
+      name: basePath ? `${baseUrl}${basePath}/client.js` : `${baseUrl}/client.js`,
       content: assetsContent,
     },
   ];

package/src/generator/genReleaseBody.ts

@@ -26,7 +26,6 @@ interface ServerValidationData {
 
 interface ReleaseData {
   env: string;
-  branchId: string;
   debug: boolean;
   replicas: number;
   realRelease: boolean;
@@ -74,7 +73,6 @@ async function mergeBodyData(app: App, opt: ReleaseData) {
     reportIdList: findAllReportIdList(app, opt.frontends),
     appId: app.id,
     env: opt.env,
-    branchId: opt.branchId,
     replicas: opt.replicas,
     appSpecification: opt.appSpecification,
     callbackLogicsName: app.getExtensionsCallbackLogics(),

package/src/generator/permission.ts

@@ -59,7 +59,7 @@ async function findViewLogicReferences(logic: Logic, vis: Set<Logic> = new Set()
 
   async function dfs(usage: Usage) {
     if (usage.node instanceof CallLogic) {
-      const logic = usage.node.logic;
+      const logic: any = usage.node?.logic || usage.node?.getAncestor?.('BusinessLogic');
       if (!vis.has(logic) && logic) {
         vis.add(logic);
         await findViewLogicReferences(logic, vis);
@@ -178,7 +178,7 @@ async function findResourcesOfLogic(logic: Logic, uploaders: Map<string, ViewEle
   return optimizeResourceData(res);
 }
 
-function getAllLogics(app: App) {
+export function getAllLogics(app: App) {
   const modules: (Module | Connector)[] = [];
   const entities: Entity[] = [];
   const logics: Logic[] = [];

package/src/index.ts

@@ -10,4 +10,5 @@ export * from './eventBus';
 export * as breakpoint from './breakpoint';
 export { operationRecordInfoMap, doOperationRecord, operationRecordQuery, operationRecordPlayback, loadApp, loadAppSync, handleApp, batchAction, batchQuery, mountDatabaseTypes } from './service/storage/init';
 export { createService } from './service/creator';
+export { stepRecorder } from './manager/stepRecorder';
 export * from './natural';

package/src/natural/genNaturalTS.ts

@@ -1,7 +1,7 @@
 import { App, View, Logic, BaseNode, Frontend } from '../concepts';
 import { shiftState, createCompilerState } from '../translator';
 
-import naslStdlibMap from './naslStdlibMap';
+import { getNaslStbMap } from './naslStdlibMap';
 
 export function genNaturalTS(app: App, currentNode?: BaseNode, focusedNodePath?: string) {
   const logic = currentNode as Logic;
@@ -14,7 +14,7 @@ export function genNaturalTSContext(app: App, currentNode?: BaseNode, focusedNod
   /* 标准库 */
   code += `\`\`\`ts\n`;
   code += '// 标准库\n';
-  code += `${Object.values(naslStdlibMap).join('\n')}\n`;
+  code += `${Object.values(getNaslStbMap(currentNode)).join('\n')}\n`;
   /* 全局上下文 */
   code += '\n// 全局上下文\n';
   app.enums.forEach((enumeration) => code += `${enumeration?.toNaturalTS()}\n`);

package/src/natural/index.ts

@@ -1,2 +1,5 @@
 export * from './genNaturalTS';
 export * from './transformTSCode';
+export * from './prompt/executeClaims';
+export * from './prompt/analyzeClaims';
+

package/src/natural/naslStdlibMap.ts

@@ -1,24 +1,30 @@
-let naslStdlibMap: any;
-/// #if process.env.BUILD_TARGET === 'node'
-if (globalThis.process) { // For TS build
+export const getNaslStbMap = (logic: any) => {
+  let naslStdlibMap: any;
+  const logicType = logic?.parentNode?.concept === 'App' ? 'global_logic' : 'view_logic';
+  /// #if process.env.BUILD_TARGET === 'node'
+  if (globalThis.process) { // For TS build
     const fs = require('fs');
     naslStdlibMap = {
-        'nasl.core.ts': fs.readFileSync(require.resolve('../../sandbox-natural/stdlib/nasl.core.ts'), 'utf8'),
-        'nasl.util.ts': fs.readFileSync(require.resolve('../../sandbox-natural/stdlib/nasl.util.ts'), 'utf8'),
-        'nasl.oql.ts': fs.readFileSync(require.resolve('../../sandbox-natural/stdlib/nasl.oql.ts'), 'utf8'),
-        'nasl.ui.ts': fs.readFileSync(require.resolve('../../sandbox-natural/stdlib/nasl.ui.ts'), 'utf8'),
+      'nasl.core.ts': fs.readFileSync(require.resolve('../../sandbox-natural/stdlib/nasl.core.ts'), 'utf8'),
+      'nasl.util.ts': fs.readFileSync(require.resolve('../../sandbox-natural/stdlib/nasl.util.ts'), 'utf8'),
+      'nasl.ui.ts': fs.readFileSync(require.resolve('../../sandbox-natural/stdlib/nasl.ui.ts'), 'utf8'),
     };
-}
-/// #endif
-/// #if process.env.BUILD_TARGET !== 'node'
-if (globalThis.window) { // For TS build
+    if (logicType === 'global_logic') {
+      naslStdlibMap['nasl.oql.ts'] = fs.readFileSync(require.resolve('../../sandbox-natural/stdlib/nasl.oql.ts'), 'utf8');
+    }
+  }
+  /// #endif
+  /// #if process.env.BUILD_TARGET !== 'node'
+  if (globalThis.window) { // For TS build
     naslStdlibMap = {
-        'nasl.core.ts': require('!!raw-loader!../../sandbox-natural/stdlib/nasl.core.ts').default,
-        'nasl.util.ts': require('!!raw-loader!../../sandbox-natural/stdlib/nasl.util.ts').default,
-        'nasl.oql.ts': require('!!raw-loader!../../sandbox-natural/stdlib/nasl.oql.ts').default,
-        'nasl.ui.ts': require('!!raw-loader!../../sandbox-natural/stdlib/nasl.ui.ts').default,
+      'nasl.core.ts': require('!!raw-loader!../../sandbox-natural/stdlib/nasl.core.ts').default,
+      'nasl.util.ts': require('!!raw-loader!../../sandbox-natural/stdlib/nasl.util.ts').default,
+      'nasl.ui.ts': require('!!raw-loader!../../sandbox-natural/stdlib/nasl.ui.ts').default,
     };
-}
-/// #endif
-
-export default naslStdlibMap;
+    if (logicType === 'global_logic') {
+      naslStdlibMap['nasl.oql.ts'] = require('!!raw-loader!../../sandbox-natural/stdlib/nasl.oql.ts').default;
+    }
+  }
+  /// #endif
+  return naslStdlibMap;
+};

package/src/natural/prompt/analyzeClaims.ts

@@ -0,0 +1,16 @@
+export const analyzeClaims = async (params: any) => {
+  const { logicType } = params;
+  const claims = `
+  - Knowledge 是你的知识库，你可以参考，但是你最终制定的计划中禁止包含方法或者函数名
+  - 如果用户没有特别指明是打印(日志/输出结果)，"输出结果"一律按照"返回输出结果"处理
+`;
+  // global_logic、view_logic、event_logic、business_Logic
+  const claimsMap = {
+    global_logic: `
+- Knowledge 是你的知识库，你可以参考，但是你最终制定的计划中禁止包含方法或者函数名
+- 如果用户没有特别指明是打印(日志/输出结果)，"输出结果"一律按照"返回输出结果"处理
+- 当前逻辑类型下暂不支持跳转页面功能，请提示用户: 如果需要跳转页面，请切换到前端页面逻辑或事件逻辑
+`
+  } as any;
+  return claimsMap?.[logicType] || claims;
+};

package/src/natural/prompt/executeClaims.ts

@@ -0,0 +1,69 @@
+export const executeClaims = async (params: any) => {
+  const { logicName, logicType } = params;
+  const claims = `
+-   语法
+    -   请使用 ts + es6 的语法
+-   函数名
+    -   函数名请使用 ${logicName}
+-   函数内的变量声明
+    -   在使用变量或者参数前，请先查找低代码平台的 ts 定义中是否已声明，如果没有声明，请先声明，并遵循 nasl.core 中的规范
+    -   变量名称禁止使用 'result'，请使用其它名称代替
+    -   类型禁止出现 any 和 undefined
+    -   在使用枚举的时候，必须加上前缀, 格式为: app.enums.枚举['属性']
+        -   例如 app.enums.UserStatusEnum['Normal']
+-   函数体
+    -   只能返回一个函数体，你需要在一个函数体中实现所有的功能
+    -   只能对 'Boolean', 'Integer', 'Double', 'Decimal', 'Long' 使用 new 关键字
+    -   禁止使用 import
+    -   禁止使用 for/forEach 语句，如果需要循环或者遍历，你**只能**使用 ForEach 方法
+    -   只获取单条数据时使用 Entity.get()，避免频繁操作实体
+    -   字符串或者变量之间的拼接或者 concat 请使用字符串插值(模板字符串)语法
+    -   需要使用 nasl.ui 中类的方法时，请使用 $refs 的前缀，例如 $refs.tableView1.reload()，禁止使用 new 创建实例
+    -   nasl.core 中的方法，请直接使用，例如 plus(left, right)，禁止出现 nasl.util.plus 等
+    -   禁止使用 标准内置对象(例如 Math、Number、Array、String 等内置对象)的方法
+    -   禁止使用 Object 的所有方法，如果想使用对象或者想要获取属性的值时，请使用 Map 系列函数
+    -   优先使用 nasl.util 中的内置函数或方法
+    -   禁止方法的连续调用
+    -   禁止使用三元表达式，可使用 if 语句或者 while 语句替换
+    -   直接输出代码结果，其他描述请以注释的形式出现
+-   返回值
+    -   如果用户没有特别指明是打印(日志/输出结果)，"输出结果"一律按照"返回输出结果"处理
+  `;
+
+  const claimsMap = {
+    global_logic: `
+-   语法
+    -   请使用 ts + es6 的语法
+-   函数名
+    -   函数名请使用 ${logicName}
+-   函数内的变量声明
+    -   在使用变量或者参数前，请先查找低代码平台的 ts 定义中是否已声明，如果没有声明，请先声明，并遵循 nasl.core 中的规范
+    -   变量名称禁止使用 'result'，请使用其它名称代替
+    -   类型禁止出现 any 和 undefined
+    -   在使用枚举的时候，必须加上前缀, 格式为: app.enums.枚举['属性']
+        -   例如 app.enums.UserStatusEnum['Normal']
+-   函数体
+    -   只能返回一个函数体，你需要在一个函数体中实现所有的功能
+    -   只能对 'Boolean', 'Integer', 'Double', 'Decimal', 'Long' 使用 new 关键字
+    -   禁止使用 import
+    -   禁止使用 for/forEach 语句，如果需要循环或者遍历，你**只能**使用 ForEach 方法
+    -   分析用户的需求，优先使用数据库的查询和数据操纵能力，例如 JOIN、SUM、GROUP_BY 等能力，使用 SQL 语句同时实现查询和计算
+    -   如果要查询，则使用 nasl.oql.query，同时分析整个需求，尽量用一句 SQL 实现
+        -   只获取单条数据时使用 Entity.get()，其它查询都使用 nasl.oql.query
+        -   禁止对 nasl.oql.query 的结果进行连续调用
+    -   避免频繁操作实体
+    -   字符串或者变量之间的拼接或者 concat 请使用字符串插值(模板字符串)语法
+    -   需要使用 nasl.ui 中类的方法时，请使用 $refs 的前缀，例如 $refs.tableView1.reload()，禁止使用 new 创建实例
+    -   nasl.core 中的方法，请直接使用，例如 plus(left, right)，禁止出现 nasl.util.plus 等
+    -   禁止使用 标准内置对象(例如 Math、Number、Array、String 等内置对象)的方法
+    -   禁止使用 Object 的所有方法，如果想使用对象或者想要获取属性的值时，请使用 Map 系列函数
+    -   优先使用 nasl.util 中的内置函数或方法
+    -   禁止方法的连续调用
+    -   禁止使用三元表达式，可使用 if 语句或者 while 语句替换
+    -   直接输出代码结果，其他描述请以注释的形式出现
+-   返回值
+    -   如果用户没有特别指明是打印(日志/输出结果)，"输出结果"一律按照"返回输出结果"处理
+    `,
+  } as any;
+  return claimsMap?.[logicType] || claims;
+};

package/src/natural/transformTSCode.ts

@@ -224,7 +224,7 @@ export function transformTSCode(tsCode: string, contextLogicName: string, type?:
   }
 
   function isPageLogic(logicName: string) {
-    return logicName.includes('on_') || logicName.includes('viewLogic_');
+    return logicName.includes('on_') || logicName.includes('viewLogic_') || logicName.includes('businessLogic_');
   }
 
   function transformLogicNode(node: babelTypes.Node, typeAnnotation?: naslTypes.TypeAnnotation): naslTypes.LogicItem {
@@ -387,6 +387,14 @@ export function transformTSCode(tsCode: string, contextLogicName: string, type?:
           }))],
         });
       }
+      if (calleeName === 'PaginateLimit') {
+        const newCallee = node?.arguments || [];
+        return new naslTypes.Paginate({
+          list: newCallee?.[0] && transformLogicNode(newCallee?.[0]),
+          page: newCallee?.[1] && transformLogicNode(newCallee?.[1]),
+          size: newCallee?.[2] && transformLogicNode(newCallee?.[2]),
+        });
+      }
       if (calleeName === 'ForEach') {
         const newCallee = node.arguments;
         const arrowFunction = node.arguments[3] as babelTypes.ArrowFunctionExpression;
@@ -430,7 +438,7 @@ export function transformTSCode(tsCode: string, contextLogicName: string, type?:
             expression: transformLogicNode(arg),
           })) as naslTypes.Argument[],
         });
-      } else if (/^app.dataSources|app.logics|load/.test(calleeName)) {
+      } else if (/^app.dataSources|app.logics/.test(calleeName)) {
         return new naslTypes.CallLogic({
           calleeNamespace: generate((node.callee as any).object).code,
           calleeName: (callee[callee.length - 1] as babelTypes.Identifier).name,
@@ -838,6 +846,8 @@ export function transformTSCodeEx(answer: any, activeLogic: any, context: any) {
     logicName = `viewLogic_${activeLogic.name}`;
   } else if (activeLogic.parentNode instanceof nasl.BindEvent && activeLogic.parentNode.parentNode instanceof nasl.ViewElement) {
     logicName = `on_${(activeLogic.parentNode).element.name}_${activeLogic.name}`;
+  } else if (activeLogic?.concept === 'BusinessLogic') {
+    logicName = `businessLogic_${activeLogic?.name}`;
   } else {
     logicName = activeLogic.name;
   }