@lcap/nasl 3.6.3-alpha.3 → 3.6.3-alpha.4

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@lcap/nasl",
   "description": "NetEase Application Specific Language",
-  "version": "3.6.3-alpha.3",
+  "version": "3.6.3-alpha.4",
   "author": "Forrest <rainforest92@126.com>",
   "scripts": {
     "clear": "rimraf ./out",

package/sandbox-natural/stdlib/nasl.core.ts

@@ -15,10 +15,7 @@ class DateTime {
 type List<T> = Array<T>;
 
 interface Entity<T> {
-  /**
-   * 只能获取一条
-   */
-  get(id: Integer): T;
+  get(id: Integer): T; // 只能获取一条 Entity 数据，返回一个 Entity 对象
   create(entity: T): T;
   update(entity: T): T;
   delete(id: Integer): void;

package/src/generator/genBundleFiles.ts

@@ -625,8 +625,8 @@ export function genBundleFiles(app: App, frontend: Frontend, config: Config) {
          `;
     content += str;
   }
-  const getBundleFileName =()=>{
-    if (config.isPreviewFe && config.previewVersion){
+  const getBundleFileName = ()=> {
+    if (config.isPreviewFe && config.previewVersion) {
       return `mockBundle-${config.previewVersion}`
     }
     return 'bundle'

package/src/generator/permission.ts

@@ -278,7 +278,7 @@ function checkUploadAuth(uploaders: Map<string, ViewElement[]>) {
   uploaders.forEach((value, key) => {
     const authValue: ResourceNode[] = [];
     value.map((node) => {
-      if (node instanceof ViewElement) {
+      if (node instanceof ViewElement && node.view) {
         const path = node.auth ? node.authPath : `${node.view.path}`;
         const type = node.auth ? 'component' : 'page';
         authValue.push({ path, type });
@@ -297,6 +297,8 @@ function checkPageAndUploadAuth(uploaders: Map<string, ViewElement[]>, key: stri
       if (!(node.getAncestor('View') as View).auth && node instanceof ViewElement && !node.auth) {
         return true;
       }
+    } else if (node.getAncestor('BusinessComponent')) {
+      return true;
     }
   });
   return flag;

package/src/generator/release-body/body.ts

@@ -50,8 +50,7 @@ async function getFrontendBundleFiles(app: App, opt: InternalReleaseData) {
     await opt.logPublishFunc?.('代码', '生成页面代码：开始');
     files = await genFrontendBundleFiles(app, opt.frontends, {
       ...opt.appInfo,
-      env: opt.env,
-      debug: opt.debug,
+      ...opt,
       appid: app.id,
       devDnsAddr: (app as any).devDnsAddr,
       miniEnable: (app as any).miniEnable,

package/src/generator/release-body/data.ts

@@ -35,7 +35,7 @@ export async function getReleaseData(app: App, data: ReleaseData, naslServer: Na
     isExport: data.config.mode === ReleaseMode.ExportCode,
     isPreviewFe: data.config.mode === ReleaseMode.ExportTemplate,
     ignoreFiles: data.config.ignoreFiles ?? false,
-    previewVersion: data.config.releaseVersion,
+    previewVersion: data.config.previewVersion ?? '',
     appSpecification: data.appSpecification,
     frontends: releaseFrontends,
     validations: {},
@@ -56,7 +56,7 @@ export async function getReleaseData(app: App, data: ReleaseData, naslServer: Na
 
   // 服务端验证规则
   if (app.preferenceMap.onDemandInterfaceGeneration !== 'false') {
-    result.validations = await getValidationRules(http, version, releaseFrontends);
+    result.validations = await getValidationRules(http, version, app.frontendTypes);
 
     if (typeof result.validations === 'string') {
       throw new Error(result.validations);

package/src/generator/release-body/types.ts

@@ -27,8 +27,8 @@ export interface ReleaseConfig {
   mode: ReleaseMode;
   /** 忽略前端文件 */
   ignoreFiles?: boolean;
-  /** 发布版本 */
-  releaseVersion?: string;
+  /** 预览版本 */
+  previewVersion?: string;
   /** 调试模式 */
   debug?: boolean;
   /**

package/src/generator/release-body/utils.ts

@@ -202,9 +202,9 @@ export async function getVersionDetail(axios: AxiosInstance, app: any) {
   };
 }
 
-export async function getValidationRules(axios: AxiosInstance, ideVersion: string, frontends: Frontend[]) {
+export async function getValidationRules(axios: AxiosInstance, ideVersion: string, frontends: FrontendType[]) {
   const formData = new FormData();
-  formData.append('file', new Blob([JSON.stringify(frontends.map((view: any) => view.toJSON()))], { type: 'application/json' }));
+  formData.append('file', new Blob([JSON.stringify(frontends.map((view) => view.toJSON()))], { type: 'application/json' }));
   const validations = await axios<HttpData>({
     method: 'post',
     url: `/api/v1/ide/nasl/frontend/call-logic/validations/batch`,

package/src/natural/genNaturalTS.ts

@@ -432,7 +432,7 @@ export function genNaturalTSContext(app: App, currentNode?: BaseNode, focusedNod
   code += '\n### [6]服务端逻辑\n';
   code += getLogics(app, currentNode, moduleIndexList).code;
 
-  code += '\n### [7]可调用的开放接口列表\n';
+  code += '\n### [7]可调用的接口列表\n';
   code += getModuleInterfaces(app, state, moduleIndexList).code;
 
   if (app?.connections?.length > 0 && logicType === 'global_logic') {

package/src/natural/prompt/analyzeClaims.ts

@@ -3,9 +3,12 @@ export const analyzeClaims = (params: any) => {
   const claims = `
   - Knowledge 是你的知识库，你可以参考，但是你最终制定的计划中禁止包含方法或者函数名
   - 如果用户没有特别指明是打印(日志/输出结果)，"输出结果"一律按照"返回输出结果"处理
+  - 涉及到查询、获取数据时，先查找当前上下文[6/7/8/9]中是否有相关的方法，如果没有，再考虑实体的方法
+    - 实体的 get 方法一次只能获取一条数据，返回一个对象，无法返回列表。
   - 如果用户的需求涉及定时或延时等操作，请提示用户：当前暂不支持定时或延时操作，请调整后重新输入。
   - 如果用户的需求需要调用某个方法并且当前上下文中不存在时，请提示用户：当前应用中暂无该方法，请先导入相关依赖库或连接器模块
     - 例如：加解密依赖库中的方法
+  - 如果用户的需求需要调用接口并且当前上下文中不存在此接口时，不需要再跟用户对话，直接返回 needImportInterface: true; executable: true; 以及 plan
 `;
   // global_logic、view_logic、event_logic、business_Logic
   const claimsMap = {
@@ -19,6 +22,7 @@ export const analyzeClaims = (params: any) => {
 - 分析用户的需求，当需要从实体中获取或者查询数据时
     - 优先使用 SQL 的查询和数据操纵能力: 例如 JOIN、SUM、GROUP_BY 等能力
     - 使用 SQL 语句同时实现查询和计算
+- 如果用户的需求需要调用接口并且当前上下文中不存在此接口时，不需要再跟用户对话，直接返回 needImportInterface: true; executable: true; 以及 plan
 `
   } as any;
   return claimsMap?.[logicType] || claims;

package/src/natural/prompt/analyzeTasks.ts

@@ -1,15 +1,16 @@
 export const analyzeTasks = () => {
   return `
--   plan:
-  -   尽可能的帮助用户将需求梳理成可执行的计划，计划包含多个任务，每个任务下可能包含多个子任务(会缩进 4 个空格)
-  -   制定的计划最终将会作为调用代码补全接口的输入, 所以你需要考虑计划内容是否完整与充分, 如果不充分，你可以继续询问用户
--   text: 如果你认为需求不够明确时，可以继续询问用户需求的细节，不可为空
--   executable
-  -   类型为 boolean, 如果你认为需求比较明确并且 plan 可执行, 返回 true, 否则返回 false
--   moduleIndexList
-  -   类型为 Array, 你需要根据用户的执行计划，从 Context Definition 中整理出执行需要用到的模块，返回对应的模块索引
-  -   用于下一步的具体实施，需要尽可能详细、精准的返回和执行计划相关的模块索引。例如："moduleIndexList": ['1','6-3','8-1-1-0']。
--   needImportInterface
-  -   类型为 boolean, 如果你认为当前上下文无法满足需求，需要另外引入开放接口, 返回 true, 否则返回 false
+- plan:
+  - 尽可能的帮助用户将需求梳理成可执行的计划，计划包含多个任务，每个任务下可能包含多个子任务(会缩进 4 个空格)
+  - 制定的计划最终将会作为调用代码补全接口的输入, 所以你需要考虑计划内容是否完整与充分, 如果不充分，你可以继续询问用户
+- text: 如果你认为需求不够明确时，可以继续询问用户需求的细节，不可为空
+- executable
+  - 类型为 boolean, 如果你认为需求比较明确并且 plan 可执行, 返回 true, 否则返回 false
+- moduleIndexList
+  - 类型为 Array, 你需要根据用户的执行计划，从 Context Definition 中整理出执行需要用到的模块或者方法，返回对应的索引
+  - 用于下一步的具体实施，需要尽可能详细、精准的返回和执行计划相关的模块或方法索引。例如："moduleIndexList": ['1','6-3','8-1-1-0']。
+- needImportInterface
+  - 类型为 boolean, 如果你认为当前上下文无法满足需求，需要另外引入接口, 返回 true, 否则返回 false
+  - 如果用户的需求需要调用接口并且当前上下文中不存在此接口时，不需要再跟用户对话，直接返回 needImportInterface: true; executable: true; 以及 plan
 `;
 };

package/src/natural/prompt/executeClaims.ts

@@ -24,8 +24,11 @@ export const executeClaims = (params: any) => {
     -   禁止使用 for/forEach 语句，如果需要循环或者遍历，你**必须**使用 ForEach 方法
     -   禁止频繁操作实体
     -   只获取单条数据时使用 namespace.Entity.get()
+        -   namespace.Entity.get 是一个整体，禁止将 namespace 赋值给变量
     -   字符串或者变量之间的拼接或者 concat 请使用字符串插值(模板字符串)语法
-    -   需要使用 nasl.ui 中类的方法时，请使用 $refs 的前缀，例如 $refs.tableView1.reload()，禁止使用 new 创建实例
+    -   需要使用 nasl.ui 中类的方法时，请使用 $refs 的前缀，例如 $refs.tableView1.reload()
+      -   禁止将 $ref 实例赋值给变量
+      -   禁止使用 new 创建实例
     -   直接输出代码结果，其他描述请以注释的形式出现
 -   返回值
     -   如果用户没有特别指明是打印(日志/输出结果)，"输出结果"一律按照"返回输出结果"处理
@@ -58,6 +61,7 @@ export const executeClaims = (params: any) => {
     -   分析用户的需求，优先使用数据库的查询和数据操纵能力，例如 JOIN、SUM、GROUP_BY 等能力，使用 SQL 语句同时实现查询和计算
     -   如果要查询，则使用 nasl.oql.query，同时分析整个需求，尽量用一句 SQL 实现
         -   只查询单条数据时使用 namespace.Entity.get()，其它查询都使用 nasl.oql.query
+            -   namespace.Entity.get 是一个整体，禁止将 namespace 赋值给变量
         -   禁止对 nasl.oql.query 的结果进行连续调用
     -   字符串或者变量之间的拼接或者 concat 请使用字符串插值(模板字符串)语法
     -   直接输出代码结果，其他描述请以注释的形式出现

package/src/natural/transformTSCode.ts

@@ -342,7 +342,7 @@ export function transformTSCode(tsCode: string, contextLogicName: string, type?:
         return new naslTypes.CallLogic({
           calleeNamespace: `elements.${(callee[1] as babelTypes.Identifier).name}.logics`,
           calleeName: (callee[2] as babelTypes.Identifier).name,
-          arguments: node.arguments.map((arg) => new naslTypes.Argument({
+          arguments: node?.arguments?.map((arg) => new naslTypes.Argument({
             expression: transformLogicNode(arg),
           })) as naslTypes.Argument[],
         });
@@ -352,7 +352,7 @@ export function transformTSCode(tsCode: string, contextLogicName: string, type?:
         return new naslTypes.CallLogic({
           calleeNamespace: `app.dataSources.defaultDS.entities.${entityName}.logics`,
           calleeName: (callee[1] as babelTypes.Identifier).name,
-          arguments: node.arguments.map((arg) => new naslTypes.Argument({
+          arguments: node?.arguments?.map((arg) => new naslTypes.Argument({
             expression: transformLogicNode(arg),
           })) as naslTypes.Argument[],
         });
@@ -375,7 +375,7 @@ export function transformTSCode(tsCode: string, contextLogicName: string, type?:
             calleeNamespace: 'nasl.util',
             calleeName: 'consoleLog',
             shortcut: true,
-            arguments: node.arguments.map((arg) => new naslTypes.Argument({
+            arguments: node?.arguments?.map((arg) => new naslTypes.Argument({
               expression: transformLogicNode(arg),
             })) as naslTypes.Argument[],
           });
@@ -384,7 +384,7 @@ export function transformTSCode(tsCode: string, contextLogicName: string, type?:
           calleeNamespace: 'nasl.logging',
           calleeName: 'INFO',
           shortcut: true,
-          arguments: node.arguments.map((arg) => new naslTypes.Argument({
+          arguments: node?.arguments?.map((arg) => new naslTypes.Argument({
             expression: transformLogicNode(arg),
           })) as naslTypes.Argument[],
         });
@@ -395,7 +395,7 @@ export function transformTSCode(tsCode: string, contextLogicName: string, type?:
           calleeNamespace: 'nasl.util',
           calleeName: curCalleeName,
           shortcut: true,
-          arguments: node.arguments.map((arg) => new naslTypes.Argument({
+          arguments: node?.arguments?.map((arg) => new naslTypes.Argument({
             expression: transformLogicNode(arg),
           })) as naslTypes.Argument[],
           typeArguments: node?.typeParameters?.params.map((curType: any) => transformTypeAnnotation({ ...curType })),
@@ -454,7 +454,7 @@ export function transformTSCode(tsCode: string, contextLogicName: string, type?:
            * @param node
            * @returns
            */
-          arguments: node.arguments.map((arg) => new naslTypes.Argument({
+          arguments: node?.arguments?.map((arg) => new naslTypes.Argument({
             expression: transformLogicNode(arg),
           })) as naslTypes.Argument[],
         });
@@ -465,7 +465,7 @@ export function transformTSCode(tsCode: string, contextLogicName: string, type?:
           calleeName: 'ListTransform',
           arguments: [new naslTypes.Argument({
             expression: transformLogicNode((node.callee as babelTypes.MemberExpression).object),
-          }), ...node.arguments.map((arg: any) => new naslTypes.Argument({
+          }), ...node?.arguments?.map((arg: any) => new naslTypes.Argument({
             expression: transformLogicNode(arg),
           }))],
         });
@@ -517,7 +517,7 @@ export function transformTSCode(tsCode: string, contextLogicName: string, type?:
           calleeNamespace: 'nasl.ui',
           calleeName: 'showMessage',
           shortcut: true,
-          arguments: node.arguments.map((arg) => new naslTypes.Argument({
+          arguments: node?.arguments?.map((arg) => new naslTypes.Argument({
             expression: transformLogicNode(arg),
           })) as naslTypes.Argument[],
         });
@@ -528,7 +528,7 @@ export function transformTSCode(tsCode: string, contextLogicName: string, type?:
           return new naslTypes.CallLogic({
             calleeNamespace: `${calleeNamespace}.${entityName}.logics`,
             calleeName: (node?.callee as any)?.property?.name,
-            arguments: node.arguments.map((arg) => new naslTypes.Argument({
+            arguments: node?.arguments?.map((arg) => new naslTypes.Argument({
               expression: transformLogicNode(arg),
             })) as naslTypes.Argument[],
           });
@@ -537,7 +537,7 @@ export function transformTSCode(tsCode: string, contextLogicName: string, type?:
         return new naslTypes.CallLogic({
           calleeNamespace: generate((node.callee as any).object).code,
           calleeName: (callee[callee.length - 1] as babelTypes.Identifier).name,
-          arguments: node.arguments.map((arg) => new naslTypes.Argument({
+          arguments: node?.arguments?.map((arg) => new naslTypes.Argument({
             expression: transformLogicNode(arg),
           })) as naslTypes.Argument[],
         });
@@ -546,7 +546,7 @@ export function transformTSCode(tsCode: string, contextLogicName: string, type?:
           return new naslTypes.CallLogic({
             calleeNamespace: '',
             calleeName: calleeName.slice('viewLogic_'.length),
-            arguments: node.arguments.map((arg) => new naslTypes.Argument({
+            arguments: node?.arguments?.map((arg) => new naslTypes.Argument({
               expression: transformLogicNode(arg),
             })) as naslTypes.Argument[],
           });
@@ -554,7 +554,7 @@ export function transformTSCode(tsCode: string, contextLogicName: string, type?:
         return new naslTypes.CallLogic({
           calleeNamespace: `app.logics`,
           calleeName,
-          arguments: node.arguments.map((arg) => new naslTypes.Argument({
+          arguments: node?.arguments?.map((arg) => new naslTypes.Argument({
             expression: transformLogicNode(arg),
           })) as naslTypes.Argument[],
         });
@@ -562,7 +562,7 @@ export function transformTSCode(tsCode: string, contextLogicName: string, type?:
         return new naslTypes.CallInterface({
           calleeNamespace: generate((node.callee as any).object).code,
           calleeName: (callee[callee.length - 1] as babelTypes.Identifier).name,
-          arguments: node.arguments.map((arg: any) => arg?.properties.map((item: any) => new naslTypes.Argument({
+          arguments: node?.arguments?.map((arg: any) => arg?.properties.map((item: any) => new naslTypes.Argument({
             keyword: item?.key?.name,
             expression: transformLogicNode(item?.value),
           }))).flat() as naslTypes.Argument[],
@@ -583,7 +583,7 @@ export function transformTSCode(tsCode: string, contextLogicName: string, type?:
           calleeNamespace: generate((node?.callee as any)?.object)?.code,
           calleeName: (callee?.[callee?.length - 1] as babelTypes.Identifier)?.name,
           handleError: true,
-          arguments: node.arguments.map((arg) => new naslTypes.Argument({
+          arguments: node?.arguments?.map((arg) => new naslTypes.Argument({
             expression: transformLogicNode(arg),
           })) as naslTypes.Argument[],
         });

package/src/server/naslServer.ts

@@ -3022,9 +3022,9 @@ class NaslServer {
               const groupByLength = callQueryComponent.groupBy.filter(
                 (item) => (item.groupElement as QueryFieldExpression)?.propertyName && (item.groupElement as QueryFieldExpression).asName
               ).length;
-              if (!groupByLength && !aggregateLength && callQueryComponentTypeAnnotation.typeKind === 'anonymousStructure') {
+              if (!groupByLength && !aggregateLength && callQueryComponentTypeAnnotation.typeKind === 'generic') {
                 // 拿到 List 的泛型（匿名数据结构）的所有属性
-                const {properties} = callQueryComponentTypeAnnotation.properties[0].typeAnnotation.typeArguments[0];
+                const {properties} = callQueryComponentTypeAnnotation.typeArguments[0];
                 const targetProperty = properties.find((p) => p.name === utils.firstLowerCase(node.name));
                 if (!targetProperty) {
                   continue;
@@ -3450,6 +3450,32 @@ class NaslServer {
               const newTextValue = node.parentNode.name === 'defaultDS' ? `/api/${newName}/import` : `/api/${node.parentNode.name}/${newName}/import`;
               minRange.setTypeMethods = 'setUrlValue';
               minRange.newValue = newTextValue;
+            } else if (minRange.node instanceof BindAttribute && (minRange.node.name === 'valueField')) {
+              // eslint-disable-next-line no-confusing-arrow
+              minRange.newValue = (minRange.node.value || '').split('.').map((v, i) => i ? v : newValue.charAt(0).toLowerCase() + newValue.slice(1)).join('.')
+              minRange.setTypeMethods = 'setValue';
+            } else if (minRange.node instanceof BindAttribute && (minRange.node.name === 'sorting') && minRange.node.value) {
+              // 现在 sorting 是不把 field 翻译出具体实体类型的，在文件系统中没有引用关系，无法处理他的改名
+              try {
+                // "{ field: undefined, order: 'desc' }" 格式解析成 Object
+                const sortingObj = JSON.parse(
+                  minRange.node.value
+                    .replace(/([{,])\s*([A-Za-z0-9_]+)\s*:/g, '$1"$2":')
+                    .replace(/undefined/g, 'null')
+                    .replace(/'/g, '"')
+                )
+                if (sortingObj.field) {
+                  const handleValue = (value: any) => {
+                    return value ? `'${value}'` : undefined
+                  }
+                  // eslint-disable-next-line no-confusing-arrow
+                  const newField = sortingObj.field.split('.').map((v: string, i: number) => i ? v: newValue.charAt(0).toLowerCase() + newValue.slice(1)).join('.')
+                  minRange.newValue = `{ field: ${handleValue(newField)}, order: ${handleValue(sortingObj.order)} }`
+                  minRange.setTypeMethods = 'setValue';
+                }
+              } catch (error) {
+                console.error(error)
+              }
             } else if (minRange.node instanceof Identifier) {
               minRange.newValue = utils.firstLowerCase(newValue);
             }
@@ -4042,7 +4068,7 @@ class NaslServer {
 
       if (['BindAttribute', 'BindDirective', 'BindStyle'].includes(node.concept)) {
         range.line = lsp2tspNumber(currentSource.end.line);
-        range.offset = 0;
+        range.offset = 1;
       }
 
       return this._getFieldKeySelectCompletion({