@lcap/nasl 1.0.1 → 2.12.0-beta.1

package/src/server/naslServer.ts

@@ -23,6 +23,7 @@ import {
     QueryFromExpression,
     QueryJoinExpression,
     QueryFieldExpression,
+    QueryGroupByExpression,
     Identifier,
     CallLogic,
     EnumItem,
@@ -43,6 +44,9 @@ import {
     Namespace,
     Theme,
     Variable,
+    DataSource,
+    Assignee,
+    SqlQueryComponent,
 } from '../concepts';
 import { lsp2tspNumber, SourceMap, SourceMapItem, embeddedTSEmitter } from '../translator';
 import axios from '../service/storage';
@@ -51,6 +55,7 @@ import { EventPayload, invokeCommand, registerCommand } from '../common';
 import { DiagnosticRecord, Diagnostic, default as diagnosticManager } from '../manager/diagnostic';
 import formatUiTs from './createUiTs';
 import { primitiveTypeList } from '../concepts/basics/types/coreTypeList';
+import { traverse } from '../utils';
 
 const EmbeddedTSFileLineMap: { [name: string]: number } = {
     Entity: 3,
@@ -58,7 +63,7 @@ const EmbeddedTSFileLineMap: { [name: string]: number } = {
 // 要Check的文件
 const filesToCheck: Set<string> = new Set();
 
-interface FileNode extends BaseNode {
+export interface FileNode extends BaseNode {
     getEmbeddedFilePath(name?: string): string;
     toEmbeddedTSFile(): {
         code: string;
@@ -86,7 +91,7 @@ const messager = new Messager({
     },
 });
 
-interface reNameMinRange extends MinRange {
+interface RenameMinRange extends MinRange {
     newValue?: any;
     setTypeMethods?: string;
 }
@@ -97,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,
@@ -139,17 +148,30 @@ const naslServer = {
                 console.log(err);
             }
         });
-        module.entities.forEach((entity) => {
+        (module as App).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 {
                 const result = _interface.toEmbeddedTSFile();
@@ -377,28 +399,34 @@ const naslServer = {
              * fileNode
              */
             const { currentSource, fileNode } = naslServer.getCurrentSource(callFunction);
-            const quickInfo = await naslServer._getTypeQuickinfo({
-                file: (fileNode as FileNode).getEmbeddedFilePath(),
-                line: lsp2tspNumber(currentSource.range.start.line),
-                offset: lsp2tspNumber(currentSource.range.start.character) + `nasl.util.C`.length,
-            });
-            if (quickInfo.responseRequired) {
-                const displayString = quickInfo?.response?.displayString || '';
-                const typeList = naslServer.getDisplayString2Type(displayString);
-                let res: Array<TypeAnnotation> = [];
-                typeList.forEach((type) => {
-                    const typeAnnotation = primitiveTypeList.find((typeAnnotation) => typeAnnotation.typeName === type);
-                    if (typeAnnotation) {
-                        res.push(typeAnnotation);
-                    } else if (type === 'unknown' || type === 'never') {
-                        return null;
-                    }
+            try {
+                const quickInfo = await naslServer._getTypeQuickinfo({
+                    file: (fileNode as FileNode).getEmbeddedFilePath(),
+                    line: lsp2tspNumber(currentSource.range.start.line),
+                    offset: lsp2tspNumber(currentSource.range.start.character) + `nasl.util.C`.length,
                 });
-                if (!res.length) {
-                    return [];
-                } else {
-                    return [{ title: '基础类型', children: res }];
+                if (quickInfo.responseRequired) {
+                    const displayString = quickInfo?.response?.displayString || '';
+                    const typeList = naslServer.getDisplayString2Type(displayString);
+                    const res: Array<TypeAnnotation> = [];
+                    typeList.forEach((type) => {
+                        const typeAnnotation = primitiveTypeList.find((typeAnnotation) => typeAnnotation.typeName === type);
+                        if (typeAnnotation) {
+                            res.push(typeAnnotation);
+                        } else if (type === 'unknown' || type === 'never') {
+                            return null;
+                        }
+                    });
+                    if (!res.length) {
+                        return [];
+                    } else {
+                        return [{ title: '基础类型', children: res }];
+                    }
                 }
+            } catch (err) {
+                console.log(err);
+                // 如果有异常就先放开全部可选，兜底逻辑
+                return [];
             }
         } else {
             // 字符串 和 inter
@@ -472,11 +500,14 @@ 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);
+            record.semanticDiagnostics.push(...this._attachDiagnostics(node));
 
             // 建议诊断
             // 实体下的建议不用展示，因为都是平台自己写的逻辑
@@ -497,8 +528,113 @@ const naslServer = {
             record.suggestionDiagnostics = [];
             // 语法诊断暂时不需要
         });
+
         return records;
     },
+    _attachDiagnostics(fileNode: BaseNode): Diagnostic[] {
+        const diagnostics: Diagnostic[] = [];
+        if (fileNode instanceof View) {
+            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 } as ViewElement });
+        }
+        if (fileNode instanceof DataSource) {
+            const dataSourceGroup = (fileNode.rootNode as App).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: <any>null,
+                                    end: <any>null,
+                                    category: 'error',
+                                    text: `Data Source is not config`,
+                                },
+                            };
+                            diagnostics.push(diagnostic);
+                        }
+                    });
+                }
+            }
+        }
+
+        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 = {
@@ -592,6 +728,33 @@ const naslServer = {
             }
         }
 
+        // 如果是DataSource就需要在单独，查一边来修改名字
+        if (node instanceof DataSource) {
+            // 过滤一把不需要改的信息
+            refsList = refsList.filter((item) => {
+                const dataSourceFile = (fileNode as 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 Entity) {
             // 过滤一把不需要改的信息
@@ -698,7 +861,7 @@ const naslServer = {
                 const fileNode = this.file2NodeMap.get(record.file);
                 if (!fileNode)
                     return null;
-                const minRange: reNameMinRange = this._findMinRange(record, fileNode as FileNode);
+                const minRange: RenameMinRange = this._findMinRange(record, fileNode as FileNode);
                 if (minRange) {
                     // 如果节点是TypeAnnotation类型,
                     // 很复杂，可能是多级嵌套结构
@@ -876,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;
 
@@ -950,6 +1113,45 @@ const naslServer = {
                     if (minRange.node instanceof QueryFieldExpression && node instanceof Entity) {
                         minRange.setTypeMethods = 'setEntityAsName';
                     }
+                    // 如果修改的是dataSource字段
+                    if (node instanceof DataSource) {
+                        const setTypeNamespace = (typeNamespace: string, record: any) => {
+                            // 先看下标位置
+                            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 TypeAnnotation) {
+                            minRange.setTypeMethods = 'setTypeNamespace';
+                            const newValue = setTypeNamespace(minRange.node.typeNamespace, record);
+                            minRange.newValue = newValue;
+                        } else if (minRange.node instanceof QueryFromExpression || minRange.node instanceof QueryJoinExpression) {
+                            minRange.setTypeMethods = 'setEntityNamespace';
+                            const newValue = setTypeNamespace(minRange.node.entityNamespace, record);
+                            minRange.newValue = newValue;
+                        } else if (minRange.node instanceof QueryFieldExpression) {
+                            return null;
+                        } else if (minRange.node instanceof CallLogic) {
+                            minRange.setTypeMethods = 'setCalleeNamespace';
+                            const newValue = setTypeNamespace(minRange.node.calleeNamespace, record);
+                            minRange.newValue = newValue;
+                        } else if (minRange.node instanceof EntityProperty) {
+                            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) {
+                        minRange.setTypeMethods = 'setEntityAsName';
+                    }
 
                     if ((minRange.node instanceof QueryFromExpression || minRange.node instanceof QueryJoinExpression) && node instanceof Entity) {
                         minRange.setTypeMethods = 'setEntityName';
@@ -957,14 +1159,23 @@ const naslServer = {
                     if (minRange.node instanceof QueryFieldExpression && node instanceof EntityProperty) {
                         minRange.setTypeMethods = 'setPropertyName';
                     }
+                    if (minRange.node instanceof QueryGroupByExpression && node instanceof EntityProperty) {
+                        minRange.setTypeMethods = 'setPropertyName';
+                    }
 
                     // 如果跳转链接或者页面变量同一个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)) {
                         return null;
                     }
+                    if (minRange.node instanceof Assignee && (node instanceof Process || node instanceof ProcessElement)) {
+                        return null;
+                    }
                     // 枚举修改枚举名，比较特殊
                     if (minRange.node instanceof EnumItem && node instanceof Enum) {
                         // 什么都不做，用来跳过修改
@@ -995,7 +1206,7 @@ const naslServer = {
                         /**
                          * 这里过滤一下，一些查找引用，重复的内容，直接屏蔽掉，防止操作重复
                          * 因为在生成的时候 ，可能弄了一些副作用的引用
-                        */
+                         */
                         // 本来是想在上面过滤一把的先放到这里匹配这两个的时候 就会找到
                         // refsList = refsList.filter((item) => {
                         //     屏蔽组件查找查到定义这里，也过滤一下
@@ -1010,7 +1221,7 @@ const naslServer = {
                      * 流程改名不触发Logic改名
                      * 如果是修改param查找到logic就不操作
                      * 除非想在内部修改别的内容所以暂时屏蔽掉
-                    */
+                     */
                     if (minRange.node instanceof Logic && node !== minRange.node) {
                         return null;
                     }
@@ -1026,18 +1237,9 @@ const naslServer = {
         console.log(result);
         return result;
     },
-    _addParamsPrepare(node: BaseNode, refsList: any[]) {
-        const App = node.rootNode;
-        const parantNode = node.parentNode as Logic | View;
-        // 收集修改
-        App.emit('collect:start', {
-            actionMsg: '增加逻辑参数',
-        });
-        node.create({
-            index: 0,
-            parentNode: parantNode,
-            parentKey: node.parentKey,
-        });
+    // 增加参数的副作用，用于更新logic和view
+    _addParamsEffect(refsList: any[], node: Param) {
+        const parantNode = node?.parentNode as Logic | View;
         refsList.forEach((record) => {
             const fileNode = this.file2NodeMap.get(record.file);
             if (!fileNode)
@@ -1046,27 +1248,45 @@ 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);
                 }
             }
         });
-        // 结束修改 ，批量操作
-        App.emit('collect:end');
+    },
+    _addParamsPrepare(node: BaseNode, refsList: any[], needAdd: boolean) {
+        if (needAdd) {
+            const App = node?.rootNode;
+            const parantNode = node?.parentNode as Logic | View;
+            // 收集修改
+            App.emit('collect:start', {
+                actionMsg: '增加逻辑参数',
+            });
+            node.create({
+                index: 0,
+                parentNode: parantNode,
+                parentKey: node.parentKey,
+            });
+            naslServer._addParamsEffect(refsList, node as Param);
+            // 结束修改 ，批量操作
+            App.emit('collect:end');
+            return node;
+        }
+        naslServer._addParamsEffect(refsList, node as Param);
+        return node;
     },
     // 查找引用
     async findReferences(node: BaseNode) {
         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]]
@@ -1098,14 +1318,15 @@ const naslServer = {
     // 获取节点的上层渲染
     _getTreeMap(minRange: MinRange, fileNode: BaseNode, resMap: Map<BaseNode, Array<Array<QuoteNode>>>, nodeMap: Map<BaseNode, QuoteNode>) {
         const minRangeNode = minRange.node;
-        let parantNode = minRangeNode;
+        let currentNode = minRangeNode;
+        let parantNode = currentNode.parentNode;
         // 顺序队列
         const queue: any[] = [];
         // 先插入自己,如果没有在往上找,
         // 一直到file节点的父级
         while (!(parantNode instanceof App)) {
             // 找到上一级 在map对象中构造出他的子集
-            const currentNode = parantNode;
+            currentNode = parantNode;
             parantNode = parantNode.parentNode;
             // 如果第一次就塞入子集和父节点，以后就只用父节点了
             // 因为部分节点没有name，先过滤掉
@@ -1153,11 +1374,11 @@ 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: Map<BaseNode, Array<Array<QuoteNode>>>) {
@@ -1224,8 +1445,16 @@ const naslServer = {
         let sourceMap = node.sourceMap;
         let fileNode = node;
         // 如果没有sourceMap,就继续向上找 ,或者到module结束
-        // 如果 节点找到 app 或者module 停止
-        while (!sourceMap && fileNode && !(fileNode.parentNode instanceof App) && !(fileNode.parentNode instanceof Module) && !(fileNode instanceof View)) {
+        // 如果 节点找到 app 或者module 停止 或者entity找到DataSource为止
+        // 如果当前节点是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;
         }
@@ -1297,313 +1526,6 @@ async function handleDelete(fileNode: BaseNode, targetNode: BaseNode, result: Re
 
     newRefs.refs.forEach((ref) => filesToCheck.add(ref.file));
 }
-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] as Logic;
-            if (this.concept === 'Logic') {
-                if (logic instanceof Logic)
-                    if (logic.calleewholeKey === (this as Logic).calleewholeKey) {
-                        targetNode = logic;
-                        break;
-                    }
-            } else {
-                if (logic instanceof Logic)
-                    if (logic.calleewholeKey === (this.parentNode as Logic).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] as Logic;
-            if (logic.getNamespace && logic.getNamespace() === (this as Logic).getNamespace()) {
-                targetNode = logic;
-                break;
-            }
-        }
-    }
-
-    try {
-        return naslServer.findReferences(targetNode);
-    } catch (err) {
-        console.log(err);
-    }
-};
-// 查找引用
-BaseNode.prototype.findUsage = function findUsage() {
-    try {
-        return naslServer.findReferences(this);
-    } catch (err) {
-        console.log(err);
-    }
-};
-BaseNode.prototype.changeName = async function changeName(newValue: string, updateAll: boolean = 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 as SetNameNode).setName(newValue);
-        } else {
-            const callback = (value: boolean) => {
-                if (value) {
-                    const App = this.rootNode;
-                    // 收集修改
-                    App.emit('collect:start', {
-                        actionMsg: '重命名并更新引用',
-                    });
-                    res.forEach((item) => {
-                        const itemNode = item.node as SetNameNode;
-                        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 as SetNameNode).setName(newValue);
-                }
-            };
-            const confirmParms = {
-                actionType: 'rename',
-                node: this,
-                newValue,
-            };
-            /**
-             * nasl和vue的通信，回退，要触发vue的watch。
-             * 因为如果没修改的话nasl不会修改view，就不会通知到页面改成旧值
-             * 先修改之
-             */
-            const closeCallBack = () => {
-                if (this.concept === 'EnumItem') {
-                    const oldValue = (this as EnumItem).value;
-                    (this as EnumItem).value = oldValue + ' ';
-                    setTimeout(() => {
-                        (this as EnumItem).value = oldValue;
-                    }, 0);
-                } else {
-                    const oldValue = this.name;
-                    this.name = oldValue + ' ';
-                    setTimeout(() => {
-                        this.name = oldValue;
-                    }, 0);
-                }
-            };
-            updateAll ? callback(true) : invokeCommand('tsConfirm.open', confirmParms, callback, closeCallBack);
-
-            return;
-        }
-    } catch (err) {
-        console.log(err);
-    }
-};
-
-/**
- * 准备删除
- */
-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 Param) {
-            const methodRefs: tsProtocol.ReferencesResponseItem[] = [];
-            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 ViewElement) {
-                this.delete();
-                return;
-            }
-            callback = () => {
-                // Structure 和 Interface是内部有delete方法
-                if (node instanceof Structure || node instanceof Interface) {
-                    (this as any).deleteLogincAndModule();
-                } else {
-                    this.delete();
-                }
-            };
-        } else {
-            // 如果有依赖就有一个查找引用提示
-            confirmParms.tipFlag = true;
-            const node = this;
-
-            // 删除页面或者流程
-            if (node instanceof View || node instanceof Process) {
-                /**
-                 * 查找这个页面是不是有依赖
-                 */
-                let viewPath = (this as FileNode).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 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: MinRange = naslServer._findMinRange(record, fileNode as FileNode);
-                        if (minRange) {
-                            if (minRange.node instanceof CallLogic) {
-                                minRange.node.setCalleeArgName(parentNode as Logic);
-                            }
-                            if (minRange.node instanceof Destination) {
-                                minRange.node.setViewArgument(parentNode as View);
-                            }
-                        }
-                    });
-                    // 结束修改 ，批量操作
-                    App.emit('collect:end');
-                    return;
-                }
-                // 删除logic节点，如果有对应的interface要一起删除
-                if (node instanceof 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: MinRange = naslServer._findMinRange(record, fileNode as FileNode);
-                        if (minRange) {
-                            if (minRange.node instanceof Interface) {
-                                minRange.node.delete();
-                            }
-                        }
-                    });
-                    // 结束修改 ，批量操作
-                    App.emit('collect:end');
-                    return;
-                }
-                // 删除权限节点
-                if (node instanceof 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: MinRange = naslServer._findMinRange(record, fileNode as FileNode);
-                        if (minRange) {
-                            if (minRange.node instanceof View || minRange.node instanceof 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 View || node instanceof Process) {
-                    this.delete();
-                }
-                // 其余的都直接调用删除
-                // Structure 和 Interface是内部有delete方法
-                if (node instanceof Structure || node instanceof Interface) {
-                    (this as any).deleteLogincAndModule();
-                } else {
-                    this.delete();
-                }
-            };
-        }
-        invokeCommand('tsConfirm.open', confirmParms, callback);
-    } catch (err) {
-        console.log(err);
-    }
-};
-
-/**
- * 如果添加需要触发查找引用并且在之后，对内容产生影响
- */
-BaseNode.prototype.addParamsPrepare = async function addParamsPrepare() {
-    try {
-        /**
-         * 查找这个节点是不是有依赖
-         */
-        const refsList = await naslServer._isHaveRef(this);
-        return naslServer._addParamsPrepare(this, refsList);
-    } catch (err) {
-        console.log(err);
-    }
-};
 
 /**
  * 除去rename场景下的更新
@@ -1737,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);
@@ -1750,12 +1673,15 @@ async function incidentalAction(action: string, fileNode: BaseNode, targetNode:
                     await handleRename(fileNodeItem, fileNodeItem, result, currentOldPath);
                     await incidentalAction(action, fileNodeItem, fileNodeItem, currentOldPath);
                 }
-            };
+            }
         }
         // 删除或新增模块
         // 需要把下面的哦内容全部都更新一遍
         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++) {
@@ -1766,7 +1692,7 @@ async function incidentalAction(action: string, fileNode: BaseNode, targetNode:
                 } else {
                     await handleDelete(node, node, result);
                 }
-            };
+            }
 
             // 删除模块通知更新列表
             if (action === 'delete') {
@@ -1778,6 +1704,22 @@ async function incidentalAction(action: string, fileNode: BaseNode, targetNode:
                 }
             }
         }
+        /**
+         * DataSource只会重命名时候，需要把子集全部重新生成一下
+         */
+        if (fileNode instanceof DataSource) {
+            (fileNode as DataSource).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);
+                }
+            });
+        }
     }
 }
 
@@ -1841,7 +1783,7 @@ embeddedTSEmitter.on('change', ($event: EventPayload) => {
     // 异步状态机,一个完成了在执行下一个
     function next() {
         const item = stackList.shift();
-        receiveHandleChange(item).then(async() => {
+        receiveHandleChange(item).then(async () => {
             if (stackList.length) {
                 next();
             } else {