@lcap/nasl 1.0.0-alpha → 1.0.0-alpha.11

package/src/generator/genBundleFiles.ts

@@ -1,4 +1,4 @@
-import { App, View, BaseNode, Entity, Structure, Enum } from '../concepts';
+import { App, View, BaseNode, Entity, Structure, Enum, uiStructures, collectionStructures, Logic } from '../concepts';
 import * as utils from '../utils';
 import { genHash, RawOptions } from '.';
 import { compileComponent } from './compileComponent';
@@ -8,7 +8,6 @@ import * as JSON5 from 'json5';
 export interface Route {
     // id?: string;
     path?: string;
-    tempPath?: string;
     routePath?: string;
     component?: RawOptions; // ExtendedVue<Vue, unknown, unknown, unknown, Record<never, any>>;
     children?: Array<Route>;
@@ -43,7 +42,7 @@ export async function genBundleFiles(app: App,
         STATIC_URL: string;
         USER_STATIC_URL: string;
     }) {
-    const { views = [], entities = [], structures = [], enums = [], logics = [], interfaces = [], interfaceDependencies = [] } = app || {};
+    const { views = [], entities = [], structures = [], enums = [], logics = [], interfaceDependencies = [] } = app || {};
 
     const componentMap: {
         [name: string]: RawOptions;
@@ -63,21 +62,31 @@ export async function genBundleFiles(app: App,
     const pages: { [name: string]: PageOptions } = {};
     let indexName = 'index';
     const dataTypes: (Entity | Structure | Enum)[] = [];
+
     const dataTypesMap: {
         [id: string]: BaseNode;
     } = {};
+
     const enumsMap: {
         [name: string]: {
             [label: string]: string;
         };
     } = {};
     const logicsMap: {
-        [id: string]: BaseNode;
+        [id: string]: {
+            config: {
+                serviceType: string;
+            };
+            url: {
+                method: string;
+                path: string;
+            };
+        };
     } = {};
     const _custom: {
         [id: string]: BaseNode;
     } = {};
-    const allInterfaces = [];
+    const allLogics: Logic[] = [];
 
     // 页面
     views.forEach((view) => {
@@ -128,10 +137,10 @@ export async function genBundleFiles(app: App,
         enums.forEach((node) => {
             const { name, enumItems } = node || {};
             const enumObj: {
-                [label: string]: string;
+                [value: string]: string;
             } = {};
             enumItems.forEach(({ label, value }) => {
-                enumObj[label] = value;
+                enumObj[value] = label;
             });
             enumsMap[name] = enumObj;
         });
@@ -139,36 +148,48 @@ export async function genBundleFiles(app: App,
 
     if (Array.isArray(entities)) {
         dataTypes.push(...entities);
+        entities.forEach((entity) => {
+            const ns = entity.ns;
+            if (Array.isArray(ns?.logics)) {
+                allLogics.push(...ns.logics);
+            }
+        });
     }
     if (Array.isArray(structures)) {
         dataTypes.push(...structures);
     }
+
     dataTypes.forEach((node) => {
         const namespace = node.getNamespace();
         const id = `${namespace}.${node.name}`;
         dataTypesMap[id] = node;
     });
 
-    if (Array.isArray(logics)) {
-        logics.forEach((node) => {
-            const namespace = node.getNamespace();
+    if (Array.isArray(uiStructures)) {
+        const namespace = 'nasl.ui';
+        uiStructures.forEach((node) => {
             const id = `${namespace}.${node.name}`;
-            logicsMap[id] = node;
+            dataTypesMap[id] = node;
         });
     }
 
-    if (Array.isArray(interfaces)) {
-        allInterfaces.push(...interfaces);
-    }
-    if (Array.isArray(interfaceDependencies)) {
-        interfaceDependencies.forEach((dependence) => {
-            const { interfaces: dependenceInterfaces = [] } = dependence || {};
-            if (Array.isArray(dependenceInterfaces)) {
-                allInterfaces.push(...dependenceInterfaces);
-            }
+    if (Array.isArray(collectionStructures)) {
+        const namespace = 'nasl.collection';
+        collectionStructures.forEach((node) => {
+            const id = `${namespace}.${node.name}`;
+            dataTypesMap[id] = node;
         });
     }
-    allInterfaces.forEach((node) => {
+
+    if (Array.isArray(logics)) {
+        allLogics.push(...logics);
+    }
+
+    allLogics.forEach((node) => {
+        logicsMap[node.name] = node.toService();
+    });
+
+    interfaceDependencies.forEach((node) => {
         const namespace = node.getNamespace();
         const id = `${namespace}.${node.name}`;
         _custom[id] = node;
@@ -189,7 +210,9 @@ export async function genBundleFiles(app: App,
         indexName,
         // extendedConfig: app.extendedConfig,
     }, null, 4);
-    const assetsInfo = await app.genAllAssetsInfo(config.STATIC_URL);
+    const assetsInfo = app.genAllAssetsInfo(config.STATIC_URL);
+    console.log(assetsInfo);
+    // debugger;
     const customNames = JSON5.stringify(assetsInfo.custom.names);
     let content = `(function(){
         `;
@@ -230,6 +253,8 @@ export async function genBundleFiles(app: App,
         window.appVM = appVM;
     })()`;
 
+    if (config.env === 'dev') {
+    }
     // // 加载资源js
     // const str = ` const el = document.createElement('iframe');
     // el.setAttribute('src', "http://defaulttenant.localhost.qa-ci.lcap.group:8850/empty?url=qa-ci.lcap.group");
@@ -251,8 +276,6 @@ export async function genBundleFiles(app: App,
     LazyLoad.css(${JSON5.stringify(assetsInfo.basic.css.concat(assetsInfo.custom.css))});
 })()
 `;
-    // ${str}`;
     outputs[`${config.USER_STATIC_URL}/${config.tenant}/${app.id}/${config.env}/client.js`] = assetsContent;
-
     return outputs;
 }

package/src/generator/genMetaData.ts

@@ -0,0 +1,111 @@
+import { App, View, BaseNode, Entity, Structure, Enum, uiStructures, collectionStructures, Logic } from '../concepts';
+
+export function genMetaData(app: App,
+    config: {
+        tenant: string;
+        env: string;
+        nuimsDomain: string;
+        STATIC_URL: string;
+        USER_STATIC_URL: string;
+    }) {
+    const dataTypesMap: {
+        [id: string]: BaseNode;
+    } = {};
+    const { entities = [], structures = [], enums = [], logics = [], interfaceDependencies = [] } = app || {};
+    const dataTypes: (Entity | Structure | Enum)[] = [];
+    const allLogics: Logic[] = [];
+    const enumsMap: {
+        [name: string]: {
+            [label: string]: string;
+        };
+    } = {};
+    const logicsMap: {
+        [id: string]: {
+            config: {
+                serviceType: string;
+            };
+            url: {
+                method: string;
+                path: string;
+            };
+        };
+    } = {};
+
+    const _custom: {
+        [id: string]: BaseNode;
+    } = {};
+
+    if (Array.isArray(enums)) {
+        dataTypes.push(...enums);
+        enums.forEach((node) => {
+            const { name, enumItems } = node || {};
+            const enumObj: {
+                [value: string]: string;
+            } = {};
+            enumItems.forEach(({ label, value }) => {
+                enumObj[value] = label;
+            });
+            enumsMap[name] = enumObj;
+        });
+    }
+
+    if (Array.isArray(entities)) {
+        dataTypes.push(...entities);
+        entities.forEach((entity) => {
+            const ns = entity.ns;
+            if (Array.isArray(ns?.logics)) {
+                allLogics.push(...ns.logics);
+            }
+        });
+    }
+    if (Array.isArray(structures)) {
+        dataTypes.push(...structures);
+    }
+
+    dataTypes.forEach((node) => {
+        const namespace = node.getNamespace();
+        const id = `${namespace}.${node.name}`;
+        dataTypesMap[id] = node;
+    });
+
+    if (Array.isArray(uiStructures)) {
+        const namespace = 'nasl.ui';
+        uiStructures.forEach((node) => {
+            const id = `${namespace}.${node.name}`;
+            dataTypesMap[id] = node;
+        });
+    }
+
+    if (Array.isArray(collectionStructures)) {
+        const namespace = 'nasl.collection';
+        collectionStructures.forEach((node) => {
+            const id = `${namespace}.${node.name}`;
+            dataTypesMap[id] = node;
+        });
+    }
+
+    if (Array.isArray(logics)) {
+        allLogics.push(...logics);
+    }
+
+    allLogics.forEach((node) => {
+        logicsMap[node.name] = node.toService();
+    });
+
+    interfaceDependencies.forEach((node) => {
+        const namespace = node.getNamespace();
+        const id = `${namespace}.${node.name}`;
+        _custom[id] = node;
+    });
+
+    return {
+        metaData: {
+            dataTypesMap,
+            enumsMap,
+            logicsMap,
+            servicesMap: {
+                _custom,
+            },
+        },
+    };
+}

package/src/generator/index.ts

@@ -2,3 +2,4 @@ export * from './genHash';
 export * from './compileComponent';
 export * from './styleReplacer';
 export * from './genBundleFiles';
+export * from './genMetaData';

package/src/index.ts

@@ -1,10 +1,11 @@
 export { EventEmitter, EventPayload, BaseNode } from './common';
 export * from './concepts';
-export { genBundleFiles } from './generator';
+export { genBundleFiles, genMetaData } from './generator';
 export * from './translator';
 export { default as diagnosticManager } from './manager/diagnostic';
 // export { default as server } from './server';
 export * as genBlock from './templator';
 export * as utils from './utils';
 export * from './config';
-export { loadApp } from './service/storage/init';
+export { loadApp, loadAppSync } from './service/storage/init';
+import './automate/engine';

package/src/server/createUiTs.ts

@@ -0,0 +1,159 @@
+import { Logic, TypeAnnotation, Param } from '..';
+
+export default function formatUiTs(allComponent: any) {
+    const indent = (tabSize: number) => ' '.repeat(tabSize * 2);
+
+    const toHump = (name: string) => name ? name.replace(/\-(\w)/g, (all, letter) => letter.toUpperCase()) : '';
+
+    const toNaslType = (type: string) => {
+        if (type === 'number')
+            return 'nasl.core.Long';
+        if (type === 'string')
+            return 'nasl.core.String';
+        if (type === 'boolean')
+            return 'nasl.core.Boolean';
+        if (type === 'Array<string>')
+            return 'nasl.collection.List<nasl.core.String>';
+        else
+            return type;
+    };
+
+    const creatMethodLogic = (method: {name: string, params: any[]}) => {
+        const { name, params } = method;
+        const logic = new Logic({
+            name,
+            params: params.map((param) => {
+                let typeAnnotation = null;
+                const { name, type } = param;
+                if (type === 'number')
+                    typeAnnotation = TypeAnnotation.createPrimitive('Long');
+                else if (type === 'string')
+                    typeAnnotation = TypeAnnotation.createPrimitive('String');
+                else if (type === 'boolean')
+                    typeAnnotation = TypeAnnotation.createPrimitive('Boolean');
+                else if (type === 'Array<string>')
+                    typeAnnotation = TypeAnnotation.createGeneric('List', {
+                        typeArguments: [TypeAnnotation.createPrimitive('String')],
+                    });
+                else {
+                    typeAnnotation = TypeAnnotation.createPrimitive('any');
+                }
+                return new Param({
+                    name,
+                    typeAnnotation,
+                });
+            }),
+        });
+        return logic;
+    };
+    const elementsLogic: { [componentName: string]: Array<Logic> } = {};
+    let value = `namespace nasl.ui {
+    export class VueComponent {
+    }
+    export class lRoot<T> extends VueComponent{
+        constructor(
+            options?: {
+              bindAttr?: () => Array<any>,
+              slotDefault?: ()=> Array<any>,
+        }){super()}
+    }
+    export class div<T> extends VueComponent {
+        constructor(
+            options?: {
+              bindAttr?: () => Array<any>,
+              slotDefault?: ()=> Array<any>,
+        }){super()}
+    }
+    export class template<T> extends VueComponent {
+        constructor(
+            options?: {
+              bindAttr?: () => Array<any>,
+              slotDefault?: ()=> Array<any>,
+        }){super()}
+    }
+    export type GetItemTypeFromDataSource<T> = T extends nasl.collection.PageOf<infer U> | nasl.collection.List<infer U> | ((...args: any) => nasl.collection.PageOf<infer U> | nasl.collection.List<infer U>) ? U : never;
+    \n`;
+    for (const i in allComponent) {
+        const item = allComponent[i];
+        const componentName = toHump(item.name);
+        if (!componentName)
+            break;
+        // console.log(item);
+        value += `export class ${componentName}<T> extends VueComponent{\n
+                constructor(\n
+                options?: {\n
+                [propname: string]: any,
+                bindAttr?: () => Array<any>,\n`;
+        // 生成slot
+        if (Object.prototype.toString.call(item.slots) === '[object Array]') {
+            let hasDefault = false;
+            if (item.attrs && item.attrs.find((item: any) => item.name === 'data-source')) {
+                // 没有插槽的
+                value += `slotDefault?: (scope: nasl.ui.ScopeOf<T>)=> Array<any>,\n`;
+                hasDefault = true;
+            }
+            item.slots.forEach((slot: any) => {
+                if (!slot.advanced) {
+                    const slotName = toHump('slot-' + slot.name);
+                    // 如果已经有带参数的slotDefault
+                    if (slotName === 'slotDefault' && hasDefault)
+                        return;
+                    if (Array.isArray(slot.props) && slot.props.length === 5) {
+                        value += indent(3);
+                        value += slotName + `?: (scope: nasl.ui.ScopeOf<T>) => Array<any>,\n`;
+                    } else if (Array.isArray(slot.props)) {
+                        value += indent(3);
+                        value += slotName + `?: (scope: {`;
+                        slot.props.forEach((prop: any) => {
+                            const type = prop.type || '';
+                            value += `${prop.name}: ${type}, `;
+                        });
+                        value += `}) => Array<any>,\n`;
+                    } else {
+                        value += indent(3);
+                        value += slotName + `?: ()=> Array<any>,\n`;
+                    }
+                }
+            });
+        } else {
+            // 没有插槽的
+            value += `slotDefault?: ()=> Array<any>,\n`;
+        }
+        value += indent(1) + '\n}){super()}\n';
+        // 生成methods
+        if (Object.prototype.toString.call(item.methods) === '[object Array]') {
+            //   beforeNavigate?:($event: {to: string | Location, replace: boolean, append: boolean, preventDefault: Function}) => void
+            const logics: Array<Logic> = [];
+            item.methods.forEach((method: any) => {
+                if (!method.advanced) {
+                    const methodName = toHump(method.name);
+                    if (Array.isArray(method.params) && method.params.length) {
+                        let methodParamStr = '';
+                        method.params.forEach((param: any) => {
+                            methodParamStr += param.name.includes('?') ? param.name : param.name + '?: ';
+                            const type = toNaslType(param.type);
+                            methodParamStr += type;
+                            methodParamStr += ',';
+                        });
+                        value += indent(1);
+                        value += methodName + `: (${methodParamStr}) => any;\n`;
+                        logics.push(creatMethodLogic(method));
+                    } else {
+                        value += indent(1);
+                        value += methodName + `: () => void;\n`;
+                        logics.push(creatMethodLogic({ name: methodName, params: [] }));
+                    }
+                }
+            });
+            elementsLogic[componentName] = logics;
+        }
+        value += '}\n';
+    }
+    value += '}\n';
+    // console.log(value);
+    // console.log(elementsLogic);
+    return {
+        code: value,
+        elementsLogic,
+    };
+}

package/src/server/entity2LogicNamespace.ts

@@ -1,10 +1,10 @@
-import { CallLogic, BindEvent, App, Namespace, Entity, BaseNode, Logic, Param, TypeAnnotation, Return, Process } from '..';
+import { CallLogic, BindEvent, App, Namespace, Entity, BaseNode, Logic, Param, TypeAnnotation, Return } from '..';
 export function entity2LogicNamespace(entity: Entity) {
     const ns = new Namespace({
         name: entity.name,
         logics: [
             new Logic({
-                name: 'get' + entity.name,
+                name: 'get',
                 params: [
                     new Param({
                         name: 'id',
@@ -25,7 +25,7 @@ export function entity2LogicNamespace(entity: Entity) {
                 body: [],
             }),
             new Logic({
-                name: 'create' + entity.name,
+                name: 'create',
                 params: [
                     new Param({
                         name: 'body',
@@ -50,7 +50,7 @@ export function entity2LogicNamespace(entity: Entity) {
                 body: [],
             }),
             new Logic({
-                name: 'update' + entity.name,
+                name: 'update',
                 params: [
                     new Param({
                         name: 'body',
@@ -75,7 +75,7 @@ export function entity2LogicNamespace(entity: Entity) {
                 body: [],
             }),
             new Logic({
-                name: 'delete' + entity.name,
+                name: 'delete',
                 params: [
                     new Param({
                         name: 'id',
@@ -86,7 +86,7 @@ export function entity2LogicNamespace(entity: Entity) {
                 body: [],
             }),
             new Logic({
-                name: 'batchCreate' + entity.name,
+                name: 'batchCreate',
                 params: [
                     new Param({
                         name: 'body',
@@ -119,7 +119,7 @@ export function entity2LogicNamespace(entity: Entity) {
                 body: [],
             }),
             new Logic({
-                name: 'batchUpdate' + entity.name,
+                name: 'batchUpdate',
                 params: [
                     new Param({
                         name: 'body',
@@ -152,7 +152,7 @@ export function entity2LogicNamespace(entity: Entity) {
                 body: [],
             }),
             new Logic({
-                name: 'batchDelete' + entity.name,
+                name: 'batchDelete',
                 params: [
                     new Param({
                         name: 'body',
@@ -165,7 +165,7 @@ export function entity2LogicNamespace(entity: Entity) {
                 body: [],
             }),
             new Logic({
-                name: 'import' + entity.name,
+                name: 'import',
                 params: [
                     new Param({
                         name: 'body',
@@ -186,3 +186,19 @@ export function entity2LogicNamespace(entity: Entity) {
 
     return ns;
 }
+
+interface entityTreeFragment {
+    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;
+}

package/src/server/getExtensionModules.ts

@@ -0,0 +1,13 @@
+import { App, Module, Namespace } from '..';
+export function getExtensionModules(app: App) {
+    return app.dependencies;
+}
+
+export function moduleToLogicNamesapce(m: Module) {
+    const ns = new Namespace({
+        name: m.name,
+        logics: m.logics,
+    });
+    ns.path = `app.${m.name}.logics`;
+    return ns;
+}

package/src/server/getInterfaces.ts

@@ -1,7 +1,7 @@
 import { CallInterface, BindEvent, App, Namespace, Interface, Entity, BaseNode, Logic, Param, TypeAnnotation, Return, Process } from '..';
 type FakeNode = Partial<Namespace> & {
-    children?: Array<FakeNode>
-    interfaces?: Array<Interface>
+    children?: Array<FakeNode>;
+    interfaces?: Array<Interface>;
 };
 function iterator(tree: Namespace, searchContent: string, fakeNode: FakeNode) {
     Object.assign(fakeNode, {
@@ -34,7 +34,7 @@ function iterator(tree: Namespace, searchContent: string, fakeNode: FakeNode) {
 }
 export function getInterfaces(node: CallInterface | BindEvent, filterText?: string) {
     const app = node.rootNode as App;
-    const _moduleList = app.dependencies.filter((item) => item.type === 'interface');
+    const _moduleList = app.interfaceDependencies.filter((item) => item.type === 'interface');
     const fakeNode = {};
     const interfaces = _moduleList.map((item) => new Namespace({ name: item.name, interfaces: item.interfaces }));
     const tree = new Namespace({

package/src/server/getLogics.ts

@@ -1,6 +1,6 @@
-import { CallLogic, BindEvent, App, Namespace, Entity, BaseNode, Logic, Param, TypeAnnotation, Return, Process } from '..';
-import { entity2LogicNamespace } from './entity2LogicNamespace';
+import { CallLogic, BindEvent, App, Namespace, Entity, BaseNode, Logic, Param, TypeAnnotation, Return, Process, ViewElement } from '..';
 import { process2LogicNamespace } from './process2LogicNamespace';
+import { moduleToLogicNamesapce } from './getExtensionModules';
 import naslServer from './naslServer';
 
 type FakeNode = Partial<Namespace> & {
@@ -52,43 +52,73 @@ function iterator(tree: FakeNode | FakeProcessNode, searchContent: string, fakeN
     }
 }
 
-export async function getLogics(node: CallLogic | BindEvent, filterText?: string) {
+function toHump(name: string): string {
+    return name.replace(/\-(\w)/g, (all, letter) => letter.toUpperCase());
+}
+export async function getLogics(node: CallLogic | BindEvent, needAllLogic: boolean = true) {
     const app = node.rootNode as App;
     if (node.concept === 'CallLogic' || node.concept === 'BindEvent') {
-        const nc = app.entities.map((entity) => entity2LogicNamespace(entity));
-        nc.map((item) => {
-            item.logics = item.logics.filter((logic) => !logic.name.startsWith('import'));
-            return item;
-        });
+        const result = [];
 
-        const ps = app.processes.map((p) => process2LogicNamespace(p));
+        if (needAllLogic) {
+            const nc = app.entities.map((entity) => entity.ns);
+            nc.map((item) => {
+                item.logics = item.logics.filter((logic) => !logic.name.startsWith('import'));
+                return item;
+            });
+            const ps = app.processes.map((p) => process2LogicNamespace(p));
+            const extensions = app.dependencies.map(moduleToLogicNamesapce);
+            const tree = new Namespace({
+                name: 'logics',
+                path: `${app.getNamespace()}.logics`,
+                title: '全局逻辑',
+                logics: app.logics,
+                children: [...nc, ...extensions, ...ps],
+            });
+            result.push(tree);
+        }
 
-        const fakeNode = {};
-        const tree = new Namespace({
-            name: 'logics',
-            path: `${app.getNamespace()}.logics`,
-            title: '全局逻辑',
-            logics: app.logics,
-            children: [...nc, ...(app.dependencies.slice(1) as any as Namespace[]), ...ps],
-        });
-        iterator(tree, filterText, fakeNode);
-        const result = [fakeNode];
         if (node.view && node.view.logics) {
+            // 获取组件逻辑, 获取传入字段的子集
+            const elements: Array<ViewElement> = [];
+            node.view.elementsMethods(node.view.elements, elements);
+            const viewElements: Array<Namespace> = [];
+            elements.forEach((item) => {
+                const itemTag = toHump(item.tag);
+                const elementsLogic = naslServer.elementsLogic;
+                const elementsLogicName = itemTag;
+                const eleLogis = elementsLogic[elementsLogicName];
+                // 看是不是有已经有有参数的函数了
+                if (Array.isArray(eleLogis) && eleLogis.length) {
+                    const viewElement = new Namespace({
+                        title: toHump(item.name),
+                        name: 'methods',
+                        logics: elementsLogic[elementsLogicName],
+                        path: `elements.${toHump(item.name)}.logics`,
+                    });
+                    viewElements.push(viewElement);
+                }
+            });
             // 增加页面逻辑
-            const fakeNode = {};
-            const tree = new Namespace(new Namespace({
+            const tree = new Namespace({
                 name: 'logics',
                 path: `${node.view.getNamespace()}.${node.view.name}.logics`,
                 title: '页面逻辑',
                 logics: node.view.logics,
-            }));
-            iterator(tree, filterText, fakeNode);
-            result.push(fakeNode);
-            // 获取组件逻辑, 获取传入字段的子集
-            // const elementsMethod = await naslServer.getElementsMethod(node, '__elements');
-            // console.log(elementsMethod);
+                children: viewElements,
+            });
+            result.push(tree);
         }
-
         return result;
     }
 }
+
+export function iteratorTree(treeList: {}[], filterText?: string) {
+    const result: {}[] = [];
+    treeList.forEach((item) => {
+        const fakeNode = {};
+        iterator(item, filterText, fakeNode);
+        result.push(fakeNode);
+    });
+    return result;
+}