midway-fatcms 0.0.1-beta.1

package/dist/service/curd/CurdMixUtils.js

@@ -0,0 +1,201 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RelatedType = exports.CrudMixUtils = void 0;
+const keys_1 = require("../../libs/crud-pro/models/keys");
+const MixinUtils_1 = require("../../libs/crud-pro/utils/MixinUtils");
+const _ = require("lodash");
+const functions_1 = require("../../libs/utils/functions");
+var RelatedType;
+(function (RelatedType) {
+    RelatedType["dict"] = "dict";
+    RelatedType["sysCfgEnum"] = "sysCfgEnum";
+    RelatedType["linkToCustom"] = "linkToCustom";
+    RelatedType["accountBasic"] = "accountBasic";
+    RelatedType["workbenchBasic"] = "workbenchBasic";
+})(RelatedType || (RelatedType = {}));
+exports.RelatedType = RelatedType;
+const { isNotEmpty } = MixinUtils_1.MixinUtils;
+function getColumnsRelationAll(sqlCfg, cfgModel) {
+    if (sqlCfg && Array.isArray(sqlCfg.columnsRelation) && sqlCfg.columnsRelation.length > 0) {
+        return sqlCfg.columnsRelation;
+    }
+    if (cfgModel && Array.isArray(cfgModel.columnsRelation) && cfgModel.columnsRelation.length > 0) {
+        return cfgModel.columnsRelation;
+    }
+    return [];
+}
+function copyBySingleSourceValue(row, sourceValue, targetColumns, getValue) {
+    // const codeObject = map.get(sourceValue);
+    const codeObject = getValue(sourceValue);
+    if (typeof codeObject === 'undefined' || codeObject === null) {
+        return;
+    }
+    if (Array.isArray(targetColumns)) {
+        for (let i = 0; i < targetColumns.length; i++) {
+            const targetColumn = targetColumns[i];
+            const toStr = targetColumn.to.replace('[$ARRAY_INDEX]', ``);
+            if (targetColumn.from === "*") {
+                _.set(row, toStr, codeObject);
+            }
+            else {
+                const dictAttrValue = _.get(codeObject, targetColumn.from);
+                if (typeof dictAttrValue !== "undefined" && dictAttrValue !== null) {
+                    _.set(row, toStr, dictAttrValue);
+                }
+            }
+        }
+    }
+}
+function copyByArraySourceValue(row, sourceValue, targetColumns, getValue) {
+    let isSetArray = false;
+    // 支持关联JSON数组
+    if (typeof sourceValue === 'string' && sourceValue.startsWith('[') && sourceValue.endsWith(']')) {
+        const codes = (0, functions_1.parseJsonObject)(sourceValue);
+        if (Array.isArray(codes)) {
+            for (let codeIndex = 0; codeIndex < codes.length; codeIndex++) {
+                const code = codes[codeIndex];
+                // const codeObject = map.get(code);
+                const codeObject = getValue(code);
+                if (codeObject) {
+                    if (Array.isArray(targetColumns)) {
+                        for (let i = 0; i < targetColumns.length; i++) {
+                            const targetColumn = targetColumns[i];
+                            if (targetColumn.from === '*') {
+                                const toStr = targetColumn.to.replace('$ARRAY_INDEX', `${codeIndex}`);
+                                _.set(row, toStr, codeObject);
+                                isSetArray = true;
+                            }
+                            else {
+                                const dictAttrValue = _.get(codeObject, targetColumn.from);
+                                if (typeof dictAttrValue !== "undefined" && dictAttrValue !== null) {
+                                    const toStr = targetColumn.to.replace('$ARRAY_INDEX', `${codeIndex}`);
+                                    _.set(row, toStr, dictAttrValue);
+                                    isSetArray = true;
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+    return isSetArray;
+}
+class CrudMixUtils {
+    constructor(relatedType) {
+        this.relatedType = relatedType;
+    }
+    getColumnsRelation(sqlCfg, cfgModel) {
+        const ss = getColumnsRelationAll(sqlCfg, cfgModel);
+        const relatedType = this.relatedType;
+        return ss.filter(s => s.relatedType === relatedType);
+    }
+    pickColumnRelations(exeCtx) {
+        const relationResult = [];
+        const cfgModel = exeCtx.getCfgModel();
+        const sqlModels = exeCtx.getSqlCfgModels();
+        if (Array.isArray(sqlModels) && sqlModels.length > 0) {
+            for (let i = 0; i < sqlModels.length; i++) {
+                const sqlModel = sqlModels[i];
+                // 只有Select语句需要
+                if (sqlModel && sqlModel.getCrudType() === keys_1.KeyOfCrudTypes.SELECT) {
+                    const columnsRelation = this.getColumnsRelation(sqlModel, cfgModel);
+                    for (let j = 0; j < columnsRelation.length; j++) {
+                        const relation = columnsRelation[j];
+                        if (relation.relatedType === this.relatedType) {
+                            relationResult.push(relation);
+                        }
+                    }
+                }
+            }
+        }
+        return _.uniqBy(relationResult, (obj) => {
+            return `${obj.relatedCode}_${obj.relatedType}_${obj.sourceColumn}_${JSON.stringify(obj.targetColumns)}`;
+        });
+    }
+    pickColumnRelationCodes(exeCtx) {
+        const relationResult = this.pickColumnRelations(exeCtx);
+        const codes = relationResult.map(e => e.relatedCode);
+        if (!codes || codes.length === 0) {
+            return [];
+        }
+        return [...new Set(codes)]; // 去重
+    }
+    forEachRowAndColumnsRelation(exeCtx, func) {
+        const sqlCfgList = exeCtx.getSqlCfgModels();
+        const resModel = exeCtx.getResModel();
+        const cfgModel = exeCtx.getCfgModel();
+        const forEachColumnsRelation = (row, columnsRelation) => {
+            for (let i = 0; i < columnsRelation.length; i++) {
+                func(row, columnsRelation[i]);
+            }
+        };
+        for (let i = 0; i < sqlCfgList.length; i++) {
+            const sqlCfg = sqlCfgList[i];
+            // 只有Select语句需要
+            if (sqlCfg && sqlCfg.getCrudType() === keys_1.KeyOfCrudTypes.SELECT) {
+                const columnsRelation = this.getColumnsRelation(sqlCfg, cfgModel);
+                if (isNotEmpty(columnsRelation)) {
+                    const resValue = resModel[sqlCfg.resName];
+                    if (Array.isArray(resValue) && isNotEmpty(resValue)) {
+                        // 多行查询时
+                        for (const row of resValue) {
+                            forEachColumnsRelation(row, columnsRelation);
+                        }
+                    }
+                    else if (typeof resValue === 'object' && isNotEmpty(resValue)) {
+                        // 单行查询时
+                        forEachColumnsRelation(resValue, columnsRelation);
+                    }
+                }
+            }
+        }
+    }
+    copyColumnRelationToRow(row, multiKeyMap, columnRelation) {
+        const { relatedCode, sourceColumn, targetColumns } = columnRelation;
+        if (!sourceColumn || !targetColumns) {
+            return;
+        }
+        const sourceValue = _.get(row, sourceColumn);
+        if (typeof sourceValue === 'undefined' || sourceValue === null) {
+            return;
+        }
+        const getValue = (code) => {
+            return multiKeyMap.getValue(relatedCode, code);
+        };
+        const isSetArray = copyByArraySourceValue(row, sourceValue, targetColumns, getValue);
+        if (!isSetArray) {
+            copyBySingleSourceValue(row, sourceValue, targetColumns, getValue);
+        }
+    }
+    /**
+     * 无relatedCode模式
+     * @param row
+     * @param map
+     * @param columnRelation
+     */
+    copyColumnRelationToRowNoRelatedCode(row, map, columnRelation) {
+        const { sourceColumn, targetColumns } = columnRelation;
+        if (!sourceColumn || !targetColumns) {
+            return;
+        }
+        const sourceValue = _.get(row, sourceColumn);
+        if (!sourceValue) {
+            return;
+        }
+        const getValue = (code) => {
+            if (!map) {
+                return null;
+            }
+            if (typeof map.get === "function") {
+                return map.get(`${code}`);
+            }
+            return map[code];
+        };
+        const isSetArray = copyByArraySourceValue(row, sourceValue, targetColumns, getValue);
+        if (!isSetArray) {
+            copyBySingleSourceValue(row, sourceValue, targetColumns, getValue);
+        }
+    }
+}
+exports.CrudMixUtils = CrudMixUtils;

package/dist/service/curd/CurdProService.d.ts

@@ -0,0 +1,39 @@
+import { Context } from '@midwayjs/koa';
+import { IRequestCfgModel, IRequestModel, ISqlCfgModel } from '../../libs/crud-pro/interfaces';
+import { SqlDbType } from '../../libs/crud-pro/models/keys';
+import { ExecuteContext, IExecuteContextHandler } from '../../libs/crud-pro/models/ExecuteContext';
+import { RelatedType } from './CurdMixUtils';
+import { BaseService } from '../base/BaseService';
+import { IRequestCfgModel2 } from '../../models/bizmodels';
+export declare class DBUtils {
+    private readonly sqlDatabase;
+    private readonly sqlDdType;
+    private readonly curdProService;
+    constructor(sqlDatabase: string, sqlDdType: SqlDbType, curdProService: CurdProService);
+    getOne(reqJson: IRequestModel, sqlTable: string): Promise<any>;
+    getList(reqJson: IRequestModel, sqlTable: string): Promise<any[]>;
+}
+export declare class CurdProService extends BaseService {
+    protected ctx: Context;
+    private mysql2Config;
+    private postgres2Config;
+    private sqlserver2Config;
+    private crudProCfg;
+    private responseCfgHandlers;
+    setResponseCfgHandlers(key: RelatedType, handler: IExecuteContextHandler): void;
+    /**
+     * Execute级别：每次调用都会产生新的
+     * @private
+     */
+    private getCrudPro;
+    /**
+     * 依赖缓存中与加载的配置
+     * @param reqJson
+     */
+    executeCrud(reqJson: IRequestModel): Promise<ExecuteContext>;
+    executeSQL(sqlCfgModel: ISqlCfgModel): Promise<any>;
+    executeCrudByCfg(reqJson: IRequestModel, cfgModel: IRequestCfgModel2): Promise<ExecuteContext>;
+    private applyStandardUpdateCfg;
+    getBbUtil(database: string, sqlDdType: SqlDbType): DBUtils;
+    getCachedCfgByMethod(method: string): Promise<IRequestCfgModel>;
+}

package/dist/service/curd/CurdProService.js

@@ -0,0 +1,322 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CurdProService = exports.DBUtils = void 0;
+const _ = require("lodash");
+const core_1 = require("@midwayjs/core");
+const CrudPro_1 = require("../../libs/crud-pro/CrudPro");
+const MySQLUtils_1 = require("../../libs/crud-pro/utils/pool/MySQLUtils");
+const PostgresUtils_1 = require("../../libs/crud-pro/utils/pool/PostgresUtils");
+const SqlServerUtils_1 = require("../../libs/crud-pro/utils/pool/SqlServerUtils");
+const keys_1 = require("../../libs/crud-pro/models/keys");
+const exceptions_1 = require("../../libs/crud-pro/exceptions");
+const ExecuteContextFunc_1 = require("../../libs/crud-pro/models/ExecuteContextFunc");
+const BaseService_1 = require("../base/BaseService");
+const bizmodels_1 = require("../../models/bizmodels");
+function toVisitor(ctx) {
+    const workbenchInfo = ctx.workbenchInfo;
+    const userSession = ctx.userSession;
+    if (!userSession || !userSession.isLogin()) {
+        return {
+            isLogin: false,
+            isSuperAdmin: false,
+            accountId: '0',
+            nickName: '匿名用户',
+            avatar: '',
+            accountType: '',
+            roleCodes: [],
+            functionCodes: [],
+            workbenchCode: (workbenchInfo === null || workbenchInfo === void 0 ? void 0 : workbenchInfo.workbench_code) || '',
+        };
+    }
+    const sessionInfo = userSession.getSessionInfo();
+    return {
+        isLogin: true,
+        isSuperAdmin: userSession.isSuperAdmin(),
+        accountId: sessionInfo.accountId,
+        nickName: sessionInfo.nickName,
+        avatar: sessionInfo.avatar,
+        accountType: sessionInfo.accountType,
+        roleCodes: sessionInfo.roleCodes || [],
+        functionCodes: sessionInfo.functionCodes || [],
+        workbenchCode: (workbenchInfo === null || workbenchInfo === void 0 ? void 0 : workbenchInfo.workbench_code) || '',
+    };
+}
+class MyContextFunc extends ExecuteContextFunc_1.BaseExecuteContextFunc {
+    constructor(cfgMap, responseCfgHandlers) {
+        super();
+        const { mysql2Config, postgres2Config, sqlserver2Config } = cfgMap;
+        this.mysql2Config = mysql2Config;
+        this.postgres2Config = postgres2Config;
+        this.sqlserver2Config = sqlserver2Config;
+        this.responseCfgHandlers = responseCfgHandlers;
+    }
+    async getConnectionPool(sqlCfgModel) {
+        if (!sqlCfgModel.sqlDatabase) {
+            console.error('查询语句中未指定数据库', sqlCfgModel.executeSql);
+            throw new exceptions_1.CommonException(exceptions_1.Exceptions.DB_QUERY_PARAM_EMPTY, '查询语句中未指定数据库');
+        }
+        const dataBaseName = sqlCfgModel.sqlDatabase;
+        const sqlDdType = sqlCfgModel.sqlDdType;
+        if (sqlDdType === keys_1.SqlDbType.postgres) {
+            const dbConfig = _.get(this.postgres2Config, dataBaseName);
+            if (!dbConfig) {
+                throw new exceptions_1.CommonException(exceptions_1.Exceptions.DB_NOT_FOUND, 'postgres配置中不存在此数据库:' + dataBaseName);
+            }
+            return (0, PostgresUtils_1.getConnectionPool)(dataBaseName, dbConfig);
+        }
+        if (sqlDdType === keys_1.SqlDbType.sqlserver) {
+            const dbConfig = _.get(this.sqlserver2Config, dataBaseName);
+            if (!dbConfig) {
+                throw new exceptions_1.CommonException(exceptions_1.Exceptions.DB_NOT_FOUND, 'sqlserver配置中不存在此数据库:' + dataBaseName);
+            }
+            return (0, SqlServerUtils_1.getConnectionPool)(dataBaseName, dbConfig);
+        }
+        const dbConfig = _.get(this.mysql2Config, dataBaseName);
+        if (!dbConfig) {
+            throw new exceptions_1.CommonException(exceptions_1.Exceptions.DB_NOT_FOUND, 'MySQL配置中不存在此数据库:' + dataBaseName);
+        }
+        return (0, MySQLUtils_1.getConnectionPool)(dataBaseName, dbConfig);
+    }
+    async afterExecuteSQLList() {
+        const exeCtx = this.getExecuteContext();
+        const handlers = Object.values(this.responseCfgHandlers);
+        for (let i = 0; i < handlers.length; i++) {
+            const handler = handlers[i];
+            await handler.handleExecuteContextPrepare(exeCtx);
+            await handler.handleExecuteContext(exeCtx);
+        }
+        return null;
+    }
+}
+class DBUtils {
+    constructor(sqlDatabase, sqlDdType, curdProService) {
+        this.sqlDatabase = sqlDatabase;
+        this.sqlDdType = sqlDdType;
+        this.curdProService = curdProService;
+    }
+    async getOne(reqJson, sqlTable) {
+        const cfgModel = {
+            sqlTable,
+            sqlSimpleName: keys_1.KeysOfSimpleSQL.SIMPLE_QUERY_ONE,
+            sqlDatabase: this.sqlDatabase,
+            sqlDdType: this.sqlDdType,
+            updateCfg: {},
+        };
+        const res = await this.curdProService.executeCrudByCfg(reqJson, cfgModel);
+        return res.getOneObj();
+    }
+    async getList(reqJson, sqlTable) {
+        const cfgModel = {
+            sqlTable,
+            sqlSimpleName: keys_1.KeysOfSimpleSQL.SIMPLE_QUERY,
+            sqlDatabase: this.sqlDatabase,
+            sqlDdType: this.sqlDdType,
+            updateCfg: {},
+        };
+        const res = await this.curdProService.executeCrudByCfg(reqJson, cfgModel);
+        return res.getResRows();
+    }
+}
+exports.DBUtils = DBUtils;
+function isSimpleQuery(sqlSimpleName) {
+    return sqlSimpleName === keys_1.KeysOfSimpleSQL.SIMPLE_QUERY ||
+        sqlSimpleName === keys_1.KeysOfSimpleSQL.SIMPLE_QUERY_COUNT ||
+        sqlSimpleName === keys_1.KeysOfSimpleSQL.SIMPLE_QUERY_PAGE ||
+        sqlSimpleName === keys_1.KeysOfSimpleSQL.SIMPLE_QUERY_ONE;
+}
+let CurdProService = class CurdProService extends BaseService_1.BaseService {
+    constructor() {
+        super(...arguments);
+        this.responseCfgHandlers = {};
+    }
+    setResponseCfgHandlers(key, handler) {
+        this.responseCfgHandlers[key] = handler;
+    }
+    /**
+     * Execute级别：每次调用都会产生新的
+     * @private
+     */
+    getCrudPro() {
+        const visitor = toVisitor(this.ctx);
+        this.logInfo('visitor', JSON.stringify(visitor));
+        const crudPro = new CrudPro_1.CrudPro();
+        crudPro.transaction = this.ctx.transaction;
+        crudPro.logger = this.getContextLogger();
+        crudPro.visitor = visitor;
+        crudPro.contextCfg = this.crudProCfg;
+        crudPro.contextFunc = new MyContextFunc({
+            mysql2Config: this.mysql2Config,
+            postgres2Config: this.postgres2Config,
+            sqlserver2Config: this.sqlserver2Config
+        }, this.responseCfgHandlers);
+        return crudPro;
+    }
+    /**
+     * 依赖缓存中与加载的配置
+     * @param reqJson
+     */
+    async executeCrud(reqJson) {
+        if (!reqJson.method) {
+            throw new Error('Method not implemented');
+        }
+        const curdPro = this.getCrudPro();
+        // 开发环境不使用缓存
+        const isEnableCache = !this.isEnableDebug();
+        return curdPro.executeCrud(reqJson, isEnableCache);
+    }
+    // 直接执行一个SQL
+    async executeSQL(sqlCfgModel) {
+        const curdPro = this.getCrudPro();
+        return curdPro.executeSQL(sqlCfgModel);
+    }
+    // 直接执行一个请求
+    async executeCrudByCfg(reqJson, cfgModel) {
+        this.logInfo('executeCrudByCfg', cfgModel);
+        if (!cfgModel.method) {
+            const req = this.ctx.req;
+            if (req) {
+                cfgModel.method = `${req.method}:${req.url}`;
+            }
+            else {
+                cfgModel.method = 'anonymous';
+            }
+        }
+        if (!cfgModel.updateCfg) {
+            cfgModel.updateCfg = {};
+        }
+        // 应用标准的updateCfg
+        this.applyStandardUpdateCfg(cfgModel);
+        const curdPro = this.getCrudPro();
+        return await curdPro.executeCrudByCfg(reqJson, cfgModel);
+    }
+    applyStandardUpdateCfg(cfgModel) {
+        const sqlSimpleName = cfgModel.sqlSimpleName;
+        const enableStandardUpdateCfg = cfgModel.enableStandardUpdateCfg; // 用于设置data字段
+        const enableStandardUpdateCfgCondition = cfgModel.enableStandardUpdateCfgCondition; // 用于设置condition字段
+        // 彻底关闭
+        if (enableStandardUpdateCfg === false) {
+            return;
+        }
+        const getDataCfgArray = () => {
+            // 明确有配置
+            if (Array.isArray(enableStandardUpdateCfg)) {
+                if (enableStandardUpdateCfg.includes('null')) {
+                    return [];
+                }
+                return enableStandardUpdateCfg;
+            }
+            // update 、insert 添加 by
+            return ['by']; // 创建/修改语句默认添加by
+        };
+        const getConditionCfgArray = () => {
+            // 明确有配置
+            if (Array.isArray(enableStandardUpdateCfgCondition)) {
+                if (enableStandardUpdateCfgCondition.includes('null')) {
+                    return [];
+                }
+                return enableStandardUpdateCfgCondition;
+            }
+            return [];
+        };
+        const dataCfgArray = getDataCfgArray();
+        const conditionCfgArray = getConditionCfgArray();
+        const mapping = {
+            'condition.created_by': { contextAsString: bizmodels_1.CTX_VISITOR_ID },
+            'condition.created_account_type': { contextAsString: bizmodels_1.CTX_VISITOR_ACCOUNT_TYPE },
+            'data.created_by': { contextAsString: bizmodels_1.CTX_VISITOR_ID },
+            'data.created_avatar': { contextAsString: bizmodels_1.CTX_VISITOR_AVATAR },
+            'data.created_nickname': { contextAsString: bizmodels_1.CTX_VISITOR_NICKNAME },
+            'data.created_account_type': { contextAsString: bizmodels_1.CTX_VISITOR_ACCOUNT_TYPE },
+            'data.modified_by': { contextAsString: bizmodels_1.CTX_VISITOR_ID },
+            'data.modified_avatar': { contextAsString: bizmodels_1.CTX_VISITOR_AVATAR },
+            'data.modified_nickname': { contextAsString: bizmodels_1.CTX_VISITOR_NICKNAME },
+            'data.modified_account_type': { contextAsString: bizmodels_1.CTX_VISITOR_ACCOUNT_TYPE },
+        };
+        const buildUpdateCfgBy = (cfgArray, prefix) => {
+            const obj = {};
+            if (Array.isArray(cfgArray)) {
+                for (let i = 0; i < cfgArray.length; i++) {
+                    const suffix = cfgArray[i];
+                    if (suffix) {
+                        const key = `${prefix}_${suffix}`;
+                        obj[key] = mapping[key];
+                    }
+                }
+            }
+            return obj;
+        };
+        // 查询语句
+        if (isSimpleQuery(sqlSimpleName)) {
+            const updateCfgObj = buildUpdateCfgBy(conditionCfgArray, 'condition.created'); // 查询用户本人创建的
+            Object.assign(cfgModel.updateCfg, updateCfgObj);
+        }
+        // 删除语句
+        if (sqlSimpleName === keys_1.KeysOfSimpleSQL.SIMPLE_DELETE) {
+            const updateCfgObj = buildUpdateCfgBy(conditionCfgArray, 'condition.created'); // 删除用户本人创建的
+            Object.assign(cfgModel.updateCfg, updateCfgObj);
+        }
+        // 插入语句
+        if (sqlSimpleName === keys_1.KeysOfSimpleSQL.SIMPLE_INSERT) {
+            const updateCfgObj1 = buildUpdateCfgBy(dataCfgArray, 'data.created');
+            Object.assign(cfgModel.updateCfg, updateCfgObj1);
+        }
+        // 更新语句
+        if (sqlSimpleName === keys_1.KeysOfSimpleSQL.SIMPLE_UPDATE) {
+            const updateCfgObj1 = buildUpdateCfgBy(dataCfgArray, 'data.modified');
+            const updateCfgObj2 = buildUpdateCfgBy(conditionCfgArray, 'condition.created'); // 更新用户本人创建的
+            Object.assign(cfgModel.updateCfg, updateCfgObj1);
+            Object.assign(cfgModel.updateCfg, updateCfgObj2);
+        }
+        // 插入或更新
+        if (sqlSimpleName === keys_1.KeysOfSimpleSQL.SIMPLE_INSERT_OR_UPDATE ||
+            sqlSimpleName === keys_1.KeysOfSimpleSQL.SIMPLE_INSERT_ON_DUPLICATE_UPDATE) {
+            const updateCfgObj1 = buildUpdateCfgBy(dataCfgArray, 'data.created');
+            const updateCfgObj2 = buildUpdateCfgBy(dataCfgArray, 'data.modified');
+            const updateCfgObj3 = buildUpdateCfgBy(conditionCfgArray, 'condition.created'); // 更新用户本人创建的
+            Object.assign(cfgModel.updateCfg, updateCfgObj1);
+            Object.assign(cfgModel.updateCfg, updateCfgObj2);
+            Object.assign(cfgModel.updateCfg, updateCfgObj3);
+        }
+    }
+    getBbUtil(database, sqlDdType) {
+        return new DBUtils(database, sqlDdType, this);
+    }
+    async getCachedCfgByMethod(method) {
+        const curdPro = this.getCrudPro();
+        const isEnableCache = !this.isEnableDebug(); // 开发环境不使用缓存
+        return curdPro.getCachedCfgByMethod(method, isEnableCache);
+    }
+};
+__decorate([
+    (0, core_1.Inject)(),
+    __metadata("design:type", Object)
+], CurdProService.prototype, "ctx", void 0);
+__decorate([
+    (0, core_1.Config)('mysql2'),
+    __metadata("design:type", Object)
+], CurdProService.prototype, "mysql2Config", void 0);
+__decorate([
+    (0, core_1.Config)('postgres2'),
+    __metadata("design:type", Object)
+], CurdProService.prototype, "postgres2Config", void 0);
+__decorate([
+    (0, core_1.Config)('sqlserver2'),
+    __metadata("design:type", Object)
+], CurdProService.prototype, "sqlserver2Config", void 0);
+__decorate([
+    (0, core_1.Config)('crudProCfg'),
+    __metadata("design:type", Object)
+], CurdProService.prototype, "crudProCfg", void 0);
+CurdProService = __decorate([
+    (0, core_1.Provide)()
+], CurdProService);
+exports.CurdProService = CurdProService;

package/dist/service/proxyapi/ProxyApiLoadService.d.ts

@@ -0,0 +1,21 @@
+import { Context } from '@midwayjs/koa';
+import { BaseService } from '../base/BaseService';
+import { RouteTrie } from './RouteTrie';
+import { IScheduleService } from '../../interface';
+/**
+ * 接口代理。 数据加载
+ */
+export declare class ProxyApiLoadService extends BaseService implements IScheduleService {
+    protected ctx: Context;
+    private curdProService;
+    private workbenchService;
+    /**
+     * 创建路由树。刷新路由缓存
+     * @param workbench_code
+     */
+    buildRouteTrie(workbench_code: string): Promise<RouteTrie>;
+    private buildUpstreamMap;
+    private loadProxyApiEntity;
+    private addUpstreamInfo;
+    runBySchedule(): Promise<any>;
+}