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

package/src/generator/icestark.ts

@@ -42,4 +42,4 @@ export default `
         });
     } else
         loadAssets();
-`;
+`;

package/src/generator/microApp.ts

@@ -3,30 +3,27 @@ import icestark from './icestark';
 import { App, Frontend } from '../concepts';
 
 const framewords = {
-    qiankun, icestark,
+  qiankun,
+  icestark,
 };
 
 export function integrateMicroApp(frontend: Frontend) {
-    if(frontend.type === 'h5') return '';
+  if (frontend.type === 'h5') return '';
 
-    let { framework, name, routePrefix, proxyPrefix, loginUrl, noAuthUrl, notFoundUrl  } = frontend.app.integration?.microApp || {};
-    if(!framework) framework = 'icestark';  // 兼容 ICESTARK 旧集成方式
+  let { framework, name, routePrefix, proxyPrefix, loginUrl, noAuthUrl, notFoundUrl } = frontend.app.integration?.microApp || {};
+  if (!framework) framework = 'icestark'; // 兼容 ICESTARK 旧集成方式
 
-    if(loginUrl === `${routePrefix}${frontend.basePath}/login`)
-        loginUrl = undefined;
-    if(noAuthUrl === `${routePrefix}${frontend.basePath}/noAuth`)
-        noAuthUrl = undefined;
-    if(notFoundUrl === `${routePrefix}${frontend.basePath}/notFound`)
-        notFoundUrl = undefined;    
+  if (loginUrl === `${routePrefix}${frontend.basePath}/login`) loginUrl = undefined;
+  if (noAuthUrl === `${routePrefix}${frontend.basePath}/noAuth`) noAuthUrl = undefined;
+  if (notFoundUrl === `${routePrefix}${frontend.basePath}/notFound`) notFoundUrl = undefined;
 
-    const properties = JSON.stringify({
-        name: name || undefined,
-        routePrefix: routePrefix || undefined,
-        proxyPrefix: proxyPrefix || undefined,
-        loginUrl: loginUrl || undefined,
-        noAuthUrl: noAuthUrl || undefined,
-        notFoundUrl: notFoundUrl || undefined,
-    });
-    return framewords[framework].replace(/\{properties\}/g, properties);
+  const properties = JSON.stringify({
+    name: name || undefined,
+    routePrefix: routePrefix || undefined,
+    proxyPrefix: proxyPrefix || undefined,
+    loginUrl: loginUrl || undefined,
+    noAuthUrl: noAuthUrl || undefined,
+    notFoundUrl: notFoundUrl || undefined,
+  });
+  return framewords[framework].replace(/\{properties\}/g, properties);
 }
-

package/src/generator/permission.ts

@@ -1,306 +1,315 @@
-import { Logic, View, BaseNode, CallLogic, ViewElement, BindEvent, BindAttribute, App, Entity, Module, Frontend, BindStyle, BindDirective, Connector } from '../concepts';
+import {
+  Logic,
+  View,
+  BaseNode,
+  CallLogic,
+  ViewElement,
+  BindEvent,
+  BindAttribute,
+  App,
+  Entity,
+  Module,
+  Frontend,
+  BindStyle,
+  BindDirective,
+  Connector,
+} from '../concepts';
 import { processToTreeFragment } from '../server/process2LogicNamespace';
 
 type Usage = {
-    node: BaseNode,
-    children?: Usage[],
-}
+  node: BaseNode;
+  children?: Usage[];
+};
 type ResourceNode = {
-    path: string,
-    type: 'component' | 'page',
+  path: string;
+  type: 'component' | 'page';
 };
 
 function isReadOnly(logic: Logic) {
-    return !!logic.module
-        || logic.parentNode?.concept === 'Namespace'
-        || logic.parentKey === 'readonly'; // process logic
+  return !!logic.module || logic.parentNode?.concept === 'Namespace' || logic.parentKey === 'readonly'; // process logic
 }
 
 const cache = new Map();
 let useCache = false;
 async function findUsage(logic: Logic) {
-    if (useCache && cache.has(logic))
-        return cache.get(logic);
+  if (useCache && cache.has(logic)) return cache.get(logic);
 
-    const res = isReadOnly(logic) ? await logic.findReadOnlyLogicUsage() : await logic.findUsage();
-    if (useCache)
-        cache.set(logic, res);
-    return res;
+  const res = isReadOnly(logic) ? await logic.findReadOnlyLogicUsage() : await logic.findUsage();
+  if (useCache) cache.set(logic, res);
+  return res;
 }
 
 function openCache() {
-    useCache = true;
-    cache.clear();
+  useCache = true;
+  cache.clear();
 }
 function closeCache() {
-    useCache = false;
-    cache.clear();
+  useCache = false;
+  cache.clear();
 }
 
 async function findViewLogicReferences(logic: Logic, vis: Set<Logic> = new Set()) {
-    const usageMap: Map<BaseNode, Usage> = await findUsage(logic);
-    const usages: Usage[] = [];
-    usageMap.forEach((usage: Usage, node: BaseNode) => {
-        if (node instanceof Frontend)
-            usages.push(usage);
-    });
-
-    async function dfs(usage: Usage) {
-        if (usage.node instanceof CallLogic) {
-            const logic = usage.node.logic;
-            if (!vis.has(logic) && logic) {
-                vis.add(logic);
-                await findViewLogicReferences(logic, vis);
-            }
-        }
-
-        if (usage.children) {
-            for (const child of usage.children) {
-                await dfs(child);
-            }
-        }
+  const usageMap: Map<BaseNode, Usage> = await findUsage(logic);
+  const usages: Usage[] = [];
+  usageMap.forEach((usage: Usage, node: BaseNode) => {
+    if (node instanceof Frontend) usages.push(usage);
+  });
+
+  async function dfs(usage: Usage) {
+    if (usage.node instanceof CallLogic) {
+      const { logic } = usage.node;
+      if (!vis.has(logic) && logic) {
+        vis.add(logic);
+        await findViewLogicReferences(logic, vis);
+      }
     }
 
-    for (const usage of usages) {
-        await dfs(usage);
+    if (usage.children) {
+      for (const child of usage.children) {
+        await dfs(child);
+      }
     }
+  }
+
+  for (const usage of usages) {
+    await dfs(usage);
+  }
 
-    return Array.from(vis);
+  return Array.from(vis);
 }
 
 async function findUIReferences(logic: Logic) {
-    const usageMap: Map<BaseNode, Usage> = await findUsage(logic);
-    const usages: Usage[] = [];
-    usageMap.forEach((usage: Usage, node: BaseNode) => {
-        if (node instanceof Frontend)
-            usages.push(usage);
+  const usageMap: Map<BaseNode, Usage> = await findUsage(logic);
+  const usages: Usage[] = [];
+  usageMap.forEach((usage: Usage, node: BaseNode) => {
+    if (node instanceof Frontend) usages.push(usage);
+  });
+
+  const res: Array<View | ViewElement> = [];
+  function dfs(usage: Usage, parent: Usage = null) {
+    if (
+      (usage.node instanceof BindEvent ||
+        usage.node instanceof BindAttribute ||
+        usage.node instanceof BindStyle ||
+        usage.node instanceof BindDirective) &&
+      (parent.node instanceof View || parent.node instanceof ViewElement)
+    )
+      res.push(parent.node);
+
+    usage.children?.forEach((child) => {
+      dfs(child, usage);
     });
+  }
 
-    const res: Array<View | ViewElement> = [];
-    function dfs(usage: Usage, parent: Usage = null) {
-        if ((usage.node instanceof BindEvent || usage.node instanceof BindAttribute || usage.node instanceof BindStyle || usage.node instanceof BindDirective)
-            && (parent.node instanceof View || parent.node instanceof ViewElement))
-            res.push(parent.node);
-
-        usage.children?.forEach((child) => {
-            dfs(child, usage);
-        });
-    }
-
-    usages.forEach((usage) => {
-        dfs(usage);
-    });
-    return res;
+  usages.forEach((usage) => {
+    dfs(usage);
+  });
+  return res;
 }
 
 function findResourcesOfUI(view: View | ViewElement) {
-    const res: ResourceNode[] = [];
-    let node: BaseNode = view;
-    while (node) {
-        if (node instanceof View && node.auth)
-            res.push({
-                path: node.authPath,
-                type: 'page',
-            });
-        else if (node instanceof ViewElement && node.auth) {
-            res.push({
-                path: node.authPath,
-                type: 'component',
-            });
-        }
-        node = node.parentNode;
+  const res: ResourceNode[] = [];
+  let node: BaseNode = view;
+  while (node) {
+    if (node instanceof View && node.auth)
+      res.push({
+        path: node.authPath,
+        type: 'page',
+      });
+    else if (node instanceof ViewElement && node.auth) {
+      res.push({
+        path: node.authPath,
+        type: 'component',
+      });
     }
-    return res;
+    node = node.parentNode;
+  }
+  return res;
 }
 
 function optimizeResourceData(resources: ResourceNode[][]) {
-    let res = removeRedundantResourceData(resources);
-    return res
+  const res = removeRedundantResourceData(resources);
+  return res;
 }
 
 // [['b'], ['a' ,'b']] 只需要保留 [['b']]
 function removeRedundantResourceData(resources: ResourceNode[][]) {
-    const wm: WeakMap<ResourceNode[], string> = new WeakMap();
-    for (const resource of resources) {
-        const hash = resource.map(({ path, type }) => `${path}_${type}`)
-            .join();
-        wm.set(resource, hash);
-    }
+  const wm: WeakMap<ResourceNode[], string> = new WeakMap();
+  for (const resource of resources) {
+    const hash = resource.map(({ path, type }) => `${path}_${type}`).join();
+    wm.set(resource, hash);
+  }
 
-    resources.sort((a, b) => wm.get(a).length - wm.get(b).length);
+  resources.sort((a, b) => wm.get(a).length - wm.get(b).length);
 
-    const res: ResourceNode[][] = [];
-    const hashs: string[] = [];
+  const res: ResourceNode[][] = [];
+  const hashs: string[] = [];
 
-    for (const resource of resources) {
-        const hash = wm.get(resource);
-        if (hashs.some((h) => hash.endsWith(h)))
-            continue;
+  for (const resource of resources) {
+    const hash = wm.get(resource);
+    if (hashs.some((h) => hash.endsWith(h))) continue;
 
-        res.push(resource);
-        hashs.push(hash);
-    }
-    return res;
+    res.push(resource);
+    hashs.push(hash);
+  }
+  return res;
 }
 
-
 async function findResourcesOfLogic(logic: Logic, uploaders: Map<string, ViewElement[]>) {
-    const logics = await findViewLogicReferences(logic);
-    logics.push(logic);
+  const logics = await findViewLogicReferences(logic);
+  logics.push(logic);
 
-    let UIs: Array<View | ViewElement> = [];
-    for (const logic of logics) {
-        UIs = UIs.concat(await findUIReferences(logic));
-    }
+  let UIs: Array<View | ViewElement> = [];
+  for (const logic of logics) {
+    UIs = UIs.concat(await findUIReferences(logic));
+  }
 
-    const service = logic.toService() as { url: { method: string, path: string } };
-    if (uploaders.has(service.url.path)) {
-        UIs = UIs.concat(uploaders.get(service.url.path));
-    }
+  const service = logic.toService() as { url: { method: string; path: string } };
+  if (uploaders.has(service.url.path)) {
+    UIs = UIs.concat(uploaders.get(service.url.path));
+  }
 
-    UIs = Array.from(new Set(UIs));
+  UIs = Array.from(new Set(UIs));
 
-    const res = UIs.map((ui) => findResourcesOfUI(ui));
+  const res = UIs.map((ui) => findResourcesOfUI(ui));
 
-    return optimizeResourceData(res);
+  return optimizeResourceData(res);
 }
 
 function getAllLogics(app: App) {
-    const modules: (Module | Connector)[] = [];
-    const entities: Entity[] = [];
-    const logics: Logic[] = [];
-
-    if (Array.isArray(app.dataSources)) {
-        app.dataSources.forEach((dataSource) => {
-            if (Array.isArray(dataSource.entities)) {
-                entities.push(...dataSource.entities);
-            }
-        });
-    }
-    app.logics && logics.push(...app.logics);
-
-    app.dependencies && modules.push(...app.dependencies);
-    app.interfaceDependencies && modules.push(...app.interfaceDependencies);
-
-    modules.forEach((module: Module) => {
-        module.logics && logics.push(...module.logics);
-        if (Array.isArray(module.dataSources)) {
-            module.dataSources.forEach((dataSource) => {
-                if (Array.isArray(dataSource.entities)) {
-                    entities.push(...dataSource.entities);
-                }
-            });
-        }
+  const modules: (Module | Connector)[] = [];
+  const entities: Entity[] = [];
+  const logics: Logic[] = [];
+
+  if (Array.isArray(app.dataSources)) {
+    app.dataSources.forEach((dataSource) => {
+      if (Array.isArray(dataSource.entities)) {
+        entities.push(...dataSource.entities);
+      }
     });
-
-    const allLogics: Logic[] = [];
-
-    if (Array.isArray(entities)) {
-        entities.forEach((entity) => {
-            const ns = entity.ns;
-            if (Array.isArray(ns?.logics)) {
-                allLogics.push(...ns.logics);
-            }
-        });
-    }
-    if (Array.isArray(logics)) {
-        allLogics.push(...logics);
+  }
+  app.logics && logics.push(...app.logics);
+
+  app.dependencies && modules.push(...app.dependencies);
+  app.interfaceDependencies && modules.push(...app.interfaceDependencies);
+
+  modules.forEach((module: Module) => {
+    module.logics && logics.push(...module.logics);
+    if (Array.isArray(module.dataSources)) {
+      module.dataSources.forEach((dataSource) => {
+        if (Array.isArray(dataSource.entities)) {
+          entities.push(...dataSource.entities);
+        }
+      });
     }
+  });
 
-    const processLogics: Logic[] = [];
-    const processTreeFragments = (app.processes || [])
-        .map(processToTreeFragment);
-    processTreeFragments.forEach((tree) => {
-        processLogics.push(...tree.logics);
-        tree.elements.forEach((element) => {
-            processLogics.push(...element.logics);
-        });
+  const allLogics: Logic[] = [];
+
+  if (Array.isArray(entities)) {
+    entities.forEach((entity) => {
+      const { ns } = entity;
+      if (Array.isArray(ns?.logics)) {
+        allLogics.push(...ns.logics);
+      }
+    });
+  }
+  if (Array.isArray(logics)) {
+    allLogics.push(...logics);
+  }
+
+  const processLogics: Logic[] = [];
+  const processTreeFragments = (app.processes || []).map(processToTreeFragment);
+  processTreeFragments.forEach((tree) => {
+    processLogics.push(...tree.logics);
+    tree.elements.forEach((element) => {
+      processLogics.push(...element.logics);
     });
+  });
 
-    return {
-        logics: allLogics,
-        processLogics,
-    };
+  return {
+    logics: allLogics,
+    processLogics,
+  };
 }
 
 function findUploaders(app: App) {
-    const map = new Map<string, ViewElement[]>();
-    app.traverseChildren((node) => {
-        if (node instanceof ViewElement && node.tag?.includes('uploader')) {
-            const urlAttr = node.bindAttrs.find((item) => item.name === 'url');
-            const url = urlAttr?.value;
-            if (url) {
-                if (!map.has(url))
-                    map.set(url, [node]);
-                else
-                    map.get(url).push(node);
-            }
-        }
-    });
-    return map;
+  const map = new Map<string, ViewElement[]>();
+  app.traverseChildren((node) => {
+    if (node instanceof ViewElement && node.tag?.includes('uploader')) {
+      const urlAttr = node.bindAttrs.find((item) => item.name === 'url');
+      const url = urlAttr?.value;
+      if (url) {
+        if (!map.has(url)) map.set(url, [node]);
+        else map.get(url).push(node);
+      }
+    }
+  });
+  return map;
 }
 function checkUploadAuth(uploaders: Map<string, ViewElement[]>) {
-    const res: ResourceNode[] = [];
-    // 如果开启控制权限-componet，没开启权限-page
-    uploaders.get('/upload')?.map(node => {
-        if (node instanceof ViewElement) {
-            if (node.auth) {
-                res.push({
-                    path: node.authPath,
-                    type: 'component',
-                });
-            } else {
-                res.push({
-                    path: `${node?.view?.path}`, // 当前页面的路径
-                    type: 'page',
-                });
-            }
-        }
-    })
-   return res;
+  const res: { key: string; authValue: ResourceNode[] }[] = [];
+  // 如果开启控制权限-component，没开启权限-page
+  uploaders.forEach((value, key) => {
+    const authValue: ResourceNode[] = [];
+    value.map((node) => {
+      if (node instanceof ViewElement) {
+        const path = node.auth ? node.authPath : `${node.view.path}`;
+        const type = node.auth ? 'component' : 'page';
+        authValue.push({ path, type });
+      }
+      return null;
+    });
+    res.push({ key, authValue });
+  });
+  return res;
 }
-function checkPageAndUploadAuth(uploaders: Map<string, ViewElement[]>) {
-    let flag: number = -1;
-    flag = uploaders.get('/upload')?.findIndex(node => {
-        if (node.getAncestor('View') instanceof View) {
-            // 当前页面未开启权限且文件上传组件也未开启权限
-            if (!(node.getAncestor('View') as View).auth && node instanceof ViewElement && !node.auth) {
-                return true
-            }
-        }
-    })
-    return flag;
+function checkPageAndUploadAuth(uploaders: Map<string, ViewElement[]>, key: string) {
+  let flag: number = -1;
+  flag = uploaders.get(key)?.findIndex((node) => {
+    if (node.getAncestor('View') instanceof View) {
+      // 当前页面未开启权限且文件上传组件也未开启权限
+      if (!(node.getAncestor('View') as View).auth && node instanceof ViewElement && !node.auth) {
+        return true;
+      }
+    }
+  });
+  return flag;
+}
+function convertArray(arr: ResourceNode[]) {
+  return arr.map((item: any) => [item]);
 }
 export async function genPermissionData(app: App) {
-    // console.time('xxx');
-    openCache();
-    const logicPageResourceDtoList: { [key: string]: ResourceNode[][] } = {};
-    const { logics, processLogics } = getAllLogics(app);
-    const uploaders = findUploaders(app);
-    for (const logic of [...logics, ...processLogics]) {
-        const resources = await findResourcesOfLogic(logic, uploaders);
-        if (resources.length === 0)
-            continue;
-        const service = logics.includes(logic) ? logic.toService() : logic.toProcessService() as { url: { method: string, path: string } };
-        const key = `${service.url.path}:${service.url.method}`;
-        logicPageResourceDtoList[key] = resources;
-    }
-    const authValue = checkUploadAuth(uploaders);
-    if (authValue?.length) {
-        logicPageResourceDtoList['/upload:POST'] = [checkPageAndUploadAuth(uploaders) != -1 ? [] : authValue];
-    }
-    closeCache();
-    // console.timeEnd('xxx');
-    return logicPageResourceDtoList;
+  // console.time('xxx');
+  openCache();
+  const logicPageResourceDtoList: { [key: string]: ResourceNode[][] } = {};
+  const { logics, processLogics } = getAllLogics(app);
+  const uploaders = findUploaders(app);
+  for (const logic of [...logics, ...processLogics]) {
+    const resources = await findResourcesOfLogic(logic, uploaders);
+    if (resources.length === 0) continue;
+    const service = logics.includes(logic) ? logic.toService() : (logic.toProcessService() as { url: { method: string; path: string } });
+    const key = `${service.url.path}:${service.url.method}`;
+    logicPageResourceDtoList[key] = resources;
+  }
+  const authValue = checkUploadAuth(uploaders);
+  if (authValue?.length) {
+    authValue.forEach((item) => {
+      const { key, authValue } = item;
+      logicPageResourceDtoList[`${key}:POST`] = checkPageAndUploadAuth(uploaders, key) !== -1 ? [] : convertArray(authValue);
+    });
+  }
+  closeCache();
+  // console.timeEnd('xxx');
+  return logicPageResourceDtoList;
 }
 export function genLogicAuthFlag(app: App) {
-    let flag = false;
-    app.traverseChildren((node) => {
-        if(flag) return;
+  let flag = false;
+  app.traverseChildren((node) => {
+    if (flag) return;
 
-        if((node instanceof View || node instanceof ViewElement) && node.auth)
-            flag = true;
-    });
+    if ((node instanceof View || node instanceof ViewElement) && node.auth) flag = true;
+  });
 
-    return flag;
+  return flag;
 }

package/src/generator/qiankun.ts

@@ -46,4 +46,4 @@ export default `
         };
     } else
         loadAssets();
-`;
+`;