@steedos/objectql 2.2.51-beta.1 → 2.2.51-beta.2

package/src/types/report.ts

@@ -1,128 +0,0 @@
-import { JsonMap } from '@salesforce/ts-types';
-import { SteedosQueryFilters, addConfigFiles, addConfig, getConfigs, getConfig } from '.';
-import { SteedosDataSourceType } from '.';
-
-export const LOADED_REPORTS_CONFIGS: Array<SteedosReportTypeConfig> = [];
-
-export type SteedosReportTypeConfig = {
-    _id: string,
-    name: string,
-    object_name: string,
-    fields: Array<string>,
-    filters: SteedosQueryFilters,
-    description: string,
-    mrt_file: string,
-    graphql: string
-}
-
-export class SteedosReportType{
-    private _datasource: SteedosDataSourceType;
-    public get datasource(): SteedosDataSourceType {
-        return this._datasource;
-    }
-
-    private __id: string;
-    public get _id(): string {
-        return this.__id;
-    }
-    public set _id(value: string) {
-        this.__id = value;
-    }
-
-    private _name: string;
-    public get name(): string {
-        return this._name;
-    }
-    public set name(value: string) {
-        this._name = value;
-    }
-
-    private _object_name: string;
-    public get object_name(): string {
-        return this._object_name;
-    }
-    public set object_name(value: string) {
-        this._object_name = value;
-    }
-
-    private _fields: Array<string>;
-    public get fields(): Array<string> {
-        return this._fields;
-    }
-    public set fields(value: Array<string>) {
-        this._fields = value;
-    }
-
-    private _filters: SteedosQueryFilters;
-    public get filters(): SteedosQueryFilters {
-        return this._filters;
-    }
-    public set filters(value: SteedosQueryFilters) {
-        this._filters = value;
-    }
-
-    private _description: string;
-    public get description(): string {
-        return this._description;
-    }
-    public set description(value: string) {
-        this._description = value;
-    }
-
-    private _mrt_file: string;
-    public get mrt_file(): string {
-        return this._mrt_file;
-    }
-    public set mrt_file(value: string) {
-        this._mrt_file = value;
-    }
-
-    private _graphql: string;
-    public get graphql(): string {
-        return this._graphql;
-    }
-    public set graphql(value: string) {
-        this._graphql = value;
-    }
-    
-    constructor(config: SteedosReportTypeConfig, datasource: SteedosDataSourceType){
-        this._datasource = datasource
-        this._id = config._id
-        this.name = config.name
-        this.object_name = config.object_name
-        this.fields = config.fields
-        this.filters = config.filters
-        this.description = config.description
-        this.mrt_file = config.mrt_file
-        this.graphql = config.graphql
-    }
-
-    toConfig(){
-        let config:JsonMap = {}
-        config._id = this._id
-        config.name = this.name
-        config.object_name = this.object_name
-        config.fields = this.fields
-        config.filters = this.filters
-        config.description = this.description
-        config.mrt_file = this.mrt_file
-        config.graphql = this.graphql
-        return config
-    }
-}
-
-export function addReportConfigFiles(filePath: string){
-    addConfigFiles('report', filePath);
-}
-
-export const addReportConfig = (appConfig: SteedosReportTypeConfig) => {
-    addConfig('report', appConfig);
-}
-
-export const getReportConfigs = () => {
-    return getConfigs('report')
-}
-
-export const getReportConfig = (_id: string):SteedosReportTypeConfig => {
-    return getConfig('report', _id);
-}

package/src/types/restrictionRule.ts

@@ -1,57 +0,0 @@
-import { registerRestrictionRules } from '../metadata-register/restrictionRules';
-import { getSteedosSchema } from '../types'
-import * as _ from 'lodash'
-import { isExpression, parseSingleExpression } from '../util'
-import { formatFiltersToODataQuery } from "@steedos/filters";
-
-export type SteedosRestrictionRuleConfig = {
-    _id: string,
-    name: string,
-    object_name: string,
-    active: boolean,
-    record_filter: string,
-    entry_criteria: string,
-    description: string
-}
-
-export class RestrictionRule {
-    static async find(objectApiName) {
-        const schema = getSteedosSchema();
-        return await registerRestrictionRules.find(schema.broker, {
-            pattern: `${objectApiName}.*`
-        })
-    }
-    static async getUserObjectFilters(objectApiName, userSession: any) {
-        const rules = await this.find(objectApiName);
-        if (_.isEmpty(rules)) {
-            return;
-        }
-        const rulesFilters = [];
-        const globalData = { now: new Date() };
-        _.each(rules, (rule) => {
-            const { active, entry_criteria, record_filter } = rule.metadata;
-            if (active) {
-                if (_.isString(entry_criteria) && isExpression(entry_criteria.trim())) {
-                    try {
-                        const meetCriteria = parseSingleExpression(entry_criteria, {}, "#", globalData, userSession);
-                        if (_.isBoolean(meetCriteria) && meetCriteria) {
-                            if (_.isString(record_filter) && isExpression(record_filter.trim())) {
-                                try {
-                                    const filters = parseSingleExpression(record_filter, {}, "#", globalData, userSession);
-                                    if (filters && !_.isString(filters)) {
-                                        rulesFilters.push(`(${formatFiltersToODataQuery(filters, userSession)})`)
-                                    }
-                                } catch (error) {
-                                    console.error(`RestrictionRule.getUserObjectFilters record_filter error`, objectApiName, record_filter, error.message);
-                                }
-                            }
-                        }
-                    } catch (error) {
-                        console.error(`RestrictionRule.getUserObjectFilters entry_criteria error`, objectApiName, entry_criteria, error.message);
-                    }
-                }
-            }
-        })
-        return rulesFilters;
-    }
-}

package/src/types/schema.ts

@@ -1,273 +0,0 @@
-import { Dictionary } from '@salesforce/ts-types';
-import { SteedosDataSourceType, SteedosDataSourceTypeConfig } from ".";
-import { isMeteor, getSteedosConfig } from "../util";
-// import { isMeteor, getSteedosConfig, wrapAsync } from "../util";
-import _ = require("underscore");
-import { getFromContainer } from 'typeorm';
-// import { loadCoreValidators } from '../validators';
-// import { loadStandardBaseObjects } from './object_dynamic_load';
-// import { preloadDBObjectFields, preloadDBObjectButtons } from '../dynamic-load';
-import { MetadataRegister } from '../metadata-register';
-import { MetadataDriver } from '../driver/metadata';
-
-
-const defaultDatasourceName = 'default';
-const meteorDatasourceName = 'meteor';
-
-export type SteedosSchemaConfig = {
-    datasources?: Dictionary<SteedosDataSourceTypeConfig>
-}
-
-export class SteedosSchema {
-    private _datasources: Dictionary<SteedosDataSourceType> = {};
-    private _objectsMap: Dictionary<{ datasourceName: string, filePath?: string }> = {};
-    private _broker: any = null;
-    private _metadataBroker: any = null;
-    metadataRegister: MetadataRegister = null;
-    metadataDriver = new MetadataDriver();
-    public get metadataBroker(): any {
-        return this._metadataBroker;
-    }
-    public set metadataBroker(value: any) {
-        this._metadataBroker = value;
-        this.metadataRegister = new MetadataRegister(this._metadataBroker);
-    }
-
-    public get broker(): any {
-        return this._broker;
-    }
-    public set broker(value: any) {
-        this._broker = value;
-    }
-
-    setObjectMap(objectName: string, options) {
-        let objectMap = this.getObjectMap(objectName);
-        if (objectMap) {
-            if (objectName != 'base' && objectName != 'core' && objectMap.datasourceName != options.datasourceName) {
-                console.log(`objectMap.datasourceName`, objectMap.datasourceName)
-                console.log(`options.datasourceName`, options.datasourceName)
-                throw new Error(`object name ${objectName} is unique, you can set table_name; see: https://developer.steedos.com/developer/object#%E5%AF%B9%E8%B1%A1%E5%90%8D-name`)
-            }
-        }
-        this._objectsMap[objectName] = options
-    }
-
-    getObjectMap(objectName: string) {
-        return this._objectsMap[objectName]
-    }
-
-    removeObjectMap(objectName: string) {
-        delete this._objectsMap[objectName]
-    }
-
-    addDataSourceFromSteedosConfig() {
-        let config: any = getSteedosConfig();
-        if (config && config.datasources) {
-            _.each(config.datasources, (datasource: any, datasource_name: string) => {
-                datasource = _.extend(datasource, datasource.connection)
-                if (datasource_name === 'default') {
-                    datasource.driver = "mongo"
-                } else if (datasource_name === meteorDatasourceName) {
-                    if (!isMeteor()) {
-                        throw new Error('not find Meteor, can not set datasource name is meteor')
-                    }
-                    datasource.driver = "meteor-mongo"
-                }
-                this.addDataSource(datasource_name, datasource);
-            })
-        }
-        this.addMeteorDatasource();
-    }
-
-    addMeteorDatasource(meteorDatasourceConfig?: SteedosDataSourceTypeConfig) {
-        if (!meteorDatasourceConfig) {
-            const steedosConfig = getSteedosConfig();
-            meteorDatasourceConfig = steedosConfig?.datasources?.meteor;
-            if (!meteorDatasourceConfig) {
-                meteorDatasourceConfig = steedosConfig?.datasources?.default;
-            }
-        }
-        if (meteorDatasourceConfig) {
-            if (isMeteor() && !this.getDataSource(meteorDatasourceName)) {
-                this.addDataSource(meteorDatasourceName, Object.assign({}, meteorDatasourceConfig, { driver: 'meteor-mongo' }));
-            }
-        }
-
-    }
-
-    constructor(config?: SteedosSchemaConfig) {
-
-        // loadCoreValidators();
-
-        // if (isMeteor())
-        //     loadStandardBaseObjects();  此代码无需运行，meteor package load 已加载。
-
-        if (config) {
-            _.each(config.datasources, (datasourceConfig, datasource_name) => {
-                this.addDataSource(datasource_name, datasourceConfig)
-            })
-        }
-        this.addDataSourceFromSteedosConfig();
-    }
-
-    /**
-     * 获取对象
-     * @param {string} name : {datacource_name}.{object_name} ，如果没有${datacource_name}部分，则默认为default
-     * @returns
-     * @memberof SteedosSchema
-     */
-    getObject(name: string) {
-        let datasource_name: string, object_name: string;
-        if (!name) {
-            throw new Error('Object name is required');
-        }
-        if (!name.split) {
-          return;
-        }
-        let args = name.split('.')
-        if (args.length == 1) {
-            object_name = name
-            let objectMap = this.getObjectMap(name);
-            if(!objectMap){
-                const services = require('../services');
-                return services.getObjectDispatcher(object_name)
-            }
-            datasource_name = objectMap.datasourceName
-        }
-        if (args.length > 1) {
-            datasource_name = args[0]
-            object_name = _.rest(args).join('.')
-        }
-
-        let datasource = this.getDataSource(datasource_name)
-
-        if (!datasource) {
-            throw new Error(`not find datasource ${datasource_name}`);
-        }
-
-        return datasource.getObject(object_name)
-    }
-
-    getLocalObject(name: string) {
-        let datasource_name: string, object_name: string;
-        if (!name) {
-            throw new Error('Object name is required');
-        }
-        let args = name.split('.')
-        if (args.length == 1) {
-            object_name = name
-            let objectMap = this.getObjectMap(name);
-            if (!objectMap) {
-                throw new Error(`not find object ${name}`);
-            }
-            datasource_name = objectMap.datasourceName
-        }
-        if (args.length > 1) {
-            datasource_name = args[0]
-            object_name = _.rest(args).join('.')
-        }
-
-        let datasource = this.getDataSource(datasource_name)
-
-        if (!datasource) {
-            throw new Error(`not find datasource ${datasource_name}`);
-        }
-
-        return datasource.getLocalObject(object_name)
-    }
-
-    addDataSource(datasource_name: string, datasourceConfig: SteedosDataSourceTypeConfig, readd?: boolean) {
-        if (this._datasources[datasource_name] && !readd) {
-            throw new Error(`datasource ${datasource_name} existed`);
-        }
-        let datasource = new SteedosDataSourceType(datasource_name, datasourceConfig, this)
-        this._datasources[datasource_name] = datasource
-        return datasource;
-    }
-
-    async removeDataSource(datasource_name) {
-        if (datasource_name != defaultDatasourceName && datasource_name != meteorDatasourceName) {
-            let datasource = this._datasources[datasource_name];
-            if (datasource) {
-                delete this._datasources[datasource_name];
-                let self = this;
-                _.each(this._objectsMap, function (map, key) {
-                    if (map && map.datasourceName === datasource_name) {
-                        self.removeObjectMap(key);
-                    }
-                })
-                await datasource.close();
-            }
-        } else {
-            throw new Error('Can not remove default datasource');
-        }
-    }
-
-    /**
-     * 转换对象的引用
-     * 包括：app.objects 及 object 的字段有 reference_to 属性的
-     * @private
-     * @param {SteedosDataSourceType} datasource
-     * @memberof SteedosSchema
-     * TODO 处理reference_to 为function的情况
-     */
-    async transformReferenceOfObject(datasource: SteedosDataSourceType): Promise<void> {
-        let objects = await datasource.getObjects();
-        _.each(objects, (object, object_name) => {
-            _.each(object.fields, (field, field_name) => {
-                field.transformReferenceOfObject()
-            })
-        })
-    }
-
-    getDataSource(datasource_name: string = meteorDatasourceName) {
-        return this._datasources[datasource_name]
-    }
-
-    getDataSources() {
-        return this._datasources
-    }
-
-    async getAllObject() {
-        let schemaObjects = [];
-        const datasources = this.getDataSources();
-        for (const name in datasources) {
-            const datasource = datasources[name]
-            const datasourceObjects = await datasource.getObjects();
-            if (datasourceObjects && datasourceObjects.length > 0) {
-                schemaObjects = schemaObjects.concat(datasourceObjects);
-            }
-        }
-        return schemaObjects;
-        // return await this.metadataBroker.call("objects.getAll");
-    }
-
-    async getAllRelationsInfo(){
-        return await this.broker.call('objects.getAllRelationsInfo');
-    }
-}
-
-export function getSteedosSchema(broker?: any, metadataBroker?: any): SteedosSchema {
-    const schema = getFromContainer(SteedosSchema);
-    if (broker) {
-        schema.broker = broker;
-    }
-    if (metadataBroker || broker) {
-        schema.metadataBroker = metadataBroker || broker;
-    }
-
-
-    // if(broker || metadataBroker){
-    //     loadStandardProfiles();
-    //     loadStandardPermissionsets();
-    // }
-
-    return schema;
-}
-
-export function getAllRelationsInfo(schema?: SteedosSchema) {
-    return (schema ? schema : getSteedosSchema()).getAllRelationsInfo();
-}
-
-(function loadRun() {
-})();

package/src/types/shareRule.ts

@@ -1,57 +0,0 @@
-import { registerShareRules } from '../metadata-register/shareRules';
-import { getSteedosSchema } from '../types'
-import * as _ from 'lodash'
-import { isExpression, parseSingleExpression } from '../util'
-import { formatFiltersToODataQuery } from "@steedos/filters";
-
-export type SteedosShareRuleConfig = {
-    _id: string,
-    name: string,
-    object_name: string,
-    active: boolean,
-    record_filter: string,
-    entry_criteria: string,
-    description: string
-}
-
-export class ShareRules {
-    static async find(objectApiName) {
-        const schema = getSteedosSchema();
-        return await registerShareRules.find(schema.broker, {
-            pattern: `${objectApiName}.*`
-        })
-    }
-    static async getUserObjectFilters(objectApiName, userSession: any) {
-        const rules = await this.find(objectApiName);
-        if (_.isEmpty(rules)) {
-            return;
-        }
-        const rulesFilters = [];
-        const globalData = { now: new Date() };
-        _.each(rules, (rule) => {
-            const { active, entry_criteria, record_filter } = rule.metadata;
-            if (active) {
-                if (_.isString(entry_criteria) && isExpression(entry_criteria.trim())) {
-                    try {
-                        const meetCriteria = parseSingleExpression(entry_criteria, {}, "#", globalData, userSession);
-                        if (_.isBoolean(meetCriteria) && meetCriteria) {
-                            if (_.isString(record_filter) && isExpression(record_filter.trim())) {
-                                try {
-                                    const filters = parseSingleExpression(record_filter, {}, "#", globalData, userSession);
-                                    if (filters && !_.isString(filters)) {
-                                        rulesFilters.push(`(${formatFiltersToODataQuery(filters, userSession)})`)
-                                    }
-                                } catch (error) {
-                                    console.error(`ShareRules.getUserObjectFilters record_filter error`, objectApiName, record_filter, error.message);
-                                }
-                            }
-                        }
-                    } catch (error) {
-                        console.error(`ShareRules.getUserObjectFilters entry_criteria error`, objectApiName, entry_criteria, error.message);
-                    }
-                }
-            }
-        })
-        return rulesFilters;
-    }
-}

package/src/types/trigger.ts

@@ -1,88 +0,0 @@
-import { Dictionary, JsonMap } from "@salesforce/ts-types";
-
-import _ = require('underscore')
-import { SteedosIDType } from "./field_types";
-import { SteedosQueryOptions } from ".";
-
-export type SteedosTriggerContextConfig = {
-    id?: SteedosIDType,
-    userId: SteedosIDType,
-    spaceId?: SteedosIDType,
-    doc?: JsonMap,
-    previousDoc?: JsonMap,  //仅afterUpdate, afterDelete时存在此属性
-    query?: SteedosQueryOptions,
-    data?: JsonMap //仅afterFind，afterCount时存在此属性
-    objectName?: string
-}
-
-export type SteedosTriggerTypeConfig = {
-    name: string,
-    on?: string,
-    when: string,
-    todo: Function
-}
-
-const ENUM_ON = ["client","server"]
-const ENUM_WHEN = ['beforeFind','beforeInsert','beforeUpdate','beforeDelete','afterFind','afterCount','afterFindOne','afterInsert','afterUpdate','afterDelete', 'beforeAggregate', 'afterAggregate']
-
-export class SteedosTriggerType implements Dictionary {
-    [key: string]: unknown;
-    private _name: string;
-
-    private _on: string;
-
-    private _when: string;
-
-    private _todo: Function;
-
-    constructor(config: SteedosTriggerTypeConfig) {
-        this.name = config.name
-        this.on = config.on
-        this.when = config.when
-        this.todo = config.todo
-    }
-
-    toConfig(){
-        let config = {
-            on: this.on,
-            when: this.when,
-            todo: this.todo
-        }
-        return config;
-    }
-
-    public get name(): string {
-        return this._name;
-    }
-    public set name(value: string) {
-        if(!value)
-            throw new Error("You must specify name for this trigger.")
-        this._name = value;
-    }
-
-    public get on(): string {
-        return this._on;
-    }
-    public set on(value: string) {
-        if(!_.contains(ENUM_ON, value))
-            throw new Error(`on must be a ${ENUM_ON.join(' or ')}.`)
-        this._on = value;
-    }
-
-    public get when(): string {
-        return this._when;
-    }
-
-    public set when(value: string) {
-        if(!_.contains(ENUM_WHEN, value))
-            throw new Error(`on must be a ${ENUM_WHEN.join(' or ')}.`)
-        this._when = value;
-    }
-
-    public get todo(): Function {
-        return this._todo;
-    }
-    public set todo(value: Function) {
-        this._todo = value;
-    }
-}

package/src/types/userSession.ts

@@ -1,45 +0,0 @@
-import { SteedosIDType } from ".";
-
-export type SteedosUserSessionSpace = {
-    _id: string,
-    name: string
-}
-
-export type SteedosUserSessionCompany = {
-    _id: string,
-    name: string
-}
-
-export type SteedosUserSessionOrganization = {
-    _id: string,
-    name: string,
-    fullname: string
-}
-
-export type SteedosUserSessionPermissionShares = {
-    _id: string,
-    object_name: string
-}
-
-export type SteedosUserSession = {
-    userId: SteedosIDType,
-    spaceId?: string,
-    name: string,
-    username?: string,
-    mobile?: string,
-    email?: string,
-    utcOffset?: number,
-    locale?: string,
-    roles?: string[],
-    space?: SteedosUserSessionSpace,
-    spaces?: SteedosUserSessionSpace[],
-    company?: SteedosUserSessionCompany,
-    companies?: SteedosUserSessionCompany[],
-    organization?: SteedosUserSessionOrganization,
-    organizations?: SteedosUserSessionOrganization[],
-    permission_shares?: SteedosUserSessionPermissionShares[],
-    company_id?: string,
-    company_ids?: string[],
-    is_space_admin?: boolean,
-    steedos_id?: string
-}

package/src/types/validation_rules.ts

@@ -1,29 +0,0 @@
-/*
- * @Author: sunhaolin@hotoa.com
- * @Date: 2021-05-24 12:32:57
- * @Description: 
- */
-
-import { computeFormula } from '../formula';
-import { SteedosTriggerContextConfig } from "./trigger";
-import { SteedosUserSession, getObject } from ".";
-
-export async function runValidationRules(method: string, context: SteedosTriggerContextConfig, objectName: string, userSession: SteedosUserSession) {
-    if ((method === 'insert' || method === 'update') && userSession) {
-        let spaceId = userSession.spaceId;
-        let userId = userSession.userId + '';
-        let doc = context.doc;
-        let validationRules = await getObject('object_validation_rules').find({ filters: [['object_name', '=', objectName], ['active', '=', true]] });
-        for (const vr of validationRules) {
-            let result;
-            try {
-                result = await computeFormula(vr.error_condition_formula, objectName, doc, userId, spaceId);
-            } catch (error) {
-                throw new Error(`公式错误，请检查错误条件公式。${error.message.replace(/\:/g, '：')}`);
-            }
-            if (result) {
-                throw new Error(vr.error_message);
-            }
-        }
-    }
-}