@lcap/nasl 3.2.0-beta.4 → 3.3.0-alpha

package/src/generator/genHash.ts

@@ -6,8 +6,8 @@ import * as crypto from 'crypto';
  * @returns MD5 hash值8位
  */
 export function genHash(content: string) {
-    const hash = crypto.createHash('md5').update(content, 'utf8').digest('hex');
-    return hash.slice(0, 8);
+  const hash = crypto.createHash('md5').update(content, 'utf8').digest('hex');
+  return hash.slice(0, 8);
 }
 
 export default genHash;

package/src/generator/genMetaData.ts

@@ -1,300 +1,319 @@
 import {
-    App, Module, View, Entity, Structure, Enum,
-    uiStructures, collectionStructures, interfaceStructures, processStructures,
-    Connector, Logic, Interface, Process, BaseNode, Frontend, authStructures,
-    httpStructures
+  App,
+  Module,
+  View,
+  Entity,
+  Structure,
+  Enum,
+  uiStructures,
+  collectionStructures,
+  interfaceStructures,
+  processStructures,
+  Connector,
+  Logic,
+  Interface,
+  Process,
+  BaseNode,
+  Frontend,
+  authStructures,
+  httpStructures,
 } from '../concepts';
 import * as utils from '../utils';
 
 // 生成typeKey
 function genSortedTypeKey(typeAnnotation: any) {
-    const {
-        typeKind, typeNamespace, typeName,
-        typeArguments, properties,
-    } = typeAnnotation || {};
-    const typeKeyArr = [];
-    if (typeKind === 'union') { // 联合类型
-        if (Array.isArray(typeArguments)) {
-            // 按返回的每个具体项排序
-            const childTypeArgs: any = typeArguments.map((typeArg) => genSortedTypeKey(typeArg)).sort((name1, name2) => name1 > name2 ? 1 : -1);
-            typeKeyArr.push(childTypeArgs.join(' | '));
-        }
-    } else if (typeKind === 'anonymousStructure') { // 匿名数据结构
-        typeKeyArr.push('{');
-        if (Array.isArray(properties)) {
-            // 按匿名数据结构的key排序
-            const childTypeArgs: any = properties.sort(({ name: name1 }, { name: name2 }) => name1 > name2 ? 1 : -1).map((typeArg) => {
-                const { name: typeArgName, typeAnnotation: typeArgTypeAnnotation } = typeArg || {};
-                return `${typeArgName}: ${genSortedTypeKey(typeArgTypeAnnotation)}`;
-            });
-            typeKeyArr.push(childTypeArgs.join(', '));
-        }
-        typeKeyArr.push('}');
-    } else {
-        const typeArr = [];
-        typeNamespace && typeArr.push(typeNamespace);
-        typeName && typeArr.push(typeName);
-        const typeKey = typeArr.join('.');
-        typeKey && typeKeyArr.push(typeKey);
-        if (typeKind === 'generic') {
-            typeKeyArr.push('<');
-            if (Array.isArray(typeArguments)) {
-                // 必须按typeArguments定义的顺序，否则实参位置不对
-                const childTypeArgs: any = typeArguments.map((typeArg) => genSortedTypeKey(typeArg));
-                typeKeyArr.push(childTypeArgs.join(', '));
-            }
-            typeKeyArr.push('>');
-        }
+  const { typeKind, typeNamespace, typeName, typeArguments, properties } = typeAnnotation || {};
+  const typeKeyArr = [];
+  if (typeKind === 'union') {
+    // 联合类型
+    if (Array.isArray(typeArguments)) {
+      // 按返回的每个具体项排序
+      const childTypeArgs: any = typeArguments.map((typeArg) => genSortedTypeKey(typeArg)).sort((name1, name2) => (name1 > name2 ? 1 : -1));
+      typeKeyArr.push(childTypeArgs.join(' | '));
+    }
+  } else if (typeKind === 'anonymousStructure') {
+    // 匿名数据结构
+    typeKeyArr.push('{');
+    if (Array.isArray(properties)) {
+      // 按匿名数据结构的key排序
+      const childTypeArgs: any = properties
+        .sort(({ name: name1 }, { name: name2 }) => (name1 > name2 ? 1 : -1))
+        .map((typeArg) => {
+          const { name: typeArgName, typeAnnotation: typeArgTypeAnnotation } = typeArg || {};
+          return `${typeArgName}: ${genSortedTypeKey(typeArgTypeAnnotation)}`;
+        });
+      typeKeyArr.push(childTypeArgs.join(', '));
+    }
+    typeKeyArr.push('}');
+  } else {
+    const typeArr = [];
+    typeNamespace && typeArr.push(typeNamespace);
+    typeName && typeArr.push(typeName);
+    const typeKey = typeArr.join('.');
+    typeKey && typeKeyArr.push(typeKey);
+    if (typeKind === 'generic') {
+      typeKeyArr.push('<');
+      if (Array.isArray(typeArguments)) {
+        // 必须按typeArguments定义的顺序，否则实参位置不对
+        const childTypeArgs: any = typeArguments.map((typeArg) => genSortedTypeKey(typeArg));
+        typeKeyArr.push(childTypeArgs.join(', '));
+      }
+      typeKeyArr.push('>');
     }
-    return typeKeyArr.join('');
+  }
+  return typeKeyArr.join('');
 }
 
 export function genMetaData(app: App, frontend: Frontend) {
-    const modules: (Module | Connector)[] = [];
-    const views: View[] = [];
-    const entities: Entity[] = [];
-    const structures: Structure[] = [];
-    const enums: Enum[] = [];
-    const logics: Logic[] = [];
-    const interfaces: Interface[] = [];
-    const processes: Process[] = [];
+  const modules: (Module | Connector)[] = [];
+  const views: View[] = [];
+  const entities: Entity[] = [];
+  const structures: Structure[] = [];
+  const enums: Enum[] = [];
+  const logics: Logic[] = [];
+  const interfaces: Interface[] = [];
+  const processes: Process[] = [];
 
-    frontend.views && views.push(...frontend.views);
-    if (Array.isArray(app.dataSources)) {
-        app.dataSources.forEach((dataSource) => {
-            if (Array.isArray(dataSource.entities)) {
-                entities.push(...dataSource.entities);
-            }
-        });
-    }
-    app.structures && structures.push(...app.structures);
-    app.enums && enums.push(...app.enums);
-    app.logics && logics.push(...app.logics);
-    app.processes && processes.push(...app.processes);
+  frontend.views && views.push(...frontend.views);
+  if (Array.isArray(app.dataSources)) {
+    app.dataSources.forEach((dataSource) => {
+      if (Array.isArray(dataSource.entities)) {
+        entities.push(...dataSource.entities);
+      }
+    });
+  }
+  app.structures && structures.push(...app.structures);
+  app.enums && enums.push(...app.enums);
+  app.logics && logics.push(...app.logics);
+  app.processes && processes.push(...app.processes);
 
-    app.dependencies && modules.push(...app.dependencies);
-    app.interfaceDependencies && modules.push(...app.interfaceDependencies);
+  app.dependencies && modules.push(...app.dependencies);
+  app.interfaceDependencies && modules.push(...app.interfaceDependencies);
 
-    modules.forEach((module: Module) => {
-        module.views && views.push(...module.views);
-        module.structures && structures.push(...module.structures);
-        module.enums && enums.push(...module.enums);
-        module.logics && logics.push(...module.logics);
-        module.interfaces && interfaces.push(...module.interfaces);
-        if (Array.isArray(module.dataSources)) {
-            module.dataSources.forEach((dataSource) => {
-                if (Array.isArray(dataSource.entities)) {
-                    entities.push(...dataSource.entities);
-                }
-            });
+  modules.forEach((module: Module) => {
+    module.views && views.push(...module.views);
+    module.structures && structures.push(...module.structures);
+    module.enums && enums.push(...module.enums);
+    module.logics && logics.push(...module.logics);
+    module.interfaces && interfaces.push(...module.interfaces);
+    if (Array.isArray(module.dataSources)) {
+      module.dataSources.forEach((dataSource) => {
+        if (Array.isArray(dataSource.entities)) {
+          entities.push(...dataSource.entities);
         }
-    });
-    const dataTypes: (Entity | Structure | Enum)[] = [];
+      });
+    }
+  });
+  const dataTypes: (Entity | Structure | Enum)[] = [];
 
-    const dataTypesMap: {
-        [id: string]: BaseNode;
-    } = {};
-    const frontendVariables = frontend.variables;
-    const frontendEvents = frontend.bindEvents;
-    const frontendEventsMap: { [id: string]: string } = {};
+  const dataTypesMap: {
+    [id: string]: BaseNode;
+  } = {};
+  const frontendVariables = frontend.variables;
+  const frontendEvents = frontend.bindEvents;
+  const frontendEventsMap: { [id: string]: string } = {};
 
-    const enumsMap: {
-        [name: string]: {
-            [label: string]: string;
-        };
-    } = {};
+  const enumsMap: {
+    [name: string]: {
+      [label: string]: string;
+    };
+  } = {};
 
-    const logicsMap: {
-        [id: string]: {
-            config: {
-                serviceType: string;
-            };
-            url: {
-                method: string;
-                path: string;
-            };
-        };
-    } = {};
-    const _custom: {
-        [id: string]: any;
-    } = {};
-    const allLogics: Logic[] = [];
+  const logicsMap: {
+    [id: string]: {
+      config: {
+        serviceType: string;
+      };
+      url: {
+        method: string;
+        path: string;
+      };
+    };
+  } = {};
+  const _custom: {
+    [id: string]: any;
+  } = {};
+  const allLogics: Logic[] = [];
 
-    if (Array.isArray(enums)) {
-        dataTypes.push(...enums);
-        enums.forEach((node) => {
-            let { name, enumItems } = node || {};
-            if (node.module) {
-                name = `extensions.${node.module.name}.enums.${name}`;
-            }
-            const enumObj: {
-                [value: string]: string;
-            } = {};
-            enumItems.forEach(({ label, value }) => {
-                enumObj[value] = label;
-            });
-            enumsMap[name] = enumObj;
-        });
-    }
+  if (Array.isArray(enums)) {
+    dataTypes.push(...enums);
+    enums.forEach((node) => {
+      let { name, enumItems } = node || {};
+      if (node.module) {
+        name = `extensions.${node.module.name}.enums.${name}`;
+      }
+      const enumObj: {
+        [value: string]: string;
+      } = {};
+      enumItems.forEach(({ label, value }) => {
+        enumObj[value] = label;
+      });
+      enumsMap[name] = enumObj;
+    });
+  }
 
-    if (Array.isArray(entities)) {
-        dataTypes.push(...entities);
-        entities.forEach((entity) => {
-            const ns = entity.ns;
-            if (Array.isArray(ns?.logics)) {
-                allLogics.push(...ns.logics);
-            }
-        });
-    }
+  if (Array.isArray(entities)) {
+    dataTypes.push(...entities);
+    entities.forEach((entity) => {
+      const { ns } = entity;
+      if (Array.isArray(ns?.logics)) {
+        allLogics.push(...ns.logics);
+      }
+    });
+  }
 
-    if (Array.isArray(structures)) {
-        dataTypes.push(...structures);
+  if (Array.isArray(structures)) {
+    dataTypes.push(...structures);
+  }
+
+  dataTypes.forEach((node) => {
+    const namespace = node.getNamespace();
+    const id = `${namespace}.${node.name}`;
+    dataTypesMap[id] = node.toJSON?.();
+    const { properties } = node as any;
+    if (Array.isArray(properties)) {
+      properties.forEach((property) => {
+        collectTypeAnnotation(property?.typeAnnotation);
+      });
     }
+  });
 
-    dataTypes.forEach((node) => {
-        const namespace = node.getNamespace();
+  [
+    {
+      namespace: 'nasl.auth',
+      list: authStructures,
+    },
+    {
+      namespace: 'nasl.ui',
+      list: uiStructures,
+    },
+    {
+      namespace: 'nasl.collection',
+      list: collectionStructures,
+    },
+    {
+      namespace: 'nasl.interface',
+      list: interfaceStructures,
+    },
+    {
+      namespace: 'nasl.process',
+      list: processStructures,
+    },
+    {
+      namespace: 'nasl.http',
+      list: httpStructures,
+    },
+  ].forEach((item) => {
+    const { namespace, list } = item || {};
+    if (Array.isArray(list)) {
+      list.forEach((node) => {
         const id = `${namespace}.${node.name}`;
         dataTypesMap[id] = node.toJSON?.();
-        const { properties } = (node) as any;
+        const { properties } = node as any;
         if (Array.isArray(properties)) {
-            properties.forEach((property) => {
-                collectTypeAnnotation(property?.typeAnnotation);
-            });
+          properties.forEach((property) => {
+            collectTypeAnnotation(property?.typeAnnotation);
+          });
         }
-    });
+      });
+    }
+  });
 
-    [
-        {
-            namespace: 'nasl.auth',
-            list: authStructures,
-        },
-        {
-            namespace: 'nasl.ui',
-            list: uiStructures,
-        },
-        {
-            namespace: 'nasl.collection',
-            list: collectionStructures,
-        },
-        {
-            namespace: 'nasl.interface',
-            list: interfaceStructures,
-        },
-        {
-            namespace: 'nasl.process',
-            list: processStructures,
-        },
-        {
-            namespace: 'nasl.http',
-            list: httpStructures,
-        },
-    ].forEach((item) => {
-        const { namespace, list } = item || {};
-        if (Array.isArray(list)) {
-            list.forEach((node) => {
-                const id = `${namespace}.${node.name}`;
-                dataTypesMap[id] = node.toJSON?.();
-                const { properties } = (node) as any;
-                if (Array.isArray(properties)) {
-                    properties.forEach((property) => {
-                        collectTypeAnnotation(property?.typeAnnotation);
-                    });
-                }
-            });
-        }
-    });
+  if (Array.isArray(logics)) {
+    allLogics.push(...logics);
+  }
 
-    if (Array.isArray(logics)) {
-        allLogics.push(...logics);
-    }
+  allLogics.forEach((node) => {
+    const namespace = node.getNamespace();
+    const id = namespace ? `${namespace}.${node.name}` : node.name;
+    logicsMap[id] = node.toService();
+  });
 
-    allLogics.forEach((node) => {
+  processes.forEach((process) => {
+    if (Array.isArray(process.logics)) {
+      process.logics.forEach((node) => {
         const namespace = node.getNamespace();
         const id = namespace ? `${namespace}.${node.name}` : node.name;
-        logicsMap[id] = node.toService();
-    });
+        logicsMap[id] = node.toProcessService();
+      });
+    }
+  });
 
-    processes.forEach((process) => {
-        if (Array.isArray(process.logics)) {
-            process.logics.forEach((node) => {
-                const namespace = node.getNamespace();
-                const id = namespace ? `${namespace}.${node.name}` : node.name;
-                logicsMap[id] = node.toProcessService();
-            });
-        }
-    });
+  interfaces.forEach((interfaceItem: Interface) => {
+    _custom[`${interfaceItem.getNamespace()}.${interfaceItem.name}`] = interfaceItem.toService();
+  });
 
-    interfaces.forEach((interfaceItem: Interface) => {
-        _custom[`${interfaceItem.getNamespace()}.${interfaceItem.name}`] = interfaceItem.toService();
-    });
+  utils.traverse(
+    (current) => {
+      const { node } = current || {};
+      collectTypeAnnotation(node?.typeAnnotation || node?.__TypeAnnotation);
+    },
+    {
+      node: {
+        children: views,
+      } as any,
+    },
+    {
+      mode: 'anyObject',
+      excludedKeySet: new Set([
+        'parentNode',
+        'sourceMap',
+        'storageJSON',
+        'tsErrorDetail',
+        'NaslAnnotatedJSON',
+        'calledFrom',
+        '_events',
+        '_collectingList',
+        '_historyList',
+      ]),
+    }
+  );
 
-    utils.traverse((current) => {
-        const { node } = current || {};
-        collectTypeAnnotation(node?.typeAnnotation || node?.__TypeAnnotation);
-    }, {
-        node: {
-            children: views,
-        } as any,
-    }, {
-        mode: 'anyObject',
-        excludedKeySet: new Set([
-            'parentNode',
-            'sourceMap',
-            'storageJSON',
-            'tsErrorDetail',
-            'NaslAnnotatedJSON',
-            'calledFrom',
-            '_events',
-            '_collectingList',
-            '_historyList',
-        ]),
+  if (Array.isArray(frontendVariables)) {
+    frontendVariables.forEach((frontendVariable) => {
+      const typeAnnotation = frontendVariable.typeAnnotation || frontendVariable.__TypeAnnotation;
+      collectTypeAnnotation(typeAnnotation);
     });
+  }
+  if (Array.isArray(frontendEvents)) {
+    frontendEvents.forEach((item) => {
+      const typeAnnotation = (item as any)?.typeAnnotation || item.__TypeAnnotation;
+      collectTypeAnnotation(typeAnnotation);
+    });
+  }
 
-    if (Array.isArray(frontendVariables)) {
-        frontendVariables.forEach((frontendVariable) => {
-            const typeAnnotation = frontendVariable.typeAnnotation || frontendVariable.__TypeAnnotation;
-            collectTypeAnnotation(typeAnnotation);
-        });
-    }
-    if (Array.isArray(frontendEvents)) {
-        frontendEvents.forEach((item) => {
-            const typeAnnotation = (item as any)?.typeAnnotation || item.__TypeAnnotation;
-            collectTypeAnnotation(typeAnnotation);
-        });
-    }
-
-    function collectTypeAnnotation(typeAnnotation: any) {
-        if (typeAnnotation) {
-            const sortedTypeKey = genSortedTypeKey(typeAnnotation);
-            if (!dataTypesMap[sortedTypeKey]) {
-                dataTypesMap[sortedTypeKey] = typeAnnotation?.toJSON?.() ?? typeAnnotation;
-                const { properties, typeArguments } = (dataTypesMap[sortedTypeKey] || {}) as any;
-                if (Array.isArray(properties)) {
-                    properties.forEach((property) => {
-                        collectTypeAnnotation(property?.typeAnnotation);
-                    });
-                }
-                if (Array.isArray(typeArguments)) {
-                    typeArguments.forEach((typeArg) => {
-                        collectTypeAnnotation(typeArg);
-                    });
-                }
-            }
+  function collectTypeAnnotation(typeAnnotation: any) {
+    if (typeAnnotation) {
+      const sortedTypeKey = genSortedTypeKey(typeAnnotation);
+      if (!dataTypesMap[sortedTypeKey]) {
+        dataTypesMap[sortedTypeKey] = typeAnnotation?.toJSON?.() ?? typeAnnotation;
+        const { properties, typeArguments } = (dataTypesMap[sortedTypeKey] || {}) as any;
+        if (Array.isArray(properties)) {
+          properties.forEach((property) => {
+            collectTypeAnnotation(property?.typeAnnotation);
+          });
+        }
+        if (Array.isArray(typeArguments)) {
+          typeArguments.forEach((typeArg) => {
+            collectTypeAnnotation(typeArg);
+          });
         }
+      }
     }
-    frontendEvents.forEach((logic) => {
-        const name = logic.getViewEventName();
-        const fn = (logic as any).toFunction();
-        frontendEventsMap[name] = fn;
-    });
-    return {
-        frontendEvents: frontendEventsMap,
-        frontendVariables,
-        dataTypesMap,
-        enumsMap,
-        logicsMap,
-        servicesMap: {
-            _custom,
-        },
-    };
+  }
+  frontendEvents.forEach((logic) => {
+    const name = logic.getViewEventName();
+    const fn = (logic as any).toFunction();
+    frontendEventsMap[name] = fn;
+  });
+  return {
+    frontendEvents: frontendEventsMap,
+    frontendVariables,
+    dataTypesMap,
+    enumsMap,
+    logicsMap,
+    servicesMap: {
+      _custom,
+    },
+  };
 }