@lcap/nasl 0.3.9-beta

package/src/types/decorators/index.ts

@@ -0,0 +1,52 @@
+/**
+ * 不可修改装饰器，非强制。
+ *
+ * 赋值时会修改值，但如果所在对象 _mutable 为 false 的话，会提示错误。
+ *
+ * *名称与 JS 和 TS 的 readonly, writable 作了区分，看起来清爽，避免混淆*。
+ */
+export function immutable() {
+    return function handleImmutable(target: any, key: string | number | symbol) { };
+}
+
+/**
+ * 表示上级对象，处理循环问题
+ */
+export function circular() {
+    return function handleCircular(target: any, key: string | number | symbol) {
+        if (!target.JSON_EXCLUDED_KEYS)
+            target.JSON_EXCLUDED_KEYS = new Set();
+        target.JSON_EXCLUDED_KEYS.add(key);
+    };
+}
+
+/**
+ * 该属性排除于 JSON 中
+ */
+export function excludedInJSON(keys?: Array<string>) {
+    return function handleCircular(target: any, key: string | number | symbol) {
+        if (!target.JSON_EXCLUDED_KEYS)
+            target.JSON_EXCLUDED_KEYS = new Set();
+        target.JSON_EXCLUDED_KEYS.add(key);
+        keys && keys.forEach((key) => target.JSON_EXCLUDED_KEYS.add(key));
+    };
+}
+
+/**
+ * 表示该方法对应一个用户行为
+ */
+export function action(name: string) {
+    return function handleAction(target: any, key: string | number | symbol) {
+        //
+    };
+}
+
+/**
+ * 表示该方法对应一个用户行为
+ * @TODO: 目前暂时跟以前的统一不起来
+ */
+export function operation(name: string) {
+    return function handleOperation(target: any, key: string | number | symbol) {
+        //
+    };
+}

package/src/types/generator/data.ts

@@ -0,0 +1,206 @@
+import {
+    App, MicroService, Interface, Enum,
+    dataTypesMap, vertexsMap, Process,
+} from '..';
+import webFileService from '../../service/webFile';
+import { saveLastModified } from './hotReload';
+
+export function dataTypesToJson() {
+    return dataTypesMap;
+}
+
+export function enumsToJson(app: App) {
+    const enums = app.firstMicroService.data.enums;
+    const enumsJson: {
+        [prop: string]: { [prop: string]: string };
+    } = {};
+    enums.forEach((enumTemp: Enum) => {
+        enumsJson[enumTemp.name] = enumsJson[enumTemp.name] || {};
+        const enumItemList = enumTemp.enumItemList;
+        enumItemList.forEach((enumItem) => {
+            enumsJson[enumTemp.name][`${enumItem.value}`] = enumItem.label;
+        });
+    });
+    return enumsJson;
+}
+
+export function apisToJson(app: App) {
+    const apiJson: {
+        [prop: string]: any;
+    } = {};
+    app.services.forEach((service) => {
+        service.interfaces.forEach((itface: Interface) => {
+            const path = itface.path || '';
+            apiJson[itface.name] = {
+                url: {
+                    path,
+                    method: itface.method,
+                },
+            };
+        });
+        if ((service as MicroService).processes) {
+            (service as MicroService).processes.forEach((process: Process) => {
+                const { launchProcessInterface, childShapes } = process;
+                const path = launchProcessInterface.path || '';
+                apiJson[launchProcessInterface.name] = {
+                    url: {
+                        path,
+                        method: launchProcessInterface.method,
+                    },
+                };
+                childShapes.forEach((processComp) => {
+                    const { type, completeTaskInterface } = processComp;
+                    if (type === 'UserTask') {
+                        const path = completeTaskInterface.path || '';
+                        apiJson[completeTaskInterface.name] = {
+                            url: {
+                                path,
+                                method: completeTaskInterface.method,
+                            },
+                        };
+                    }
+                });
+            });
+        }
+    });
+    return apiJson;
+}
+
+export async function generateDataJson(app: App) {
+    const services = await app.loadServices();
+    const service = app.firstMicroService;
+    await service.loadStructures();
+    await service.loadInterfaces();
+    await service.loadEntities();
+    return {
+        dataTypes: dataTypesToJson(),
+        enums: enumsToJson(app),
+        apis: apisToJson(app),
+    };
+}
+
+export function saveDataTypesCache(app: App) {
+    const serviceId = app.firstMicroService.id;
+    const path = `dataTypes.json`;
+
+    const promise = webFileService.saveFile({
+        body: {
+            serviceId,
+            type: 'cache',
+            path,
+            content: JSON.stringify(dataTypesToJson()),
+        },
+    });
+
+    saveLastModified(serviceId, path);
+    return promise;
+}
+
+export async function loadDataTypesCache(serviceId: string) {
+    const result = await webFileService.loadFile({
+        query: {
+            serviceId,
+            path: `dataTypes.json`,
+        },
+    });
+    return result && JSON.parse(result.content);
+}
+
+export function saveEnumsCache(app: App) {
+    const serviceId = app.firstMicroService.id;
+    const path = `enums.json`;
+
+    const promise = webFileService.saveFile({
+        body: {
+            serviceId,
+            type: 'cache',
+            path,
+            content: JSON.stringify(enumsToJson(app)),
+        },
+    });
+
+    saveLastModified(serviceId, path);
+    return promise;
+}
+
+export async function loadEnumsCache(serviceId: string) {
+    const result = await webFileService.loadFile({
+        query: {
+            serviceId,
+            path: `enums.json`,
+        },
+    });
+    return result && JSON.parse(result.content);
+}
+
+export function saveApisCache(app: App) {
+    const serviceId = app.firstMicroService.id;
+    const path = `apis.json`;
+
+    const promise = webFileService.saveFile({
+        body: {
+            serviceId,
+            type: 'cache',
+            path,
+            content: JSON.stringify(apisToJson(app)),
+        },
+    });
+
+    saveLastModified(serviceId, path);
+    return promise;
+}
+
+export async function loadApisCache(serviceId: string) {
+    const result = await webFileService.loadFile({
+        query: {
+            serviceId,
+            path: `apis.json`,
+        },
+    });
+    return result && JSON.parse(result.content);
+}
+
+export function getVertexIdToName() {
+    const res: { [prop: string]: string } = {};
+    for (const [id, vertex] of vertexsMap) {
+        res[id] = vertex.name || (vertex as any).value;
+    }
+    return res;
+}
+
+export async function saveVertexIdToName(app: App) {
+    const serviceId = app.firstMicroService.id;
+    const path = `vertexIdToName.json`;
+
+    // 合并原来的json。原因：如果有页面没有打开，vertexsMap里会没有那些页面的element点
+    let nameJson = await webFileService.loadFile({
+        query: {
+            serviceId,
+            path,
+        },
+    });
+    nameJson = nameJson && JSON.parse(nameJson.content) || {};
+
+    const promise = webFileService.saveFile({
+        body: {
+            serviceId,
+            type: 'cache',
+            path,
+            content: JSON.stringify(Object.assign(nameJson, getVertexIdToName())),
+        },
+    });
+
+    saveLastModified(serviceId, path);
+    return promise;
+}
+
+export async function loadVertexIdToName(app: App) {
+    const serviceId = app.firstMicroService.id;
+    const result = await webFileService.loadFile({
+        query: {
+            serviceId,
+            path: `vertexIdToName.json`,
+        },
+    });
+    return result && JSON.parse(result.content);
+}

package/src/types/generator/hotReload.ts

@@ -0,0 +1,31 @@
+import webFileService from '../../service/webFile';
+
+/**
+ * 生成上次修改的缓存
+ * @param serviceId
+ * @param path
+ */
+export function saveLastModified(serviceId: string, path?: string) {
+    return webFileService.saveFile({
+        body: {
+            serviceId,
+            type: 'last-modified',
+            path: 'lastModified.json',
+            content: JSON.stringify({ timestamp: new Date().toJSON(), path }),
+        },
+    });
+}
+/**
+ * 加载上次修改的缓存
+ * @param serviceId
+ * @param path
+ */
+export async function loadLastModified(serviceId: string) {
+    const result = await webFileService.loadFile({
+        query: {
+            serviceId,
+            path: 'lastModified.json',
+        },
+    });
+    return result && JSON.parse(result.content);
+}

package/src/types/generator/index.ts

@@ -0,0 +1,4 @@
+export * from './hotReload';
+export * from './data';
+export * from './page';
+export * from './load';

package/src/types/generator/load.ts

@@ -0,0 +1,97 @@
+// 加载时的三个缓存，和 generator 的缓存有点像，所以暂时放在这里
+import { config, WebService, MicroService, View, utils } from '..';
+import { loadCacheService } from '../../service/webFile';
+import { ServiceType } from '../../service/common/preprocess';
+
+/**
+ * 生成接口列表缓存
+ */
+export function saveInterfacesCache(service: MicroService) {
+    if (!config.initialLoadCache)
+        return;
+
+    const timestamp = +new Date();
+    const json: Array<any> = [];
+
+    service.interfaces.forEach((item) => {
+        const itface = item.toJSON();
+        itface.serviceType = (ServiceType as any)[itface.serviceType] || itface.serviceType;
+        itface._cacheTimestamp = timestamp;
+
+        // 目前 interface 下不会自动生成 logic
+        const logic = item.logic.toJSON();
+        logic.body = null;
+        logic.serviceType = (ServiceType as any)[logic.serviceType];
+        itface.logic = logic;
+        json.push(itface);
+    });
+
+    return loadCacheService.setCache({
+        body: {
+            type: 'INTERFACE_LIST',
+            key: service.id,
+            data: JSON.stringify(json),
+            timestamp: +new Date(),
+        },
+    });
+}
+
+export function savePageTreeCache(service: WebService) {
+    if (!config.initialLoadCache)
+        return;
+
+    const timestamp = +new Date();
+    const json: Array<any> = [];
+
+    service.pages.forEach((item) => {
+        const page = item.toJSON();
+        page._cacheTimestamp = timestamp;
+        utils.traverse((current) => {
+            if (current.node.level === 'view') {
+                const viewJson = current.node;
+                viewJson.$html = null;
+                viewJson.$def.logics.forEach((logic: any) => {
+                    logic.body = null;
+                });
+            }
+        }, { node: page }, { mode: 'anyObject' });
+        json.push(page);
+    });
+
+    return loadCacheService.setCache({
+        body: {
+            type: 'PAGE_LIST',
+            key: service.id,
+            data: JSON.stringify(json),
+            timestamp: +new Date(),
+        },
+    });
+}
+
+export function saveViewDetailCache(view: View) {
+    if (!config.initialLoadCache)
+        return;
+
+    const timestamp = +new Date();
+    const json = view.toJSON('', ['children']);
+    delete json.children;
+    json._cacheTimestamp = timestamp;
+
+    return loadCacheService.setCache({
+        body: {
+            type: 'PAGE_DETAIL',
+            key: view.id,
+            data: JSON.stringify(json),
+            timestamp: +new Date(),
+        },
+    });
+}
+
+export function clearLoadCache(type: string, key: string) {
+    return loadCacheService.clearCache({
+        query: {
+            type,
+            key,
+        },
+    });
+}

package/src/types/generator/page.ts

@@ -0,0 +1,37 @@
+import { View } from '..';
+import webFileService from '../../service/webFile';
+import { saveLastModified } from './hotReload';
+
+/**
+ * 保存子页面缓存
+ * @param view
+ */
+export function saveViewCache(view: View) {
+    const serviceId = view.page.service.id;
+    const path = `ID_${view.id}.vue.json`;
+
+    const promise = webFileService.saveFile({
+        body: {
+            serviceId,
+            path,
+            type: 'options-vue',
+            content: JSON.stringify(view.toVueOptions({ finalCode: false })),
+        },
+    });
+
+    saveLastModified(serviceId, path);
+    return promise;
+}
+/**
+ * 加载子页面缓存
+ * @param view
+ */
+export async function loadViewCache(serviceId: string, viewId: string) {
+    const result = await webFileService.loadFile({
+        query: {
+            serviceId,
+            path: `ID_${viewId}.vue.json`,
+        },
+    });
+    return result && JSON.parse(result.content);
+}

package/src/types/history.ts

@@ -0,0 +1,14 @@
+export interface HistoryRecord {
+    content: string,
+    timestamp: number,
+};
+
+export default {
+    records: [] as Array<HistoryRecord>,
+    push(content: string) {
+        this.records.push({ content, timestamp: +new Date() });
+    },
+    clear() {
+        this.records = [];
+    },
+};

package/src/types/index.ts

@@ -0,0 +1,161 @@
+export { EventEmitter } from './common/EventEmitter';
+export { Vertex } from './common/Vertex';
+export { default as PackageJSON } from './common/PackageJSON';
+export { vertexsMap, genFinalCode } from './cacheData';
+
+export { App } from './app/App';
+export { History } from './app/History';
+export { Service, WebService, MicroService, SERVICE_TYPE } from './app/Service';
+
+export { DataNode } from './data/DataNode';
+export { GlobalLogicNode } from './data/GlobalLogicNode';
+export { Entity, systemProperty } from './data/Entity';
+export { EntityProperty } from './data/EntityProperty';
+export { EntityIndex } from './data/EntityIndex';
+export { Structure } from './data/Structure';
+export { StructureProperty } from './data/StructureProperty';
+export { Enum } from './data/Enum';
+export { EnumItem } from './data/EnumItem';
+export * from './data/dataTypes';
+export * from './data/dataTypeUtils';
+export { Interface } from './data/Interface';
+export { Category } from './data/GlobalLogicNode';
+export { Logic } from './logic/Logic';
+export { LogicItem, LogicNode, ExpressionNode, evaluate } from './logic/LogicItem';
+export { BaseVariable, updateVariablesChildrenSchema, updateAllVariablesChildrenSchema } from './logic/BaseVariable';
+export { Param } from './logic/Param';
+export { Variable } from './logic/Variable';
+export { Return } from './logic/Return';
+
+export { Page } from './page/Page';
+export { View } from './page/View';
+export { ViewParam } from './page/ViewParam';
+export { ViewVariable } from './page/ViewVariable';
+export { Lifecycle } from './page/Lifecycle';
+export { Block } from './page/Block';
+export { Process } from './process/Process';
+export { ProcessComponent } from './process/ProcessComponent';
+export { ProcessParam } from './process/ProcessParam';
+export { ProcessReturn } from './process/ProcessReturn';
+export { ProcessProperty } from './process/ProcessProperty';
+export { ProcessComponentReturn } from './process/ProcessComponentReturn';
+export { ProcessComponentVariable } from './process/ProcessComponentVariable';
+export { ProcessComponentAttribute } from './process/ProcessComponentAttribute';
+export { ProcessComponentProperty } from './process/ProcessComponentProperty';
+export { ProcessInterface } from './process/ProcessInterface';
+export { Element } from './page/Element';
+export { Attr } from './page/Attr';
+export { Event } from './page/Event';
+export { Directive } from './page/Directive';
+export { Nuims } from './nuims/Nuims';
+export * from './data/Schema';
+
+export { default as config } from './config';
+export { default as history } from './history';
+export { default as typeCheck } from './typeCheck';
+export { default as login } from './login';
+export * as utils from './utils';
+export * as genBlock from './data/genBlock';
+export * as generator from './generator';
+
+/**
+ * 层级枚举
+ * 目前是弱一点的判断
+ */
+export enum LEVEL_ENUM {
+    vertex = 'vertex',
+    edge = 'edge',
+
+    app = 'app',
+    service = 'service',
+
+    page = 'page',
+    view = 'view',
+    block = 'block',
+
+    logic = 'logic',
+    param = 'param',
+    variable = 'variable',
+    return = 'return',
+    interface = 'interface',
+
+    dataNode = 'dataNode',
+    gloablLogicNode = 'gloablLogicNode',
+    category = 'category',
+    entity = 'entity',
+    structure = 'structure',
+    enum = 'enum',
+    enumItem = 'enumItem',
+    schema = 'schema',
+    property = 'property',
+    entityIndex = 'entityIndex',
+
+    lifecycle = 'lifecycle',
+    element = 'element',
+    attr = 'attr',
+    event = 'event',
+    directive = 'directive',
+
+    logicItem = 'logicItem',
+    logicNode = 'logicNode',
+    expressionNode = 'expressionNode',
+
+    process = 'process',
+    processComponent = 'processComponent',
+    processParam = 'processParam',
+    processReturn = 'processReturn',
+    processProperty = 'processProperty',
+    processComponentReturn = 'processComponentReturn',
+    processComponentVariable = 'processComponentVariable',
+    processComponentAttribute = 'processComponentAttribute',
+    processComponentProperty = 'processComponentProperty',
+}
+
+export const LEVEL_NAME_MAP = {
+    app: '应用',
+    service: '服务',
+
+    page: '页面',
+    view: '子页面',
+    block: '区块',
+
+    logic: '逻辑',
+    param: '输入参数',
+    variable: '局部变量',
+    return: '输出参数',
+    interface: '接口',
+
+    dataNode: '数据',
+    entity: '实体',
+    structure: '数据结构',
+    enum: '枚举',
+    enumItem: '枚举项',
+    property: '属性',
+
+    lifecycle: '生命周期',
+    element: '元素',
+    attr: '属性',
+    event: '事件',
+    directive: '指令',
+
+    logicItem: '逻辑项',
+    logicNode: '逻辑节点',
+    expressionNode: '表达式节点',
+};
+
+/**
+ * 操作模式
+ */
+export enum ACTION_MODE {
+    undoRedo = 'undoRedo',
+    local = 'local',
+    mock = 'mock',
+}
+export interface ActionOptions {
+    actionMode?: ACTION_MODE;
+    actionName?: string;
+    actionDesc?: string;
+    actionIgnore?: boolean;
+    loadHistory?: boolean;
+    checkTypeIgnore?: boolean;
+}