@lcap/nasl 3.0.0-beta.5 → 3.0.0-beta.7

package/src/concepts/dist/StringLiteral__.js

@@ -0,0 +1,158 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+exports.__esModule = true;
+exports.StringLiteral = void 0;
+var translator_1 = require("../translator");
+var decorators_1 = require("../decorators");
+var classMap_1 = require("../common/classMap");
+var LogicItem__1 = require("./LogicItem__");
+/**
+ * 字符串字面量
+ */
+var StringLiteral = /** @class */ (function (_super) {
+    __extends(StringLiteral, _super);
+    /**
+     * @param source 需要合并的部分参数
+     */
+    function StringLiteral(source) {
+        var _this = this;
+        source = Object.assign({}, StringLiteral_1.getDefaultOptions(), source);
+        _this = _super.call(this, source) || this;
+        /**
+         * 产品概念
+         */
+        _this.concept = 'StringLiteral';
+        /**
+         * 字面量的值
+         */
+        _this.value = '';
+        _super.prototype.subConstructor.call(_this, source);
+        return _this;
+    }
+    StringLiteral_1 = StringLiteral;
+    StringLiteral.prototype.getClassName = function () {
+        return 'StringLiteral';
+    };
+    StringLiteral.from = function (source, parentNode, parentKey) {
+        return _super.from.call(this, source, parentNode, parentKey);
+    };
+    //================================================================================
+    // ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑
+    // 自动生成的代码已结束。下面可以手动编写。
+    //================================================================================
+    StringLiteral.prototype.toVue = function (options) {
+        var code = '';
+        if (typeof this.value === 'string') {
+            code = "`" + this.value + "`";
+            if ((options === null || options === void 0 ? void 0 : options.finalCode) !== false) {
+                code = "`" + this.value.replace(/['"`\\]/g, function (m) {
+                    var escape = '\\\\';
+                    escape = '\\\\';
+                    /// #if process.env.BUILD_TARGET === 'node'
+                    escape = '\\';
+                    /// #endif
+                    if (m === '\\') {
+                        return "" + escape + escape;
+                    }
+                    else {
+                        return "" + escape + m;
+                    }
+                }) + "`";
+            }
+        }
+        return code;
+    };
+    StringLiteral.prototype.toUI = function () {
+        var code = '';
+        if (typeof this.value === 'string') {
+            code = "`" + this.value + "`";
+        }
+        return code;
+    };
+    StringLiteral.prototype.toJS = function () {
+        var code = "";
+        if (typeof this.value === 'string') {
+            code += "`" + this.value.replace(/['"`\\]/g, function (m) { return "\\" + m; }) + "`";
+        }
+        return code;
+    };
+    StringLiteral.prototype.toBrief = function () {
+        return "`" + this.value + "`";
+    };
+    StringLiteral.prototype.toEmbeddedTS = function (state, isRequired) {
+        var code = '';
+        if (typeof this.value === 'string') {
+            code += "new nasl.core.String('StringLiteral')";
+        }
+        else {
+            code += isRequired ? '__IDENTIFIER__' : "''";
+        }
+        return code;
+    };
+    /**
+     * 设置字符串内容
+     */
+    StringLiteral.prototype.setValue = function (value) {
+        var object = {
+            value: value
+        };
+        this.update(__assign({}, object));
+    };
+    /**
+     * 获取添加时的默认选项
+     * @returns
+     */
+    StringLiteral.getDefaultOptions = function () {
+        return { value: '' };
+    };
+    var StringLiteral_1;
+    __decorate([
+        decorators_1.property()
+    ], StringLiteral.prototype, "concept");
+    __decorate([
+        decorators_1.property()
+    ], StringLiteral.prototype, "value");
+    __decorate([
+        translator_1.withSourceMap()
+    ], StringLiteral.prototype, "toEmbeddedTS");
+    StringLiteral = StringLiteral_1 = __decorate([
+        decorators_1.concept('字符串字面量')
+    ], StringLiteral);
+    return StringLiteral;
+}(LogicItem__1["default"]));
+exports.StringLiteral = StringLiteral;
+classMap_1["default"].StringLiteral = StringLiteral;
+exports["default"] = StringLiteral;
+//================================================================================
+// ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑
+// 自动生成的代码已结束。下面可以手动编写。
+//================================================================================

package/src/sentry/index.ts

@@ -5,6 +5,7 @@ export const BEFORE_HOOK = 'before';
 export const AFTER_HOOK = 'after';
 
 export const NASL_NODE = 'nasl-node';
+export const NASL_SERVER = 'nasl-server';
 export const TS_WORKER_MESSAGER = 'ts-worker-messager';
 
 export const getAxios = () => axios;
@@ -19,18 +20,32 @@ type Source = {
     result?: any;
 };
 
-type Listener = (source: Source) => void;
+type Listener = (source: Source) => Function | void;
 
 type Monitor = (key: string) => <T extends ClassType>(SourceClass: T) => T;
 
-const passthroughProperties = ['constructor', 'getClassName'];
+const flag = '__monitor__';
+const passthroughProperties = ['constructor', 'getClassName', 'getAncestor'];
 
-const previousStore: { [key:string]: Source } = {};
+const classStore: { [key:string]: ClassType } = {};
 const listenersStore: { [key:string]: Listener[] } = {};
 
 const isPromise = (obj: any) => obj && typeof obj.then === 'function';
+const isUsefulProperty = (SourceClass: ClassType) => (property: string) => {
+    if (!SourceClass || !property) {
+        return;
+    }
+
+    if (passthroughProperties.includes(property)) {
+        return false;
+    }
+
+    if (typeof SourceClass.prototype[property] !== 'function') {
+        return false;
+    }
 
-export const getPrevious = (key: string) => previousStore[key];
+    return !SourceClass.prototype[property][flag];
+};
 
 export const removeListener = (key: string) => (listener: Listener) => {
     listenersStore[key] = listenersStore[key] || [];
@@ -49,15 +64,66 @@ export const addListener = (key: string) => (listener: Listener, capture = false
     return () => removeListener(key)(listener);
 };
 
-const fireListeners = (key: string) => (source: Source) => {
-    listenersStore[key] = listenersStore[key] || [];
-    listenersStore[key].forEach((listener) => listener(source));
+const fireListeners = (key: string) => (source: Source): Function => {
+    const { [key]: listeners = [] } = listenersStore;
+    const effects = listeners.map((listener) => listener(source));
+
+    return () => effects.forEach((effect) => effect && effect());
+};
+
+const monitor = (key: string, SourceClass: ClassType, TargetClass: ClassType) => (name: string) => {
+    if (!TargetClass || !SourceClass) {
+        return;
+    }
+
+    if (!key || !name) {
+        return;
+    }
+
+    const { [name]: callback } = SourceClass.prototype;
+
+    TargetClass.prototype[name] = function (...params: any[]) {
+        const effect = fireListeners(key)({
+            hook: BEFORE_HOOK,
+            instance: this,
+            name,
+            params,
+        });
+
+        const result = callback.apply(this, params);
+
+        if (isPromise(result)) {
+            return result.then((data: any) => {
+                fireListeners(key)({
+                    hook: AFTER_HOOK,
+                    instance: this,
+                    result: data,
+                    params,
+                    name,
+                });
+
+                effect && effect();
+                return data;
+            });
+        }
+
+        fireListeners(key)({
+            hook: AFTER_HOOK,
+            instance: this,
+            name,
+            params,
+            result,
+        });
+
+        effect && effect();
+        return result;
+    };
 
-    return source;
+    TargetClass.prototype[name][flag] = true;
 };
 
 export const sentryMonitor: Monitor = (key) => (SourceClass) => {
-    if (!key) {
+    if (!key || !SourceClass) {
         return SourceClass;
     }
 
@@ -76,65 +142,41 @@ export const sentryMonitor: Monitor = (key) => (SourceClass) => {
     }
 
     const properties = Object.getOwnPropertyNames(SourceClass.prototype);
-    const names = properties.filter((property) => {
-        if (passthroughProperties.includes(property)) {
-            return false;
-        }
-
-        return typeof SourceClass.prototype[property] === 'function';
-    });
-
-    names.forEach((name) => {
-        const { [name]: callback } = SourceClass.prototype;
+    const names = properties.filter(isUsefulProperty(SourceClass));
 
-        TargetClass.prototype[name] = function (...params: any[]) {
-            const current = previousStore[key];
+    classStore[key] = SourceClass;
+    names.forEach(monitor(key, SourceClass, TargetClass));
 
-            previousStore[key] = fireListeners(key)({
-                hook: BEFORE_HOOK,
-                instance: this,
-                name,
-                params,
-            });
+    return TargetClass;
+};
 
-            const result = callback.apply(this, params);
+export const extendSentryMonitor: Monitor = (key) => (SourceClass) => {
+    if (!key || !SourceClass) {
+        return SourceClass;
+    }
 
-            if (isPromise(result)) {
-                return result.then((data: any) => {
-                    fireListeners(key)({
-                        hook: AFTER_HOOK,
-                        instance: this,
-                        result: data,
-                        params,
-                        name,
-                    });
+    const { [key]: TargetClass } = classStore;
 
-                    previousStore[key] = current;
-                    return data;
-                });
-            }
+    if (!TargetClass) {
+        return;
+    }
 
-            fireListeners(key)({
-                hook: AFTER_HOOK,
-                instance: this,
-                name,
-                params,
-                result,
-            });
+    const properties = Object.getOwnPropertyNames(SourceClass.prototype);
+    const names = properties.filter(isUsefulProperty(SourceClass));
 
-            previousStore[key] = current;
-            return result;
-        };
-    });
+    names.forEach(monitor(key, SourceClass, TargetClass));
 
-    return TargetClass;
+    return TargetClass as typeof SourceClass;
 };
 
-export const getPreviousFromNaslNode = () => getPrevious(NASL_NODE);
-export const getPreviousFromTSWorkerMessager = () => getPrevious(TS_WORKER_MESSAGER);
-
 export const addListenerToNaslNode = addListener(NASL_NODE);
+export const addListenerToNaslServer = addListener(NASL_SERVER);
 export const addListenerToTSWorkerMessager = addListener(TS_WORKER_MESSAGER);
 
 export const sentryMonitorNaslNode = sentryMonitor(NASL_NODE);
-export const sentryMonitorTSWorkerMessager = sentryMonitor(TS_WORKER_MESSAGER);
+export const sentryMonitorNaslServer = sentryMonitor(NASL_SERVER);
+export const sentryMonitorTSWorkerMessager = sentryMonitor(TS_WORKER_MESSAGER);
+
+export const extendSentryMonitorNaslNode = extendSentryMonitor(NASL_NODE);
+export const extendSentryMonitorNaslServer = extendSentryMonitor(NASL_SERVER);
+export const extendSentryMonitorTSWorkerMessager = extendSentryMonitor(TS_WORKER_MESSAGER);

package/src/server/dist/naslServer.js

@@ -985,7 +985,10 @@ var NaslServer = /** @class */ (function () {
                 switch (_a.label) {
                     case 0:
                         // 开始诊断和标注
-                        common_1.invokeCommand('naslServer:startWork');
+                        try {
+                            common_1.invokeCommand('naslServer:startWork');
+                        }
+                        catch (err) { }
                         return [4 /*yield*/, this.getDiagnosticRecords(fileNames)];
                     case 1:
                         records = _a.sent();
@@ -2561,6 +2564,52 @@ var NaslServer = /** @class */ (function () {
                         if (node instanceof concepts_1.Entity) {
                             // 过滤一把不需要改的信息
                             refsList = refsList.filter(function (item) { return fileNode.getEmbeddedFilePath() !== item.file || item.isDefinition === true; });
+                            // 防止死循环
+                            // const forRefsList = [...refsList];
+                            // for (let i = 0; i < forRefsList.length; i++) {
+                            //     const refItem = forRefsList[i];
+                            //     if (refItem.lineText?.includes('new nasl.langUtil.Collection')) {
+                            //         try {
+                            //             const fileNode = this.file2NodeMap.get(refItem.file);
+                            //             if (!fileNode)
+                            //                 return;
+                            //             const minRange = this._findMinRange(refItem, fileNode as FileNode);
+                            //             if (minRange.node && (minRange.node instanceof QueryFromExpression || minRange.node instanceof QueryJoinExpression)) {
+                            //                 const callQueryComponent = minRange.node.getAncestor('CallQueryComponent') as CallQueryComponent;
+                            //                 const callQueryComponentTypeAnnotation = callQueryComponent.typeAnnotation;
+                            //                 const { currentSource: qcTypeAnnotationCurrentSource, fileNode } = callQueryComponentTypeAnnotation.getCurrentSource();
+                            //                 const { currentSource: logicCurrentSource } = fileNode.getCurrentSource();
+                            //                 const aggregateLength = callQueryComponent.select.selectAggregateElements.filter((item: any) => item.aggregateName && item.asName).length;
+                            //                 const groupByLength = callQueryComponent.groupBy.filter((item) => (item.groupElement as QueryFieldExpression)?.propertyName && (item.groupElement as QueryFieldExpression).asName).length;
+                            //                 if (!groupByLength && !aggregateLength && callQueryComponentTypeAnnotation.typeKind === 'anonymousStructure') {
+                            //                 // 拿到 List 的泛型（匿名数据结构）的所有属性
+                            //                     const properties = callQueryComponentTypeAnnotation.properties[0].typeAnnotation.typeArguments[0].properties;
+                            //                     const targetProperty = properties.find((p) => p.name === utils.firstLowerCase(node.name));
+                            //                     if (!targetProperty) {
+                            //                         continue;
+                            //                     }
+                            //                     const { currentSource: propertyTypeCurrentSource } = targetProperty.typeAnnotation.getCurrentSource();
+                            //                     // 减去 ": " 2个字符、减去属性名长度
+                            //                     const propertyCharacter = propertyTypeCurrentSource.range.start.character - 2 - targetProperty.name.length;
+                            //                     const propertyOffset = propertyCharacter - qcTypeAnnotationCurrentSource.range.start.character;
+                            //                     const qcTypeAnnotationOffset = logicCurrentSource.code.indexOf(qcTypeAnnotationCurrentSource.code);
+                            //                     const declarationCodeArr = logicCurrentSource.code.slice(0, qcTypeAnnotationOffset).split('\n');
+                            //                     const line = declarationCodeArr.length - 1;
+                            //                     const character = declarationCodeArr[declarationCodeArr.length - 1].length;
+                            //                     // eslint-disable-next-line no-await-in-loop
+                            //                     const newRefs = await this.references({
+                            //                         file: (fileNode as any).getEmbeddedFilePath(),
+                            //                         line: line + 2,
+                            //                         offset: character + 1 + propertyOffset,
+                            //                     });
+                            //                     refsList.push(...newRefs.refs);
+                            //                 }
+                            //             }
+                            //         } catch (e) {
+                            //             console.error('naslServer实体引用', e);
+                            //         }
+                            //     }
+                            // }
                             // 不再当前文件里
                             // 或者在当前列表但是位置小于entity的结束位置
                         }
@@ -2920,6 +2969,8 @@ var NaslServer = /** @class */ (function () {
                         var newTextValue = node.parentNode.name === 'defaultDS' ? "/api/" + newName + "/import" : "/api/" + node.parentNode.name + "/" + newName + "/import";
                         minRange.setTypeMethods = 'setUrlValue';
                         minRange.newValue = newTextValue;
+                        // } else if (minRange.node instanceof Identifier) {
+                        //     minRange.newValue = utils.firstLowerCase(newValue);
                     }
                 }
                 // 如果是修改实体属性，要同步实体属性

package/src/server/entity2LogicNamespace.ts

@@ -23,7 +23,7 @@ export function entity2LogicNamespace(entity: Entity) {
             new Param({
                 name: 'body',
                 typeAnnotation: TypeAnnotation.createGeneric('List', {
-                    typeArguments: [TypeAnnotation.createPrimitive(keys[0].typeAnnotation.typeName)],
+                    typeArguments: [TypeAnnotation.createPrimitive(keys?.[0]?.typeAnnotation.typeName)],
                 }),
                 required: true,
             }),

package/src/server/extendBaseNode.ts

@@ -5,6 +5,8 @@ import { BaseNode, CallLogic, Destination, EnumItem, Interface, Logic, Param, Pr
 import { EventPayload, invokeCommand, registerCommand } from '../common';
 import { getNodeByNodeCallee, getNaslNodeByNodeCallee } from '../automate/engine/utils';
 
+import { extendSentryMonitorNaslNode } from '../sentry';
+
 interface SetNameNode extends BaseNode {
     setName(name: string): any;
     [propname: string]: any;
@@ -119,7 +121,12 @@ BaseNode.prototype.changeName = async function changeName(newValue: string, upda
                         const itemNode = item.node as SetNameNode;
                         if (item.newValue) {
                             // 如果有指定的修改方法，就用那个，没有就修改名字
-                            item.setTypeMethods ? itemNode[item.setTypeMethods](item.newValue) : itemNode.setName?.(item.newValue);
+                            if (item.setTypeMethods) {
+                                const func = itemNode && itemNode[item.setTypeMethods];
+                                typeof func === 'function' && itemNode[item.setTypeMethods](item.newValue);
+                            } else {
+                                itemNode.setName?.(item.newValue);
+                            }
                         } else {
                             if (_this.concept === 'AuthLogicForCallInterface' && itemNode.concept === 'CallAuthInterface') {
                                 const { calleewholeKey } = itemNode;
@@ -471,3 +478,5 @@ BaseNode.prototype.getSelectRef = function getSelectRef(newTypeAnnotation: TypeA
         console.log(err);
     }
 };
+
+extendSentryMonitorNaslNode(BaseNode);

package/src/server/formatTsUtils.ts

@@ -753,7 +753,7 @@ export function formatBackendVariables(variables: Array<BackendVariable>) {
                 namespace,
             }),
         };
-        const noChildType = isNoChildType(itemNode.typeAnnotation.typeKey);
+        const noChildType = isNoChildType(itemNode.typeAnnotation?.typeKey);
 
         if (!noChildType) {
             nextFindTypeChild(itemNode.typeAnnotation.typeKey, newItem, itemNode);
@@ -775,7 +775,7 @@ export function formatFrontEndVariables(frontEndVariables: Array<Variable>) {
                 namespace,
             }),
         };
-        const noChildType = isNoChildType(itemNode.typeAnnotation.typeKey);
+        const noChildType = isNoChildType(itemNode.typeAnnotation?.typeKey);
 
         if (!noChildType) {
             nextFindTypeChild(itemNode.typeAnnotation.typeKey, newItem, itemNode);

package/src/server/getInterfaces.ts

@@ -33,7 +33,7 @@ function iterator(tree: Namespace, searchContent: string, fakeNode: FakeNode) {
     }
 }
 export function getInterfaces(node: CallInterface | BindEvent, filterText?: string) {
-    const app = node.rootNode as App;
+    const app = node?.rootNode as App;
     const _moduleList = app.interfaceDependencies.filter((item) => item.type === 'interface');
     const fakeNode = {};
     const interfaces = _moduleList.map((item) => new Namespace({ name: item.name, interfaces: item.interfaces }));

package/src/server/getLogics.ts

@@ -79,7 +79,7 @@ function javaLogicDataSourceLogics(logics: Logic[]) {
 
 export async function getLogics(node: CallLogic | BindEvent | Identifier | Logic, needAllLogic: boolean = true) {
     const app = node?.rootNode as App;
-    if (node.concept === 'CallLogic' || node.concept === 'BindEvent' || node.concept === 'Logic') {
+    if (node?.concept === 'CallLogic' || node?.concept === 'BindEvent' || node?.concept === 'Logic') {
         const result = [];
 
         if (needAllLogic) {
@@ -314,7 +314,7 @@ export async function getLogics(node: CallLogic | BindEvent | Identifier | Logic
             result.push(systemTree);
         }
         return result;
-    } else if (node.concept === 'Identifier') {
+    } else if (node?.concept === 'Identifier') {
         const extensions = app.dependencies.map((dep) => moduleToLogicNamesapce(dep, app.overriddenLogics)).filter((item) => item.logics && item.logics.length);
         const tree = new Namespace({
             name: 'category`',

package/src/server/getMemberIdentifier.ts

@@ -249,7 +249,7 @@ export function getEnumsIdentifier(node: BaseNode): CompletionProperty[] {
 // 获取后端全局变量
 export function getBackendVariablesIdentifier(node: BaseNode): CompletionProperty[] {
     const app = node.rootNode as App;
-    const variables = app?.backend.variables;
+    const variables = app?.backend?.variables;
     const newvariables = variables ? formatBackendVariables(variables) : [];
 
     return newvariables;
@@ -298,7 +298,7 @@ export async function getSelectNextCompletionData(node: Identifier, completionPr
 
         const app = node.getAncestor('App');
         const naslServer = (app as any).naslServer;
-        const nextCompletion = await naslServer.getFieldKeySelectCompletion(node, fieldKey);
+        const nextCompletion = naslServer && await naslServer.getFieldKeySelectCompletion(node, fieldKey);
         const completionData = formatVariableData(nextCompletion, node, completionProperty);
         return completionData;
     }

package/src/server/getScope.ts

@@ -10,9 +10,9 @@ type wordScope = {
 
 export function getLogicScopeWords(logic: Logic): wordScope {
     const scope: wordScope = {
-        Param: logic.params.map((p) => p.name),
-        Return: logic.returns.map((p) => p.name),
-        Variable: logic.variables.map((p) => p.name),
+        Param: logic ? logic.params.map((p) => p.name) : [],
+        Return: logic ? logic.returns.map((p) => p.name) : [],
+        Variable: logic ? logic.variables.map((p) => p.name) : [],
         Constant: [],
         Logic: []
     };

package/src/server/naslServer.ts

@@ -5,7 +5,7 @@ import { Worker } from 'worker_threads';
 /// #endif
 
 import { config } from '../config';
-import { sentryMonitorTSWorkerMessager } from '../sentry';
+import { sentryMonitorNaslServer, sentryMonitorTSWorkerMessager } from '../sentry';
 import Messager from '../common/Messager';
 import * as tsProtocol from 'typescript/lib/protocol';
 import { formatEnums } from '../server/getMemberIdentifier';
@@ -179,7 +179,8 @@ export function getDisplayString2Type(displayString: string) {
     return typeList;
 }
 
-export class NaslServer {
+@sentryMonitorNaslServer
+class NaslServer {
     messager: Messager = undefined;
 
     worker: Worker = undefined;
@@ -944,7 +945,9 @@ export class NaslServer {
 
     async getDiagnosticRecordsAndPushAll(fileNames?: Array<string>) {
         // 开始诊断和标注
-        invokeCommand('naslServer:startWork');
+        try {
+            invokeCommand('naslServer:startWork');
+        } catch (err) { }
         const records = await this.getDiagnosticRecords(fileNames);
         // diagnosticManager.pushAll(records);
     }
@@ -974,7 +977,7 @@ export class NaslServer {
                 return;
 
             // 先获取原来的节点先清除一下之前有异常的节点，下面重新赋值
-            const oldRecord = this.diagnosticManager.getRecord(record.id);
+            const oldRecord = this.diagnosticManager.getRecord?.(record.id);
             oldRecord?.semanticDiagnostics.forEach((item) => {
                 if (item.node) {
                     item.node.tsErrorDetail = undefined;
@@ -2239,7 +2242,7 @@ export class NaslServer {
                 }
                 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 typeKey = (typeAnnotation?.typeKey.match(regNamespace) && typeAnnotation?.typeKey.match(regNamespace)[1]) || typeAnnotation?.typeKey;
                 const typeKeyArr = typeKey.split('.');
                 if (typeKeyArr[0] === 'apis') {
                     const structureName = typeKeyArr[3];
@@ -3652,7 +3655,7 @@ export class NaslServer {
             args.push(fileDetail);
         });
         // console.time('请求');
-        const resultMap: any = (await this.getNaslNodeTypeFull(args)).response;
+        const resultMap: any = (await this.getNaslNodeTypeFull(args))?.response;
         // console.timeEnd('请求');
 
         // console.log(resultMap);
@@ -3824,7 +3827,7 @@ export class NaslServer {
             record.id = fileNode.id;
             record.node = fileNode;
             if (!['Structure', 'DataSource', 'Entity', 'Enum', 'Role'].includes(fileNode.concept)) {
-                fileNode.sourceMap.forEach((item, nodeItem) => {
+                fileNode.sourceMap && fileNode.sourceMap.forEach((item, nodeItem) => {
                     nodes.push({
                         filePath: record.filePath,
                         node: nodeItem,
@@ -4405,3 +4408,5 @@ export class NaslServer {
         }
     }
 }
+
+export { NaslServer };

package/src/server/translator.ts

@@ -699,9 +699,9 @@ export function naslNodeTranslateMessage(minRange: MinRange, tsErrorDetail: Diag
 
     if (/'__UpdateNoProperty__' is declared but its value is never read./.exec(text)) {
         tsErrorDetail.message = '局部更新：未选择任何属性';
-        const callLogic = node.parentNode.parentNode.parentNode as CallLogic;
-        const bodyArgument = callLogic.arguments.find((item) => item.keyword === 'body');
-        node = bodyArgument.expression;
+        const callLogic = node?.parentNode?.parentNode?.parentNode as CallLogic;
+        const bodyArgument = callLogic?.arguments?.find((item) => item.keyword === 'body');
+        node = bodyArgument?.expression;
     }
 
     // 左右类型不一致的，把上级信息带上

package/src/service/storage/init.ts

@@ -441,7 +441,7 @@ class TaskQueue {
         }));
         await storageService.saveFrontendNasl({
             body: {
-                nasl: app.toJSON(),
+                nasl: app?.toJSON(),
                 failedQueue,
                 queue,
                 errorInfo: options.errorInfo,

package/src/utils/string.ts

@@ -31,7 +31,7 @@ export const Camel2Snake = (name: string) => name.replace(/([A-Z])/g, (m, $1, of
  * 首字母大写
  * @param value 字符串
  */
-export const firstUpperCase = (value: string) => value.replace(/^\S/, (letter) => letter.toUpperCase());
+export const firstUpperCase = (value: string) => value.replace?.(/^\S/, (letter) => letter.toUpperCase());
 /**
  * 首字母小写
  * @param value 字符串