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

package/src/templator/genQueryComponent.ts

@@ -1,324 +1,374 @@
 import * as utils from '../utils';
-import { App, Module, Namespace, Entity, Structure, QueryJoinExpression, QueryAggregateExpression, QueryFieldExpression, CallQueryComponent, StructureProperty, DataSource, TypeAnnotation } from '../concepts';
-import { NameGroup, NaslCoreTypeAnnotation, NaslCollectionTypeAnnotation, NaslTypeAnnotation, NaslQueryExpression, NaslLogicItem, NaslNode } from './utils';
+import {
+  App,
+  Module,
+  Namespace,
+  Entity,
+  Structure,
+  QueryJoinExpression,
+  QueryAggregateExpression,
+  QueryFieldExpression,
+  CallQueryComponent,
+  StructureProperty,
+  DataSource,
+  TypeAnnotation,
+} from '../concepts';
+import {
+  NameGroup,
+  NaslCoreTypeAnnotation,
+  NaslCollectionTypeAnnotation,
+  NaslTypeAnnotation,
+  NaslQueryExpression,
+  NaslLogicItem,
+  NaslNode,
+} from './utils';
 
 export function genQueryStructure(allEntities: Array<Entity>, nameGroup: NameGroup) {
-    allEntities = Array.from(new Set(allEntities));
-    return NaslNode.Structure({
-        name: nameGroup.structure,
-        origin: 'CallQueryComponent',
-        properties: allEntities.map((entity) =>
-            NaslNode.StructureProperty({
-                name: utils.firstLowerCase(entity.name),
-                typeAnnotation: NaslTypeAnnotation.Reference({
-                    typeNamespace: entity.getNamespace(),
-                    typeName: entity.name,
-                }),
-            })),
-    });
+  allEntities = Array.from(new Set(allEntities));
+  return NaslNode.Structure({
+    name: nameGroup.structure,
+    origin: 'CallQueryComponent',
+    properties: allEntities.map((entity) =>
+      NaslNode.StructureProperty({
+        name: utils.firstLowerCase(entity.name),
+        typeAnnotation: NaslTypeAnnotation.Reference({
+          typeNamespace: entity.getNamespace(),
+          typeName: entity.name,
+        }),
+      })
+    ),
+  });
 }
 
 function genWhereExpression(entity: Entity) {
-    const properties = entity.properties.filter((property) => property?.display.inFilter);
-    const expressions = properties.map((property) => {
-        const res = NaslLogicItem.BinaryExpression({
-            left: NaslQueryExpression.QueryFieldExpression({
-                label: '查询组件实体属性',
-                isDotStar: false,
-                entityAsName: entity.name,
-                propertyName: property.name,
-            }),
-            right: NaslLogicItem.MemberExpression({
-                object: NaslLogicItem.Identifier({
-                    name: 'filter',
-                }),
-                property: NaslLogicItem.Identifier({
-                    name: property.name,
-                }),
-            }),
-            operator: '==',
-        });
-        if (!property.relationEntity && ['String', 'Text'].includes(property.typeAnnotation.typeName)) {
-            Object.assign(res, {
-                operator: 'like',
-            });
-        }
-        return res;
+  const properties = entity.properties.filter((property) => property?.display.inFilter);
+  const expressions = properties.map((property) => {
+    const res = NaslLogicItem.BinaryExpression({
+      left: NaslQueryExpression.QueryFieldExpression({
+        label: '查询组件实体属性',
+        isDotStar: false,
+        entityAsName: entity.name,
+        propertyName: property.name,
+      }),
+      right: NaslLogicItem.MemberExpression({
+        object: NaslLogicItem.Identifier({
+          name: 'filter',
+        }),
+        property: NaslLogicItem.Identifier({
+          name: property.name,
+        }),
+      }),
+      operator: '==',
     });
+    if (!property.relationEntity && ['String', 'Text'].includes(property.typeAnnotation.typeName)) {
+      Object.assign(res, {
+        operator: 'like',
+      });
+    }
+    return res;
+  });
 
-    function transList2Tree(arr: Array<object>): object {
-        if (arr.length <= 1)
-            return arr[0];
+  function transList2Tree(arr: Array<object>): object {
+    if (arr.length <= 1) return arr[0];
 
-        const len = arr.length;
-        const mid = len >> 1;
-        const left = arr.slice(0, mid);
-        const right = arr.slice(mid);
-        return NaslLogicItem.BinaryExpression({
-            operator: '&&',
-            left: transList2Tree(left),
-            right: transList2Tree(right),
-        });
-    }
-    return transList2Tree(expressions);
+    const len = arr.length;
+    const mid = len >> 1;
+    const left = arr.slice(0, mid);
+    const right = arr.slice(mid);
+    return NaslLogicItem.BinaryExpression({
+      operator: '&&',
+      left: transList2Tree(left),
+      right: transList2Tree(right),
+    });
+  }
+  return transList2Tree(expressions);
 }
 
 export function genQueryAssignment(allEntities: Array<Entity>, nameGroup: NameGroup, supportFilter: boolean, supportSort: boolean) {
-    allEntities = Array.from(allEntities);
-    const entity = allEntities.shift();
-    const moduleNode = entity.app;
-    const moduleNamespace = moduleNode?.getNamespace();
+  allEntities = Array.from(allEntities);
+  const entity = allEntities.shift();
+  const moduleNode = entity.app;
+  const moduleNamespace = moduleNode?.getNamespace();
 
-    const from = NaslQueryExpression.QueryFromExpression({
-        entityNamespace: entity.getNamespace(),
-        entityName: entity.name,
-        joinParts: allEntities.map((relationEntity) => {
-            const onExpressions = entity.properties?.filter((property) => property.relationEntity === relationEntity.name).map((leftProperty) => NaslLogicItem.BinaryExpression({
-                operator: '==',
-                left: NaslQueryExpression.QueryFieldExpression({
-                    label: '查询组件实体属性',
-                    isDotStar: false,
-                    entityAsName: entity.name,
-                    propertyName: leftProperty.name,
-                }),
-                right: NaslQueryExpression.QueryFieldExpression({
-                    label: '查询组件实体属性',
-                    isDotStar: false,
-                    entityAsName: relationEntity.name,
-                    propertyName: leftProperty.relationProperty,
-                }),
-            }));
-            return NaslQueryExpression.QueryJoinExpression({
-                entityNamespace: relationEntity.getNamespace(),
-                entityName: relationEntity.name,
-                joinType: 'LEFT',
-                onExpressions,
-                joinParts: [],
-            });
-        }),
-    });
-    const selectElements: Array<QueryAggregateExpression | QueryFieldExpression> = [];
-    selectElements.push(QueryFieldExpression.from({
-        entityAsName: entity.name,
+  const from = NaslQueryExpression.QueryFromExpression({
+    entityNamespace: entity.getNamespace(),
+    entityName: entity.name,
+    joinParts: allEntities.map((relationEntity) => {
+      const onExpressions = entity.properties
+        ?.filter((property) => property.relationEntity === relationEntity.name)
+        .map((leftProperty) =>
+          NaslLogicItem.BinaryExpression({
+            operator: '==',
+            left: NaslQueryExpression.QueryFieldExpression({
+              label: '查询组件实体属性',
+              isDotStar: false,
+              entityAsName: entity.name,
+              propertyName: leftProperty.name,
+            }),
+            right: NaslQueryExpression.QueryFieldExpression({
+              label: '查询组件实体属性',
+              isDotStar: false,
+              entityAsName: relationEntity.name,
+              propertyName: leftProperty.relationProperty,
+            }),
+          })
+        );
+      return NaslQueryExpression.QueryJoinExpression({
+        entityNamespace: relationEntity.getNamespace(),
+        entityName: relationEntity.name,
+        joinType: 'LEFT',
+        onExpressions,
+        joinParts: [],
+      });
+    }),
+  });
+  const selectElements: Array<QueryAggregateExpression | QueryFieldExpression> = [];
+  selectElements.push(
+    QueryFieldExpression.from({
+      entityAsName: entity.name,
+      isDotStar: true,
+    })
+  );
+  from.joinParts.forEach((joinPart) => {
+    selectElements.push(
+      QueryFieldExpression.from({
+        entityAsName: joinPart.entityName,
         isDotStar: true,
-    }));
-    from.joinParts.forEach((joinPart) => {
-        selectElements.push(QueryFieldExpression.from({
-            entityAsName: joinPart.entityName,
-            isDotStar: true,
-        }));
-    });
-    const select = NaslQueryExpression.QuerySelectExpression({
-        label: '查询组件Select子句',
-        distinct: false,
-        star: true,
-        selectElements,
-    });
-    const where: any = supportFilter ? genWhereExpression(entity) : undefined;
-    const aStructureProperties = [NaslNode.StructureProperty({
-        name: utils.firstLowerCase(entity.name),
-        typeAnnotation: NaslTypeAnnotation.Reference({
-            typeNamespace: entity.getNamespace(),
-            typeName: entity.name,
-        }),
-    }), ...(allEntities.map((relationEntity) => (NaslNode.StructureProperty({
+      })
+    );
+  });
+  const select = NaslQueryExpression.QuerySelectExpression({
+    label: '查询组件Select子句',
+    distinct: false,
+    star: true,
+    selectElements,
+  });
+  const where: any = supportFilter ? genWhereExpression(entity) : undefined;
+  const aStructureProperties = [
+    NaslNode.StructureProperty({
+      name: utils.firstLowerCase(entity.name),
+      typeAnnotation: NaslTypeAnnotation.Reference({
+        typeNamespace: entity.getNamespace(),
+        typeName: entity.name,
+      }),
+    }),
+    ...allEntities.map((relationEntity) =>
+      NaslNode.StructureProperty({
         name: utils.firstLowerCase(relationEntity.name),
         typeAnnotation: NaslTypeAnnotation.Reference({
-            typeNamespace: relationEntity.getNamespace(),
-            typeName: relationEntity.name,
+          typeNamespace: relationEntity.getNamespace(),
+          typeName: relationEntity.name,
         }),
-    }))))];
-    return NaslLogicItem.Assignment({
-        left: NaslLogicItem.Identifier({
-            name: 'result',
-        }),
-        right: NaslQueryExpression.CallQueryComponent({
-            label: '数据查询',
-            // 2.11版本的数据查询，返回类型将自动推断
-            // 2.22版本的数据查询，实体支持列筛选，(select.selectElements 会初始化实体对应的 QueryFieldExpression 节点)
-            ideVersion: '2.22',
-            typeAnnotation: NaslTypeAnnotation.AnonymousStructure(aStructureProperties),
-            select,
-            from,
-            where,
-            groupBy: [],
-            having: null,
-            orderBy: supportSort ? [
-                NaslQueryExpression.QueryOrderByExpression({
-                    label: '查询组件OrderBy元素',
-                    order: NaslLogicItem.Identifier({
-                        name: 'order',
-                    }),
-                    orderElement: NaslLogicItem.Identifier({
-                        name: 'sort',
-                    }),
-                }),
-            ] : [],
-            logicName: nameGroup.logic,
-            structureName: nameGroup.structure,
-            limit: NaslQueryExpression.QueryLimitExpression({
-                label: '查询组件 Limit 子句',
-                pageElement: NaslLogicItem.Identifier({
-                    name: 'page',
-                }),
-                pageSizeElement: NaslLogicItem.Identifier({
-                    name: 'size',
-                }),
+      })
+    ),
+  ];
+  return NaslLogicItem.Assignment({
+    left: NaslLogicItem.Identifier({
+      name: 'result',
+    }),
+    right: NaslQueryExpression.CallQueryComponent({
+      label: '数据查询',
+      // 2.11版本的数据查询，返回类型将自动推断
+      // 2.22版本的数据查询，实体支持列筛选，(select.selectElements 会初始化实体对应的 QueryFieldExpression 节点)
+      ideVersion: '2.22',
+      typeAnnotation: NaslTypeAnnotation.AnonymousStructure(aStructureProperties),
+      select,
+      from,
+      where,
+      groupBy: [],
+      having: null,
+      orderBy: supportSort
+        ? [
+            NaslQueryExpression.QueryOrderByExpression({
+              label: '查询组件OrderBy元素',
+              order: NaslLogicItem.Identifier({
+                name: 'order',
+              }),
+              orderElement: NaslLogicItem.Identifier({
+                name: 'sort',
+              }),
             }),
+          ]
+        : [],
+      logicName: nameGroup.logic,
+      structureName: nameGroup.structure,
+      limit: NaslQueryExpression.QueryLimitExpression({
+        label: '查询组件 Limit 子句',
+        pageElement: NaslLogicItem.Identifier({
+          name: 'page',
         }),
-    });
+        pageSizeElement: NaslLogicItem.Identifier({
+          name: 'size',
+        }),
+      }),
+    }),
+  });
 }
 
 export function genQueryLogic(allEntities: Array<Entity>, nameGroup: NameGroup, supportFilter: boolean, supportSort: boolean, parentNode: any) {
-    const entity = allEntities?.[0];
-    const moduleNode = entity.app;
-    const moduleNamespace = moduleNode?.getNamespace();
+  const entity = allEntities?.[0];
+  const moduleNode = entity.app;
+  const moduleNamespace = moduleNode?.getNamespace();
 
-    const logic = NaslNode.Logic({
-        name: nameGroup.logic,
-        description: '',
-        params: [
-            NaslNode.Param({
-                name: 'page',
-                typeAnnotation: NaslCoreTypeAnnotation.Long,
-            }),
-            NaslNode.Param({
-                name: 'size',
-                typeAnnotation: NaslCoreTypeAnnotation.Long,
-            }),
-        ],
-        returns: [
-            NaslNode.Return({
-                name: 'result',
-                typeAnnotation: null,
-            }),
-        ],
-        variables: [] as Array<any>,
-        body: [NaslLogicItem.Start, genQueryAssignment(allEntities, nameGroup, supportFilter, supportSort), NaslLogicItem.End],
-        playground: [] as Array<any>,
-    });
-    if (supportSort) {
-        logic.params.push(NaslNode.Param({
-            name: 'sort',
-            typeAnnotation: NaslCoreTypeAnnotation.String,
-        }), NaslNode.Param({
-            name: 'order',
-            typeAnnotation: NaslCoreTypeAnnotation.String,
-        }));
-    }
+  const logic = NaslNode.Logic({
+    name: nameGroup.logic,
+    description: '',
+    params: [
+      NaslNode.Param({
+        name: 'page',
+        typeAnnotation: NaslCoreTypeAnnotation.Long,
+      }),
+      NaslNode.Param({
+        name: 'size',
+        typeAnnotation: NaslCoreTypeAnnotation.Long,
+      }),
+    ],
+    returns: [
+      NaslNode.Return({
+        name: 'result',
+        typeAnnotation: null,
+      }),
+    ],
+    variables: [] as Array<any>,
+    body: [NaslLogicItem.Start, genQueryAssignment(allEntities, nameGroup, supportFilter, supportSort), NaslLogicItem.End],
+    playground: [] as Array<any>,
+  });
+  if (supportSort) {
+    logic.params.push(
+      NaslNode.Param({
+        name: 'sort',
+        typeAnnotation: NaslCoreTypeAnnotation.String,
+      }),
+      NaslNode.Param({
+        name: 'order',
+        typeAnnotation: NaslCoreTypeAnnotation.String,
+      })
+    );
+  }
 
-    if (supportFilter && entity) {
-        logic.params.push(NaslNode.Param({
-            name: 'filter',
-            typeAnnotation: NaslTypeAnnotation.Reference({
-                typeNamespace: entity.getNamespace(),
-                typeName: entity.name,
-            }),
-        }) as any);
-    }
-    return logic;
+  if (supportFilter && entity) {
+    logic.params.push(
+      NaslNode.Param({
+        name: 'filter',
+        typeAnnotation: NaslTypeAnnotation.Reference({
+          typeNamespace: entity.getNamespace(),
+          typeName: entity.name,
+        }),
+      }) as any
+    );
+  }
+  return logic;
 }
 
 export async function joinEntity(callQueryComponent: CallQueryComponent, entity: Entity, recordStructure: Structure | TypeAnnotation) {
-    const dataSource = entity.parentNode as DataSource;
-    const from = callQueryComponent.from;
-    let joinInfo;
-    // 无法判断用户行为，优先加有关系的
-    const lastEntity = dataSource.findEntityByName(from.entityName);
-    // lastEntity 和 entity Join
-    // 判断要不要自动关联 onExpression
-    // 一般左联是自动有的了
-    const rightProperty = entity.properties.find((property) => property.relationEntity === lastEntity.name);
-    if (rightProperty) {
-        const leftProperty = lastEntity.properties.find((property) => property.name === rightProperty.relationProperty);
-        joinInfo = {
-            leftProperty,
-            rightProperty,
-        };
-    } else {
-        const leftProperty = lastEntity.properties.find((property) => property.relationEntity === entity.name);
-        if (leftProperty) {
-            const rightProperty = entity.properties.find((property) => property.name === leftProperty.relationProperty);
-            joinInfo = {
-                leftProperty,
-                rightProperty,
-            };
-        }
-    }
-    const queryJoinExpression = NaslQueryExpression.QueryJoinExpression({
-        joinType: 'LEFT',
-        entityNamespace: entity.getNamespace(),
-        entityName: entity.name,
-        joinParts: [],
-        onExpressions: [],
-    });
-    if (joinInfo) {
-        queryJoinExpression.onExpressions.push(NaslLogicItem.BinaryExpression({
-            operator: '==',
-            left: NaslQueryExpression.QueryFieldExpression({
-                label: '查询组件实体属性',
-                isDotStar: false,
-                entityAsName: joinInfo.leftProperty.entity.name,
-                propertyName: joinInfo.leftProperty.name,
-            }),
-            right: NaslQueryExpression.QueryFieldExpression({
-                label: '查询组件实体属性',
-                isDotStar: false,
-                entityAsName: joinInfo.rightProperty.entity.name,
-                propertyName: joinInfo.rightProperty.name,
-            }),
-        }));
-    } else {
-        queryJoinExpression.onExpressions.push(NaslLogicItem.BinaryExpression({
-            operator: '==',
-            left: NaslQueryExpression.QueryFieldExpression({
-                label: '查询组件实体属性',
-                isDotStar: false,
-                entityAsName: lastEntity.name,
-            }),
-            right: NaslQueryExpression.QueryFieldExpression({
-                label: '查询组件实体属性',
-                isDotStar: false,
-                entityAsName: entity.name,
-            }),
-        }));
+  const dataSource = entity.parentNode as DataSource;
+  const { from } = callQueryComponent;
+  let joinInfo;
+  // 无法判断用户行为，优先加有关系的
+  const lastEntity = dataSource.findEntityByName(from.entityName);
+  // lastEntity 和 entity Join
+  // 判断要不要自动关联 onExpression
+  // 一般左联是自动有的了
+  const rightProperty = entity.properties.find((property) => property.relationEntity === lastEntity.name);
+  if (rightProperty) {
+    const leftProperty = lastEntity.properties.find((property) => property.name === rightProperty.relationProperty);
+    joinInfo = {
+      leftProperty,
+      rightProperty,
+    };
+  } else {
+    const leftProperty = lastEntity.properties.find((property) => property.relationEntity === entity.name);
+    if (leftProperty) {
+      const rightProperty = entity.properties.find((property) => property.name === leftProperty.relationProperty);
+      joinInfo = {
+        leftProperty,
+        rightProperty,
+      };
     }
-    const structureProperty = StructureProperty.from(NaslNode.StructureProperty({
-        name: utils.firstLowerCase(entity.name),
-        typeAnnotation: NaslTypeAnnotation.Reference({
-            typeNamespace: entity.getNamespace(),
-            typeName: entity.name,
+  }
+  const queryJoinExpression = NaslQueryExpression.QueryJoinExpression({
+    joinType: 'LEFT',
+    entityNamespace: entity.getNamespace(),
+    entityName: entity.name,
+    joinParts: [],
+    onExpressions: [],
+  });
+  if (joinInfo) {
+    queryJoinExpression.onExpressions.push(
+      NaslLogicItem.BinaryExpression({
+        operator: '==',
+        left: NaslQueryExpression.QueryFieldExpression({
+          label: '查询组件实体属性',
+          isDotStar: false,
+          entityAsName: joinInfo.leftProperty.entity.name,
+          propertyName: joinInfo.leftProperty.name,
+        }),
+        right: NaslQueryExpression.QueryFieldExpression({
+          label: '查询组件实体属性',
+          isDotStar: false,
+          entityAsName: joinInfo.rightProperty.entity.name,
+          propertyName: joinInfo.rightProperty.name,
+        }),
+      })
+    );
+  } else {
+    queryJoinExpression.onExpressions.push(
+      NaslLogicItem.BinaryExpression({
+        operator: '==',
+        left: NaslQueryExpression.QueryFieldExpression({
+          label: '查询组件实体属性',
+          isDotStar: false,
+          entityAsName: lastEntity.name,
         }),
-    }), recordStructure, 'properties');
+        right: NaslQueryExpression.QueryFieldExpression({
+          label: '查询组件实体属性',
+          isDotStar: false,
+          entityAsName: entity.name,
+        }),
+      })
+    );
+  }
+  const structureProperty = StructureProperty.from(
+    NaslNode.StructureProperty({
+      name: utils.firstLowerCase(entity.name),
+      typeAnnotation: NaslTypeAnnotation.Reference({
+        typeNamespace: entity.getNamespace(),
+        typeName: entity.name,
+      }),
+    }),
+    recordStructure,
+    'properties'
+  );
 
-    if (recordStructure instanceof Structure)
-        recordStructure.addProperty(structureProperty);
-    else if (recordStructure instanceof TypeAnnotation)
-        recordStructure.properties.push(structureProperty);
+  if (recordStructure instanceof Structure) recordStructure.addProperty(structureProperty);
+  else if (recordStructure instanceof TypeAnnotation) recordStructure.properties.push(structureProperty);
 
-    const newJoinPartLogicItem = QueryJoinExpression.from(queryJoinExpression, callQueryComponent, 'joinParts');
-    from.addJoinPart(newJoinPartLogicItem);
-    callQueryComponent.saveStructure();
+  const newJoinPartLogicItem = QueryJoinExpression.from(queryJoinExpression, callQueryComponent, 'joinParts');
+  from.addJoinPart(newJoinPartLogicItem);
+  callQueryComponent.saveStructure();
 }
 
 export default genQueryAssignment;
 
 export function genEditQueryStructure(allEntities: Array<Entity>, nameGroup: NameGroup) {
-    allEntities = Array.from(new Set(allEntities));
-    const properties = allEntities.map((entity) =>
-        NaslNode.StructureProperty({
-            name: utils.firstLowerCase(entity.name),
-            typeAnnotation: NaslTypeAnnotation.Reference({
-                typeNamespace: entity.getNamespace(),
-                typeName: entity.name,
-            }),
-        }));
-    properties.push(NaslNode.StructureProperty({
-        name: 'editing',
-        typeAnnotation: NaslCoreTypeAnnotation.String,
-    }));
-    return NaslNode.Structure({
-        name: nameGroup.structure,
-        properties,
-    });
+  allEntities = Array.from(new Set(allEntities));
+  const properties = allEntities.map((entity) =>
+    NaslNode.StructureProperty({
+      name: utils.firstLowerCase(entity.name),
+      typeAnnotation: NaslTypeAnnotation.Reference({
+        typeNamespace: entity.getNamespace(),
+        typeName: entity.name,
+      }),
+    })
+  );
+  properties.push(
+    NaslNode.StructureProperty({
+      name: 'editing',
+      typeAnnotation: NaslCoreTypeAnnotation.String,
+    })
+  );
+  return NaslNode.Structure({
+    name: nameGroup.structure,
+    properties,
+  });
 }