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

package/src/server/entity2LogicNamespace.ts

@@ -1,383 +1,403 @@
-import { CallLogic, EntityProperty, BindEvent, App, Namespace, Entity, BaseNode, Logic, Param, TypeAnnotation, Function, Return, AnonymousFunction, NewList } from '..';
+import {
+  CallLogic,
+  EntityProperty,
+  BindEvent,
+  App,
+  Namespace,
+  Entity,
+  BaseNode,
+  Logic,
+  Param,
+  TypeAnnotation,
+  Function,
+  Return,
+  AnonymousFunction,
+  NewList,
+} from '..';
 
 export function entity2LogicNamespace(entity: Entity) {
-    const properties = entity.properties;
-    const keys = properties.filter((item) => item.primaryKey);
-    const params = keys.map((item: EntityProperty) => new Param({ name: item.name, typeAnnotation: TypeAnnotation.createPrimitive(item.typeAnnotation.typeName), required: true }));
-    const batchDeleteParams
-        = keys.length > 1 ? [
-            new Param({
-                name: 'body',
-                typeAnnotation: TypeAnnotation.createGeneric('List', {
-                    typeArguments: [
-                        TypeAnnotation.from({
-                            typeKind: 'reference',
-                            typeNamespace: entity.getNamespace(),
-                            typeName: entity.name,
-                        }),
-                    ],
+  const { properties } = entity;
+  const keys = properties.filter((item) => item.primaryKey);
+  const params = keys.map(
+    (item: EntityProperty) =>
+      new Param({ name: item.name, typeAnnotation: TypeAnnotation.createPrimitive(item.typeAnnotation.typeName), required: true })
+  );
+  const batchDeleteParams =
+    keys.length > 1
+      ? [
+          new Param({
+            name: 'body',
+            typeAnnotation: TypeAnnotation.createGeneric('List', {
+              typeArguments: [
+                TypeAnnotation.from({
+                  typeKind: 'reference',
+                  typeNamespace: entity.getNamespace(),
+                  typeName: entity.name,
                 }),
-                required: true,
+              ],
             }),
-        ] : [
-            new Param({
-                name: 'body',
-                typeAnnotation: TypeAnnotation.createGeneric('List', {
-                    typeArguments: [TypeAnnotation.createPrimitive(keys?.[0]?.typeAnnotation.typeName)],
-                }),
-                required: true,
+            required: true,
+          }),
+        ]
+      : [
+          new Param({
+            name: 'body',
+            typeAnnotation: TypeAnnotation.createGeneric('List', {
+              typeArguments: [TypeAnnotation.createPrimitive(keys?.[0]?.typeAnnotation.typeName)],
             }),
+            required: true,
+          }),
         ];
-    const ns = new Namespace({
-        name: entity.name,
-        logics: [
-            new Logic({
-                name: 'get',
-                description: '根据id查询数据记录',
-                params,
-                returns: [
-                    new Return({
-                        name: 'result',
-                        typeAnnotation: new TypeAnnotation({
-                            typeKind: 'reference',
-                            typeNamespace: entity.getNamespace(),
-                            typeName: entity.name,
-                        }),
-                    }),
-                ],
-                body: [],
+  const ns = new Namespace({
+    name: entity.name,
+    logics: [
+      new Logic({
+        name: 'get',
+        description: '根据id查询数据记录',
+        params,
+        returns: [
+          new Return({
+            name: 'result',
+            typeAnnotation: new TypeAnnotation({
+              typeKind: 'reference',
+              typeNamespace: entity.getNamespace(),
+              typeName: entity.name,
             }),
-            new Logic({
-                name: 'create',
-                description: '根据body创建一条数据记录',
-                params: [
-                    new Param({
-                        name: 'body',
-                        typeAnnotation: new TypeAnnotation({
-                            typeKind: 'reference',
-                            typeNamespace: entity.getNamespace(),
-                            typeName: entity.name,
-                        }),
-                        required: true,
-                    }),
-                ],
-                returns: [
-                    new Return({
-                        name: 'result',
-                        typeAnnotation: new TypeAnnotation({
-                            typeKind: 'reference',
-                            typeNamespace: entity.getNamespace(),
-                            typeName: entity.name,
-                        }),
-                    }),
-                ],
-                body: [],
+          }),
+        ],
+        body: [],
+      }),
+      new Logic({
+        name: 'create',
+        description: '根据body创建一条数据记录',
+        params: [
+          new Param({
+            name: 'body',
+            typeAnnotation: new TypeAnnotation({
+              typeKind: 'reference',
+              typeNamespace: entity.getNamespace(),
+              typeName: entity.name,
             }),
-            new Logic({
-                name: 'update',
-                description: '根据body的id，将body所有属性更新到数据记录',
-                params: [
-                    new Param({
-                        name: 'body',
-                        typeAnnotation: new TypeAnnotation({
-                            typeKind: 'reference',
-                            typeNamespace: entity.getNamespace(),
-                            typeName: entity.name,
-                        }),
-                        required: true,
-                    }),
-                    new Param({
-                        name: 'properties',
-                        defaultExpression: new AnonymousFunction({
-                            description: '',
-                            params: [
-                                new Param({
-                                    name: 'item',
-                                    typeAnnotation: new TypeAnnotation({
-                                        typeKind: 'reference',
-                                        typeNamespace: entity.getNamespace(),
-                                        typeName: entity.name,
-                                    }),
-                                }),
-                            ],
-                            body: new NewList({
-                                concept: 'NewList',
-                            }),
-                        }),
-                        required: false,
-                    }),
-                ],
-                returns: [
-                    new Return({
-                        name: 'result',
-                        typeAnnotation: new TypeAnnotation({
-                            typeKind: 'reference',
-                            typeNamespace: entity.getNamespace(),
-                            typeName: entity.name,
-                        }),
-                    }),
-                ],
-                body: [],
+            required: true,
+          }),
+        ],
+        returns: [
+          new Return({
+            name: 'result',
+            typeAnnotation: new TypeAnnotation({
+              typeKind: 'reference',
+              typeNamespace: entity.getNamespace(),
+              typeName: entity.name,
             }),
-            new Logic({
-                name: 'delete',
-                description: '根据id删除数据记录',
-                params,
-                body: [],
+          }),
+        ],
+        body: [],
+      }),
+      new Logic({
+        name: 'update',
+        description: '根据body的id，将body所有属性更新到数据记录',
+        params: [
+          new Param({
+            name: 'body',
+            typeAnnotation: new TypeAnnotation({
+              typeKind: 'reference',
+              typeNamespace: entity.getNamespace(),
+              typeName: entity.name,
             }),
-            new Logic({
-                name: 'createOrUpdate',
-                description: '当body中id查询为空则创建数据记录，id查询不为空则更新',
-                params: [
-                    new Param({
-                        name: 'body',
-                        typeAnnotation: new TypeAnnotation({
-                            typeKind: 'reference',
-                            typeNamespace: entity.getNamespace(),
-                            typeName: entity.name,
-                        }),
-                        required: true,
-                    }),
-                ],
-                body: [],
-                returns: [
-                    new Return({
-                        name: 'result',
-                        typeAnnotation: new TypeAnnotation({
-                            typeKind: 'reference',
-                            typeNamespace: entity.getNamespace(),
-                            typeName: entity.name,
-                        }),
-                    }),
-                ],
+            required: true,
+          }),
+          new Param({
+            name: 'properties',
+            defaultExpression: new AnonymousFunction({
+              description: '',
+              params: [
+                new Param({
+                  name: 'item',
+                  typeAnnotation: new TypeAnnotation({
+                    typeKind: 'reference',
+                    typeNamespace: entity.getNamespace(),
+                    typeName: entity.name,
+                  }),
+                }),
+              ],
+              body: new NewList({
+                concept: 'NewList',
+              }),
             }),
-            new Logic({
-                name: 'updateBy',
-                description: '根据条件，将body除id外所有属性更新到数据记录',
-                params: [
-                    new Param({
-                        name: 'filter',
-                        defaultExpression: new Function({
-                            name: 'filter',
-                            description: '',
-                            params: [
-                                // 实体的 updateBy、deleteBy 方法的 filter 参数后端要求使用 _ 变量名，类型为本实体
-                                new Param({
-                                    name: '_',
-                                    typeAnnotation: new TypeAnnotation({
-                                        typeKind: 'reference',
-                                        typeNamespace: entity.getNamespace(),
-                                        typeName: entity.name,
-                                    }),
-                                }),
-                            ],
-                            returns: [
-                                new Return({
-                                    typeAnnotation: TypeAnnotation.createPrimitive('Boolean'),
-                                }),
-                            ],
-                        }),
-                        required: true,
-                    }),
-                    new Param({
-                        name: 'body',
-                        typeAnnotation: new TypeAnnotation({
-                            typeKind: 'reference',
-                            typeNamespace: entity.getNamespace(),
-                            typeName: entity.name,
-                        }),
-                        required: true,
-                    }),
-                    new Param({
-                        name: 'properties',
-                        defaultExpression: new AnonymousFunction({
-                            description: '',
-                            params: [
-                                new Param({
-                                    name: 'item',
-                                    typeAnnotation: new TypeAnnotation({
-                                        typeKind: 'reference',
-                                        typeNamespace: entity.getNamespace(),
-                                        typeName: entity.name,
-                                    }),
-                                }),
-                            ],
-                            body: new NewList({
-                                concept: 'NewList',
-                            }),
-                        }),
-                        required: false,
-                    }),
-                ],
-                returns: [
-                    new Return({
-                        name: 'result',
-                        typeAnnotation: TypeAnnotation.createPrimitive('Long'),
-                    }),
-                ],
-                body: [],
+            required: false,
+          }),
+        ],
+        returns: [
+          new Return({
+            name: 'result',
+            typeAnnotation: new TypeAnnotation({
+              typeKind: 'reference',
+              typeNamespace: entity.getNamespace(),
+              typeName: entity.name,
             }),
-            new Logic({
-                name: 'deleteBy',
-                description: '根据条件删除数据记录',
-                params: [
-                    new Param({
-                        name: 'filter',
-                        defaultExpression: new Function({
-                            name: 'filter',
-                            description: '',
-                            params: [
-                                // 实体的 updateBy、deleteBy 方法的 filter 参数后端要求使用 _ 变量名，类型为本实体
-                                new Param({
-                                    name: '_',
-                                    typeAnnotation: new TypeAnnotation({
-                                        typeKind: 'reference',
-                                        typeNamespace: entity.getNamespace(),
-                                        typeName: entity.name,
-                                    }),
-                                }),
-                            ],
-                            returns: [
-                                new Return({
-                                    typeAnnotation: TypeAnnotation.createPrimitive('Boolean'),
-                                }),
-                            ],
-                        }),
-                        required: true,
-                    }),
-                ],
-                body: [],
+          }),
+        ],
+        body: [],
+      }),
+      new Logic({
+        name: 'delete',
+        description: '根据id删除数据记录',
+        params,
+        body: [],
+      }),
+      new Logic({
+        name: 'createOrUpdate',
+        description: '当body中id查询为空则创建数据记录，id查询不为空则更新',
+        params: [
+          new Param({
+            name: 'body',
+            typeAnnotation: new TypeAnnotation({
+              typeKind: 'reference',
+              typeNamespace: entity.getNamespace(),
+              typeName: entity.name,
             }),
-            new Logic({
-                name: 'batchCreate',
-                description: '批量创建数据记录',
-                params: [
-                    new Param({
-                        name: 'body',
-                        typeAnnotation: TypeAnnotation.createGeneric('List', {
-                            typeArguments: [
-                                TypeAnnotation.from({
-                                    typeKind: 'reference',
-                                    typeNamespace: entity.getNamespace(),
-                                    typeName: entity.name,
-                                }),
-                            ],
-                        }),
-                        required: true,
-                    }),
-                ],
-                returns: [
-                    new Return({
-                        name: 'result',
-                        typeAnnotation: TypeAnnotation.createGeneric('List', {
-                            typeArguments: [
-                                TypeAnnotation.from({
-                                    typeKind: 'reference',
-                                    typeNamespace: entity.getNamespace(),
-                                    typeName: entity.name,
-                                }),
-                            ],
-                        }),
-                    }),
-                ],
-                body: [],
+            required: true,
+          }),
+        ],
+        body: [],
+        returns: [
+          new Return({
+            name: 'result',
+            typeAnnotation: new TypeAnnotation({
+              typeKind: 'reference',
+              typeNamespace: entity.getNamespace(),
+              typeName: entity.name,
             }),
-            new Logic({
-                name: 'batchUpdate',
-                description: '批量更新数据记录，更新策略为全部更新',
-                params: [
-                    new Param({
-                        name: 'body',
-                        typeAnnotation: TypeAnnotation.createGeneric('List', {
-                            typeArguments: [
-                                TypeAnnotation.from({
-                                    typeKind: 'reference',
-                                    typeNamespace: entity.getNamespace(),
-                                    typeName: entity.name,
-                                }),
-                            ],
-                        }),
-                        required: true,
-                    }),
-                    new Param({
-                        name: 'properties',
-                        defaultExpression: new AnonymousFunction({
-                            description: '',
-                            params: [
-                                new Param({
-                                    name: 'item',
-                                    typeAnnotation: new TypeAnnotation({
-                                        typeKind: 'reference',
-                                        typeNamespace: entity.getNamespace(),
-                                        typeName: entity.name,
-                                    }),
-                                }),
-                            ],
-                            body: new NewList({
-                                concept: 'NewList',
-                            }),
-                        }),
-                        required: false,
-                    }),
-                ],
-                returns: [
-                    new Return({
-                        name: 'result',
-                        typeAnnotation: TypeAnnotation.createGeneric('List', {
-                            typeArguments: [
-                                TypeAnnotation.from({
-                                    typeKind: 'reference',
-                                    typeNamespace: entity.getNamespace(),
-                                    typeName: entity.name,
-                                }),
-                            ],
-                        }),
-                    }),
-                ],
-                body: [],
+          }),
+        ],
+      }),
+      new Logic({
+        name: 'updateBy',
+        description: '根据条件，将body除id外所有属性更新到数据记录',
+        params: [
+          new Param({
+            name: 'filter',
+            defaultExpression: new Function({
+              name: 'filter',
+              description: '',
+              params: [
+                // 实体的 updateBy、deleteBy 方法的 filter 参数后端要求使用 _ 变量名，类型为本实体
+                new Param({
+                  name: '_',
+                  typeAnnotation: new TypeAnnotation({
+                    typeKind: 'reference',
+                    typeNamespace: entity.getNamespace(),
+                    typeName: entity.name,
+                  }),
+                }),
+              ],
+              returns: [
+                new Return({
+                  typeAnnotation: TypeAnnotation.createPrimitive('Boolean'),
+                }),
+              ],
             }),
-            new Logic({
-                name: 'batchDelete',
-                description: '批量删除数据记录',
-                params: batchDeleteParams,
-                body: [],
+            required: true,
+          }),
+          new Param({
+            name: 'body',
+            typeAnnotation: new TypeAnnotation({
+              typeKind: 'reference',
+              typeNamespace: entity.getNamespace(),
+              typeName: entity.name,
+            }),
+            required: true,
+          }),
+          new Param({
+            name: 'properties',
+            defaultExpression: new AnonymousFunction({
+              description: '',
+              params: [
+                new Param({
+                  name: 'item',
+                  typeAnnotation: new TypeAnnotation({
+                    typeKind: 'reference',
+                    typeNamespace: entity.getNamespace(),
+                    typeName: entity.name,
+                  }),
+                }),
+              ],
+              body: new NewList({
+                concept: 'NewList',
+              }),
             }),
-            new Logic({
-                name: 'import',
-                description: '导入数据记录，需要配合文件上传组件使用',
-                params: [
-                    new Param({
-                        name: 'body',
-                        typeAnnotation: TypeAnnotation.createPrimitive('Binary'),
-                        required: true,
-                    }),
-                ],
-                returns: [
-                    new Return({
-                        name: 'result',
-                        typeAnnotation: TypeAnnotation.createPrimitive('String'),
-                    }),
-                ],
-                body: [],
+            required: false,
+          }),
+        ],
+        returns: [
+          new Return({
+            name: 'result',
+            typeAnnotation: TypeAnnotation.createPrimitive('Long'),
+          }),
+        ],
+        body: [],
+      }),
+      new Logic({
+        name: 'deleteBy',
+        description: '根据条件删除数据记录',
+        params: [
+          new Param({
+            name: 'filter',
+            defaultExpression: new Function({
+              name: 'filter',
+              description: '',
+              params: [
+                // 实体的 updateBy、deleteBy 方法的 filter 参数后端要求使用 _ 变量名，类型为本实体
+                new Param({
+                  name: '_',
+                  typeAnnotation: new TypeAnnotation({
+                    typeKind: 'reference',
+                    typeNamespace: entity.getNamespace(),
+                    typeName: entity.name,
+                  }),
+                }),
+              ],
+              returns: [
+                new Return({
+                  typeAnnotation: TypeAnnotation.createPrimitive('Boolean'),
+                }),
+              ],
             }),
+            required: true,
+          }),
+        ],
+        body: [],
+      }),
+      new Logic({
+        name: 'batchCreate',
+        description: '批量创建数据记录',
+        params: [
+          new Param({
+            name: 'body',
+            typeAnnotation: TypeAnnotation.createGeneric('List', {
+              typeArguments: [
+                TypeAnnotation.from({
+                  typeKind: 'reference',
+                  typeNamespace: entity.getNamespace(),
+                  typeName: entity.name,
+                }),
+              ],
+            }),
+            required: true,
+          }),
+        ],
+        returns: [
+          new Return({
+            name: 'result',
+            typeAnnotation: TypeAnnotation.createGeneric('List', {
+              typeArguments: [
+                TypeAnnotation.from({
+                  typeKind: 'reference',
+                  typeNamespace: entity.getNamespace(),
+                  typeName: entity.name,
+                }),
+              ],
+            }),
+          }),
+        ],
+        body: [],
+      }),
+      new Logic({
+        name: 'batchUpdate',
+        description: '批量更新数据记录，更新策略为全部更新',
+        params: [
+          new Param({
+            name: 'body',
+            typeAnnotation: TypeAnnotation.createGeneric('List', {
+              typeArguments: [
+                TypeAnnotation.from({
+                  typeKind: 'reference',
+                  typeNamespace: entity.getNamespace(),
+                  typeName: entity.name,
+                }),
+              ],
+            }),
+            required: true,
+          }),
+          new Param({
+            name: 'properties',
+            defaultExpression: new AnonymousFunction({
+              description: '',
+              params: [
+                new Param({
+                  name: 'item',
+                  typeAnnotation: new TypeAnnotation({
+                    typeKind: 'reference',
+                    typeNamespace: entity.getNamespace(),
+                    typeName: entity.name,
+                  }),
+                }),
+              ],
+              body: new NewList({
+                concept: 'NewList',
+              }),
+            }),
+            required: false,
+          }),
+        ],
+        returns: [
+          new Return({
+            name: 'result',
+            typeAnnotation: TypeAnnotation.createGeneric('List', {
+              typeArguments: [
+                TypeAnnotation.from({
+                  typeKind: 'reference',
+                  typeNamespace: entity.getNamespace(),
+                  typeName: entity.name,
+                }),
+              ],
+            }),
+          }),
+        ],
+        body: [],
+      }),
+      new Logic({
+        name: 'batchDelete',
+        description: '批量删除数据记录',
+        params: batchDeleteParams,
+        body: [],
+      }),
+      new Logic({
+        name: 'import',
+        description: '导入数据记录，需要配合文件上传组件使用',
+        params: [
+          new Param({
+            name: 'body',
+            typeAnnotation: TypeAnnotation.createPrimitive('Binary'),
+            required: true,
+          }),
+        ],
+        returns: [
+          new Return({
+            name: 'result',
+            typeAnnotation: TypeAnnotation.createPrimitive('String'),
+          }),
         ],
-    });
-    ns.parentNode = entity;
-    return ns;
+        body: [],
+      }),
+    ],
+  });
+  ns.parentNode = entity;
+  return ns;
 }
 
 interface entityTreeFragment {
-    logics: Array<Logic>;
-    name: string;
-    id: string;
-    concept: string;
+  logics: Array<Logic>;
+  name: string;
+  id: string;
+  concept: string;
 }
 export function entityToTreeFragment(entity: Entity) {
-    const fragment: entityTreeFragment = {
-        name: entity.name,
-        id: entity.id,
-        concept: entity.concept,
-        logics: entity.ns.logics,
-    };
-    return fragment;
+  const fragment: entityTreeFragment = {
+    name: entity.name,
+    id: entity.id,
+    concept: entity.concept,
+    logics: entity.ns.logics,
+  };
+  return fragment;
 }