@steedos/objectql 2.2.50 → 2.2.51-beta.4

package/src/dynamic-load/method.ts

@@ -1,63 +0,0 @@
-import { SteedosActionTypeConfig } from '../types'
-import { Dictionary, JsonMap } from '@salesforce/ts-types';
-import { getObjectConfig } from '../types'
-import _ = require('lodash');
-var util = require('../util');
-var clone = require('clone');
-
-const _lazyLoadMethods: Dictionary<any> = {};
-
-const addLazyLoadMethods = function(objectName: string, json: SteedosActionTypeConfig){
-    if(!_lazyLoadMethods[objectName]){
-        _lazyLoadMethods[objectName] = []
-    }
-    _lazyLoadMethods[objectName].push(json)
-}
-
-const getLazyLoadMethods = function(objectName: string){
-    return _lazyLoadMethods[objectName]
-}
-
-export const loadObjectLazyMethods = function(objectName: string){
-    let methods = getLazyLoadMethods(objectName);
-    _.each(methods, function(methods){
-        addObjectMethodConfig(clone(methods));
-    })
-}
-
-export const addObjectMethodConfig = (json: JsonMap)=>{
-    if (!json.listenTo) {
-        throw new Error('missing attribute listenTo')
-    }
-
-    if (!_.isString(json.listenTo) && !_.isFunction(json.listenTo)) {
-        throw new Error('listenTo must be a function or string')
-    }
-
-    let object_name = '';
-
-    if (_.isString(json.listenTo)) {
-        object_name = json.listenTo
-    } else if (_.isFunction(json.listenTo)) {
-        object_name = json.listenTo()
-    }
-
-    let object = getObjectConfig(object_name);
-    if (object) {
-        if(!object.methods){
-            object.methods = {}
-        }
-        delete json.listenTo
-
-        Object.assign(object.methods, json);
-
-    }
-    addLazyLoadMethods(object_name, Object.assign({}, json, {listenTo: object_name}));
-}
-
-export const loadObjectMethods = function (filePath: string){
-    let methods = util.loadMethods(filePath)
-    _.each(methods, (json: JsonMap) => {
-        addObjectMethodConfig(json);
-    })
-}

package/src/dynamic-load/object_translations.ts

@@ -1,61 +0,0 @@
-/*
- * @Author: baozhoutao@steedos.com
- * @Date: 2022-03-28 09:35:34
- * @LastEditors: baozhoutao@steedos.com
- * @LastEditTime: 2022-06-18 10:36:17
- * @Description: 
- */
-import { getSteedosSchema } from '../types/schema';
-import path = require('path');
-import * as _ from 'underscore';
-import { map, defaultsDeep, each, filter, reverse } from 'lodash';
-var util = require('../util');
-
-// const addObjectsTranslation = async (objectApiName, data)=>{
-//     return await getSteedosSchema().metadataBroker?.call('translations.addObjectTranslation', {
-//         objectApiName, data
-//     })
-// }
-
-const addObjectTranslations = async (data) => {
-    return await getSteedosSchema().metadataBroker?.call('translations.addObjectTranslations', {
-        data
-    })
-}
-
-export const addObjectTranslationsFiles = async (filePath: string)=>{
-    if(!path.isAbsolute(filePath)){
-        throw new Error(`${filePath} must be an absolute path`);
-    }
-
-    let objectTranslations = util.loadObjectTranslations(filePath)
-    // for (const element of objectTranslations) {
-    //     try {
-    //         await addObjectsTranslation(element.objectApiName, element)
-    //     } catch (error) {
-    //         console.error(`addObjectsTranslation error`, error.message)
-    //     }
-    // }
-    if (objectTranslations && objectTranslations.length > 0) {
-        await addObjectTranslations(objectTranslations);
-    }
-}
-
-export const getObjectTranslations = async ()=>{
-    const objectsTranslations = await getSteedosSchema().metadataBroker.call('translations.getObjectTranslations');
-    const objectTranslationsTemplates = await getSteedosSchema().metadataBroker.call('translations.getObjectTranslationTemplates');
-
-    const results = [];
-
-    map(objectTranslationsTemplates, ({metadata: defaultTranslation})=>{
-        each(['zh-CN', 'en'], (lng)=>{
-            let objectTranslation = {};
-            const objectTranslations: Array<any> = filter(objectsTranslations, {lng: lng, objectApiName: defaultTranslation.objectApiName});
-            if(objectTranslations.length > 0){
-                objectTranslation = defaultsDeep(objectTranslation, ...(reverse(objectTranslations)))
-            }
-            results.push(defaultsDeep({ lng: lng }, objectTranslation, defaultTranslation));
-        })
-    });
-    return results;
-}   

package/src/dynamic-load/originalObject.ts

@@ -1,8 +0,0 @@
-import { getOriginalObjectConfig } from '../types';
-
-var util = require('../util');
-
-export function overrideOriginalObject(objectName, data){
-    const originalObjectConfig = getOriginalObjectConfig(objectName);
-    util.extend(originalObjectConfig, data);
-}

package/src/dynamic-load/package.ts

@@ -1,312 +0,0 @@
-import _ = require('lodash');
-import { getLazyLoadFields } from './field';
-import { getLazyLoadButtons } from './button';
-import { addObjectConfig } from '../types/object_dynamic_load';
-import { addPermissionConfig, getLazyLoadPermissions, 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();
-                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;
-        }
-
-        if (!element.permission_set) {
-            element.permission_set = {}
-        }
-        _.each(getLazyLoadPermissions(element.name), function (permission) {
-            util.extend(element.permission_set, {[permission.name]: permission})
-        })
-
-        addObjectConfig(element, datasource, null);
-    }
-
-    loadObjectTriggers(packagePath, serviceName);
-    //此功能不支持微服务模式
-    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

@@ -1,23 +0,0 @@
-import { LoadPageFile } from '@steedos/metadata-core';
-import { registerPage } from '../metadata-register/page';
-import { getSteedosSchema } from '../types'
-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];
-        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

@@ -1,71 +0,0 @@
-import { Dictionary } from '@salesforce/ts-types';
-import { getObjectConfig, getSteedosSchema, SteedosObjectPermissionTypeConfig } from '../types'
-import { registerPermissionFields } from '../metadata-register/permissionFields'
-import _ = require('lodash');
-var util = require('../util');
-var clone = require('clone');
-
-const _lazyLoads: Dictionary<any> = {};
-
-const addLazyLoad = function(objectName: string, json: SteedosObjectPermissionTypeConfig){
-    if(!_lazyLoads[objectName]){
-        _lazyLoads[objectName] = []
-    }
-    _lazyLoads[objectName].push(json)
-}
-
-const getLazyLoads = function(objectName: string){
-    return _lazyLoads[objectName]
-}
-
-export const getLazyLoadPermissions  = function(objectName: string){
-    return getLazyLoads(objectName);
-}
-
-export const lazyloadPermissions = function(objectName: string){
-    let permissions = getLazyLoads(objectName);
-    _.each(permissions, function(permission){
-        addPermissionConfig(permission.object_name, clone(permission));
-    })
-}
-
-export const addPermissionConfig = (objectName: string, json: SteedosObjectPermissionTypeConfig)=>{
-    if (!json.object_name) {
-        throw new Error('missing attribute object_name')
-    }
-    let object = getObjectConfig(json.object_name);
-    if (object) {
-        if(!object.permission_set){
-            object.permission_set = {}
-        }
-        util.extend(object.permission_set, {[json.name]: json})
-        // getDataSource(object.datasource).setObjectPermission(objectName, json);
-    } else {
-        addLazyLoad(objectName, json);
-    }
-}
-
-export const loadObjectPermissions = async function (filePath: string, serviceName: string){
-    let permissions = util.loadPermissions(filePath);
-    permissions.forEach(permission => {
-        addPermissionConfig(permission.object_name, permission);
-    });
-    if(serviceName)
-        for await (const permission of permissions) {
-            const { field_permissions } = permission;
-            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}`,
-                        "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,
-                    })
-                }
-            }
-        }
-}

package/src/dynamic-load/permissionset.ts

@@ -1,78 +0,0 @@
-import { SteedosPermissionsetTypeConfig } from '../ts-types';
-import { getSteedosSchema } from '../types/schema';
-var util = require('../util');
-var clone = require('clone');
-var _ = require('underscore');
-const PERMISSIONS = {
-  allowEdit: false,
-  allowDelete: false,
-  allowRead: true,
-};
-
-const BASERECORD = {
-  is_system: true,
-  type: "permission_set",
-  record_permissions: PERMISSIONS
-};
-
-const STANDARD_PERMISSIONSETS = {
-    none: {_id: 'none', name: 'none', label: 'none', license: '', ...BASERECORD}
-}
-
-const getStandardpPermissionset = function(name){
-    return getStandardpPermissionsets()[name];
-}
-
-const getStandardpPermissionsets = function(){
-    return clone(STANDARD_PERMISSIONSETS);
-}
-
-// const PERMISSION_SET_KEY = 'STANDARD_PERMISSION_SETS';
-
-const addPermissionset = async function(json: SteedosPermissionsetTypeConfig, serviceName: string){
-    if(!json.name){
-        throw new Error('missing attribute name: ' + (json as any)?.__filename)
-    }
-    let permissionsetConfig = null;
-
-    if(_.include(_.keys(STANDARD_PERMISSIONSETS), json.name)){
-        permissionsetConfig = Object.assign({}, getStandardpPermissionset(json.name), json, clone(BASERECORD))
-    }else{
-        permissionsetConfig = Object.assign({}, json, clone(BASERECORD))
-    }
-    const schema = getSteedosSchema();
-    await schema.metadataRegister?.addPermissionset(serviceName, permissionsetConfig);
-}
-
-export const loadStandardPermissionsets = async function(serviceName: string){
-    const schema = getSteedosSchema();
-    const keys = _.keys(STANDARD_PERMISSIONSETS);
-    for (const key of keys) {
-        const standardPermissionset = STANDARD_PERMISSIONSETS[key];
-        await schema.metadataRegister.addPermissionset(serviceName, standardPermissionset);
-    }
-}
-
-export const loadSourcePermissionset = async function (filePath: string, serviceName: string){
-    let permissionsets = util.loadPermissionsets(filePath)
-    for (const permissionset of permissionsets) {
-        await addPermissionset(permissionset, serviceName);
-     }
-}
-
-export const getSourcePermissionset = async function(name){
-    const schema = getSteedosSchema();
-    const permissionset = await schema.metadataRegister.getPermissionset(name);
-    return permissionset?.metadata
-}
-
-export const getSourcePermissionsetKeys = async function(){
-    const permissionsets = await getSourcePermissionsets();
-    return _.pluck(permissionsets, 'name');
-}
-
-export const getSourcePermissionsets = async function(){
-    const schema = getSteedosSchema();
-    const permissionsets = await schema.metadataRegister.getPermissionsets();
-    return  permissionsets ? _.pluck(permissionsets, 'metadata') : [];
-}