@lcap/nasl 2.20.0-beta.2 → 2.20.0-beta.4

package/src/concepts/OqlQueryComponent__.ts

@@ -54,8 +54,6 @@ export class OqlQueryComponent extends LogicItem {
     @property()
     dataSource: string = undefined;
 
-    
-
     /**
      * @param source 需要合并的部分参数
      */
@@ -69,7 +67,6 @@ export class OqlQueryComponent extends LogicItem {
         return super.from(source, parentNode, parentKey) as OqlQueryComponent;
     }
 
-    
     /**
      * 设置SQL 查询
      */
@@ -82,10 +79,6 @@ export class OqlQueryComponent extends LogicItem {
         });
     }
 
-    
-
-    
-
     /**
     * 删除类型标注
     * @param name 类型标注名称
@@ -272,24 +265,44 @@ export class OqlQueryComponent extends LogicItem {
     @withSourceMap()
     toEmbeddedTS(state?: TranslatorState): string {
         let code: string;
-        code = `(function(): `;
-        code += `${this.typeAnnotation ? this.typeAnnotation.toEmbeddedTS(shiftState(state, code)) : '__NO_SELECT_TYPE__'} {\n`;
-        // app.dataSources.defaultDS;
+        const typeAnnotation = this.typeAnnotation;
+        if (typeAnnotation) {
+            code = `(function(): ${typeAnnotation.toEmbeddedTS()} {\n`;
+        } else {
+            code = `(function __oqlQueryFn${String(this.id).slice(0, 8)} () {\n`;
+        }
+
+        const indent1 = indent((state?.tabSize || 0) + 1);
+        // this.dataSource: 'app.dataSources.defaultDS';
         if (this.dataSource) {
-            code += indent((state?.tabSize || 0) + 1);
+            code += indent1;
             code += `const dataSource = ${this.dataSource || 'app.dataSources.defaultDS'};\n`;
         }
+        const hasSyntaxErrors = !!this.codeSourceMap?.oqlSyntaxError?.syntaxErrors?.length;
         // 生成内部的ts内容
-        if (this.codeSourceMap) {
-            code += this.codeSourceMap.typescript || '';
-            if (!this.code) {
-                // SQL 为空
-                code += '__OQL_EMPTY_ERROR__;';
-            } else if (this.codeSourceMap.lexicalErrorCode === 1001) {
+        if (!this.code) {
+            // SQL 为空
+            code += `${indent1}__OQL_EMPTY_ERROR__;\n`;
+        } else if (hasSyntaxErrors) {
+            const syntaxErrors = this.codeSourceMap?.oqlSyntaxError?.syntaxErrors || [];
+            const warningList = syntaxErrors.filter((err: any) => err.errorMsg.includes('别名不符合规范'));
+            if (warningList.length === syntaxErrors.length) {
+                // SQL 别名警告
+                code += `${indent1}__OQL_ALIAS_WARNING__;\n`;
+            } else {
+                if (warningList.length > 0) {
+                    // SQL 别名警告
+                    code += `${indent1}__OQL_ALIAS_WARNING__;\n`;
+                }
                 // SQL 语法错误
-                code += '__OQL_GRAMMAR_ERROR__;';
+                code += `${indent1}__OQL_GRAMMAR_ERROR__;\n`;
             }
         }
+        // insert typescript code
+        const typescript = this.codeSourceMap?.typescript;
+        if (typescript) {
+            code += `${indent1}const __oqlQueryResult = ${typescript};`;
+        }
 
         // 临时方案拼接字符串
         this.getTextVariables();
@@ -300,7 +313,12 @@ export class OqlQueryComponent extends LogicItem {
             code += ';\n';
         });
         code += '\n';
-        code += indent((state?.tabSize || 0) + 1) + 'return;\n';
+
+        if (typescript && !typeAnnotation) {
+            code += `${indent1}return __oqlQueryResult;\n`;
+        } else {
+            code += `${indent1}return;\n`;
+        }
         code += indent((state?.tabSize || 0)) + '})()';
         return code;
     }
@@ -314,6 +332,8 @@ export class OqlQueryComponent extends LogicItem {
                     oqlIdentifier: 'myoqlIdentifier',
                     dataSourceName: this.dataSource,
                     oql: this.code,
+                    ideVersion: this.app.ideVersion,
+                    dataSourceNasl: this.app.findNodeByCompleteName(this.dataSource).toJSON(),
                     typeScriptStartLine: 1,
                     typeScriptStartLineColumn: 1,
                 },
@@ -335,7 +355,7 @@ export class OqlQueryComponent extends LogicItem {
         };
     }
 
-    _TsVariables: Array<Identifier | MemberExpression>= [];
+    _TsVariables: Array<Identifier | MemberExpression> = [];
 
     // 节点的sourcemap
     codeSourceMap: any = undefined;

package/src/concepts/Param__.ts

@@ -9,13 +9,13 @@ import Function from './Function__';
 import AnonymousFunction from './AnonymousFunction__';
 
 function tryJSONParse(str: string) {
-  let result;
+    let result;
 
-  try {
-    result = JSON.parse(str);
-  } catch (e) { }
+    try {
+        result = JSON.parse(str);
+    } catch (e) { }
 
-  return result;
+    return result;
 }
 
 //================================================================================
@@ -195,10 +195,6 @@ export class Param extends BaseNode {
         });
     }
 
-    
-
-    
-
     /**
     * 删除类型标注
     * @param name 类型标注名称
@@ -271,97 +267,97 @@ export class Param extends BaseNode {
   completionChildren: Array<EntityProperty | StructureProperty> = undefined;
 
   toJS(state?: TranslatorState): string {
-    if (this.view) {
-      const typeAnnotation = this.typeAnnotation || this.__TypeAnnotation;
-      const needGenInitFromSchema = typeAnnotation && (
-        !['primitive', 'union'].includes(typeAnnotation.typeKind)
+      if (this.view) {
+          const typeAnnotation = this.typeAnnotation || this.__TypeAnnotation;
+          const needGenInitFromSchema = typeAnnotation && (
+              !['primitive', 'union'].includes(typeAnnotation.typeKind)
         || typeAnnotation.typeName === 'DateTime'
-      );
-      let code = `${this.name} = `;
-      if (needGenInitFromSchema) {
-        code += `this.$genInitFromSchema('${typeAnnotation?.sortedTypeKey}',`;
-      }
-      const defaultValue = this.defaultValue;
-      const defaultValueType = Object.prototype.toString.call(defaultValue);
-      const { typeKind, typeNamespace, typeName } = typeAnnotation || {};
-      // 设置成null，才能同步给后端清除该值，但是null对checkbox组件是一种特殊状态
-      let parsedValue = defaultValue ?? undefined;
-      if (
-        defaultValueType === '[object String]'
+          );
+          let code = `${this.name} = `;
+          if (needGenInitFromSchema) {
+              code += `this.$genInitFromSchema('${typeAnnotation?.sortedTypeKey}',`;
+          }
+          const defaultValue = this.defaultValue;
+          const defaultValueType = Object.prototype.toString.call(defaultValue);
+          const { typeKind, typeNamespace, typeName } = typeAnnotation || {};
+          // 设置成null，才能同步给后端清除该值，但是null对checkbox组件是一种特殊状态
+          let parsedValue = defaultValue ?? undefined;
+          if (
+              defaultValueType === '[object String]'
         && (
-          !(typeKind === 'primitive' && typeNamespace === 'nasl.core' && ['String', 'Text', 'Email'].includes(typeName))
+            !(typeKind === 'primitive' && typeNamespace === 'nasl.core' && ['String', 'Text', 'Email'].includes(typeName))
           && !(this.isEnum())
           && !['union'].includes(typeKind)
         )
-      ) {
-        // 一些特殊情况，特殊处理成undefined
-        // 1.defaultValue在nasl节点上错误得赋值给了空制符串
-        if ([''].includes(defaultValue)) {
-          parsedValue = undefined;
-        } else {
-          parsedValue = tryJSONParse(defaultValue) ?? defaultValue;
-        }
-      }
-      code += `${this.name} || (this.$route.query.hasOwnProperty('${this.name}') ? this.$genInitFromSchema('${typeAnnotation?.sortedTypeKey}', this.$route.query.${this.name}) : ${JSON.stringify(this.defaultValue)})`;
+          ) {
+              // 一些特殊情况，特殊处理成undefined
+              // 1.defaultValue在nasl节点上错误得赋值给了空制符串
+              if ([''].includes(defaultValue)) {
+                  parsedValue = undefined;
+              } else {
+                  parsedValue = tryJSONParse(defaultValue) ?? defaultValue;
+              }
+          }
+          code += `${this.name} || (this.$route.query.hasOwnProperty('${this.name}') ? this.$genInitFromSchema('${typeAnnotation?.sortedTypeKey}', this.$route.query.${this.name}) : ${JSON.stringify(this.defaultValue)})`;
 
-      if (needGenInitFromSchema) {
-        code += `)`;
+          if (needGenInitFromSchema) {
+              code += `)`;
+          }
+          return code;
+      } else {
+          return '';
       }
-      return code;
-    } else {
-      return '';
-    }
   }
 
   isEnum() {
-    return this.typeAnnotation?.typeNamespace?.endsWith('.enums');
+      return this.typeAnnotation?.typeNamespace?.endsWith('.enums');
   }
 
   @withSourceMap()
   toEmbeddedTS(state?: TranslatorState, dontType?: boolean): string {
-    let code = this.name;
-    // 回调函数类的参数
-    if (this?.typeAnnotation?.typeKind === 'function') {
-      code += ':{(';
-      const paramTypes = this.typeAnnotation?.typeArguments || [];
-      paramTypes.forEach((type, index) => {
-        code += `type${index + 1}:` + type.toEmbeddedTS(shiftState(state, code));
-        if (index !== paramTypes.length - 1) {
-          code += ',';
-        } else {
-          code += ')';
-        }
-      });
-      code += ':';
-      const returnTypes = (this.typeAnnotation?.returnType || []);
-      returnTypes.forEach((type) => {
-        code += type.toEmbeddedTS(shiftState(state, code));
-      });
-      code += '}';
-      return code;
-    }
+      let code = this.name;
+      // 回调函数类的参数
+      if (this?.typeAnnotation?.typeKind === 'function') {
+          code += ':{(';
+          const paramTypes = this.typeAnnotation?.typeArguments || [];
+          paramTypes.forEach((type, index) => {
+              code += `type${index + 1}:` + type.toEmbeddedTS(shiftState(state, code));
+              if (index !== paramTypes.length - 1) {
+                  code += ',';
+              } else {
+                  code += ')';
+              }
+          });
+          code += ':';
+          const returnTypes = (this.typeAnnotation?.returnType || []);
+          returnTypes.forEach((type) => {
+              code += type.toEmbeddedTS(shiftState(state, code));
+          });
+          code += '}';
+          return code;
+      }
 
-    if (this.defaultExpression instanceof Function || this.defaultExpression instanceof AnonymousFunction) {
-      code += this.required ? ': ' : '?: ';
-      code += this.defaultExpression.toEmbeddedTSDefinition(shiftState(state, code));
-    } else if (!dontType && this.typeAnnotation) {
-      code += ': ';
-      code += this.typeAnnotation.toEmbeddedTS(shiftState(state, code));
-      // toTS暂时只需要翻译引用数据类型的，因为值都是字符串
-      // 就不在这里赋值了，这里单纯就为了快速查找
-      // 并且屏蔽了一些异常的错误
-      if (this.typeAnnotation?.typeKind !== 'primitive' && this.defaultValue) {
-        if (this.isEnum()) {
-          code += `= ${this.typeAnnotation.typeKey}['${this.defaultValue}']`;
-        }
+      if (this.defaultExpression instanceof Function || this.defaultExpression instanceof AnonymousFunction) {
+          code += this.required ? ': ' : '?: ';
+          code += this.defaultExpression.toEmbeddedTSDefinition(shiftState(state, code));
+      } else if (!dontType && this.typeAnnotation) {
+          code += ': ';
+          code += this.typeAnnotation.toEmbeddedTS(shiftState(state, code));
+          // toTS暂时只需要翻译引用数据类型的，因为值都是字符串
+          // 就不在这里赋值了，这里单纯就为了快速查找
+          // 并且屏蔽了一些异常的错误
+          if (this.typeAnnotation?.typeKind !== 'primitive' && this.defaultValue) {
+              if (this.isEnum()) {
+                  code += `= ${this.typeAnnotation.typeKey}['${this.defaultValue}']`;
+              }
+          }
       }
-    }
-    return code;
+      return code;
   }
 
   @withSourceMap()
   toEmbeddedNameTS(state?: TranslatorState): string {
-    return `${this.name}`;
+      return `${this.name}`;
   }
   /**
    * 设置数据类型
@@ -374,47 +370,47 @@ export class Param extends BaseNode {
    */
   async setDataType(typeKey: string): Promise<void>;
   async setDataType(typeAnnotation: TypeAnnotation | string) {
-    if (typeof typeAnnotation === 'string') {
-      typeAnnotation = dataTypesMap[typeAnnotation];
-      if (!typeAnnotation)
-        // eslint-disable-next-line prefer-rest-params
-        throw new Error('找不到类型：' + arguments[0]);
-    } else {
-      typeAnnotation._delete?.();
-      const relationOptions = { parentId: this.id, parentConcept: this.concept, parentNode: this };
-      Object.assign(typeAnnotation, relationOptions);
-    }
-    const object: any = {
-      typeAnnotation,
-    };
+      if (typeof typeAnnotation === 'string') {
+          typeAnnotation = dataTypesMap[typeAnnotation];
+          if (!typeAnnotation)
+          // eslint-disable-next-line prefer-rest-params
+              throw new Error('找不到类型：' + arguments[0]);
+      } else {
+          typeAnnotation._delete?.();
+          const relationOptions = { parentId: this.id, parentConcept: this.concept, parentNode: this };
+          Object.assign(typeAnnotation, relationOptions);
+      }
+      const object: any = {
+          typeAnnotation,
+      };
 
-    // 切换类型的时候如果有默认值就清除掉
-    if (this.defaultValue) {
-      object.defaultValue = '';
-    }
-    try {
-      this.completionChildren = this.getSelectRef(typeAnnotation);
-    } catch (err) {
-      this.completionChildren = [];
-      console.log(err);
-    }
-    // 处理下拉属性
-    return this.update({
-      ...object,
-    });
+      // 切换类型的时候如果有默认值就清除掉
+      if (this.defaultValue) {
+          object.defaultValue = '';
+      }
+      try {
+          this.completionChildren = this.getSelectRef(typeAnnotation);
+      } catch (err) {
+          this.completionChildren = [];
+          console.log(err);
+      }
+      // 处理下拉属性
+      return this.update({
+          ...object,
+      });
   }
 
   public static getDefaultOptions() {
-    return {
-      required: true,
-      defaultValue: '',
-      typeAnnotation: {
-        concept: 'TypeAnnotation',
-        typeKind: 'primitive',
-        typeNamespace: 'nasl.core',
-        typeName: 'String',
-      },
-    };
+      return {
+          required: true,
+          defaultValue: '',
+          typeAnnotation: {
+              concept: 'TypeAnnotation',
+              typeKind: 'primitive',
+              typeNamespace: 'nasl.core',
+              typeName: 'String',
+          },
+      };
   }
 
   _readonly: boolean = false;
@@ -422,86 +418,92 @@ export class Param extends BaseNode {
    * 是否可编辑
    * */
   get readonly() {
-    return !!this.module || this._readonly;
+      return !!this.module || this._readonly;
   }
 
   set readonly(val) {
-    this._readonly = val;
+      this._readonly = val;
   }
   get hasChildren() {
-    const { typeKind, typeNamespace } = this.typeAnnotation;
-    if (typeKind === 'reference' || typeKind === 'generic') {
-      if (typeNamespace.endsWith('.enums'))
-        return null;
-      return [{}];
-    }
-    return null;
+      const { typeKind, typeNamespace, typeName } = this.typeAnnotation;
+      if (typeKind === 'reference' || typeKind === 'generic') {
+          if (typeNamespace.endsWith('.enums'))
+              return null;
+          return [{}];
+      } else if (typeNamespace === 'nasl.core' && ['String', 'Text', 'Email'].includes(typeName)) {
+          return [{}];
+      }
+      return null;
   }
   get isTreeLeaf() {
-    return !this.hasChildren;
+      return !this.hasChildren;
   }
   getSelectRef(newTypeAnnotation: TypeAnnotation) {
-    try {
-      const { typeName, typeKind, typeNamespace } = newTypeAnnotation || this.typeAnnotation;
-      let completionChildren;
-      if (typeKind === 'reference') {
-        if (typeNamespace === 'nasl.ui' || typeNamespace === 'nasl.process' || typeNamespace === 'nasl.auth') {
-          const node = getNaslNodeByNodeCallee(typeNamespace, typeName);
-          const properties = (node as Structure)?.properties || [];
-          completionChildren = properties;
-        } else if (typeNamespace.endsWith('.enums')) {
-          completionChildren = [];
-        } else {
-          const node = getNodeByNodeCallee(this.app, typeNamespace + '.' + typeName);
-          const properties = node?.properties || [];
-          completionChildren = properties;
-        }
-      } else if (typeKind === 'generic') {
-        // if (typeNamespace === 'nasl.collection' || typeNamespace === 'nasl.ui' || typeNamespace === 'nasl.interface') {
-        // }
-        const node = getNaslNodeByNodeCallee(typeNamespace, typeName);
-        const properties = ((node as Structure)?.properties && [...(node as Structure)?.properties]) || [];
-        for (let i = 0; i < properties.length; i++) {
-          const item = properties[i];
-          if (item?.typeAnnotation?.typeKind === 'typeParam') {
-            const newItem = StructureProperty.from(item.toJSON());
-            newItem.typeAnnotation = this?.typeAnnotation?.typeArguments[0];
-            newItem.parentNode = this;
-            properties[i] = newItem;
+      try {
+          const { typeName, typeKind, typeNamespace, sortedTypeKey } = newTypeAnnotation || this.typeAnnotation;
+          let completionChildren;
+          if (typeKind === 'reference') {
+              if (typeNamespace === 'nasl.ui' || typeNamespace === 'nasl.process' || typeNamespace === 'nasl.auth') {
+                  const node = getNaslNodeByNodeCallee(typeNamespace, typeName);
+                  const properties = (node as Structure)?.properties || [];
+                  completionChildren = properties;
+              } else if (typeNamespace.endsWith('.enums')) {
+                  completionChildren = [];
+              } else {
+                  const node = getNodeByNodeCallee(this.app, typeNamespace + '.' + typeName);
+                  const properties = node?.properties || [];
+                  completionChildren = properties;
+              }
+          } else if (typeKind === 'generic') {
+              // if (typeNamespace === 'nasl.collection' || typeNamespace === 'nasl.ui' || typeNamespace === 'nasl.interface') {
+              // }
+              const node = getNaslNodeByNodeCallee(typeNamespace, typeName);
+              const properties = ((node as Structure)?.properties && [...(node as Structure)?.properties]) || [];
+              for (let i = 0; i < properties.length; i++) {
+                  const item = properties[i];
+                  if (item?.typeAnnotation?.typeKind === 'typeParam') {
+                      const newItem = StructureProperty.from(item.toJSON());
+                      newItem.typeAnnotation = this?.typeAnnotation?.typeArguments[0];
+                      newItem.parentNode = this;
+                      properties[i] = newItem;
+                  }
+              }
+              completionChildren = properties;
+          } else if (typeNamespace === 'nasl.core' && ['String', 'Text', 'Email'].includes(typeName)) {
+              const node = getNaslNodeByNodeCallee(typeNamespace, typeName);
+              const properties = ((node as Structure)?.properties && [...(node as Structure)?.properties]) || [];
+              completionChildren = properties;
+          } else {
+              completionChildren = [];
           }
-        }
-        completionChildren = properties;
-      } else {
-        completionChildren = [];
+          return completionChildren;
+      } catch (err) {
+          console.log(err);
       }
-      return completionChildren;
-    } catch (err) {
-      console.log(err);
-    }
   }
 
   setnNewTypeAnnotation(oldTypeAnnotation: TypeAnnotation) {
-    const json = oldTypeAnnotation.toJSON();
-    const typeAnnotation = TypeAnnotation.from(json);
-    this.typeAnnotation = typeAnnotation;
+      const json = oldTypeAnnotation.toJSON();
+      const typeAnnotation = TypeAnnotation.from(json);
+      this.typeAnnotation = typeAnnotation;
   }
   get isFunction() {
-    return this.typeAnnotation.typeKind === 'function';
+      return this.typeAnnotation.typeKind === 'function';
   }
 
   get getFunctionSign() {
-    if (this.isFunction) {
-      const paramTypes = this.typeAnnotation.typeArguments || [];
-      const returnTypes = this.typeAnnotation.returnType || [];
-      const paramTypeNames = paramTypes.map((item) => item.sign);
-      const returnTypeNames = returnTypes.map((item) => item.sign);
-      return `(${paramTypeNames.toString()}) → ${returnTypeNames.toString()}`;
-    } else {
-      return '';
-    }
+      if (this.isFunction) {
+          const paramTypes = this.typeAnnotation.typeArguments || [];
+          const returnTypes = this.typeAnnotation.returnType || [];
+          const paramTypeNames = paramTypes.map((item) => item.sign);
+          const returnTypeNames = returnTypes.map((item) => item.sign);
+          return `(${paramTypeNames.toString()}) → ${returnTypeNames.toString()}`;
+      } else {
+          return '';
+      }
   }
 
-  //================================================================================
+    //================================================================================
     // 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！
     // ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓
     //================================================================================

package/src/concepts/ProcessElement__.ts

@@ -1598,7 +1598,8 @@ export class ProcessElement extends BaseNode {
             || this.type === 'AutoTask'
             || this.type === 'InclusiveGateway') {
             const prevTasks = getPreviousTask(this);
-            let prevCode = `${tab4}const ${this.process.name} = {\n`;
+            let prevCode = `${tab4}__ProcessIdentification__;\n`;
+            prevCode += `${tab4}const ${this.process.name} = {\n`;
             const processName = this.process.name;
             this.process.params.forEach((p) => {
                 prevCode += `${tab5}${p.name}: app.processes.${processName}.${p.name},\n`;

package/src/concepts/ProcessOutcome__.ts

@@ -28,7 +28,7 @@ export class ProcessOutcome extends LogicItem {
      * 判断结果标题
      */
     @property()
-    label: string = '判断结果';
+    label: string = '流向';
 
     /**
      * 关联连接器

package/src/concepts/ProcessOutcomes__.ts

@@ -27,7 +27,7 @@ export class ProcessOutcomes extends LogicItem {
      * 判断结果数组标题
      */
     @property()
-    label: string = '判断结果';
+    label: string = '流向';
 
     /**
      * 关联连接器

package/src/concepts/Process__.ts

@@ -1227,6 +1227,7 @@ export class Process extends BaseNode {
         const tab3 = indent((state?.tabSize || 0) + 3);
         // code += `${tab1}namespace variables{\n`;
 
+        code += `${tab1}let __ProcessIdentification__: string;\n`;
         code += `${tab1}export namespace logics {\n`;
         const logic = genLaunchProcess(this);
         // sourceMap 映射

package/src/concepts/Return__.ts

@@ -372,11 +372,13 @@ export class Return extends BaseNode {
     get hasChildren() {
         if (!this.typeAnnotation)
             return null;
-        const { typeKind, typeNamespace } = this.typeAnnotation;
+        const { typeKind, typeNamespace, typeName } = this.typeAnnotation;
         if (typeKind === 'reference' || typeKind === 'generic') {
             if (typeNamespace.endsWith('.enums'))
                 return null;
             return [{}];
+        } else if (typeNamespace === 'nasl.core' && ['String', 'Text', 'Email'].includes(typeName)) {
+            return [{}];
         }
         return null;
     }
@@ -385,7 +387,7 @@ export class Return extends BaseNode {
     }
     getSelectRef(newTypeAnnotation: TypeAnnotation) {
         try {
-            const { typeName, typeKind, typeNamespace } = newTypeAnnotation || this.typeAnnotation;
+            const { typeName, typeKind, typeNamespace, sortedTypeKey } = newTypeAnnotation || this.typeAnnotation;
             let completionChildren;
             if (typeKind === 'reference') {
                 if (typeNamespace === 'nasl.ui' || typeNamespace === 'nasl.process' || typeNamespace === 'nasl.auth') {
@@ -412,6 +414,10 @@ export class Return extends BaseNode {
                     }
                 }
                 completionChildren = properties;
+            } else if (typeNamespace === 'nasl.core' && ['String', 'Text', 'Email'].includes(typeName)) {
+                const node = getNaslNodeByNodeCallee(typeNamespace, typeName);
+                const properties = ((node as Structure)?.properties && [...(node as Structure)?.properties]) || [];
+                completionChildren = properties;
             } else {
                 completionChildren = [];
             }