@lcap/nasl 2.18.0 → 2.20.0-beta.1

package/src/generator/genMetaData.ts

@@ -1,65 +1,99 @@
-import { App, View, BaseNode, Module, Interface, Entity, Structure, Enum, uiStructures, collectionStructures, processStructures, Logic, Process, DataSource } from '../concepts';
-
-export function genMetaData(app: App,
-    config: {
-        tenant: string;
-        env: string;
-        nuimsDomain: string;
-        envNuimsDomain: Object;
-        STATIC_URL: string;
-        USER_STATIC_URL: string;
-        extendedConfig: string;
-        lowcodeDomain: string;
-    }) {
+import {
+    App, Module, View, Entity, Structure, Enum,
+    uiStructures, collectionStructures, interfaceStructures, processStructures,
+    Logic, Interface, Process, BaseNode, Frontend,
+} 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('>');
+        }
+    }
+    return typeKeyArr.join('');
+}
+
+export function genMetaData(app: App, frontend: Frontend) {
     const modules: Module[] = [];
     const views: View[] = [];
-    const dataSources: DataSource[] = [];
+    const entities: Entity[] = [];
     const structures: Structure[] = [];
     const enums: Enum[] = [];
     const logics: Logic[] = [];
     const interfaces: Interface[] = [];
     const processes: Process[] = [];
 
-    const {
-        dataSources: appDataSources = [],
-        structures: appStructures = [],
-        enums: appEnums = [],
-        logics: appLogics = [],
-        interfaceDependencies: appInterfaceDependencies = [],
-        dependencies: appDependencies = [],
-        processes: appProcesses = [],
-    } = app || {};
-    dataSources.push(...appDataSources);
-    structures.push(...appStructures);
-    enums.push(...appEnums);
-    logics.push(...appLogics);
-    processes.push(...appProcesses);
-    if (Array.isArray(appDependencies)) {
-        modules.push(...appDependencies);
-    }
-    if (Array.isArray(appInterfaceDependencies)) {
-        modules.push(...appInterfaceDependencies);
+    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);
+
     modules.forEach((module: Module) => {
-        const {
-            views: moduleViews = [],
-            structures: moduleStructures = [],
-            enums: moduleEnums = [],
-            logics: moduleLogics = [],
-            interfaces: moduleInterfaces = [],
-        } = module;
-        views.push(...moduleViews);
-        structures.push(...moduleStructures);
-        enums.push(...moduleEnums);
-        logics.push(...moduleLogics);
-        interfaces.push(...moduleInterfaces);
+        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 dataTypesMap: {
         [id: string]: BaseNode;
     } = {};
-    const frontendVariables = app.frontendVariables;
+    const frontendVariables = frontend.variables;
     const enumsMap: {
         [name: string]: {
             [label: string]: string;
@@ -80,6 +114,7 @@ export function genMetaData(app: App,
         [id: string]: any;
     } = {};
     const allLogics: Logic[] = [];
+
     if (Array.isArray(enums)) {
         dataTypes.push(...enums);
         enums.forEach((node) => {
@@ -96,17 +131,17 @@ export function genMetaData(app: App,
             enumsMap[name] = enumObj;
         });
     }
-    if (Array.isArray(dataSources)) {
-        dataSources.forEach((dataSource) => {
-            dataSource.entities.forEach((entity) => {
-                dataTypes.push(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.ns;
+            if (Array.isArray(ns?.logics)) {
+                allLogics.push(...ns.logics);
+            }
         });
     }
+
     if (Array.isArray(structures)) {
         dataTypes.push(...structures);
     }
@@ -114,31 +149,47 @@ export function genMetaData(app: App,
     dataTypes.forEach((node) => {
         const namespace = node.getNamespace();
         const id = `${namespace}.${node.name}`;
-        dataTypesMap[id] = node;
+        dataTypesMap[id] = node.toJSON?.();
+        const { properties } = (node) as any;
+        if (Array.isArray(properties)) {
+            properties.forEach((property) => {
+                collectTypeAnnotation(property?.typeAnnotation);
+            });
+        }
     });
-    if (Array.isArray(uiStructures)) {
-        const namespace = 'nasl.ui';
-        uiStructures.forEach((node) => {
-            const id = `${namespace}.${node.name}`;
-            dataTypesMap[id] = node;
-        });
-    }
 
-    if (Array.isArray(collectionStructures)) {
-        const namespace = 'nasl.collection';
-        collectionStructures.forEach((node) => {
-            const id = `${namespace}.${node.name}`;
-            dataTypesMap[id] = node;
-        });
-    }
-
-    if (Array.isArray(processStructures)) {
-        const namespace = 'nasl.process';
-        processStructures.forEach((node) => {
-            const id = `${namespace}.${node.name}`;
-            dataTypesMap[id] = node;
-        });
-    }
+    [
+        {
+            namespace: 'nasl.ui',
+            list: uiStructures,
+        },
+        {
+            namespace: 'nasl.collection',
+            list: collectionStructures,
+        },
+        {
+            namespace: 'nasl.interface',
+            list: interfaceStructures,
+        },
+        {
+            namespace: 'nasl.process',
+            list: processStructures,
+        },
+    ].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);
@@ -164,6 +215,55 @@ export function genMetaData(app: App,
         _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',
+        ]),
+    });
+
+    if (Array.isArray(frontendVariables)) {
+        frontendVariables.forEach((frontendVariable) => {
+            const typeAnnotation = frontendVariable.typeAnnotation || frontendVariable.__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);
+                    });
+                }
+            }
+        }
+    }
+
     return {
         frontendVariables,
         dataTypesMap,

package/src/generator/genReleaseBody.ts

@@ -1,5 +1,6 @@
-import { App, Assignment, BatchAssignment, CallFunction, CallInterface, CallLogic, ForEachStatement, IfStatement, Logic, LogicItem, Match, MatchCase, Role, SwitchCase, SwitchStatement, View, ViewElement, WhileStatement } from '../concepts';
-import { genBundleFiles } from './genBundleFiles';
+import { App, Assignment, BatchAssignment, CallFunction, CallInterface, CallLogic, ForEachStatement, IfStatement, Logic, LogicItem, Match, MatchCase, Role, SwitchCase, SwitchStatement, View, ViewElement, WhileStatement, Frontend } from '../concepts';
+import { genFrontendBundleFiles } from './genBundleFiles';
+import { genPermissionData } from './permission';
 
 export async function genReleaseBody(app: App, {
     env,
@@ -8,6 +9,7 @@ export async function genReleaseBody(app: App, {
     realRelease,
     appInfo,
     staticUrl,
+    frontends = [],
 }: {
     env: string,
     replicas: number,
@@ -26,21 +28,48 @@ export async function genReleaseBody(app: App, {
         tenantLabel: string,
     },
     staticUrl?: string,
+    frontends: Array<Frontend>,
 }) {
+    let authReport: ReturnType<typeof getAuthReport>;
+    let logicPageResourceDtoList;
+    if (realRelease) {
+        authReport = getAuthReport(app, frontends);
+        const permissionData = await genPermissionData(app);
+        authReport.resourceDataList = authReport.resourceDataList.concat(permissionData.resourceDataList);
+        authReport.resourceList = authReport.resourceList.concat(permissionData.resourceList);
+
+        logicPageResourceDtoList = permissionData.logicPageResourceDtoList;
+    }
+
+    const releaseFrontends = app.frontends.map((frontend) => ({
+        name: frontend.name,
+        type: frontend.type,
+        path: frontend.path,
+        selected: frontends.includes(frontend),
+    }));
+
     const body = {
-        ...(realRelease ? getAuthReport(app) : undefined), // 如果发布需要上报权限，导出源码不需要
-        noAuthApiPathList: getAuthApiPathList(app),
-        reportIdList: findAllReportIdList(app),
+        ...authReport, // 如果发布需要上报权限，导出源码不需要
+        logicPageResourceDtoList,
+        noAuthApiPathList: getAuthApiPathList(app, frontends),
+        reportIdList: findAllReportIdList(app, frontends),
         appId: app.id,
         env,
         replicas,
+        callbackLogicsName: app.getExtensionsCallbackLogics(),
         generateMini,
+        frontends: releaseFrontends,
         files: [] as Array<{ name: string, content: string }>,
     };
+    let NaslAnnotatedJSON;
+    try {
+        NaslAnnotatedJSON = await (app as any).naslServer.getNaslAnnotatedJSON(app, true);
+    } catch (err) {
+        console.error(err);
+        throw new Error('代码标注失败');
+    }
 
-    const NaslAnnotatedJSON = await (app as any).naslServer.getNaslAnnotatedJSON(app, true);
-
-    let files = genBundleFiles(app, Object.assign({}, appInfo, {
+    let files = genFrontendBundleFiles(app, frontends, Object.assign({}, appInfo, {
         env,
         appid: app.id,
         devDnsAddr: (app as any).devDnsAddr,
@@ -59,7 +88,9 @@ export async function genReleaseBody(app: App, {
     const jsonString = JSON.stringify(NaslAnnotatedJSON);
 
     // 打印传给服务端的nasl,为了服务端排查问题方便
-    // console.warn(NaslAnnotatedJSON, '标注后的nasl');
+    if (globalThis.window) {
+        console.log(NaslAnnotatedJSON, '标注后的nasl');
+    }
     files.push({ name: 'nasl-annotated.json', content: jsonString });
 
     body.files = files;
@@ -69,11 +100,11 @@ export async function genReleaseBody(app: App, {
 /**
  * 权限上报数据
  */
-function getAuthReport(app: App) {
+function getAuthReport(app: App, frontends: Array<Frontend>) {
     const result = {
         roleList: [] as Array<Role>,
         resourceList: [] as Array<string>,
-        resourceDataList: [] as Array<{ value: string, description: string }>,
+        resourceDataList: [] as Array<{ value: string, description: string, type: 'page' | 'component' | 'logic', clientType?: string }>,
         roleResourceMappingList: [] as Array<{ roleName: string, resourcePath: string }>,
     };
 
@@ -84,12 +115,12 @@ function getAuthReport(app: App) {
         return authDirective?.value;
     };
 
-    const loopViews = (view: View | ViewElement, isMain: boolean) => {
+    const loopViews = (view: View | ViewElement, isMain: boolean, frontend: Frontend) => {
         if (view.children) {
-            view.children.forEach((item) => loopViews(item, false));
+            view.children.forEach((item) => loopViews(item, false, frontend));
         }
         if (view.concept === 'View' && view.elements) {
-            view.elements.forEach((item) => loopViews(item, false));
+            view.elements.forEach((item) => loopViews(item, false, frontend));
         }
 
         if ((view.concept === 'View' && view.auth)
@@ -100,6 +131,8 @@ function getAuthReport(app: App) {
             result.resourceDataList.push({
                 value: view.authPath,
                 description: view.authDescription,
+                type: view.concept === 'View' ? 'page' : 'component',
+                clientType: frontend.name,
             });
             if (view.bindRoles) {
                 const _arr = view.bindRoles.map((it) => ({
@@ -111,7 +144,9 @@ function getAuthReport(app: App) {
             }
         }
     };
-    app.views.forEach((view) => loopViews(view, true));
+    frontends.forEach((frontend) => {
+        frontend.views.forEach((view) => loopViews(view, true, frontend));
+    });
 
     return result;
 }
@@ -120,8 +155,8 @@ function getAuthReport(app: App) {
 /**
  * 上报白名单
  */
-function getAuthApiPathList(app: App) {
-    const thisDiffLogicList: Array<string> = [];
+function getAuthApiPathList(app: App, frontends: Array<Frontend>) {
+    const thisDiffLogicList: Array<{logicName:string, frontendName: string}> = [];
 
     /* 转换Path */
     function getPathMethods(logicNameSpace: string) {
@@ -213,7 +248,7 @@ function getAuthApiPathList(app: App) {
         }
     }
     /* 获取LogicITEM */
-    function getStatement(state: LogicItem) {
+    function getStatement(state: LogicItem, frontend: Frontend) {
         let logicItems: Array<LogicItem> = [];
         if (state instanceof Assignment) {
             logicItems = [state.left, state.right];
@@ -224,18 +259,18 @@ function getAuthApiPathList(app: App) {
         } else if (state instanceof ForEachStatement) {
             logicItems = [...state.body, state.each, state.start, state.end];
         } else if (state instanceof Match) {
-            logicItems = state.cases.map(getStatement).flat(1);
+            logicItems = state.cases.map((case1) => getStatement(case1, frontend)).flat(1);
         } else if (state instanceof MatchCase) {
             logicItems = [...state.patterns as LogicItem[], ...state.body];
         } else if (state instanceof SwitchStatement) {
-            logicItems = state.cases.map(getStatement).flat(1);
+            logicItems = state.cases.map((case1) => getStatement(case1, frontend)).flat(1);
         } else if (state instanceof SwitchCase) {
             logicItems = [state.test, ...state.consequent];
         } else if (state instanceof WhileStatement) {
             logicItems = [state.test, ...state.body];
         } else if (state instanceof CallLogic) {
             logicItems = state.arguments?.map((item) => item.expression);
-            getLogic(state.calleewholeKey);
+            getLogic(state.calleewholeKey, frontend);
         } else if (state instanceof CallFunction) {
             logicItems = state.arguments?.map((item) => item.expression);
         } else if (state instanceof CallInterface) {
@@ -245,27 +280,27 @@ function getAuthApiPathList(app: App) {
         return logicItems.filter((item) => !!item);
     }
     /* 获取非鉴权全局逻辑 */
-    function getLogic(key: string) {
-        if (!thisDiffLogicList.includes(key)) {
-            thisDiffLogicList.push(key);
+    function getLogic(key: string, frontend: Frontend) {
+        if (!thisDiffLogicList.find((diffLogic) => diffLogic.logicName === key && diffLogic.frontendName === frontend.name)) {
+            thisDiffLogicList.push({ logicName: key, frontendName: frontend.name });
             const logic: Logic = app.findNodeByCompleteName(key);
             if (logic && logic.body && logic.body.length > 2) {
-                logic.body.map((item) => getStatement(item));
+                logic.body.map((item) => getStatement(item, frontend));
             }
         }
     }
 
     const importList: Array<string> = [];
-    const itemloop = (state: LogicItem, view: View | ViewElement) => {
-        const logicItems = getStatement(state);
+    const itemloop = (state: LogicItem, view: View | ViewElement, frontend: Frontend) => {
+        const logicItems = getStatement(state, frontend);
         if (logicItems.length) {
-            logicItems.map((item) => itemloop(item, view));
+            logicItems.map((item) => itemloop(item, view, frontend));
         }
     };
 
-    const loopEle = (view: View | ViewElement) => {
-        view?.children?.forEach(loopEle);
-        view.concept === 'View' && view?.elements?.forEach(loopEle);
+    const loopEle = (view: View | ViewElement, frontend: Frontend) => {
+        view?.children?.forEach((vitem) => loopEle(vitem, frontend));
+        view.concept === 'View' && view?.elements?.forEach((ele) => loopEle(ele, frontend));
         if (!view.parentAuth) {
             if (view.bindEvents) {
                 view.bindEvents.forEach((item) => {
@@ -273,7 +308,7 @@ function getAuthApiPathList(app: App) {
                         item.logics.forEach((logic) => {
                             if (logic.body.length > 2) {
                                 logic.body.forEach((it) => {
-                                    itemloop(it, view);
+                                    itemloop(it, view, frontend);
                                 });
                             }
                         });
@@ -288,14 +323,14 @@ function getAuthApiPathList(app: App) {
             }
         }
     };
-    const loopViews = (view: View, isChild: boolean) => {
+    const loopViews = (view: View, isChild: boolean, frontend:Frontend) => {
         // 有权限的页面下的逻辑都不需要上报白名单
         if (!view.auth) {
             if (view.logics) {
                 view.logics.forEach((logic) => {
                     if (logic.body.length > 2) {
                         logic.body.forEach((it) => {
-                            itemloop(it, view);
+                            itemloop(it, view, frontend);
                         });
                     }
                 });
@@ -306,7 +341,7 @@ function getAuthApiPathList(app: App) {
                         item.logics.forEach((logic) => {
                             if (logic.body.length > 2) {
                                 logic.body.forEach((it) => {
-                                    itemloop(it, view);
+                                    itemloop(it, view, frontend);
                                 });
                             }
                         });
@@ -314,27 +349,35 @@ function getAuthApiPathList(app: App) {
                 });
             }
 
-            view.children.forEach((item) => loopViews(item, true));
+            view.children.forEach((item) => loopViews(item, true, frontend));
         }
         if (!isChild) {
-            view.children.forEach(loopEle);
-            view.elements.forEach(loopEle);
+            view.children.forEach((vitem) => loopEle(vitem, frontend));
+            view.elements.forEach((vele) => loopEle(vele, frontend));
         }
     };
-    app.views.map((item) => loopViews(item, false));
+    frontends.forEach((frontend) => {
+        frontend.views.forEach((view) => loopViews(view, true, frontend));
+    });
 
-    const diffLogicList = thisDiffLogicList.filter((item) => item.startsWith('app') || item.startsWith('extensions'));
-    const authApiList = [...diffLogicList.map(getPathMethods), ...Array.from(new Set(importList.map((item) => item + ':POST')))].filter((item) => !!item);
+    const diffLogicList = thisDiffLogicList.filter((item) => item.logicName.startsWith('app') || item.logicName.startsWith('extensions'));
+    const authApiList = [
+        ...diffLogicList.map((diffLogic) => {
+            const path = getPathMethods(diffLogic.logicName);
+            return `${path}:${diffLogic.frontendName}`;
+        }),
+        ...Array.from(new Set(importList.map((item) => item + ':POST'))),
+    ].filter((item) => !!item);
     return authApiList;
 }
 
 /**
  * 获取页面中所有 分析报告组件 的reportId
  */
-function findAllReportIdList(app: App) {
+function findAllReportIdList(app: App, frontends: Array<Frontend>) {
     const reportIds: string[] = [];
-    app?.views.forEach((view) => {
-        loop(view);
+    frontends.forEach((frontend) => {
+        frontend.views.forEach((view) => loop(view));
     });
 
     function loop(root: View | ViewElement) {

package/src/generator/index.ts

@@ -4,3 +4,4 @@ export * from './styleReplacer';
 export * from './genBundleFiles';
 export * from './genMetaData';
 export * from './genReleaseBody';
+export * from './permission';