@steedos/objectql 2.1.82 → 2.1.84

package/src/dynamic-load/package.ts

@@ -0,0 +1,303 @@
+import _ = require('lodash');
+import { getLazyLoadFields } from './field';
+import { getLazyLoadButtons } from './button';
+import { addObjectConfig } from '../types/object_dynamic_load';
+import { addPermissionConfig, loadObjectMethods, loadObjectTriggers } from '../dynamic-load'
+import { getSteedosSchema } from '../types'
+import { objectToJson } from '../util/convert';
+import { registerPermissionFields } from '..';
+var util = require('../util');
+var clone = require('clone');
+// let Fiber = require('fibers');
+declare var Creator: any;
+
+/***
+ * 此文件应该迁移到metadata/core中：系统的结构为所有元数据加载都有metadata/core处理，这样metadata的处理就集中了，规则也就一致了，目前metadata core、objectql各自维护一套。
+ */
+const getListenTo = function (json) {
+    if (!json.listenTo) {
+        console.log('json', json);
+        throw new Error('missing attribute listenTo');
+    }
+
+    if (!_.isString(json.listenTo) && !_.isFunction(json.listenTo)) {
+        throw new Error('listenTo must be a function or string')
+    }
+
+    let listenTo: string = '';
+
+    if (_.isString(json.listenTo)) {
+        listenTo = json.listenTo
+    } else if (_.isFunction(json.listenTo)) {
+        listenTo = json.listenTo()
+    }
+    return listenTo;
+}
+
+const loadPackageObjects = function (filePath: string) {
+    const objectJsons = util.loadObjects(filePath);
+    return objectJsons;
+}
+
+const loadPackageFields = function (filePath: string) {
+    const fieldJsons = util.loadFields(filePath);
+    return fieldJsons;
+}
+
+const loadPackageListViews = function (filePath: string) {
+    let listViewJsons = util.loadListViews(filePath);
+    return listViewJsons;
+}
+
+const loadPackageButtons = function (filePath: string) {
+    let buttonJsons = util.loadButtons(filePath);
+    return buttonJsons;
+}
+
+const loadPackageActions = function (filePath: string) {
+    let actions = util.loadActions(filePath);
+    return _.map(actions, actionToMetadata);
+}
+
+const loadPackageActionScripts = function (filePath: string) {
+    let buttonScripts = util.loadButtonScripts(filePath);
+    return _.map(buttonScripts, actionToMetadata);
+}
+
+const actionToMetadata = (config) => {
+    const actions = {};
+    let object_name = getListenTo(config);
+    const keys = _.keys(config);
+    _.each(keys, (key) => {
+        if (key.endsWith('Visible')) {
+            if (_.isFunction(config[key])) {
+                const _key = key.replace(/(.*)Visible/, '$1');
+                if (!actions[_key]) {
+                    actions[_key] = {};
+                }
+                actions[_key]._visible = config[key].toString();
+            }
+        } else {
+            if (_.isFunction(config[key])) {
+                if (!actions[key]) {
+                    actions[key] = {};
+                }
+                actions[key]._todo = config[key].toString();
+            }
+        }
+    })
+    return { object_name, actions };
+}
+
+const loadPackagePermissions = function (filePath: string) {
+    let permissions = util.loadPermissions(filePath);
+    return _.map(permissions, (permission) => {
+        delete permission.field_permissions;
+        return permission;
+    });
+}
+
+const registerPackageFieldPermissions = async function (filePath: string, broker, serviceName: string) {
+    let permissions = util.loadPermissions(filePath);
+    permissions.forEach(permission => {
+        addPermissionConfig(permission.object_name, permission);
+    });
+
+    const data = [];
+
+    for (const permission of permissions) {
+        const { field_permissions } = permission;
+        if (field_permissions && _.isArray(field_permissions) && field_permissions.length > 0) {
+            for (const field_permission of field_permissions) {
+                data.push({
+                    "name": `${permission.name}.${permission.object_name}.${field_permission.field}`,
+                    "permission_set_id": permission.name,
+                    "permission_object": `${permission.name}_${permission.object_name}`,
+                    "object_name": permission.object_name,
+                    "field": field_permission.field,
+                    "readable": field_permission.readable,
+                    "editable": field_permission.editable,
+                    "is_system": true,
+                })
+            }
+        }
+    }
+    if (data.length > 0) {
+        return await registerPermissionFields.mregister(broker, serviceName, data);
+    }
+}
+
+async function addObjectConfigs(broker, serviceName, objectConfigs) {
+    let metadatas = clone(objectConfigs);
+    _.map(metadatas, (metadata) => {
+        delete metadata.triggers;
+        delete metadata.listeners;
+        delete metadata.methods;
+        objectToJson(metadata);
+    })
+    const res = await broker.call("objects.addConfigs", { data: metadatas }, {
+        meta: {
+            metadataServiceName: serviceName,
+            caller: {
+                nodeID: broker.nodeID
+            }
+        }
+    });
+    return res;
+}
+
+/**
+ * 加载软件包下的所有元数据
+ * 1 在内存中合并所有对象元数据并发送: object.yml 、field.yml、.listview.yml、.button.yml、TODO .action.yml
+ * 2 TODO 其他元数据发送
+ * @param packagePath 软件包路径
+ * @param datasource 软件数据源
+ * @param serviceName 软件包服务名称
+ */
+export const loadPackageMetadatas = async function (packagePath: string, datasource: string, serviceName?: string) {
+    let packageObjects = loadPackageObjects(packagePath);
+    const packageFields = loadPackageFields(packagePath);
+    const packageListviews = loadPackageListViews(packagePath);
+    const packageButtons = loadPackageButtons(packagePath);
+    const packageActions = loadPackageActions(packagePath);
+    const packageActionScripts = loadPackageActionScripts(packagePath);
+    const packagePermissions = loadPackagePermissions(packagePath);
+
+    const packageObjectApiNames = _.map(packageObjects, 'name');
+
+    packageObjects = _.map(packageObjects, (packageObject) => {
+        _.map(packageFields, (field) => {
+            if (field && field.object_name == packageObject.name) {
+                packageObject = _.defaultsDeep(packageObject, { fields: { [field.name]: field } }, packageObject);
+            }
+        })
+        _.map(packageListviews, (listview) => {
+            if (listview && listview.object_name == packageObject.name) {
+                packageObject = _.defaultsDeep(packageObject, { list_views: { [listview.name]: listview } }, packageObject);
+            }
+        })
+
+        _.map(packageButtons, (button) => {
+            if (button && button.object_name == packageObject.name) {
+                packageObject = _.defaultsDeep(packageObject, { actions: { [button.name]: button } }, packageObject);
+            }
+        })
+
+        _.map(packageActions, (action) => {
+            if (action && action.object_name == packageObject.name) {
+                packageObject = _.defaultsDeep(packageObject, { actions: action.actions }, packageObject);
+            }
+        })
+
+        _.map(packageActionScripts, (actionScript) => {
+            if (actionScript && actionScript.object_name == packageObject.name) {
+                packageObject = _.defaultsDeep(packageObject, { actions: actionScript.actions }, packageObject);
+            }
+        })
+
+        _.map(packagePermissions, (permission) => {
+            if (permission && permission.object_name == packageObject.name) {
+                packageObject = _.defaultsDeep(packageObject, { permission_set: { [permission.name]: permission } }, packageObject);
+            }
+        })
+        return packageObject;
+    })
+    for (const element of packageObjects) {
+        if (datasource) {
+            element.datasource = datasource
+        }
+        if (!element.extend) {
+            element.isMain = true;
+        }
+        let startNo = 10;
+        _.each(element.fields, function (field) {
+            if (!_.has(field, 'sort_no')) {
+                field.sort_no = startNo;
+                startNo = startNo + 10;
+            }
+        })
+        if (!element.fields) {
+            element.fields = {}
+        }
+        _.each(getLazyLoadFields(element.name), function (field) {
+            util.extend(element.fields, { [field.name]: field })
+        })
+        if (!element.actions) {
+            element.actions = {}
+        }
+        _.each(getLazyLoadButtons(element.name), function (action) {
+            util.extend(element.actions, { [action.name]: action })
+        })
+        let _mf = _.maxBy(_.values(element.fields), function (field) { return field.sort_no; });
+        if (_mf && element.name) {
+            element.fields_serial_number = _mf.sort_no + 10;
+        }
+        addObjectConfig(element, datasource, null);
+    }
+
+    loadObjectTriggers(packagePath);
+    //此功能不支持微服务模式
+    loadObjectMethods(packagePath); 
+
+    await addObjectConfigs(getSteedosSchema().metadataBroker, serviceName, packageObjects);
+    if (serviceName) {
+        for await (const packageField of packageFields) {
+            if (packageField && !_.includes(packageObjectApiNames, packageField.object_name)) {
+
+                await getSteedosSchema().metadataRegister.addObjectConfig(serviceName, Object.assign({ extend: packageField.object_name }, {
+                    fields: {
+                        [packageField.name]: packageField
+                    }
+                }));
+            }
+        }
+
+        for await (const packageListview of packageListviews) {
+            if (packageListview && !_.includes(packageObjectApiNames, packageListview.object_name)) {
+                await getSteedosSchema().metadataRegister.addObjectConfig(serviceName, Object.assign({ extend: packageListview.object_name }, {
+                    list_views: {
+                        [packageListview.name]: packageListview
+                    }
+                }));
+            }
+        }
+
+        for await (const packageButton of packageButtons) {
+            if (packageButton && !_.includes(packageObjectApiNames, packageButton.object_name)) {
+                await getSteedosSchema().metadataRegister.addObjectConfig(serviceName, Object.assign({ extend: packageButton.object_name }, {
+                    actions: {
+                        [packageButton.name]: packageButton
+                    }
+                }));
+            }
+        }
+
+        for await (const packageAction of packageActions) {
+            if (packageAction && !_.includes(packageObjectApiNames, packageAction.object_name)) {
+                await getSteedosSchema().metadataRegister.addObjectConfig(serviceName, Object.assign({ extend: packageAction.object_name }, {
+                    actions: packageAction.actions
+                }));
+            }
+        }
+
+        for await (const packageActionScript of packageActionScripts) {
+            if (packageActionScript && !_.includes(packageObjectApiNames, packageActionScript.object_name)) {
+                await getSteedosSchema().metadataRegister.addObjectConfig(serviceName, Object.assign({ extend: packageActionScript.object_name }, {
+                    actions: packageActionScript.actions
+                }));
+            }
+        }
+
+        for await (const permission of packagePermissions) {
+            if (permission && !_.includes(packageObjectApiNames, permission.object_name)) {
+                await getSteedosSchema().metadataRegister.addObjectConfig(serviceName, Object.assign({ extend: permission.object_name }, {
+                    permission_set: {
+                        [permission.name]: permission
+                    }
+                }));
+            }
+        }
+    }
+
+    await registerPackageFieldPermissions(packagePath, getSteedosSchema().metadataBroker, packagePath)
+}

package/src/dynamic-load/page.ts

@@ -6,12 +6,18 @@ const loadPageFile = new LoadPageFile();
 export const registerPackagePages = async (packagePath: string, packageServiceName: string)=>{
     const pages = loadPageFile.load(packagePath);
     const schema = getSteedosSchema();
+    const data = [];
     for (const apiName in pages) {
         const page = pages[apiName];
-        await registerPage.register(schema.broker, packageServiceName, Object.assign(page, {is_system:true, record_permissions: {
+        data.push(Object.assign(page, {
+            is_system: true, record_permissions: {
             allowEdit: false,
             allowDelete: false,
             allowRead: true,
         }}))
+
+    }
+    if (data.length > 0) {
+        await registerPage.mregister(schema.broker, packageServiceName, data)
     }
 }

package/src/dynamic-load/permission.ts

@@ -49,11 +49,7 @@ export const loadObjectPermissions = async function (filePath: string, serviceNa
     if(serviceName)
         for await (const permission of permissions) {
             const { field_permissions } = permission;
-            delete permission.field_permissions;
-            await getSteedosSchema().metadataRegister.addObjectConfig(serviceName, Object.assign({extend: permission.object_name}, {permission_set: {
-                [permission.name]: permission
-            }}));
-            if (field_permissions) {
+            if (field_permissions && _.isArray(field_permissions) && field_permissions.length > 0) {
                 for await (const field_permission of field_permissions) {
                     await registerPermissionFields.register(getSteedosSchema().broker, serviceName, {
                         "name": `${permission.name}.${permission.object_name}.${field_permission.field}`,

package/src/dynamic-load/preload_data.ts

@@ -98,8 +98,7 @@ export const preloadDBPermissionFields = async function (datasource: SteedosData
         Creator.Collections[tableName] = Creator.createCollection({ name: tableName });
     }
     let records: any = await datasource.find(tableName, {});
-
-    for await (const element of records) {
-        await registerPermissionFields.register(schema.broker, `~database-${tableName}`, element);
+    if (records && records.length > 0) {
+        await registerPermissionFields.mregister(schema.broker, `~database-${tableName}`, records);
     }
 }

package/src/dynamic-load/query.ts

@@ -6,12 +6,17 @@ const loadQueryFile = new LoadQueryFile();
 export const registerPackageQueries = async (packagePath: string, packageServiceName: string)=>{
     const packageQueries = loadQueryFile.load(packagePath);
     const schema = getSteedosSchema();
+    const data = [];
     for (const apiName in packageQueries) {
         const query = packageQueries[apiName];
-        await registerQuery.register(schema.broker, packageServiceName, Object.assign(query, {is_system:true, record_permissions: {
+        data.push(Object.assign(query, {
+            is_system: true, record_permissions: {
             allowEdit: false,
             allowDelete: false,
             allowRead: true,
         }}))
     }
+    if (data.length > 0) {
+        await registerQuery.mregister(schema.broker, packageServiceName, data)
+    }
 }

package/src/dynamic-load/restrictionRules.ts

@@ -6,14 +6,18 @@ const loadRestrictionRules = new LoadRestrictionRules();
 export const registerPackageRestrictionRules = async (packagePath: string, packageServiceName: string) => {
     const metadata = loadRestrictionRules.load(packagePath);
     const schema = getSteedosSchema();
+    const data = [];
     for (const apiName in metadata) {
         const item = metadata[apiName];
-        await registerRestrictionRules.register(schema.broker, packageServiceName, Object.assign(item, {
+        data.push(Object.assign(item, {
             is_system: true, record_permissions: {
                 allowEdit: false,
                 allowDelete: false,
                 allowRead: true,
             }
-        }))
+        }));
+    }
+    if (data.length > 0) {
+        await registerRestrictionRules.mregister(schema.broker, packageServiceName, data)
     }
 }

package/src/dynamic-load/shareRules.ts

@@ -6,9 +6,10 @@ const loadShareRules = new LoadShareRules();
 export const registerPackageShareRules = async (packagePath: string, packageServiceName: string) => {
     const metadata = loadShareRules.load(packagePath);
     const schema = getSteedosSchema();
+    const data = [];
     for (const apiName in metadata) {
         const item = metadata[apiName];
-        await registerShareRules.register(schema.broker, packageServiceName, Object.assign(item, {
+        data.push(Object.assign(item, {
             is_system: true, record_permissions: {
                 allowEdit: false,
                 allowDelete: false,
@@ -16,4 +17,7 @@ export const registerPackageShareRules = async (packagePath: string, packageServ
             }
         }))
     }
+    if (data.length > 0) {
+        await registerShareRules.mregister(schema.broker, packageServiceName, data)
+    }
 }

package/src/dynamic-load/translations.ts

@@ -43,7 +43,9 @@ export const addTranslationsFiles = async (filePath: string)=>{
             console.error(`addTranslation error`, error.message)
         }
     }
-    await brokeEmitEvents(filePath)
+    if (translations && translations.length > 0) {
+        await brokeEmitEvents(filePath)
+    }
 }
 
 export const getTranslations = async ()=>{

package/src/metadata-register/_base.ts

@@ -26,6 +26,29 @@ export class RegisterBase{
         return res;
     }
 
+    async mregister(broker, packageServiceName, configs) {
+        const metadatas = clone(configs);
+
+        const mdata = {};
+
+        _.map(metadatas, (metadata) => {
+            mdata[this.getApiName(metadata)] = metadata
+        })
+
+        const res = await broker.call(`${this.serviceName}.madd`, { data: mdata }, {
+            meta: {
+                metadataServiceName: packageServiceName,
+                caller: {
+                    nodeID: broker.nodeID,
+                    service: {
+                        name: packageServiceName,
+                    }
+                }
+            }
+        });
+        return res;
+    }
+
     async remove(broker, packageServiceName, metadataApiNameOrConfig: string | JsonMap) {
         let metadataApiName = metadataApiNameOrConfig;
         if (_.isObject(metadataApiName)) {

package/src/metadata-register/object.ts

@@ -1,7 +1,5 @@
-// import { createObjectService } from './objectServiceManager';
-// import { getObjectServiceName } from '../services/index';
 import * as _ from 'underscore';
-import { objectToJson } from '../util';
+import { objectToJson, jsonToObject } from '../util/convert';
 const clone = require('clone');
 
 export async function registerObject(broker, serviceName, objectConfig) {
@@ -67,21 +65,4 @@ export async function removeObject(broker, objectApiName) {
         }
     }});
     return res;
-}
-
-function funEval (funStr){
-	try{
-		return eval(funStr)
-	}catch (e){
-		console.error(e, funStr);
-	}
-};
-
-export function jsonToObject(objectMetadata){
-    _.forEach(objectMetadata.fields, (field, key)=>{
-        const _reference_to = field._reference_to;
-        if(_reference_to && _.isString(_reference_to)){
-            field.reference_to = funEval(`(${_reference_to})`);
-        }
-    })
 }

package/src/services/datasourceServiceFactory.ts

@@ -0,0 +1,37 @@
+import * as _ from 'underscore';
+import { getDataSourceServiceName } from './index';
+import { jsonToObject } from '../util/convert';
+const LocalDataSourceServices = {};
+
+
+export async function createDataSourceService(broker, dataSource) {
+    const dataSourceName = dataSource.name;
+    const serviceName = getDataSourceServiceName(dataSourceName);
+
+    if (LocalDataSourceServices[serviceName]) {
+        return;
+    }
+
+    let service = broker.createService({
+        name: serviceName,
+        events: {
+            [`${dataSourceName}.*.metadata.objects.inserted`]: {
+                handler(ctx) {
+                    let objectConfig = ctx.params.data;
+                    jsonToObject(objectConfig)
+                    dataSource.initObject(objectConfig)
+                    /**
+                     * 每次都需要初始化，TypeORM不适用于微服务模式
+                     */
+                    dataSource.initTypeORM();
+                }
+            }
+        }
+    })
+    if (!broker.started) { //如果broker未启动则手动启动service
+        await broker._restartService(service)
+    }
+    await broker.waitForServices(service.name, null, 10);
+    LocalDataSourceServices[serviceName] = true;
+    return service
+} 

package/src/services/helpers/graphql.ts

@@ -260,9 +260,11 @@ export async function dealWithRelatedFields(
   let steedosSchema = getSteedosSchema();
   let objectName = objectConfig.name;
   let obj = steedosSchema.getObject(objectName);
-  // 拆开 使用单独的promise处理
-  let detailsInfo = await obj.getDetailsInfo();
-  let lookupsInfo = await obj.getLookupDetailsInfo();
+
+  const relationsInfo = await obj.getRelationsInfo();
+  let detailsInfo = relationsInfo.details || [];
+  let lookupsInfo = relationsInfo.lookup_details || [];
+
   let relatedInfos = detailsInfo.concat(lookupsInfo);
   for (const info of relatedInfos) {
     if (!info.startsWith("__")) {

package/src/services/index.ts

@@ -1,6 +1,13 @@
 export * from './objectServiceDispatcher';
 export * from './objectService';
 
+export * from './datasourceServiceFactory';
+export * from './objectServiceFactory';
+
 export function getObjectServiceName(objectApiName: string){
     return `@${objectApiName}`;
+}
+
+export function getDataSourceServiceName(dataSource: string) {
+    return `~dataSource-${dataSource}`;
 }

package/src/services/objectService.ts

@@ -4,7 +4,7 @@ import { getObjectConfig } from '../types/object_dynamic_load';
 import _ = require('underscore');
 import { generateActionRestProp, generateActionGraphqlProp, generateSettingsGraphql, RELATED_PREFIX, _getRelatedType, correctName, getGraphqlActions, getRelatedResolver, dealWithRelatedFields } from './helpers';
 import { getObjectServiceName } from '.';
-import { jsonToObject } from '../metadata-register/object';
+import { jsonToObject } from '../util/convert';
 import { extend } from '../util';
 const Future = require('fibers/future');
 // import { parse } from '@steedos/formula';
@@ -617,9 +617,10 @@ module.exports = {
                 resolvers[objectApiName][relatedFieldName] = getRelatedResolver(objectApiName, detailObjectApiName, detailFieldName, detailFieldReferenceToFieldName);
             }
         };
-        schema.events[`${getObjectServiceName(objectConfig.name)}.metadata.objects.inserted`] = {
+        schema.events[`${objectConfig.datasource}.${getObjectServiceName(objectConfig.name)}.metadata.objects.inserted`] = {
             handler: async function (ctx) {
                 let objectConfig = ctx.params.data;
+               // console.log(`${objectConfig.datasource}.${getObjectServiceName(objectConfig.name)}.metadata.objects.inserted`);
                 // 对象发生变化时，重新创建Steedos Object 对象
                 const datasource = getDataSource(objectConfig.datasource);
                 if (datasource) {
@@ -639,13 +640,13 @@ module.exports = {
                       await datasource.init();
                     }
 
-                    if(datasource.name === 'meteor' && Creator.Objects[objectConfig.name]){
+                    if (datasource.name === 'meteor' && Creator.Objects[objectConfig.name]) {
                         jsonToObject(objectConfig);
                         const localTriggers = (localObjectConfig as any).triggers;
                         if(localTriggers){
                             objectConfig.triggers = localTriggers; 
                         }
-                        extend(objectConfig, {triggers: (localObjectConfig as any)._baseTriggers})
+                        extend(objectConfig, { triggers: Creator.Objects[objectConfig.name].triggers }, { triggers: (localObjectConfig as any)._baseTriggers })
                         Creator.Objects[objectConfig.name] = objectConfig;
                         
                         await Future.task(() => {

package/src/{metadata-register/objectServiceManager.ts → services/objectServiceFactory.ts}

@@ -1,17 +1,17 @@
 import * as _ from 'underscore';
-import { getObjectServiceName } from '../services/index';
+import { getObjectServiceName } from './index';
 const objectService = require('../services/objectService');
 
 const LocalObjectServices = {};
 
-function onDestroyObjectService(objectApiName){
+function onDestroyObjectService(objectApiName) {
     const serviceName = getObjectServiceName(objectApiName);
     delete LocalObjectServices[serviceName]
 }
 
 export async function createObjectService(broker, serviceName, objectConfig) {
-    if(LocalObjectServices[serviceName]){
-        return ;
+    if (LocalObjectServices[serviceName]) {
+        return;
     }
     let service = broker.createService({
         name: serviceName,