@lcap/nasl 1.0.1 → 2.12.0-beta.1

package/out/server/naslServer.js

@@ -17,6 +17,7 @@ const common_1 = require("../common");
 const diagnostic_1 = __importDefault(require("../manager/diagnostic"));
 const createUiTs_1 = __importDefault(require("./createUiTs"));
 const coreTypeList_1 = require("../concepts/basics/types/coreTypeList");
+const utils_1 = require("../utils");
 const EmbeddedTSFileLineMap = {
     Entity: 3,
 };
@@ -35,6 +36,9 @@ const messager = new Messager_1.default({
         }
     },
 });
+let isChangeInterface = false; //判断是否导入接口
+let actionArr = []; //用于导入接口收集更改的节点
+let timer = null; //超时器用于收集导入接口相关
 const naslServer = {
     messager,
     worker,
@@ -78,17 +82,30 @@ const naslServer = {
                 console.log(err);
             }
         });
-        module.entities.forEach((entity) => {
+        module.dataSources?.forEach((dataSource) => {
+            // 本身dataSource也要生成一个文件用于改名
             try {
-                const result = entity.toEmbeddedTSFile();
+                const result = dataSource.toEmbeddedTSFile();
                 results.push(result);
                 // sourceMap都存在目录级别内容下，在页面层级下去找
-                entity.sourceMap = result.sourceMap;
-                this.file2NodeMap.set(result.filePath, entity);
+                dataSource.sourceMap = result.sourceMap;
+                this.file2NodeMap.set(result.filePath, dataSource);
             }
             catch (err) {
                 console.log(err);
             }
+            dataSource.entities.forEach((entity) => {
+                try {
+                    const result = entity.toEmbeddedTSFile();
+                    results.push(result);
+                    // sourceMap都存在目录级别内容下，在页面层级下去找
+                    entity.sourceMap = result.sourceMap;
+                    this.file2NodeMap.set(result.filePath, entity);
+                }
+                catch (err) {
+                    console.log(err);
+                }
+            });
         });
         module.interfaces.forEach((_interface) => {
             try {
@@ -322,31 +339,38 @@ const naslServer = {
              * fileNode
              */
             const { currentSource, fileNode } = naslServer.getCurrentSource(callFunction);
-            const quickInfo = await naslServer._getTypeQuickinfo({
-                file: fileNode.getEmbeddedFilePath(),
-                line: (0, translator_1.lsp2tspNumber)(currentSource.range.start.line),
-                offset: (0, translator_1.lsp2tspNumber)(currentSource.range.start.character) + `nasl.util.C`.length,
-            });
-            if (quickInfo.responseRequired) {
-                const displayString = quickInfo?.response?.displayString || '';
-                const typeList = naslServer.getDisplayString2Type(displayString);
-                let res = [];
-                typeList.forEach((type) => {
-                    const typeAnnotation = coreTypeList_1.primitiveTypeList.find((typeAnnotation) => typeAnnotation.typeName === type);
-                    if (typeAnnotation) {
-                        res.push(typeAnnotation);
+            try {
+                const quickInfo = await naslServer._getTypeQuickinfo({
+                    file: fileNode.getEmbeddedFilePath(),
+                    line: (0, translator_1.lsp2tspNumber)(currentSource.range.start.line),
+                    offset: (0, translator_1.lsp2tspNumber)(currentSource.range.start.character) + `nasl.util.C`.length,
+                });
+                if (quickInfo.responseRequired) {
+                    const displayString = quickInfo?.response?.displayString || '';
+                    const typeList = naslServer.getDisplayString2Type(displayString);
+                    const res = [];
+                    typeList.forEach((type) => {
+                        const typeAnnotation = coreTypeList_1.primitiveTypeList.find((typeAnnotation) => typeAnnotation.typeName === type);
+                        if (typeAnnotation) {
+                            res.push(typeAnnotation);
+                        }
+                        else if (type === 'unknown' || type === 'never') {
+                            return null;
+                        }
+                    });
+                    if (!res.length) {
+                        return [];
                     }
-                    else if (type === 'unknown' || type === 'never') {
-                        return null;
+                    else {
+                        return [{ title: '基础类型', children: res }];
                     }
-                });
-                if (!res.length) {
-                    return [];
-                }
-                else {
-                    return [{ title: '基础类型', children: res }];
                 }
             }
+            catch (err) {
+                console.log(err);
+                // 如果有异常就先放开全部可选，兜底逻辑
+                return [];
+            }
         }
         else {
             // 字符串 和 inter
@@ -421,9 +445,13 @@ const naslServer = {
                 item.node ? (item.node.tsErrorDetail = undefined) : '';
             });
             // 语义诊断
+            if (isChangeInterface) {
+                this.existStructureFix(record.semanticDiagnostics, node, this);
+            }
             record.semanticDiagnostics = record.semanticDiagnostics
                 .map((diag) => this._resolveDiagnostic(diag, node))
                 .filter((diag) => !!diag);
+            record.semanticDiagnostics.push(...this._attachDiagnostics(node));
             // 建议诊断
             // 实体下的建议不用展示，因为都是平台自己写的逻辑
             // if (node instanceof Entity) {
@@ -445,6 +473,110 @@ const naslServer = {
         });
         return records;
     },
+    _attachDiagnostics(fileNode) {
+        const diagnostics = [];
+        if (fileNode instanceof concepts_1.View) {
+            (0, utils_1.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') {
+                            const diagnostic = {
+                                node: bindAttr,
+                                severity: 'error',
+                                message: '页面元素双向绑定：只允许绑定可赋值的变量和字段。',
+                            };
+                            bindAttr.tsErrorDetail = diagnostic;
+                            diagnostics.push(diagnostic);
+                        }
+                    });
+                }
+            }, { node: { children: fileNode.elements } });
+        }
+        if (fileNode instanceof concepts_1.DataSource) {
+            const dataSourceGroup = fileNode.rootNode.configuration?.getGroup('dataSource');
+            if (dataSourceGroup) {
+                const property = dataSourceGroup.getProperty(fileNode.name);
+                if (property && property.values) {
+                    property.values.forEach((propertyValue) => {
+                        if (!propertyValue.value && fileNode.name !== 'defaultDS') {
+                            const diagnostic = {
+                                node: fileNode,
+                                severity: 'error',
+                                message: `数据源配置：数据源${property.name}${propertyValue.env === 'dev' ? '开发环境' : '生产环境'}未配置数据信息`,
+                                // 保留原来的内容方便查询一些问题
+                                originalDiagnostic: {
+                                    fileName: '',
+                                    start: null,
+                                    end: null,
+                                    category: 'error',
+                                    text: `Data Source is not config`,
+                                },
+                            };
+                            diagnostics.push(diagnostic);
+                        }
+                    });
+                }
+            }
+        }
+        return diagnostics;
+    },
+    /* 接口导入查找 */
+    existStructureFix(semanticDiagnostics, node, that) {
+        let module;
+        semanticDiagnostics.map((diag) => {
+            const minRange = this._findMinRange(diag, node);
+            if (diag.text?.includes('has no exported member named')) {
+                if (minRange.node instanceof concepts_1.Logic) {
+                    return null;
+                }
+                const typeAnnotation = minRange.node instanceof concepts_1.TypeAnnotation ? minRange.node.upperNode.typeAnnotation : minRange.node.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.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, 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(concepts_1.TypeAnnotation.from(item.typeannotation));
+                });
+                app.emit('collect:end');
+                actionArr = [];
+                isChangeInterface = false;
+                clearTimeout(timer);
+                timer = null;
+            }, 2000);
+        }
+    },
     _resolveDiagnostic(diagnostic, fileNode) {
         const minRange = this._findMinRange(diagnostic, fileNode);
         const tsErrorDetail = {
@@ -538,6 +670,33 @@ const naslServer = {
                 }
             }
         }
+        // 如果是DataSource就需要在单独，查一边来修改名字
+        if (node instanceof concepts_1.DataSource) {
+            // 过滤一把不需要改的信息
+            refsList = refsList.filter((item) => {
+                const dataSourceFile = fileNode.getEmbeddedFilePath();
+                const entityFilePrefix = dataSourceFile.replace('.ts', '');
+                /**
+                 * 特殊处理,因为关联属性或者关联实体等等都是在实体里,在实体中因为自己不可以是自己的类型
+                 * 所以全部过滤掉了,
+                 * 但是在datasource里面在实体里会有大量的引用,不需要全部修改.只需要处理除了8个函数之外的引用
+                 * 所以底部内容是8个函数,所以这里就 用entity的行数 减去8个函数的行数,然后其余的在进行处理
+                 * 进行过滤
+                 */
+                // 不要数据源下面的实体里的引用 ,保留原始的节点内容
+                let flag = false;
+                if (item.file.includes(entityFilePrefix)) {
+                    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) {
+                        flag = true;
+                    }
+                }
+                // 属于实体而且需要修改和查到  ||  不是实体前缀的 || 他本身
+                return flag || !item.file.includes(entityFilePrefix) || dataSourceFile === item.file;
+            });
+        }
         // 如果是entity就需要在单独，查一边来修改名字
         if (node instanceof concepts_1.Entity) {
             // 过滤一把不需要改的信息
@@ -819,20 +978,20 @@ const naslServer = {
                 // logic 和 views名称修改 可能会触发bindEvent修改
                 if (minRange.node instanceof concepts_1.BindEvent) {
                     // 页面逻辑直接赋值就可以, 因为是相对路径
-                    if ((node instanceof concepts_1.ViewElement)) {
+                    if (node instanceof concepts_1.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;
                         // 先看下标位置
@@ -893,19 +1052,70 @@ const naslServer = {
                 if (minRange.node instanceof concepts_1.QueryFieldExpression && node instanceof concepts_1.Entity) {
                     minRange.setTypeMethods = 'setEntityAsName';
                 }
+                // 如果修改的是dataSource字段
+                if (node instanceof concepts_1.DataSource) {
+                    const setTypeNamespace = (typeNamespace, record) => {
+                        // 先看下标位置
+                        const lineText = record.lineText;
+                        const index = lineText.indexOf(typeNamespace);
+                        // 在把开始结束位置的-开始位置，来知道是哪里要替换
+                        const start = record.start.offset - index - 1;
+                        const end = record.end.offset - index - 1;
+                        // 新的完整的value
+                        const newTextValue = typeNamespace.substring(0, start) + newValue + typeNamespace.substring(end, typeNamespace.length);
+                        minRange.newValue = newTextValue;
+                        return newTextValue;
+                    };
+                    if (minRange.node instanceof concepts_1.TypeAnnotation) {
+                        minRange.setTypeMethods = 'setTypeNamespace';
+                        const newValue = setTypeNamespace(minRange.node.typeNamespace, record);
+                        minRange.newValue = newValue;
+                    }
+                    else if (minRange.node instanceof concepts_1.QueryFromExpression || minRange.node instanceof concepts_1.QueryJoinExpression) {
+                        minRange.setTypeMethods = 'setEntityNamespace';
+                        const newValue = setTypeNamespace(minRange.node.entityNamespace, record);
+                        minRange.newValue = newValue;
+                    }
+                    else if (minRange.node instanceof concepts_1.QueryFieldExpression) {
+                        return null;
+                    }
+                    else if (minRange.node instanceof concepts_1.CallLogic) {
+                        minRange.setTypeMethods = 'setCalleeNamespace';
+                        const newValue = setTypeNamespace(minRange.node.calleeNamespace, record);
+                        minRange.newValue = newValue;
+                    }
+                    else if (minRange.node instanceof concepts_1.EntityProperty) {
+                        minRange.setTypeMethods = 'setRelationNamespace';
+                        const newValue = setTypeNamespace(minRange.node.relationNamespace, record);
+                        minRange.newValue = newValue;
+                    }
+                    else if (minRange.node instanceof concepts_1.SqlQueryComponent) {
+                        minRange.setTypeMethods = 'setDataSource';
+                    }
+                }
+                if (minRange.node instanceof concepts_1.QueryGroupByExpression && node instanceof concepts_1.Entity) {
+                    minRange.setTypeMethods = 'setEntityAsName';
+                }
                 if ((minRange.node instanceof concepts_1.QueryFromExpression || minRange.node instanceof concepts_1.QueryJoinExpression) && node instanceof concepts_1.Entity) {
                     minRange.setTypeMethods = 'setEntityName';
                 }
                 if (minRange.node instanceof concepts_1.QueryFieldExpression && node instanceof concepts_1.EntityProperty) {
                     minRange.setTypeMethods = 'setPropertyName';
                 }
+                if (minRange.node instanceof concepts_1.QueryGroupByExpression && node instanceof concepts_1.EntityProperty) {
+                    minRange.setTypeMethods = 'setPropertyName';
+                }
                 // 如果跳转链接或者页面变量同一个param和TypeAnnotation 有两个过滤掉一个
-                if ((minRange.node instanceof concepts_1.Param || minRange.node instanceof concepts_1.Variable || minRange.node instanceof concepts_1.Return) && (node instanceof concepts_1.Entity || node instanceof concepts_1.Enum || node instanceof concepts_1.Structure)) {
+                if ((minRange.node instanceof concepts_1.Param || minRange.node instanceof concepts_1.Variable || minRange.node instanceof concepts_1.Return)
+                    && (node instanceof concepts_1.Entity || node instanceof concepts_1.Enum || node instanceof concepts_1.Structure)) {
                     return null;
                 }
                 if (minRange.node instanceof concepts_1.Destination && (node instanceof concepts_1.Process || node instanceof concepts_1.ProcessElement)) {
                     return null;
                 }
+                if (minRange.node instanceof concepts_1.Assignee && (node instanceof concepts_1.Process || node instanceof concepts_1.ProcessElement)) {
+                    return null;
+                }
                 // 枚举修改枚举名，比较特殊
                 if (minRange.node instanceof concepts_1.EnumItem && node instanceof concepts_1.Enum) {
                     // 什么都不做，用来跳过修改
@@ -936,7 +1146,7 @@ const naslServer = {
                     /**
                      * 这里过滤一下，一些查找引用，重复的内容，直接屏蔽掉，防止操作重复
                      * 因为在生成的时候 ，可能弄了一些副作用的引用
-                    */
+                     */
                     // 本来是想在上面过滤一把的先放到这里匹配这两个的时候 就会找到
                     // refsList = refsList.filter((item) => {
                     //     屏蔽组件查找查到定义这里，也过滤一下
@@ -951,7 +1161,7 @@ const naslServer = {
                  * 流程改名不触发Logic改名
                  * 如果是修改param查找到logic就不操作
                  * 除非想在内部修改别的内容所以暂时屏蔽掉
-                */
+                 */
                 if (minRange.node instanceof concepts_1.Logic && node !== minRange.node) {
                     return null;
                 }
@@ -967,18 +1177,9 @@ const naslServer = {
         console.log(result);
         return result;
     },
-    _addParamsPrepare(node, refsList) {
-        const App = node.rootNode;
-        const parantNode = node.parentNode;
-        // 收集修改
-        App.emit('collect:start', {
-            actionMsg: '增加逻辑参数',
-        });
-        node.create({
-            index: 0,
-            parentNode: parantNode,
-            parentKey: node.parentKey,
-        });
+    // 增加参数的副作用，用于更新logic和view
+    _addParamsEffect(refsList, node) {
+        const parantNode = node?.parentNode;
         refsList.forEach((record) => {
             const fileNode = this.file2NodeMap.get(record.file);
             if (!fileNode)
@@ -987,27 +1188,45 @@ const naslServer = {
             if (minRange) {
                 // 如果找到节点是callLogic就去更新
                 if (minRange.node instanceof concepts_1.CallLogic && node instanceof concepts_1.Param) {
-                    minRange.node.setCalleeArgName((parantNode));
+                    minRange.node.setCalleeArgName(parantNode);
                 }
                 // 如果节点参数增加页面也要更新
                 if (minRange.node instanceof concepts_1.Destination && node instanceof concepts_1.Param) {
-                    minRange.node.setViewArgument((parantNode));
+                    minRange.node.setViewArgument(parantNode);
                 }
             }
         });
-        // 结束修改 ，批量操作
-        App.emit('collect:end');
+    },
+    _addParamsPrepare(node, refsList, needAdd) {
+        if (needAdd) {
+            const App = node?.rootNode;
+            const parantNode = node?.parentNode;
+            // 收集修改
+            App.emit('collect:start', {
+                actionMsg: '增加逻辑参数',
+            });
+            node.create({
+                index: 0,
+                parentNode: parantNode,
+                parentKey: node.parentKey,
+            });
+            naslServer._addParamsEffect(refsList, node);
+            // 结束修改 ，批量操作
+            App.emit('collect:end');
+            return node;
+        }
+        naslServer._addParamsEffect(refsList, node);
+        return node;
     },
     // 查找引用
     async findReferences(node) {
         let refsList = await naslServer._isHaveRef(node);
         // 如果查找引用查到自己里面的引用不展示
-        refsList = refsList.filter((item) => {
-            // 自己引用自己的过滤掉
-            // 删除的时候过滤一把组件删除提示
-            // 展示组件自己屏蔽掉
-            return !item.isDefinition && !(item.lineText.includes(' = new nasl.ui.'));
-        });
+        refsList = refsList.filter((item) => 
+        // 自己引用自己的过滤掉
+        // 删除的时候过滤一把组件删除提示
+        // 展示组件自己屏蔽掉
+        !item.isDefinition && !item.lineText.includes(' = new nasl.ui.'));
         // 最后返回的结果
         let result = new Map();
         // 树的构造，key： 一个file的node， 值是 [[logic, params],[logic, returns]]
@@ -1040,14 +1259,15 @@ const naslServer = {
     // 获取节点的上层渲染
     _getTreeMap(minRange, fileNode, resMap, nodeMap) {
         const minRangeNode = minRange.node;
-        let parantNode = minRangeNode;
+        let currentNode = minRangeNode;
+        let parantNode = currentNode.parentNode;
         // 顺序队列
         const queue = [];
         // 先插入自己,如果没有在往上找,
         // 一直到file节点的父级
         while (!(parantNode instanceof concepts_1.App)) {
             // 找到上一级 在map对象中构造出他的子集
-            const currentNode = parantNode;
+            currentNode = parantNode;
             parantNode = parantNode.parentNode;
             // 如果第一次就塞入子集和父节点，以后就只用父节点了
             // 因为部分节点没有name，先过滤掉
@@ -1094,12 +1314,12 @@ const naslServer = {
             }
         }
         // 一个logic 或者 view可能会有多个顺序队列
-        if (resMap.get(fileNode)) {
+        if (resMap.get(currentNode)) {
             // 是否展示两个内容全等，但是两个queue的node可能不一样，但是只需要展示一个
-            resMap.get(fileNode).push(queue);
+            resMap.get(currentNode).push(queue);
         }
         else {
-            resMap.set(fileNode, [queue]);
+            resMap.set(currentNode, [queue]);
         }
     },
     handleTreeMap(resMap) {
@@ -1166,8 +1386,14 @@ const naslServer = {
         let sourceMap = node.sourceMap;
         let fileNode = node;
         // 如果没有sourceMap,就继续向上找 ,或者到module结束
-        // 如果 节点找到 app 或者module 停止
-        while (!sourceMap && fileNode && !(fileNode.parentNode instanceof concepts_1.App) && !(fileNode.parentNode instanceof concepts_1.Module) && !(fileNode instanceof concepts_1.View)) {
+        // 如果 节点找到 app 或者module 停止 或者entity找到DataSource为止
+        // 如果当前节点是view就不要向上查找了
+        while (!sourceMap
+            && fileNode
+            && !(fileNode.parentNode instanceof concepts_1.App)
+            && !(fileNode.parentNode instanceof concepts_1.Module)
+            && !(fileNode.parentNode instanceof concepts_1.DataSource)
+            && !(fileNode instanceof concepts_1.View)) {
             fileNode = fileNode.parentNode;
             sourceMap = fileNode?.sourceMap;
         }
@@ -1240,320 +1466,6 @@ async function handleDelete(fileNode, targetNode, result) {
     await naslServer.updateFiles({ outputFiles });
     newRefs.refs.forEach((ref) => filesToCheck.add(ref.file));
 }
-concepts_1.BaseNode.prototype.findReadOnlyLogicUsage = function () {
-    let targetNode;
-    if (this.parentNode.concept === 'Namespace' || this.parentNode.parentNode.concept === 'Namespace') {
-        const sourceMap = this.parentNode.concept === 'Namespace' ? this.parentNode.parentNode.sourceMap : this.parentNode.parentNode.parentNode.sourceMap;
-        for (const item of sourceMap) {
-            const logic = item[0];
-            if (this.concept === 'Logic') {
-                if (logic instanceof concepts_1.Logic)
-                    if (logic.calleewholeKey === this.calleewholeKey) {
-                        targetNode = logic;
-                        break;
-                    }
-            }
-            else {
-                if (logic instanceof concepts_1.Logic)
-                    if (logic.calleewholeKey === this.parentNode.calleewholeKey) {
-                        targetNode = logic;
-                        break;
-                    }
-            }
-        }
-    }
-    else if (this.parentNode.concept === 'Module') {
-        // 父级是模块的还是用它本身去查找引用
-        targetNode = this;
-    }
-    else {
-        const sourceMap = this.parentNode.sourceMap;
-        for (const item of sourceMap) {
-            const logic = item[0];
-            if (logic.getNamespace && logic.getNamespace() === this.getNamespace()) {
-                targetNode = logic;
-                break;
-            }
-        }
-    }
-    try {
-        return naslServer.findReferences(targetNode);
-    }
-    catch (err) {
-        console.log(err);
-    }
-};
-// 查找引用
-concepts_1.BaseNode.prototype.findUsage = function findUsage() {
-    try {
-        return naslServer.findReferences(this);
-    }
-    catch (err) {
-        console.log(err);
-    }
-};
-concepts_1.BaseNode.prototype.changeName = async function changeName(newValue, updateAll = false) {
-    console.log(newValue);
-    console.log(this);
-    try {
-        /**
-         * 查找这个节点是不是有依赖
-         */
-        const refsList = await naslServer._isHaveRef(this);
-        // 是不是有引用有的话，就返回
-        /**
-         * @param this 当前重命名的节点
-         * @param newValue 传递过来的新值，给MemberExpression用的比较特殊
-         * 而且，这个新值不一定会用到，MemberExpression在批量更新的时候，可以取到新的value， 这里需要位置信息防止 a.a.a.a 中的一个a发生修改
-         * @returns 找到的引用
-         */
-        const res = naslServer._renamePrepare(this, refsList, newValue);
-        if (res.length <= 1) {
-            this.setName(newValue);
-        }
-        else {
-            const callback = (value) => {
-                if (value) {
-                    const App = this.rootNode;
-                    // 收集修改
-                    App.emit('collect:start', {
-                        actionMsg: '重命名并更新引用',
-                    });
-                    res.forEach((item) => {
-                        const itemNode = item.node;
-                        if (item.newValue) {
-                            // 如果有指定的修改方法，就用那个，没有就修改名字
-                            item.setTypeMethods ? itemNode[item.setTypeMethods](item.newValue) : itemNode.setName?.(item.newValue);
-                        }
-                        else {
-                            item.setTypeMethods ? itemNode[item.setTypeMethods](newValue) : itemNode.setName?.(newValue);
-                        }
-                    });
-                    // 结束修改 ，批量操作
-                    App.emit('collect:end');
-                }
-                else {
-                    this.setName(newValue);
-                }
-            };
-            const confirmParms = {
-                actionType: 'rename',
-                node: this,
-                newValue,
-            };
-            /**
-             * nasl和vue的通信，回退，要触发vue的watch。
-             * 因为如果没修改的话nasl不会修改view，就不会通知到页面改成旧值
-             * 先修改之
-             */
-            const closeCallBack = () => {
-                if (this.concept === 'EnumItem') {
-                    const oldValue = this.value;
-                    this.value = oldValue + ' ';
-                    setTimeout(() => {
-                        this.value = oldValue;
-                    }, 0);
-                }
-                else {
-                    const oldValue = this.name;
-                    this.name = oldValue + ' ';
-                    setTimeout(() => {
-                        this.name = oldValue;
-                    }, 0);
-                }
-            };
-            updateAll ? callback(true) : (0, common_1.invokeCommand)('tsConfirm.open', confirmParms, callback, closeCallBack);
-            return;
-        }
-    }
-    catch (err) {
-        console.log(err);
-    }
-};
-/**
- * 准备删除
- */
-concepts_1.BaseNode.prototype.prepareDelete = async function prepareDelete() {
-    try {
-        /**
-         * 查找这个节点是不是有依赖
-         */
-        const node = this;
-        let refsList = await naslServer._isHaveRef(node);
-        // 删除的时候过滤一把组件删除提示
-        refsList = refsList.filter((item) => {
-            // 因为ui组件本身会多渲染一次,就先过滤一个 
-            return !(item.lineText.includes(': nasl.ui.'));
-        });
-        // 删除参数单独处理
-        if (node instanceof concepts_1.Param) {
-            const methodRefs = [];
-            refsList.forEach((item) => {
-                // 入参查找引用,查到logic 和自己,内容完全一样,就保留一个
-                const find = methodRefs.find((findItem) => item.lineText === findItem.lineText);
-                if (!find) {
-                    methodRefs.push(item);
-                }
-            });
-            refsList = methodRefs;
-        }
-        // delete的弹框展示
-        const confirmParms = {
-            actionType: 'delete',
-            tipFlag: false,
-            node,
-            icon: 'warning',
-        };
-        let callback = null;
-        if (refsList.length <= 1) {
-            // 页面组件直接删除然后return
-            if (node instanceof concepts_1.ViewElement) {
-                this.delete();
-                return;
-            }
-            callback = () => {
-                // Structure 和 Interface是内部有delete方法
-                if (node instanceof concepts_1.Structure || node instanceof concepts_1.Interface) {
-                    this.deleteLogincAndModule();
-                }
-                else {
-                    this.delete();
-                }
-            };
-        }
-        else {
-            // 如果有依赖就有一个查找引用提示
-            confirmParms.tipFlag = true;
-            const node = this;
-            // 删除页面或者流程
-            if (node instanceof concepts_1.View || node instanceof concepts_1.Process) {
-                /**
-                 * 查找这个页面是不是有依赖
-                 */
-                let viewPath = this.getEmbeddedFilePath();
-                viewPath = viewPath.slice(0, viewPath.length - 3);
-                const find = refsList.find((record) => !record.file.includes(viewPath));
-                // 如果没有别的文件的依赖，就直接delete
-                if (!find) {
-                    this.delete();
-                    return;
-                }
-            }
-            callback = () => {
-                // removeParam
-                // 跟rename 还不太一样，部分修改依赖修改好的值，然后在下面的修改需要把自己传递进去
-                if (node instanceof concepts_1.Param) {
-                    const App = this.rootNode;
-                    const parentNode = this.parentNode;
-                    // 收集修改
-                    App.emit('collect:start', {
-                        actionMsg: '删除参数',
-                    });
-                    this.delete();
-                    refsList.forEach((record) => {
-                        const fileNode = naslServer.file2NodeMap.get(record.file);
-                        if (!fileNode)
-                            return null;
-                        const minRange = naslServer._findMinRange(record, fileNode);
-                        if (minRange) {
-                            if (minRange.node instanceof concepts_1.CallLogic) {
-                                minRange.node.setCalleeArgName(parentNode);
-                            }
-                            if (minRange.node instanceof concepts_1.Destination) {
-                                minRange.node.setViewArgument(parentNode);
-                            }
-                        }
-                    });
-                    // 结束修改 ，批量操作
-                    App.emit('collect:end');
-                    return;
-                }
-                // 删除logic节点，如果有对应的interface要一起删除
-                if (node instanceof concepts_1.Logic) {
-                    const App = this.rootNode;
-                    // 收集修改
-                    App.emit('collect:start', {
-                        actionMsg: '删除逻辑并删除导出的接口',
-                    });
-                    this.delete();
-                    refsList.forEach((record) => {
-                        const fileNode = naslServer.file2NodeMap.get(record.file);
-                        if (!fileNode)
-                            return null;
-                        const minRange = naslServer._findMinRange(record, fileNode);
-                        if (minRange) {
-                            if (minRange.node instanceof concepts_1.Interface) {
-                                minRange.node.delete();
-                            }
-                        }
-                    });
-                    // 结束修改 ，批量操作
-                    App.emit('collect:end');
-                    return;
-                }
-                // 删除权限节点
-                if (node instanceof concepts_1.Role) {
-                    const App = this.rootNode;
-                    // 收集修改
-                    App.emit('collect:start', {
-                        actionMsg: '删除权限',
-                    });
-                    this.delete();
-                    refsList.forEach((record) => {
-                        const fileNode = naslServer.file2NodeMap.get(record.file);
-                        if (!fileNode)
-                            return null;
-                        const minRange = naslServer._findMinRange(record, fileNode);
-                        if (minRange) {
-                            if (minRange.node instanceof concepts_1.View || minRange.node instanceof concepts_1.ViewElement) {
-                                // oldName旧的节点存的值
-                                // newValue用户输入值
-                                // node.bindRoles 存的
-                                const str = minRange.node.bindRoles.toString().replace(this.name, '');
-                                const newBindRoles = str.split(',').filter((item) => !!item);
-                                minRange.node.setBindRoles(newBindRoles);
-                            }
-                        }
-                    });
-                    // 结束修改 ，批量操作
-                    App.emit('collect:end');
-                    return;
-                }
-                // 删除页面或者流程,如果上一步没有return 就说明他是有别的引用的，会有引用弹框
-                if (node instanceof concepts_1.View || node instanceof concepts_1.Process) {
-                    this.delete();
-                }
-                // 其余的都直接调用删除
-                // Structure 和 Interface是内部有delete方法
-                if (node instanceof concepts_1.Structure || node instanceof concepts_1.Interface) {
-                    this.deleteLogincAndModule();
-                }
-                else {
-                    this.delete();
-                }
-            };
-        }
-        (0, common_1.invokeCommand)('tsConfirm.open', confirmParms, callback);
-    }
-    catch (err) {
-        console.log(err);
-    }
-};
-/**
- * 如果添加需要触发查找引用并且在之后，对内容产生影响
- */
-concepts_1.BaseNode.prototype.addParamsPrepare = async function addParamsPrepare() {
-    try {
-        /**
-         * 查找这个节点是不是有依赖
-         */
-        const refsList = await naslServer._isHaveRef(this);
-        return naslServer._addParamsPrepare(this, refsList);
-    }
-    catch (err) {
-        console.log(err);
-    }
-};
 /**
  * 除去rename场景下的更新
  * @param fileNode 文件级别的节点
@@ -1676,6 +1588,7 @@ async function incidentalAction(action, fileNode, targetNode, oldpath) {
             for (let i = 0; i < fileNodeChildren.length; i++) {
                 const fileNodeItem = fileNodeChildren[i];
                 const result = fileNodeItem.toEmbeddedTSFile();
+                fileNodeItem.sourceMap = result.sourceMap;
                 if (action === 'create') {
                     await handleChange(fileNodeItem, fileNodeItem, result, action);
                     await incidentalAction(action, fileNodeItem, fileNodeItem);
@@ -1692,12 +1605,14 @@ async function incidentalAction(action, fileNode, targetNode, oldpath) {
                     await incidentalAction(action, fileNodeItem, fileNodeItem, currentOldPath);
                 }
             }
-            ;
         }
         // 删除或新增模块
         // 需要把下面的哦内容全部都更新一遍
         if (fileNode instanceof concepts_1.Module) {
-            const module = (targetNode);
+            if (fileNode.type === 'interface' && fileNode.isAdd && action === 'create') {
+                isChangeInterface = true;
+            }
+            const module = targetNode;
             const results = [];
             naslServer.contentToFile(module, results);
             for (let i = 0; i < results.length; i++) {
@@ -1710,7 +1625,6 @@ async function incidentalAction(action, fileNode, targetNode, oldpath) {
                     await handleDelete(node, node, result);
                 }
             }
-            ;
             // 删除模块通知更新列表
             if (action === 'delete') {
                 try {
@@ -1722,6 +1636,23 @@ async function incidentalAction(action, fileNode, targetNode, oldpath) {
                 }
             }
         }
+        /**
+         * DataSource只会重命名时候，需要把子集全部重新生成一下
+         */
+        if (fileNode instanceof concepts_1.DataSource) {
+            fileNode.entities.forEach(async (entity) => {
+                try {
+                    const result = entity.toEmbeddedTSFile();
+                    const parentPath = oldpath.replace('.ts', '/');
+                    const currentOldPath = parentPath + '/entities/' + entity.name + '.ts';
+                    // 因为重命名这里只有当前修改父级的 旧名称, 所以他的子集也要根据旧名称去查依赖 更新内容
+                    await handleRename(entity, entity, result, currentOldPath);
+                }
+                catch (err) {
+                    console.log(err);
+                }
+            });
+        }
     }
 }
 async function receiveHandleChange($event) {