@lcap/nasl 2.12.0-beta → 2.12.0-beta.1

package/src/generator/genBundleFiles.ts

@@ -1,4 +1,4 @@
-import { App, Module, View, BaseNode, Entity, Structure, Enum, uiStructures, collectionStructures, Logic, Interface, Process } from '../concepts';
+import { App, Module, View, BaseNode, Entity, Structure, Enum, uiStructures, collectionStructures, processStructures, Logic, Interface, Process } from '../concepts';
 import * as utils from '../utils';
 import { genHash, RawOptions } from '.';
 import { compileComponent } from './compileComponent';
@@ -20,8 +20,8 @@ export interface PageOptions {
     hasUserCenter: boolean;
     hasAuth: boolean;
     domainName: string;
-    nuimsDomain: string;
     auth: boolean;
+    subPage: object;
     documentTitle?: string;
     router: {
         notFound: string;
@@ -44,8 +44,12 @@ export async function genBundleFiles(app: App,
         USER_STATIC_URL: string;
         extendedConfig: string;
         lowcodeDomain: string;
+        envLcpDomain: any,
+        envNuimsDomain: any,
         appid: string;
     }) {
+    const fnNuimsDomain = config?.envNuimsDomain?.[config?.env] || config?.nuimsDomain;
+    const fnLowcodeDomain = config?.envLcpDomain?.[config?.env]?.lcpDomain || config?.lowcodeDomain;
     const modules: Module[] = [];
     const views: View[] = [];
     const entities: Entity[] = [];
@@ -135,8 +139,8 @@ export async function genBundleFiles(app: App,
             hasUserCenter: app.hasUserCenter,
             hasAuth: app.hasAuth,
             domainName: app.name,
-            nuimsDomain: config.nuimsDomain,
             auth: view.auth,
+            subPage: view.children,
             documentTitle: app.documentTitle,
             router: {
                 notFound: '/',
@@ -217,6 +221,14 @@ export async function genBundleFiles(app: App,
         });
     }
 
+    if (Array.isArray(processStructures)) {
+        const namespace = 'nasl.process';
+        processStructures.forEach((node) => {
+            const id = `${namespace}.${node.name}`;
+            dataTypesMap[id] = node;
+        });
+    }
+
     if (Array.isArray(logics)) {
         allLogics.push(...logics);
     }
@@ -252,9 +264,11 @@ export async function genBundleFiles(app: App,
             },
         },
         extendedConfig: config.extendedConfig,
-        lowcodeDomain: config.lowcodeDomain,
+        lowcodeDomain: fnLowcodeDomain,
         tenant: config.tenant,
         env: config.env,
+        nuimsDomain: fnNuimsDomain,
+        envNuimsDomain: config.envNuimsDomain,
         indexName,
     }, null, 4);
 
@@ -341,6 +355,8 @@ export async function genBundleFiles(app: App,
             tenant: data.tenant,
             env: data.env,
             extendedConfig: data.extendedConfig,
+            nuimsDomain: data.nuimsDomain,
+            envNuimsDomain: data.envNuimsDomain,
             envConfig: {
                 lowcodeDomain: data.lowcodeDomain,
             },
@@ -350,7 +366,7 @@ export async function genBundleFiles(app: App,
 
     if (config.env === 'dev') {
         // 加载资源js
-        const domain = config.lowcodeDomain.slice(config.lowcodeDomain.indexOf('.') + 1);
+        const domain = fnLowcodeDomain.slice(fnLowcodeDomain.indexOf('.') + 1);
         const targetUrl = `${location.origin}/empty?url=${domain}&appid=${config.appid}`;
         const str = `
        if(!document.querySelector("iframe[name='iframeEmpty']")){

package/src/generator/genMetaData.ts

@@ -1,10 +1,11 @@
-import { App, View, BaseNode, Module, Interface, Entity, Structure, Enum, uiStructures, collectionStructures, Logic, Process, DataSource } from '../concepts';
+import { App, View, BaseNode, Module, Interface, Entity, Structure, Enum, uiStructures, collectionStructures, processStructures, Logic, Process, DataSource } from '../concepts';
 
 export function genMetaData(app: App,
     config: {
         tenant: string;
         env: string;
         nuimsDomain: string;
+        envNuimsDomain: Object;
         STATIC_URL: string;
         USER_STATIC_URL: string;
         extendedConfig: string;
@@ -127,6 +128,14 @@ export function genMetaData(app: App,
         });
     }
 
+    if (Array.isArray(processStructures)) {
+        const namespace = 'nasl.process';
+        processStructures.forEach((node) => {
+            const id = `${namespace}.${node.name}`;
+            dataTypesMap[id] = node;
+        });
+    }
+
     if (Array.isArray(logics)) {
         allLogics.push(...logics);
     }

package/src/index.ts

@@ -8,5 +8,5 @@ export * as genBlock from './templator';
 export * as utils from './utils';
 export * from './config';
 export * from './eventBus';
-export { loadApp, loadAppSync } from './service/storage/init';
+export { loadApp, loadAppSync, handleApp } from './service/storage/init';
 import './automate/engine';

package/src/server/getLogics.ts

@@ -128,12 +128,18 @@ export async function getLogics(node: CallLogic | BindEvent, needAllLogic: boole
             });
             tree.expanded = true;
             result.push(tree);
-
             const systemTree = new Namespace({
                 name: 'category',
                 path: `nasl`,
                 title: '系统逻辑',
                 children: [
+                    new Namespace({
+                        name: 'category',
+                        path: `process`,
+                        title: '流程逻辑',
+                        logics: stdlibNamespace.findChild('process').logics,
+                        expanded: true,
+                    }),
                     new Namespace({
                         name: 'category',
                         path: `browser`,
@@ -158,6 +164,8 @@ export async function getLogics(node: CallLogic | BindEvent, needAllLogic: boole
                 ],
                 expanded: true,
             });
+            if (!app.processes.length)
+                systemTree.children.shift();
 
             systemTree.expanded = true;
             systemTree.children.forEach((child) => (child.expanded = true));
@@ -169,6 +177,13 @@ export async function getLogics(node: CallLogic | BindEvent, needAllLogic: boole
                 path: `nasl`,
                 title: '系统逻辑',
                 children: [
+                    new Namespace({
+                        name: 'category',
+                        path: `process`,
+                        title: '流程逻辑',
+                        logics: stdlibNamespace.findChild('process').logics,
+                        expanded: true,
+                    }),
                     new Namespace({
                         name: 'category',
                         path: `configuration`,
@@ -179,6 +194,8 @@ export async function getLogics(node: CallLogic | BindEvent, needAllLogic: boole
                 ],
                 expanded: true,
             });
+            if (!app.processes.length)
+                systemTree.children.shift();
 
             systemTree.expanded = true;
             systemTree.children.forEach((child) => (child.expanded = true));

package/src/server/getMemberIdentifier.ts

@@ -76,6 +76,10 @@ function createType2Annotation(type: string): TypeAnnotation {
             typeAnnotation = TypeAnnotation.createReference(types[types.length - 1], {
                 typeNamespace: 'nasl.ui',
             });
+        } else if (type.startsWith('nasl.process')) {
+            typeAnnotation = TypeAnnotation.createReference(types[types.length - 1], {
+                typeNamespace: 'nasl.process',
+            });
         } else if (type.startsWith('nasl.collection')) {
             typeAnnotation = TypeAnnotation.createGeneric(types[types.length - 1], {
                 typeNamespace: 'nasl.collection',

package/src/server/getProcesses.ts

@@ -536,6 +536,13 @@ export function getFlowAfterElements(el: ProcessElement) {
     const links = elems.filter(e => e.type === 'SequenceFlow' && e.sourceRef === processname);
     return links;
 }
+export function getFlowBeforeElements(el: ProcessElement) {
+    const process = el.process;
+    const processname = el.name;
+    const elems = process.elements;
+    const links = elems.filter(e => e.type === 'SequenceFlow' && e.targetRef === processname);
+    return links;
+}
 
 export function isFromStartNode(el: ProcessElement) {
     const process = el.process;
@@ -587,4 +594,4 @@ export function findNodeAfterNodeInFlow(el: ProcessElement) {
         });
     }
     return Array.from(nodeSet);
-}
+}

package/src/server/naslServer.ts

@@ -46,6 +46,7 @@ import {
     Variable,
     DataSource,
     Assignee,
+    SqlQueryComponent,
 } from '../concepts';
 import { lsp2tspNumber, SourceMap, SourceMapItem, embeddedTSEmitter } from '../translator';
 import axios from '../service/storage';
@@ -101,6 +102,10 @@ interface QuoteNode {
     expanded: boolean;
     children?: QuoteNode[];
 }
+let isChangeInterface = false; //判断是否导入接口
+type ActionNode = { target: Variable; typeannotation: TypeAnnotation };
+let actionArr: Array<ActionNode> = []; //用于导入接口收集更改的节点
+let timer: number = null; //超时器用于收集导入接口相关
 const naslServer = {
     messager,
     worker,
@@ -495,8 +500,10 @@ const naslServer = {
             oldRecord?.semanticDiagnostics.forEach((item) => {
                 item.node ? (item.node.tsErrorDetail = undefined) : '';
             });
-
             // 语义诊断
+            if (isChangeInterface) {
+                this.existStructureFix(record.semanticDiagnostics, node as FileNode, this);
+            }
             record.semanticDiagnostics = record.semanticDiagnostics
                 .map((diag) => this._resolveDiagnostic(diag as unknown as tsProtocol.DiagnosticWithFileName, node as FileNode))
                 .filter((diag) => !!diag);
@@ -521,6 +528,7 @@ const naslServer = {
             record.suggestionDiagnostics = [];
             // 语法诊断暂时不需要
         });
+
         return records;
     },
     _attachDiagnostics(fileNode: BaseNode): Diagnostic[] {
@@ -529,8 +537,7 @@ const naslServer = {
             traverse((current) => {
                 if (current.node.tag) {
                     current.node.bindAttrs.forEach((bindAttr) => {
-                        if ((bindAttr.model || bindAttr.sync)
-                            && bindAttr.expression && bindAttr.expression.concept !== 'Identifier' && bindAttr.expression.concept !== 'MemberExpression') {
+                        if ((bindAttr.model || bindAttr.sync) && bindAttr.expression && bindAttr.expression.concept !== 'Identifier' && bindAttr.expression.concept !== 'MemberExpression') {
                             const diagnostic = {
                                 node: bindAttr,
                                 severity: 'error',
@@ -549,7 +556,7 @@ const naslServer = {
                 const property = dataSourceGroup.getProperty(fileNode.name);
                 if (property && property.values) {
                     property.values.forEach((propertyValue) => {
-                        if (!propertyValue.value) {
+                        if (!propertyValue.value && fileNode.name !== 'defaultDS') {
                             const diagnostic = {
                                 node: fileNode,
                                 severity: 'error',
@@ -572,6 +579,62 @@ const naslServer = {
 
         return diagnostics;
     },
+    /* 接口导入查找 */
+    existStructureFix(semanticDiagnostics: Diagnostic[], node: FileNode, that: any) {
+        let module: Module;
+        semanticDiagnostics.map((diag) => {
+            const minRange = this._findMinRange(diag as unknown as tsProtocol.DiagnosticWithFileName, node);
+            if (diag.text?.includes('has no exported member named')) {
+                if (minRange.node instanceof Logic) {
+                    return null;
+                }
+                const typeAnnotation = minRange.node instanceof TypeAnnotation ? (minRange.node.upperNode as Variable).typeAnnotation : (minRange.node as Variable).typeAnnotation;
+                const regNamespace = /<(\S*)>/;
+                const typeKey = (typeAnnotation.typeKey.match(regNamespace) && typeAnnotation.typeKey.match(regNamespace)[1]) || typeAnnotation.typeKey;
+                const typeKeyArr = typeKey.split('.');
+                if (typeKeyArr[0] === 'apis') {
+                    const structureName = typeKeyArr[3];
+                    const moduleName = typeKeyArr[1];
+                    const app = (typeAnnotation.upperNode as Variable).app;
+                    if (!app) {
+                        return null;
+                    }
+                    module = app.interfaceDependencies?.find((item) => item.name === moduleName);
+                    let existStructure = module?.structures?.find((item) => item.name.toUpperCase() === structureName.toUpperCase());
+                    if (!existStructure) {
+                        const realName = structureName.replace(/\d*$/, (m) => String(''));
+                        existStructure = module?.structures?.find((item) => item.name.toUpperCase() === realName.toUpperCase());
+                    }
+                    if (existStructure) {
+                        const editTypeAnnotation = JSON.parse(JSON.stringify(typeAnnotation).replace(new RegExp(structureName, 'g'), existStructure.name));
+                        actionArr.push({ target: typeAnnotation.parentNode as Variable, typeannotation: editTypeAnnotation });
+                    }
+                }
+                return null;
+            } else {
+                return diag;
+            }
+        });
+        if (actionArr.length) {
+            if (timer)
+                return;
+            timer = window.setTimeout(() => {
+                const app = actionArr[0].target.app;
+                app.emit('collect:start', {
+                    actionMsg: '设置导入接口数据类型错误',
+                });
+                module.isAdd && module.setIsAdd(false);
+                actionArr.forEach((item) => {
+                    item.target.setDataType(TypeAnnotation.from(item.typeannotation));
+                });
+                app.emit('collect:end');
+                actionArr = [];
+                isChangeInterface = false;
+                clearTimeout(timer);
+                timer = null;
+            }, 2000);
+        }
+    },
     _resolveDiagnostic(diagnostic: tsProtocol.DiagnosticWithFileName, fileNode: FileNode): Diagnostic {
         const minRange = this._findMinRange(diagnostic, fileNode);
         const tsErrorDetail = {
@@ -684,7 +747,7 @@ const naslServer = {
                     const entity = this.file2NodeMap.get(item.file);
                     const { currentSource } = naslServer.getCurrentSource(entity);
                     // 32 8个函数的总行数
-                    if (item.end.line < (currentSource.range.end.line - 32) && item.start.line > 1) {
+                    if (item.end.line < currentSource.range.end.line - 32 && item.start.line > 1) {
                         flag = true;
                     }
                 }
@@ -976,19 +1039,19 @@ const naslServer = {
                     // logic 和 views名称修改 可能会触发bindEvent修改
                     if (minRange.node instanceof BindEvent) {
                         // 页面逻辑直接赋值就可以, 因为是相对路径
-                        if ((node instanceof ViewElement)) {
+                        if (node instanceof ViewElement) {
                             minRange.setTypeMethods = 'setCalleeNamespace';
                             minRange.newValue = 'elements.' + newValue + '.logics';
                         } else {
                             /**
-                         * 如果namespce是 'app.views.Student.views.404.views.505.views.update'
-                         * 在ts中会是'app.views.Student.views.$404.views.$505.views.update'
-                         * 但是505 要改名为 666 ，要存的是666
-                         * 'app.views.Student.views.404.views.666.views.update'
-                         * 1.取到转后的
-                         * 2.在匹配到的内容中取转后的namespace的位置
-                         * 3.然后把namespace中的 $替换成 ''
-                         */
+                             * 如果namespce是 'app.views.Student.views.404.views.505.views.update'
+                             * 在ts中会是'app.views.Student.views.$404.views.$505.views.update'
+                             * 但是505 要改名为 666 ，要存的是666
+                             * 'app.views.Student.views.404.views.666.views.update'
+                             * 1.取到转后的
+                             * 2.在匹配到的内容中取转后的namespace的位置
+                             * 3.然后把namespace中的 $替换成 ''
+                             */
                             const tsCalleeNamespace = minRange.node.tsCalleeNamespace;
                             const oldValue = tsCalleeNamespace;
 
@@ -1082,6 +1145,8 @@ const naslServer = {
                             minRange.setTypeMethods = 'setRelationNamespace';
                             const newValue = setTypeNamespace(minRange.node.relationNamespace, record);
                             minRange.newValue = newValue;
+                        } else if (minRange.node instanceof SqlQueryComponent) {
+                            minRange.setTypeMethods = 'setDataSource';
                         }
                     }
                     if (minRange.node instanceof QueryGroupByExpression && node instanceof Entity) {
@@ -1099,7 +1164,10 @@ const naslServer = {
                     }
 
                     // 如果跳转链接或者页面变量同一个param和TypeAnnotation 有两个过滤掉一个
-                    if ((minRange.node instanceof Param || minRange.node instanceof Variable || minRange.node instanceof Return) && (node instanceof Entity || node instanceof Enum || node instanceof Structure)) {
+                    if (
+                        (minRange.node instanceof Param || minRange.node instanceof Variable || minRange.node instanceof Return)
+                        && (node instanceof Entity || node instanceof Enum || node instanceof Structure)
+                    ) {
                         return null;
                     }
                     if (minRange.node instanceof Destination && (node instanceof Process || node instanceof ProcessElement)) {
@@ -1138,7 +1206,7 @@ const naslServer = {
                         /**
                          * 这里过滤一下，一些查找引用，重复的内容，直接屏蔽掉，防止操作重复
                          * 因为在生成的时候 ，可能弄了一些副作用的引用
-                        */
+                         */
                         // 本来是想在上面过滤一把的先放到这里匹配这两个的时候 就会找到
                         // refsList = refsList.filter((item) => {
                         //     屏蔽组件查找查到定义这里，也过滤一下
@@ -1153,7 +1221,7 @@ const naslServer = {
                      * 流程改名不触发Logic改名
                      * 如果是修改param查找到logic就不操作
                      * 除非想在内部修改别的内容所以暂时屏蔽掉
-                    */
+                     */
                     if (minRange.node instanceof Logic && node !== minRange.node) {
                         return null;
                     }
@@ -1180,11 +1248,11 @@ const naslServer = {
             if (minRange) {
                 // 如果找到节点是callLogic就去更新
                 if (minRange.node instanceof CallLogic && node instanceof Param) {
-                    minRange.node.setCalleeArgName((parantNode) as Logic);
+                    minRange.node.setCalleeArgName(parantNode as Logic);
                 }
                 // 如果节点参数增加页面也要更新
                 if (minRange.node instanceof Destination && node instanceof Param) {
-                    minRange.node.setViewArgument((parantNode) as View);
+                    minRange.node.setViewArgument(parantNode as View);
                 }
             }
         });
@@ -1202,12 +1270,12 @@ const naslServer = {
                 parentNode: parantNode,
                 parentKey: node.parentKey,
             });
-            naslServer._addParamsEffect(refsList, (node) as Param);
+            naslServer._addParamsEffect(refsList, node as Param);
             // 结束修改 ，批量操作
             App.emit('collect:end');
             return node;
         }
-        naslServer._addParamsEffect(refsList, (node) as Param);
+        naslServer._addParamsEffect(refsList, node as Param);
         return node;
     },
     // 查找引用
@@ -1215,10 +1283,10 @@ const naslServer = {
         let refsList = await naslServer._isHaveRef(node);
         // 如果查找引用查到自己里面的引用不展示
         refsList = refsList.filter((item) =>
-            // 自己引用自己的过滤掉
-            // 删除的时候过滤一把组件删除提示
-            // 展示组件自己屏蔽掉
-            !item.isDefinition && !(item.lineText.includes(' = new nasl.ui.')));
+        // 自己引用自己的过滤掉
+        // 删除的时候过滤一把组件删除提示
+        // 展示组件自己屏蔽掉
+            !item.isDefinition && !item.lineText.includes(' = new nasl.ui.'));
         // 最后返回的结果
         let result = new Map();
         // 树的构造，key： 一个file的node， 值是 [[logic, params],[logic, returns]]
@@ -1379,7 +1447,14 @@ const naslServer = {
         // 如果没有sourceMap,就继续向上找 ,或者到module结束
         // 如果 节点找到 app 或者module 停止 或者entity找到DataSource为止
         // 如果当前节点是view就不要向上查找了
-        while (!sourceMap && fileNode && !(fileNode.parentNode instanceof App) && !(fileNode.parentNode instanceof Module) && !(fileNode.parentNode instanceof DataSource) && !(fileNode instanceof View)) {
+        while (
+            !sourceMap
+            && fileNode
+            && !(fileNode.parentNode instanceof App)
+            && !(fileNode.parentNode instanceof Module)
+            && !(fileNode.parentNode instanceof DataSource)
+            && !(fileNode instanceof View)
+        ) {
             fileNode = fileNode.parentNode;
             sourceMap = fileNode?.sourceMap;
         }
@@ -1584,6 +1659,7 @@ async function incidentalAction(action: string, fileNode: BaseNode, targetNode:
             for (let i = 0; i < fileNodeChildren.length; i++) {
                 const fileNodeItem = fileNodeChildren[i];
                 const result = (fileNodeItem as FileNode).toEmbeddedTSFile();
+                fileNodeItem.sourceMap = result.sourceMap;
                 if (action === 'create') {
                     await handleChange(fileNodeItem, fileNodeItem, result, action);
                     await incidentalAction(action, fileNodeItem, fileNodeItem);
@@ -1602,7 +1678,10 @@ async function incidentalAction(action: string, fileNode: BaseNode, targetNode:
         // 删除或新增模块
         // 需要把下面的哦内容全部都更新一遍
         if (fileNode instanceof Module) {
-            const module: Module = (targetNode) as Module;
+            if (fileNode.type === 'interface' && fileNode.isAdd && action === 'create') {
+                isChangeInterface = true;
+            }
+            const module: Module = targetNode as Module;
             const results: Array<ReturnType<Structure['toEmbeddedTSFile']>> = [];
             naslServer.contentToFile(module, results);
             for (let i = 0; i < results.length; i++) {
@@ -1629,7 +1708,7 @@ async function incidentalAction(action: string, fileNode: BaseNode, targetNode:
          * DataSource只会重命名时候，需要把子集全部重新生成一下
          */
         if (fileNode instanceof DataSource) {
-            (fileNode as DataSource).entities.forEach(async(entity) => {
+            (fileNode as DataSource).entities.forEach(async (entity) => {
                 try {
                     const result = entity.toEmbeddedTSFile();
                     const parentPath = oldpath.replace('.ts', '/');

package/src/server/translator.ts

@@ -360,6 +360,8 @@ export function naslNodeTranslateMessage(minRange: MinRange, tsErrorDetail: Diag
             return null;
         } else if (text.startsWith(`Namespace 'nasl.ui' has no exported member `)) {
             return null;
+        } else if (text.startsWith(`Function expression, which lacks return-type annotation, implicitly has an 'any[]' return type.`)) {
+            return null;
         }
     }
     // 处理bindevent参数没传递的报错
@@ -369,20 +371,35 @@ export function naslNodeTranslateMessage(minRange: MinRange, tsErrorDetail: Diag
             return null;
         }
 
-        if (node instanceof ProcessElement && (node.type === 'UserTask' || node.type === 'AutoTask')) {
+        if (node instanceof ProcessElement && (node.type === 'UserTask' || node.type === 'AutoTask' || node.type === 'StartNoneEvent')) {
+            const reg = /Expected (.+?) arguments, but got (.+?)./.exec(text);
             let u = '用户任务';
             if(node.type === 'AutoTask') {
                 u = '自动任务';
             }
-            tsErrorDetail.message = `${u}出口顺序流个数不能大于1`;
+            if(reg[2] === '0') {
+                tsErrorDetail.message = `${u}出口顺序流个数不能是0`;
+            } else {
+                tsErrorDetail.message = `${u}出口顺序流个数不能大于1`;
+            }
+           
+            if(node.type === 'StartNoneEvent') {
+                tsErrorDetail.message = `开始节点只能有一个出口顺序流`;
+            }
         }
 
         if (node instanceof ProcessElement && (node.type === 'ExclusiveGateway' || node.type === 'ParallelGateway')) {
+            const reg = /Expected (.+?) arguments, but got (.+?)./.exec(text);
             let u = '排他网关';
             if(node.type === 'ParallelGateway') {
                 u = '并行网关';
             }
-            tsErrorDetail.message = `${u}出口顺序流个数不能小于2`;
+            if(reg[2] === '0') {
+                tsErrorDetail.message = `${u}出口顺序流和入口顺序流个数不能等于0`;
+            } else {
+                tsErrorDetail.message = `${u}出口顺序流和入口顺序流个数同时等于1，该${u}没有意义`;
+            }
+            
         }
     }
 

package/src/service/creator/errHandles.js

@@ -26,6 +26,12 @@ export default {
         if (config.noErrorTip)
             return;
 
+        // 检测到当前应用拉取操作已被强制结束
+        if(err.code === 401650) {
+            eventBus.emit('forceCancelPull');
+            return;
+        }
+
         if (versionStatus[err.code])
             eventBus.emit('updateVersionStatus', {
                 status: versionStatus[err.code],