@lcap/nasl 0.3.9-beta

package/spec/spec.yaml

@@ -0,0 +1,416 @@
+App
+  level: LEVEL_ENUM
+  id: string
+  appId: string
+  name: string
+  title: string
+  icon: string
+  description: string
+  dnsAddr: string
+  officialType: 'offical' | 'nonofficial'
+  ideVersion: string
+  projectId: string
+  tenantId: string
+  userGroupId: string
+  services: Array<Service>
+  firstWebService: WebService
+  firstMicroService: MicroService
+Service
+  level: LEVEL_ENUM
+  type: SERVICE_TYPE
+  id: string
+  name: string
+  title: string
+  icon: string
+  appId: string
+  data: DataNode
+  interfaces: Array<Interface>
+  app: App
+  expanded: boolean
+WebService
+  type: SERVICE_TYPE
+  status: 'UNPUBLISHED' | 'PUBLISHED' | 'REPOSITORYCREATED' | 'FSSTARTED' | 'APPINIT' | 'CODESYNCED' | 'CICDCREATED'
+  officialType: 'official' | 'nonofficial'
+  dnsAddr: string
+  packageInfo: {
+  template: {
+    name: string;
+    version: string;
+  };
+  ui: {
+    name: string;
+    version: string;
+  };
+  componentDependencies: {
+    [name: string]: string;
+  };
+}
+  config: string
+  api: {
+  features: {
+    [name: string]: boolean;
+  };
+  builtInFunctions: {
+    [name: string]: any;
+  };
+}
+  pages: Array<Page>
+MicroService
+  type: SERVICE_TYPE
+  packageName: string
+  serverPort: number
+  interfaces: Array<Interface>
+EventEmitter
+  _events: {
+  [name: string]: Array<EventListener>;
+}
+Vertex
+  _mutable: undefined
+  level: LEVEL_ENUM
+  JSON_EXCLUDED_KEYS: Set<string>
+  id: string
+  createdBy: string
+  createdTime: string
+  updatedBy: string
+  updatedTime: string
+  ideVersion: string
+  editable: boolean
+  editing: boolean
+  expanded: boolean
+  isLeaf: boolean
+DataNode
+  level: LEVEL_ENUM
+  type: 'entities' | 'structures'
+  entities: Array<Entity>
+  structures: Array<Structure>
+  enums: Array<Enum>
+  erdiagrams: Array<any>
+  entityExpanded: boolean
+  structureExpanded: boolean
+  enumExpanded: boolean
+  service: Service
+Entity
+  level: LEVEL_ENUM
+  id: string
+  schemaRef: string
+  name: string
+  description: string
+  type: 'object'
+  propertyList: Array<EntityProperty>
+  resolvers: Array<Resolver>
+  serviceId: string
+  serviceType: string
+  service: MicroService
+  dataNode: DataNode
+  existingNames: Array<string>
+EntityProperty
+  level: LEVEL_ENUM
+  id: string
+  name: string
+  label: string
+  description: string
+  type: string
+  format: string
+  $ref: string
+  $refId: string
+  relationship: string
+  rules: Array<string>
+  display: Display
+  defaultValue: string | boolean | number
+  entityId: string
+  root: Entity
+  isLeaf: boolean
+  existingNames: Array<string>
+Enum
+  level: LEVEL_ENUM
+  id: string
+  schemaRef: string
+  name: string
+  label: string
+  description: string
+  type: 'enum'
+  enumItemList: Array<EnumItem>
+  serviceId: string
+  serviceType: string
+  service: Service
+  dataNode: DataNode
+  existingNames: Array<string>
+EnumItem
+  id: string
+  value: string
+  label: string
+  root: Enum
+Interface
+  level: LEVEL_ENUM
+  id: string
+  key: string
+  name: string
+  protocol: string
+  host: string
+  port: string
+  path: string
+  method: string
+  description: string
+  logicId: string
+  logic: Logic
+  serviceType: 'micro' | 'entity' | 'microservice'
+  serviceId: string
+  entityId: string
+  serviceName: string
+  service: MicroService
+  parameters: string
+  responses: string
+  requestBody: string
+  moreChildrenFields: Array<string>
+  existingNames: Array<string>
+Structure
+  level: LEVEL_ENUM
+  id: string
+  schemaRef: string
+  name: string
+  description: string
+  type: 'object'
+  propertyList: Array<StructureProperty>
+  resolvers: string
+  serviceId: string
+  serviceType: string
+  entityId: string
+  service: Service
+  dataNode: DataNode
+  existingNames: Array<string>
+StructureProperty
+  level: LEVEL_ENUM
+  id: string
+  name: string
+  label: string
+  description: string
+  type: string
+  format: string
+  required: boolean
+  $ref: string
+  isArray: boolean
+  rules: any
+  defaultValue: string | boolean | number
+  structureId: string
+  root: Structure
+  isLeaf: undefined
+  existingNames: Array<string>
+BaseVariable
+  level: LEVEL_ENUM
+  type: undefined
+  id: string
+  code: string
+  name: string
+  description: string
+  _posIndex: number
+  logicId: string
+  logic: Logic
+  schema: Schema
+  schemaChildren: Array<Schema>
+  required: boolean
+  isLeaf: undefined
+Logic
+  level: LEVEL_ENUM
+  id: string
+  name: string
+  description: string
+  moduleId: string
+  moduleType: 'view' | 'microService'
+  serviceId: string
+  serviceType: 'view' | 'entity' | 'microService'
+  entityId: string
+  params: Array<Param>
+  returns: Array<Return>
+  variables: Array<Variable>
+  body: Array<LogicItem>
+  playgroundId: string
+  playground: Array<LogicItem>
+  interface: Interface
+  view: View
+  moreChildrenFields: Array<string>
+LogicItem
+  level: LEVEL_ENUM
+  id: string
+  parentId: string
+  parentAttr: string
+  parent: LogicItem
+  logicId: string
+  logic: Logic
+  label: string
+  offsetX: string
+  offsetY: string
+  type: string
+  refTarget: any
+  callInterParam: any
+  callInterParamValue: any
+  builtInFuncParamValue: any
+  pageParamKey: any
+  pageParamKeyValue: any
+LogicNode
+  type: LOGIC_TYPE
+  test: ExpressionNode
+  consequent: Array<LogicNode>
+  alternate: Array<LogicNode>
+  cases: Array<LogicNode>
+  each: ExpressionNode
+  item: ExpressionNode
+  index: ExpressionNode
+  start: ExpressionNode
+  end: ExpressionNode
+  body: Array<LogicNode>
+  operator: string
+  left: LogicItem
+  right: LogicItem
+  arguments: Array<ExpressionNode>
+  value: string
+  method: string
+  entity: string
+  action: string
+  processDefinitionKey: string
+  taskId: string
+  finished: string
+  processInstanceId: string
+  schemaRef: string
+  cron: string
+  page: string
+  url: string
+  code: string
+  calleeCode: string
+  name: string
+ExpressionNode
+  type: LOGIC_TYPE
+  left: LogicItem
+  right: LogicItem
+  code: string
+  name: string
+  key: ExpressionNode
+  value: string | ExpressionNode
+  object: ExpressionNode
+  property: ExpressionNode
+  operator: string
+  properties: Array<ExpressionNode>
+  elements: Array<ExpressionNode>
+  callee: ExpressionNode
+  schemaRef: string
+Param
+  level: LEVEL_ENUM
+  in: string
+  entityFieldId: string
+  defaultValue: string
+Return
+  level: LEVEL_ENUM
+Variable
+  level: LEVEL_ENUM
+  defaultValue: string
+Attr
+  level: LEVEL_ENUM
+  type: 'string' | 'static' | 'dynamic'
+  id: string
+  name: string
+  value: string
+  model: boolean
+  sync: boolean
+  expression: ExpressionNode
+  elementId: string
+  element: Element
+Block
+  level: LEVEL_ENUM
+  id: string
+  name: string
+  title: string
+  template: string
+  $html: Element
+  definition: string
+  $def: {
+  logics: Array<Logic>;
+  params: Array<ViewParam>;
+  variables: Array<Variable>;
+  lifecycles: Array<Lifecycle>;
+}
+  style: string
+  script: string
+Directive
+  level: LEVEL_ENUM
+  type: 'string' | 'static' | 'dynamic'
+  id: string
+  name: string
+  rawName: string
+  value: string
+  arg: string
+  modifiers: {
+  [key: string]: boolean;
+}
+  expression: ExpressionNode
+  elementId: string
+  element: Element
+Element
+  level: LEVEL_ENUM
+  type: number
+  id: string
+  tag: string
+  name: string
+  attrList: Array<Attr>
+  eventList: Array<Event>
+  directiveList: Array<Directive>
+  slotTarget: string
+  slotScope: string
+  staticClass: string
+  staticStyle: string
+  nodePath: string
+  parentId: string
+  parent: Element
+  viewId: string
+  view: View
+  children: Array<Element>
+Event
+  level: LEVEL_ENUM
+  id: string
+  name: string
+  value: string
+  logicId: string
+  logic: string
+  elementId: string
+  element: Element
+Lifecycle
+  level: LEVEL_ENUM
+  id: string
+  name: string
+  logicId: string
+  viewId: string
+  view: View
+Page
+  level: LEVEL_ENUM
+  id: string
+  name: string
+  title: string
+  auth: boolean
+  isIndex: boolean
+  rootView: View
+  serviceId: string
+  service: WebService
+  childrenField: string
+  moreChildrenFields: Array<string>
+View
+  level: LEVEL_ENUM
+  id: string
+  name: string
+  path: string
+  tempPath: string
+  code: string
+  title: string
+  crumb: string
+  first: string
+  parentId: string
+  script: string
+  page: Page
+  parent: View
+  children: Array<View>
+  moreChildrenFields: Array<string>
+ViewParam
+  level: LEVEL_ENUM
+  view: View
+  defaultValue: string
+ViewVariable
+  view: View
+  viewId: string
+  defaultValue: string

package/spec-build/index.ts

@@ -0,0 +1,98 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import * as globby from 'globby';
+import * as babel from '@babel/core';
+import generator from '@babel/generator';
+import traverse from '@babel/traverse';
+
+const isFirstUpperCase = (str: string) => str[0].toUpperCase() === str[0];
+const firstToLowerCase = (str: string) => str[0].toLowerCase() + str.slice(1);
+
+interface ConceptProperty {
+    name: string,
+    value?: string,
+    type?: string,
+    immutable?: boolean,
+    circular?: boolean,
+    excludedInJSON?: boolean,
+    action?: string,
+    inherited?: boolean,
+}
+interface Concept {
+    name: string,
+    propertyList: Array<ConceptProperty>,
+}
+
+const conceptMap: { [name: string]: Concept } = {};
+
+function parse() {
+    globby.sync(['./src/types/**/*.ts']).forEach((filePath) => {
+        const baseName = path.basename(filePath, '.ts');
+        if (!isFirstUpperCase(baseName))
+            return;
+
+        const code = fs.readFileSync(filePath, 'utf8');
+        const ast = babel.parse(code, {
+            filename: filePath,
+            plugins: [
+                require('@babel/plugin-syntax-typescript'),
+                [require('@babel/plugin-proposal-decorators'), {
+                    decoratorsBeforeExport: false,
+                    legacy: false,
+                }],
+            ],
+        });
+
+        traverse(ast, {
+            enter(path) {
+                if (path.isClassDeclaration()) {
+                    const concept: Concept = {
+                        name: path.node.id.name,
+                        propertyList: path.node.body.body
+                            .filter((property) => property.type === 'ClassProperty')
+                            .map((property) => {
+                                property = property as babel.types.ClassProperty;
+                                const result: ConceptProperty = {
+                                    name: (property.key as babel.types.Identifier).name,
+                                    type: property.typeAnnotation ? generator(property.typeAnnotation).code.replace(/^:\s*/, '') : undefined,
+                                };
+
+                                property.decorators && property.decorators.forEach((decorator) => {
+                                    if (decorator.expression.type === 'CallExpression' && decorator.expression.callee.type === 'Identifier') {
+                                        if (decorator.expression.callee.name === 'immutable')
+                                            result.immutable = true;
+                                        else if (decorator.expression.callee.name === 'circular')
+                                            result.circular = true;
+                                        else if (decorator.expression.callee.name === 'excludedInJSON')
+                                            result.excludedInJSON = true;
+                                        else if (decorator.expression.callee.name === 'action')
+                                            result.action = 'true';
+                                    }
+                                });
+                                return result;
+                            }),
+                    };
+                    conceptMap[concept.name] = concept;
+                }
+            },
+        });
+    });
+}
+
+function generateConcept(concept: Concept) {
+    const outputs = [];
+    outputs.push(`${concept.name}`);
+    concept.propertyList.forEach((property) => {
+        outputs.push(`  ${property.name}: ${property.type}`);
+    });
+
+    return outputs.join('\n');
+}
+
+function generate() {
+    const json = JSON.stringify(conceptMap, null, 4);
+    fs.writeFileSync('./spec/conceptMap.json', json, 'utf8');
+}
+
+parse();
+generate();

package/src/routes.map.js

@@ -0,0 +1,5 @@
+export default {
+    specification: {
+        first: true,
+    },
+};

package/src/service/app/api.js

@@ -0,0 +1,84 @@
+export default {
+    loadApps: {
+        url: {
+            method: 'get',
+            path: '/api/v1/lcpapp/listApp',
+        },
+    },
+    loadApp: {
+        url: {
+            method: 'get',
+            path: '/api/v1/lcpapp/getLcpAppByAppId',
+        },
+        config: {
+            preprocess: (info) => {
+                const query = info.url.query;
+                query.lcpAppId = query.id;
+                delete query.id;
+                return info;
+            },
+            postprocess: (result) => {
+                result.id = result.appId;
+                return result;
+            },
+        },
+    },
+    loadServices: {
+        url: {
+            method: 'get',
+            path: '/api/v1/lcpapp/listModules',
+        },
+        config: {
+            preprocess: (info) => {
+                const query = info.url.query;
+                query.lcpAppId = query.appId;
+                delete query.appId;
+                return info;
+            },
+            postprocess: (result) => result.map((item) => ({
+                id: item.moduleId,
+                appId: item.appId,
+                name: item.moduleName,
+                title: item.moduleTitle,
+                level: 'service',
+                type: item.moduleType === 'app' ? 'web' : 'micro',
+                icon: item.moduleIcon,
+                status: item.moduleStatus,
+                officialType: item.officialType,
+                createdTime: item.createdTime,
+                createdBy: item.createdBy,
+                updatedTime: item.updatedTime,
+                updatedBy: item.updatedBy,
+            })),
+        },
+    },
+    loadWebService: {
+        url: {
+            method: 'get',
+            path: '/api/v1/app/getAppById',
+        },
+        config: { postprocess: (result) => {
+            return {
+                id: result.id,
+                appId: result.lcpAppId,
+                name: result.name,
+                title: result.title,
+                level: 'service',
+                type: result.type === 'app' ? 'web' : 'micro',
+                icon: result.icon,
+                status: result.status,
+                officialType: result.officialType,
+                createdTime: result.createdTime,
+                createdBy: result.createdBy,
+                updatedTime: result.updatedTime,
+                updatedBy: result.updatedBy,
+            };
+        } },
+    },
+    checkTemplateName: {
+        url: {
+            method: 'get',
+            path: '/api/v1/assets/template/name/check',
+        },
+    },
+};

package/src/service/app/index.d.tmp

@@ -0,0 +1,16 @@
+import { App, Service, WebService, MicroService } from '../../types';
+
+declare const service: {
+    loadApps: () => Promise<{ count: number, rows: Array<App> }>,
+    loadApp: ({
+        query: { id: string },
+    }) => Promise<App>,
+    loadServices: ({
+        query: { appId: string },
+    }) => Promise<Array<Service>>,
+    loadWebService: ({
+        query: { id: string },
+    }) => Promise<WebService>,
+};
+
+export default service;

package/src/service/app/index.js

@@ -0,0 +1,6 @@
+import { createService } from '../create';
+import api from './api';
+
+const service = createService(api);
+
+export default service;

package/src/service/assets/asset.js

@@ -0,0 +1,76 @@
+const platformVersion = 1;
+
+export default {
+    loadList: {
+        url: {
+            method: 'get',
+            path: '/api/v1/assetdsl/simple/assetlist',
+            query: {
+                platformVersion,
+            },
+        },
+    },
+    loadVersionList: {
+        url: {
+            method: 'get',
+            path: '/api/v1/assetdsl/simple/version/assetlist',
+            query: {
+                platformVersion,
+            },
+        },
+    },
+    loadOfficialList: {
+        url: {
+            method: 'get',
+            path: '/api/v1/official/assetdsl/simple/assetlist',
+            query: {
+                platformVersion,
+            },
+        },
+    },
+    loadOfficialVersionList: {
+        url: {
+            method: 'get',
+            path: '/api/v1/official/assetdsl/simple/version/assetlist',
+            query: {
+                platformVersion,
+            },
+        },
+    },
+    loadUnpublishList: {
+        url: {
+            method: 'get',
+            path: '/api/v1/assetdsl/unpub/list',
+            query: {
+                platformVersion,
+            },
+        },
+    },
+    loadUnpublishDetail: {
+        url: {
+            method: 'get',
+            path: '/api/v1/assetdsl/unpub/list',
+            query: {
+                platformVersion,
+            },
+        },
+    },
+    loadDetail: {
+        url: {
+            method: 'get',
+            path: '/api/v1/assetdsl/detail',
+            query: {
+                platformVersion,
+            },
+        },
+    },
+    loadOfficialDetail: {
+        url: {
+            method: 'get',
+            path: '/api/v1/official/assetdsl/detail',
+            query: {
+                platformVersion,
+            },
+        },
+    },
+};

package/src/service/assets/block.js

@@ -0,0 +1,8 @@
+export default {
+    loadList: {
+        url: {
+            path: '/api/v1/block/list',
+            method: 'get',
+        },
+    },
+};