@lcap/nasl 2.20.0-beta.3 → 2.20.0-beta.5

package/src/generator/dist/permission.js

@@ -0,0 +1,405 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __spreadArrays = (this && this.__spreadArrays) || function () {
+    for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;
+    for (var r = Array(s), k = 0, i = 0; i < il; i++)
+        for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)
+            r[k] = a[j];
+    return r;
+};
+exports.__esModule = true;
+exports.genPermissionData = void 0;
+var concepts_1 = require("../concepts");
+var process2LogicNamespace_1 = require("../server/process2LogicNamespace");
+function isReadOnly(logic) {
+    var _a;
+    return !!logic.module
+        || ((_a = logic.parentNode) === null || _a === void 0 ? void 0 : _a.concept) === 'Namespace'
+        || logic.parentKey === 'readonly'; // process logic
+}
+var cache = new Map();
+var useCache = false;
+function findUsage(logic) {
+    return __awaiter(this, void 0, void 0, function () {
+        var res, _a;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    if (useCache && cache.has(logic))
+                        return [2 /*return*/, cache.get(logic)];
+                    if (!isReadOnly(logic)) return [3 /*break*/, 2];
+                    return [4 /*yield*/, logic.findReadOnlyLogicUsage()];
+                case 1:
+                    _a = _b.sent();
+                    return [3 /*break*/, 4];
+                case 2: return [4 /*yield*/, logic.findUsage()];
+                case 3:
+                    _a = _b.sent();
+                    _b.label = 4;
+                case 4:
+                    res = _a;
+                    if (useCache)
+                        cache.set(logic, res);
+                    return [2 /*return*/, res];
+            }
+        });
+    });
+}
+function openCache() {
+    useCache = true;
+    cache.clear();
+}
+function closeCache() {
+    useCache = false;
+    cache.clear();
+}
+function findViewLogicReferences(logic, vis) {
+    if (vis === void 0) { vis = new Set(); }
+    return __awaiter(this, void 0, void 0, function () {
+        function dfs(usage) {
+            return __awaiter(this, void 0, void 0, function () {
+                var logic_1, _i, _a, child;
+                return __generator(this, function (_b) {
+                    switch (_b.label) {
+                        case 0:
+                            if (!(usage.node instanceof concepts_1.CallLogic)) return [3 /*break*/, 2];
+                            logic_1 = usage.node.logic;
+                            if (!(!vis.has(logic_1) && logic_1)) return [3 /*break*/, 2];
+                            vis.add(logic_1);
+                            return [4 /*yield*/, findViewLogicReferences(logic_1, vis)];
+                        case 1:
+                            _b.sent();
+                            _b.label = 2;
+                        case 2:
+                            if (!usage.children) return [3 /*break*/, 6];
+                            _i = 0, _a = usage.children;
+                            _b.label = 3;
+                        case 3:
+                            if (!(_i < _a.length)) return [3 /*break*/, 6];
+                            child = _a[_i];
+                            return [4 /*yield*/, dfs(child)];
+                        case 4:
+                            _b.sent();
+                            _b.label = 5;
+                        case 5:
+                            _i++;
+                            return [3 /*break*/, 3];
+                        case 6: return [2 /*return*/];
+                    }
+                });
+            });
+        }
+        var usageMap, usages, _i, usages_1, usage;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, findUsage(logic)];
+                case 1:
+                    usageMap = _a.sent();
+                    usages = [];
+                    usageMap.forEach(function (usage, node) {
+                        if (node instanceof concepts_1.View)
+                            usages.push(usage);
+                    });
+                    _i = 0, usages_1 = usages;
+                    _a.label = 2;
+                case 2:
+                    if (!(_i < usages_1.length)) return [3 /*break*/, 5];
+                    usage = usages_1[_i];
+                    return [4 /*yield*/, dfs(usage)];
+                case 3:
+                    _a.sent();
+                    _a.label = 4;
+                case 4:
+                    _i++;
+                    return [3 /*break*/, 2];
+                case 5: return [2 /*return*/, Array.from(vis)];
+            }
+        });
+    });
+}
+function findUIReferences(logic) {
+    return __awaiter(this, void 0, void 0, function () {
+        function dfs(usage, parent) {
+            var _a;
+            if (parent === void 0) { parent = null; }
+            if (['logic1', 'logic2'].includes(logic.name)) {
+                console.log(usage.node);
+            }
+            if ((usage.node instanceof concepts_1.BindEvent || usage.node instanceof concepts_1.BindAttribute)
+                && (parent.node instanceof concepts_1.View || parent.node instanceof concepts_1.ViewElement))
+                res.push(parent.node);
+            (_a = usage.children) === null || _a === void 0 ? void 0 : _a.forEach(function (child) {
+                dfs(child, usage);
+            });
+        }
+        var usageMap, usages, res;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, findUsage(logic)];
+                case 1:
+                    usageMap = _a.sent();
+                    usages = [];
+                    usageMap.forEach(function (usage, node) {
+                        if (node instanceof concepts_1.View)
+                            usages.push(usage);
+                    });
+                    res = [];
+                    usages.forEach(function (usage) {
+                        dfs(usage);
+                    });
+                    return [2 /*return*/, res];
+            }
+        });
+    });
+}
+function findResourcesOfUI(view) {
+    var res = [];
+    var node = view;
+    while (node) {
+        if (node instanceof concepts_1.View && node.auth)
+            res.push({
+                path: node.authPath,
+                type: 'page'
+            });
+        else if (node instanceof concepts_1.ViewElement) {
+            var hasAuth = node.bindDirectives.find(function (directive) { return directive.name === 'auth'; });
+            if (hasAuth)
+                res.push({
+                    path: node.authPath,
+                    type: 'component'
+                });
+        }
+        node = node.parentNode;
+    }
+    return res;
+}
+function optimizeResourceData(resources) {
+    var res = removeRedundantResourceData(resources);
+    res = removeRedundantResourceData2(res);
+    return res;
+}
+// [['b'], ['a' ,'b']] 只需要保留 [['b']]
+function removeRedundantResourceData(resources) {
+    var wm = new WeakMap();
+    for (var _i = 0, resources_1 = resources; _i < resources_1.length; _i++) {
+        var resource = resources_1[_i];
+        var hash = resource.map(function (_a) {
+            var path = _a.path, type = _a.type;
+            return path + "_" + type;
+        })
+            .join();
+        wm.set(resource, hash);
+    }
+    resources.sort(function (a, b) { return wm.get(a).length - wm.get(b).length; });
+    var res = [];
+    var hashs = [];
+    ;
+    var _loop_1 = function (resource) {
+        var hash = wm.get(resource);
+        if (hashs.some(function (h) { return hash.endsWith(h); }))
+            return "continue";
+        res.push(resource);
+        hashs.push(hash);
+    };
+    for (var _a = 0, resources_2 = resources; _a < resources_2.length; _a++) {
+        var resource = resources_2[_a];
+        _loop_1(resource);
+    }
+    return res;
+}
+// 子页面有权限，父页面默认也有权限，所以不需要记录父页面权限；
+// 组件有权限，组件所在的页面默认也有权限，所以不需要记录页面权限
+function removeRedundantResourceData2(resources) {
+    return resources.map(function (resource) {
+        if (resource.length <= 1)
+            return resource;
+        if (resource[0].type === 'page')
+            return resource.slice(0, 1);
+        else if (resource[0].type === 'component')
+            return resource.filter(function (item) { return item.type === 'component'; });
+    });
+}
+function findResourcesOfLogic(logic, uploaders) {
+    return __awaiter(this, void 0, void 0, function () {
+        var logics, UIs, _i, logics_1, logic_2, _a, _b, service, res;
+        return __generator(this, function (_c) {
+            switch (_c.label) {
+                case 0:
+                    if (['logic1', 'logic2'].includes(logic.name)) {
+                        debugger;
+                    }
+                    return [4 /*yield*/, findViewLogicReferences(logic)];
+                case 1:
+                    logics = _c.sent();
+                    logics.push(logic);
+                    UIs = [];
+                    _i = 0, logics_1 = logics;
+                    _c.label = 2;
+                case 2:
+                    if (!(_i < logics_1.length)) return [3 /*break*/, 5];
+                    logic_2 = logics_1[_i];
+                    _b = (_a = UIs).concat;
+                    return [4 /*yield*/, findUIReferences(logic_2)];
+                case 3:
+                    UIs = _b.apply(_a, [_c.sent()]);
+                    if (['logic1', 'logic2'].includes(logic_2.name)) {
+                        console.log(UIs);
+                    }
+                    _c.label = 4;
+                case 4:
+                    _i++;
+                    return [3 /*break*/, 2];
+                case 5:
+                    service = logic.toService();
+                    if (uploaders.has(service.url.path)) {
+                        UIs = UIs.concat(uploaders.get(service.url.path));
+                    }
+                    UIs = Array.from(new Set(UIs));
+                    res = UIs.map(function (ui) { return findResourcesOfUI(ui); });
+                    if (['logic1', 'logic2'].includes(logic.name)) {
+                        console.log(logic.name, UIs, res);
+                    }
+                    return [2 /*return*/, optimizeResourceData(res)];
+            }
+        });
+    });
+}
+function getAllLogics(app) {
+    var modules = [];
+    var entities = [];
+    var logics = [];
+    if (Array.isArray(app.dataSources)) {
+        app.dataSources.forEach(function (dataSource) {
+            if (Array.isArray(dataSource.entities)) {
+                entities.push.apply(entities, dataSource.entities);
+            }
+        });
+    }
+    app.logics && logics.push.apply(logics, app.logics);
+    app.dependencies && modules.push.apply(modules, app.dependencies);
+    app.interfaceDependencies && modules.push.apply(modules, app.interfaceDependencies);
+    modules.forEach(function (module) {
+        module.logics && logics.push.apply(logics, module.logics);
+        if (Array.isArray(module.dataSources)) {
+            module.dataSources.forEach(function (dataSource) {
+                if (Array.isArray(dataSource.entities)) {
+                    entities.push.apply(entities, dataSource.entities);
+                }
+            });
+        }
+    });
+    var allLogics = [];
+    if (Array.isArray(entities)) {
+        entities.forEach(function (entity) {
+            var ns = entity.ns;
+            if (Array.isArray(ns === null || ns === void 0 ? void 0 : ns.logics)) {
+                allLogics.push.apply(allLogics, ns.logics);
+            }
+        });
+    }
+    if (Array.isArray(logics)) {
+        allLogics.push.apply(allLogics, logics);
+    }
+    var processLogics = [];
+    var processTreeFragments = (app.processes || [])
+        .map(process2LogicNamespace_1.processToTreeFragment);
+    processTreeFragments.forEach(function (tree) {
+        processLogics.push.apply(processLogics, tree.logics);
+        tree.elements.forEach(function (element) {
+            processLogics.push.apply(processLogics, element.logics);
+        });
+    });
+    return {
+        logics: allLogics,
+        processLogics: processLogics
+    };
+}
+function findUploaders(app) {
+    var map = new Map();
+    app.traverseChildren(function (node) {
+        var _a;
+        if (node instanceof concepts_1.ViewElement && ((_a = node.tag) === null || _a === void 0 ? void 0 : _a.includes('uploader'))) {
+            var urlAttr = node.bindAttrs.find(function (item) { return item.name === 'url'; });
+            var url = urlAttr === null || urlAttr === void 0 ? void 0 : urlAttr.value;
+            if (url) {
+                if (!map.has(url))
+                    map.set(url, [node]);
+                else
+                    map.get(url).push(node);
+            }
+        }
+    });
+    return map;
+}
+function genPermissionData(app) {
+    return __awaiter(this, void 0, void 0, function () {
+        var logicPageResourceDtoList, _a, logics, processLogics, uploaders, _i, _b, logic, resources, service, key;
+        return __generator(this, function (_c) {
+            switch (_c.label) {
+                case 0:
+                    // console.time('xxx');
+                    openCache();
+                    logicPageResourceDtoList = {};
+                    _a = getAllLogics(app), logics = _a.logics, processLogics = _a.processLogics;
+                    uploaders = findUploaders(app);
+                    _i = 0, _b = __spreadArrays(logics, processLogics);
+                    _c.label = 1;
+                case 1:
+                    if (!(_i < _b.length)) return [3 /*break*/, 4];
+                    logic = _b[_i];
+                    return [4 /*yield*/, findResourcesOfLogic(logic, uploaders)];
+                case 2:
+                    resources = _c.sent();
+                    if (resources.length === 0)
+                        return [3 /*break*/, 3];
+                    service = logics.includes(logic) ? logic.toService() : logic.toProcessService();
+                    key = service.url.path + ":" + service.url.method;
+                    logicPageResourceDtoList[key] = resources;
+                    _c.label = 3;
+                case 3:
+                    _i++;
+                    return [3 /*break*/, 1];
+                case 4:
+                    closeCache();
+                    // console.timeEnd('xxx');
+                    return [2 /*return*/, logicPageResourceDtoList];
+            }
+        });
+    });
+}
+exports.genPermissionData = genPermissionData;

package/src/generator/genBundleFiles.ts

@@ -82,7 +82,7 @@ export function genBundleFiles(app: App, frontend: Frontend,
         let routePath = viewName;
         if (isRootView) {
             rootViewData.push({ name: viewName, title: view.title || viewName, isIndex: view.isIndex });
-            routePath = `/${viewName}`;
+            routePath = `${frontend.basePath}/${viewName}`;
             if (!isViewAuth) {
                 if (viewName === 'notFound') {
                     defaultRoute = routePath;
@@ -133,11 +133,17 @@ export function genBundleFiles(app: App, frontend: Frontend,
         routes.push(route);
         if (view.isIndex) {
             routes.push({
-                path: '/',
-                redirect: `'/${view.name}'`,
+                path: frontend.basePath ? frontend.basePath : '/',
+                redirect: `'${frontend.basePath}/${view.name}'`,
             });
         }
     });
+    if (frontend.basePath) {
+        routes.push({
+            path: '/',
+            redirect: `'${frontend.basePath}'`,
+        });
+    }
     const authResourcePathMap: any = {};
     // 默认跳转子页面开启权限的情况，需要把父页面也都加入权限校验列表
     if (Array.isArray(authResourceViews)) {
@@ -150,6 +156,9 @@ export function genBundleFiles(app: App, frontend: Frontend,
                     if (parentViewNode.concept === 'View') {
                         authResourcePathMap[parentViewNode.path] = true;
                     } else { // viewNode是根页面
+                        if (frontend.basePath) {
+                            authResourcePathMap[frontend.basePath] = true;
+                        }
                         authResourcePathMap['/'] = true;
                     }
                     viewNode = parentViewNode;
@@ -214,6 +223,7 @@ export function genBundleFiles(app: App, frontend: Frontend,
             documentTitle: frontend.documentTitle,
             rootViewData,
             basePath: frontend.basePath,
+            frontendName: frontend.name,
         },
         dnsAddr: app.dnsAddr,
         devDnsAddr: config.devDnsAddr,
@@ -357,7 +367,7 @@ export function genBundleFiles(app: App, frontend: Frontend,
         bundleMinPath = `${baseUrl}${frontend.basePath}/bundle.${genHash(content)}.min.js`;
     }
     const bundleSourceMapPath = `${bundlePath}.map`;
-    const otherJsList = config.miniEnable ? ['//res.wx.qq.com/open/js/jweixin-1.3.2.js'] : [];
+    const otherJsList = (frontend as any)?.appletsConfig?.enable ? ['//res.wx.qq.com/open/js/jweixin-1.3.2.js'] : [];
     const assetsContent = `(function() {
     LazyLoad.js(${JSON5.stringify(assetsInfo.basic.js.concat(assetsInfo.custom.js, otherJsList).concat([bundleMinPath]))});
     LazyLoad.css(${JSON5.stringify(assetsInfo.basic.css.concat(assetsInfo.custom.css))});
@@ -377,9 +387,18 @@ export function genBundleFiles(app: App, frontend: Frontend,
             sourceMap: {
                 url: bundleSourceMapPath,
             },
+            compress: {
+                // @ts-ignore
+                awaits: false,
+            },
         });
     } else {
-        minifyObj = UglifyJS.minify(content);
+        minifyObj = UglifyJS.minify(content, {
+            compress: {
+                // @ts-ignore
+                awaits: false,
+            },
+        });
     }
     const outputs = [
         {

package/src/generator/genReleaseBody.ts

@@ -1,11 +1,11 @@
-import { App, Assignment, BatchAssignment, CallFunction, CallInterface, CallLogic, ForEachStatement, IfStatement, Logic, LogicItem, Match, MatchCase, Role, SwitchCase, SwitchStatement, View, ViewElement, WhileStatement, Frontend } from '../concepts';
+import { App, Assignment, BatchAssignment, CallFunction, CallInterface, CallLogic, ForEachStatement, IfStatement, Logic, LogicItem, Match, MatchCase, MemberExpression, Role, SwitchCase, SwitchStatement, View, ViewElement, WhileStatement, StringInterpolation, Frontend, ExternalDestination, NewComposite, SelectMembers, NewList } from '../concepts';
 import { genFrontendBundleFiles } from './genBundleFiles';
-import { genPermissionData } from './permission';
+import { genPermissionData, genLogicAuthFlag } from './permission';
+import * as utils from '../utils';
 
 export async function genReleaseBody(app: App, {
     env,
     replicas,
-    generateMini,
     realRelease,
     appInfo,
     staticUrl,
@@ -13,7 +13,6 @@ export async function genReleaseBody(app: App, {
 }: {
     env: string,
     replicas: number,
-    generateMini: boolean,
     realRelease: boolean,
     appInfo: {
         tenant: string,
@@ -34,11 +33,7 @@ export async function genReleaseBody(app: App, {
     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;
+        logicPageResourceDtoList = await genPermissionData(app);
     }
 
     const releaseFrontends = app.frontends.map((frontend) => ({
@@ -46,21 +41,26 @@ export async function genReleaseBody(app: App, {
         type: frontend.type,
         path: frontend.path,
         selected: frontends.includes(frontend),
+        title: frontend.title,
     }));
 
     const body = {
         ...authReport, // 如果发布需要上报权限，导出源码不需要
         logicPageResourceDtoList,
+        logicAuthFlag: genLogicAuthFlag(app),
         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 }>,
     };
+
+    if (logicPageResourceDtoList)
+        Object.assign(body, { logicPageResourceDtoList });
+
     let NaslAnnotatedJSON;
     try {
         NaslAnnotatedJSON = await (app as any).naslServer.getNaslAnnotatedJSON(app, true);
@@ -69,22 +69,29 @@ export async function genReleaseBody(app: App, {
         throw new Error('代码标注失败');
     }
 
-    let files = genFrontendBundleFiles(app, frontends, Object.assign({}, appInfo, {
-        env,
-        appid: app.id,
-        devDnsAddr: (app as any).devDnsAddr,
-        miniEnable: (app as any).miniEnable,
-    }) as any);
-    if (files && files.length === 0) {
-        throw new Error('前端代码生成失败');
-    }
+    // 可能所有的前端都不选
+    let files = [];
+    if (frontends && frontends.length) {
+        files = genFrontendBundleFiles(app, frontends, Object.assign({}, appInfo, {
+            env,
+            appid: app.id,
+            devDnsAddr: (app as any).devDnsAddr,
+            miniEnable: (app as any).miniEnable,
+        }) as any);
+        if (files && files.length === 0) {
+            throw new Error('前端代码生成失败');
+        }
 
-    if (staticUrl)
-        files = replaceAssetUrl(files, appInfo.USER_STATIC_URL, staticUrl);
+        if (staticUrl)
+            files = replaceAssetUrl(files, appInfo.USER_STATIC_URL, staticUrl);
+    }
 
     // 如果是发布，就排除views，导出源码就不排除
-    if (realRelease)
-        delete NaslAnnotatedJSON.views;
+    if (realRelease) {
+        NaslAnnotatedJSON.frontends.forEach((frontend: Frontend) => {
+            delete frontend.views;
+        });
+    }
     const jsonString = JSON.stringify(NaslAnnotatedJSON);
 
     // 打印传给服务端的nasl,为了服务端排查问题方便
@@ -156,7 +163,7 @@ function getAuthReport(app: App, frontends: Array<Frontend>) {
  * 上报白名单
  */
 function getAuthApiPathList(app: App, frontends: Array<Frontend>) {
-    const thisDiffLogicList: Array<{logicName:string, frontendName: string}> = [];
+    const thisDiffLogicList: Array<{ logicName: string, frontendName: string }> = [];
 
     /* 转换Path */
     function getPathMethods(logicNameSpace: string) {
@@ -275,6 +282,16 @@ function getAuthApiPathList(app: App, frontends: Array<Frontend>) {
             logicItems = state.arguments?.map((item) => item.expression);
         } else if (state instanceof CallInterface) {
             logicItems = state.arguments?.map((item) => item.expression);
+        } else if (state instanceof MemberExpression) {
+            logicItems = [state.object, state.property];
+        } else if (state instanceof StringInterpolation) {
+            logicItems = [...state.expressions];
+        } else if (state instanceof ExternalDestination) {
+            logicItems = [state.anchor, state.link];
+        } else if (state instanceof NewComposite) {
+            logicItems = [...(state.rights || []).map((item) => item.expression)];
+        } else if (state instanceof NewList) {
+            logicItems = [...state.items];
         }
 
         return logicItems.filter((item) => !!item);
@@ -290,7 +307,7 @@ function getAuthApiPathList(app: App, frontends: Array<Frontend>) {
         }
     }
 
-    const importList: Array<string> = [];
+    const importList: Array<{ path: string, frontendName: string }> = [];
     const itemloop = (state: LogicItem, view: View | ViewElement, frontend: Frontend) => {
         const logicItems = getStatement(state, frontend);
         if (logicItems.length) {
@@ -315,15 +332,42 @@ function getAuthApiPathList(app: App, frontends: Array<Frontend>) {
                     }
                 });
             }
+            const bindExpressions = [];
+            const bindAttrs = (view as ViewElement).bindAttrs || [];
+            const bindDirectives = (view as ViewElement).bindDirectives || [];
+            const bindStyles = (view as ViewElement).bindStyles || [];
+            bindExpressions.push(...bindAttrs, ...bindDirectives, ...bindStyles);
+            if (Array.isArray(bindExpressions) && bindExpressions.length) {
+                bindExpressions.forEach((bindExpression) => utils.traverse((current) => {
+                    if (current.node instanceof CallLogic) {
+                        getLogic((current.node as CallLogic).calleewholeKey, frontend);
+                    }
+                }, { node: bindExpression }, {
+                    mode: 'anyObject',
+                    excludedKeySet: new Set([
+                        // 排除playground里的表达式
+                        'playground',
+                        'parentNode',
+                        'sourceMap',
+                        'storageJSON',
+                        'tsErrorDetail',
+                        'NaslAnnotatedJSON',
+                        'calledFrom',
+                        '_events',
+                        '_collectingList',
+                        '_historyList',
+                    ]),
+                }));
+            }
         }
         if (view.concept === 'ViewElement' && (view.tag === 'u-uploader' || view.tag === 'van-uploader')) {
             const attr = view?.bindAttrs.find((item) => item.name === 'url');
             if (attr?.value.endsWith('/import') && !view.parentAuth) {
-                importList.push(attr?.value);
+                importList.push({ path: attr?.value, frontendName: frontend.name });
             }
         }
     };
-    const loopViews = (view: View, isChild: boolean, frontend:Frontend) => {
+    const loopViews = (view: View, isChild: boolean, frontend: Frontend) => {
         // 有权限的页面下的逻辑都不需要上报白名单
         if (!view.auth) {
             if (view.logics) {
@@ -357,16 +401,18 @@ function getAuthApiPathList(app: App, frontends: Array<Frontend>) {
         }
     };
     frontends.forEach((frontend) => {
-        frontend.views.forEach((view) => loopViews(view, true, frontend));
+        frontend.views.forEach((view) => loopViews(view, false, frontend));
     });
 
     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'))),
+            if (path)
+                return `${path}:${diffLogic.frontendName}`;
+            return '';
+        }).filter((path) => !!path),
+        ...Array.from(new Set(importList.map((item) => `${item.path}:POST:${item.frontendName}`))),
     ].filter((item) => !!item);
     return authApiList;
 }