midway-fatcms 0.0.1-beta.54 → 0.0.1-beta.56

package/src/service/curd/CurdProService.ts

@@ -0,0 +1,231 @@
+import * as _ from 'lodash';
+import { Config, Inject, Provide } from '@midwayjs/core';
+import { CrudPro } from '@/libs/crud-pro/CrudPro';
+import { Context } from '@midwayjs/koa';
+import { IConnectionPool, ICrudProCfg, IRequestCfgModel, IRequestModel, ISqlCfgModel } from '@/libs/crud-pro/interfaces';
+import { SqlCfgModel } from '@/libs/crud-pro/models/SqlCfgModel';
+import { getConnectionPool as getMySQLConnectionPool } from '../../libs/crud-pro/utils/pool/MySQLUtils';
+import { getConnectionPool as getPostgresConnectionPool } from '../../libs/crud-pro/utils/pool/PostgresUtils';
+import { getConnectionPool as getSqlServerConnectionPool } from '../../libs/crud-pro/utils/pool/SqlServerUtils';
+import { SqlDbType } from '@/libs/crud-pro/models/keys';
+import { CommonException, Exceptions } from '@/libs/crud-pro/exceptions';
+import { UserSessionInfo } from '@/models/userSession';
+import { BaseExecuteContextFunc } from '@/libs/crud-pro/models/ExecuteContextFunc';
+import { ExecuteContext, IExecuteContextHandler } from '@/libs/crud-pro/models/ExecuteContext';
+import { RelatedType } from './CurdMixUtils';
+import { BaseService } from '../base/BaseService';
+import { IRequestCfgModel2, IVisitorExt } from '@/models/bizmodels';
+import { IWorkbenchEntity } from '@/models/SystemEntities';
+import { CrudProQuick } from '@/service/curd/CrudProQuick';
+import { fixCfgModel } from './fixCfgModel';
+import { GLOBAL_STATIC_CONFIG } from '@/libs/global-config/global-config';
+
+function toVisitor(ctx: Context): IVisitorExt {
+  const workbenchInfo: IWorkbenchEntity = ctx.workbenchInfo;
+  const userSession: UserSessionInfo = ctx.userSession;
+  if (!userSession || !userSession.isLogin()) {
+    return {
+      isLogin: false,
+      isSuperAdmin: false,
+      accountId: '0',
+      nickName: '匿名用户',
+      avatar: '',
+      accountType: '',
+      roleCodes: [],
+      functionCodes: [],
+      workbenchCode: workbenchInfo?.workbench_code || '',
+      bizExt: {}
+    };
+  }
+
+  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?.workbench_code || '',
+    bizExt: sessionInfo.bizExt || {}
+  };
+}
+
+class MyContextFunc extends BaseExecuteContextFunc {
+  private readonly mysql2Config: any;
+  private readonly postgres2Config: any;
+  private readonly sqlserver2Config: any;
+  private readonly responseCfgHandlers: Record<string, IExecuteContextHandler>;
+
+  constructor(cfgMap: any, responseCfgHandlers: Record<string, IExecuteContextHandler>) {
+    super();
+    const { mysql2Config, postgres2Config, sqlserver2Config } = cfgMap;
+    this.mysql2Config = mysql2Config;
+    this.postgres2Config = postgres2Config;
+    this.sqlserver2Config = sqlserver2Config;
+    this.responseCfgHandlers = responseCfgHandlers;
+  }
+
+  async getConnectionPool(sqlCfgModel: SqlCfgModel): Promise<IConnectionPool> {
+    if (!sqlCfgModel.sqlDatabase) {
+      console.error('[MyContextFunc]查询语句中未指定数据库', sqlCfgModel.executeSql);
+      throw new CommonException(Exceptions.DB_QUERY_PARAM_EMPTY, '查询语句中未指定数据库');
+    }
+    const dataBaseName = sqlCfgModel.sqlDatabase;
+    const sqlDbType = sqlCfgModel.sqlDbType;
+
+    if (sqlDbType === SqlDbType.postgres) {
+      const dbConfig = _.get(this.postgres2Config, dataBaseName);
+      if (!dbConfig) {
+        console.error('[MyContextFunc]postgres配置中不存在此数据库', JSON.stringify(sqlCfgModel));
+        throw new CommonException(Exceptions.DB_NOT_FOUND, 'postgres配置中不存在此数据库:' + dataBaseName);
+      }
+      return getPostgresConnectionPool(dataBaseName, dbConfig);
+    }
+
+    if (sqlDbType === SqlDbType.sqlserver) {
+      const dbConfig = _.get(this.sqlserver2Config, dataBaseName);
+      if (!dbConfig) {
+        console.error('[MyContextFunc]sqlserver配置中不存在此数据库', JSON.stringify(sqlCfgModel));
+        throw new CommonException(Exceptions.DB_NOT_FOUND, 'sqlserver配置中不存在此数据库:' + dataBaseName);
+      }
+      return getSqlServerConnectionPool(dataBaseName, dbConfig);
+    }
+
+    const dbConfig = _.get(this.mysql2Config, dataBaseName);
+    if (!dbConfig) {
+      console.error('[MyContextFunc]MySQL配置中不存在此数据库', JSON.stringify(sqlCfgModel));
+      throw new CommonException(Exceptions.DB_NOT_FOUND, 'MySQL配置中不存在此数据库:' + dataBaseName);
+    }
+    return getMySQLConnectionPool(dataBaseName, dbConfig);
+  }
+
+  async afterExecuteSQLList(): Promise<any> {
+    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;
+  }
+
+  /**
+   * 在执行之前可以根据业务需要修改需要执行的内容
+   * @param reqJson
+   * @param cfgJson
+   */
+  async beforeExecuteSQLList(reqJson: IRequestModel, cfgJson: IRequestCfgModel): Promise<any> {
+    const { bizUpdateCfgModelForCrudPro } = GLOBAL_STATIC_CONFIG.getConfig();
+    if (typeof bizUpdateCfgModelForCrudPro === 'function') {
+      await bizUpdateCfgModelForCrudPro(reqJson, cfgJson);
+    }
+    return Promise.resolve();
+  }
+}
+
+@Provide()
+export class CurdProService extends BaseService {
+  @Inject()
+  protected ctx: Context;
+
+  @Config('mysql2')
+  private mysql2Config: any;
+
+  @Config('postgres2')
+  private postgres2Config: any;
+
+  @Config('sqlserver2')
+  private sqlserver2Config: any;
+
+  @Config('crudProCfg')
+  private crudProCfg: ICrudProCfg;
+
+  private responseCfgHandlers: Record<RelatedType, IExecuteContextHandler> = {} as any;
+
+  public setResponseCfgHandlers(key: RelatedType, handler: IExecuteContextHandler) {
+    this.responseCfgHandlers[key] = handler;
+  }
+
+  public getResponseCfgHandlers(): Record<RelatedType, IExecuteContextHandler> {
+    return this.responseCfgHandlers;
+  }
+
+  /**
+   * Execute级别：每次调用都会产生新的
+   * @private
+   */
+  private getCrudPro(): CrudPro {
+    const visitor = toVisitor(this.ctx);
+    this.logInfo('visitor', JSON.stringify(visitor));
+
+    const crudPro = new CrudPro();
+    crudPro.transaction = this.ctx.transaction;
+    crudPro.logger = this.getContextLogger() as any;
+    crudPro.visitor = visitor;
+
+    const crudProCfg: ICrudProCfg = this.crudProCfg || {};
+    const { SystemDbName, SystemDbType } = GLOBAL_STATIC_CONFIG.getConfig();
+    crudProCfg.sysDatabaseName = SystemDbName;
+    crudProCfg.sysDatabaseDbType = SystemDbType;
+
+    crudPro.contextCfg = crudProCfg;
+
+    crudPro.contextFunc = new MyContextFunc(
+      {
+        mysql2Config: this.mysql2Config,
+        postgres2Config: this.postgres2Config,
+        sqlserver2Config: this.sqlserver2Config,
+      },
+      this.responseCfgHandlers
+    );
+
+    return crudPro;
+  }
+
+  /**
+   * 依赖缓存中与加载的配置
+   * @param reqJson
+   */
+  async executeCrud(reqJson: IRequestModel): Promise<ExecuteContext> {
+    if (!reqJson.method) {
+      throw new Error('Method not implemented');
+    }
+    const curdPro = this.getCrudPro();
+
+    // 开发环境不使用缓存
+    const isEnableCache = !this.isEnableDebug();
+
+    return curdPro.executeCrud(reqJson, isEnableCache);
+  }
+
+  // 直接执行一个SQL
+  public async executeSQL(sqlCfgModel: ISqlCfgModel): Promise<any> {
+    const curdPro = this.getCrudPro();
+    return curdPro.executeSQL(sqlCfgModel);
+  }
+
+  // 直接执行一个请求
+  public async executeCrudByCfg(reqJson: IRequestModel, cfgModel: IRequestCfgModel2): Promise<ExecuteContext> {
+    this.logInfo('executeCrudByCfg', cfgModel);
+    const curdPro = this.getCrudPro();
+
+    // 应用标准的updateCfg。
+    fixCfgModel(cfgModel);
+    return await curdPro.executeCrudByCfg(reqJson, cfgModel);
+  }
+
+  public getBbUtil(sqlDatabase: string, sqlDbType: SqlDbType, sqlTable?: string): CrudProQuick {
+    const curdPro = this.getCrudPro();
+    return new CrudProQuick(curdPro, sqlDatabase, sqlDbType, sqlTable);
+  }
+
+  public async getCachedCfgByMethod(method: string): Promise<IRequestCfgModel> {
+    const curdPro = this.getCrudPro();
+    const isEnableCache = !this.isEnableDebug(); // 开发环境不使用缓存
+    return curdPro.getCachedCfgByMethod(method, isEnableCache);
+  }
+}

package/src/service/curd/fixCfgModel.ts

@@ -0,0 +1,120 @@
+import * as _ from 'lodash';
+import { CTX_VISITOR_ACCOUNT_TYPE, CTX_VISITOR_AVATAR, CTX_VISITOR_ID, CTX_VISITOR_NICKNAME, IRequestCfgModel2 } from '@/models/bizmodels';
+import { KeysOfSimpleSQL } from '@/libs/crud-pro/models/keys';
+
+function isSimpleQuery(sqlSimpleName: KeysOfSimpleSQL): boolean {
+  return sqlSimpleName === KeysOfSimpleSQL.SIMPLE_QUERY || sqlSimpleName === KeysOfSimpleSQL.SIMPLE_QUERY_COUNT || sqlSimpleName === KeysOfSimpleSQL.SIMPLE_QUERY_PAGE || sqlSimpleName === KeysOfSimpleSQL.SIMPLE_QUERY_ONE;
+}
+
+function fixCfgModel(cfgModel: IRequestCfgModel2) {
+  if (!cfgModel.method) {
+    cfgModel.method = 'anonymous';
+  }
+
+  if (!cfgModel.updateCfg) {
+    cfgModel.updateCfg = {};
+  }
+
+  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: CTX_VISITOR_ID },
+    'condition.created_account_type': { contextAsString: CTX_VISITOR_ACCOUNT_TYPE },
+
+    'data.created_by': { contextAsString: CTX_VISITOR_ID },
+    'data.created_avatar': { contextAsString: CTX_VISITOR_AVATAR },
+    'data.created_nickname': { contextAsString: CTX_VISITOR_NICKNAME },
+    'data.created_account_type': { contextAsString: CTX_VISITOR_ACCOUNT_TYPE },
+
+    'data.modified_by': { contextAsString: CTX_VISITOR_ID },
+    'data.modified_avatar': { contextAsString: CTX_VISITOR_AVATAR },
+    'data.modified_nickname': { contextAsString: CTX_VISITOR_NICKNAME },
+    'data.modified_account_type': { contextAsString: CTX_VISITOR_ACCOUNT_TYPE },
+  };
+
+  const buildUpdateCfgBy = (cfgArray: string[], prefix: string): any => {
+    const obj: any = {};
+    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'); // 查询用户本人创建的
+    _.merge(cfgModel.updateCfg, updateCfgObj);
+  }
+
+  // 删除语句
+  if (sqlSimpleName === KeysOfSimpleSQL.SIMPLE_DELETE) {
+    const updateCfgObj = buildUpdateCfgBy(conditionCfgArray, 'condition.created'); // 删除用户本人创建的
+    _.merge(cfgModel.updateCfg, updateCfgObj);
+  }
+
+  // 插入语句
+  if (sqlSimpleName === KeysOfSimpleSQL.SIMPLE_INSERT) {
+    const updateCfgObj1 = buildUpdateCfgBy(dataCfgArray, 'data.created');
+    _.merge(cfgModel.updateCfg, updateCfgObj1);
+  }
+
+  // 更新语句
+  if (sqlSimpleName === KeysOfSimpleSQL.SIMPLE_UPDATE) {
+    const updateCfgObj1 = buildUpdateCfgBy(dataCfgArray, 'data.modified');
+    const updateCfgObj2 = buildUpdateCfgBy(conditionCfgArray, 'condition.created'); // 更新用户本人创建的
+    _.merge(cfgModel.updateCfg, updateCfgObj1);
+    _.merge(cfgModel.updateCfg, updateCfgObj2);
+  }
+
+  // 插入或更新
+  if (sqlSimpleName === KeysOfSimpleSQL.SIMPLE_INSERT_OR_UPDATE || sqlSimpleName === KeysOfSimpleSQL.SIMPLE_INSERT_ON_DUPLICATE_UPDATE) {
+    const updateCfgObj1 = buildUpdateCfgBy(dataCfgArray, 'data.created');
+    const updateCfgObj2 = buildUpdateCfgBy(dataCfgArray, 'data.modified');
+    const updateCfgObj3 = buildUpdateCfgBy(conditionCfgArray, 'condition.created'); // 更新用户本人创建的
+    _.merge(cfgModel.updateCfg, updateCfgObj1);
+    _.merge(cfgModel.updateCfg, updateCfgObj2);
+    _.merge(cfgModel.updateCfg, updateCfgObj3);
+  }
+}
+
+export { fixCfgModel };

package/src/service/proxyapi/ProxyApiLoadService.ts

@@ -0,0 +1,174 @@
+import { Inject, Provide } from '@midwayjs/core';
+import { Context } from '@midwayjs/koa';
+import * as _ from 'lodash';
+import { BaseService } from '../base/BaseService';
+import { getRouteTrie, RouteTrie } from './RouteTrie';
+import { RouteHandler } from './RouteHandler';
+import { CurdProService } from '../curd/CurdProService';
+import { SystemTables} from '../../models/SystemTables';
+import { KeysOfSimpleSQL } from '../../libs/crud-pro/models/keys';
+import { IProxyApiEntity, IUpstreamInfo } from '../../models/SystemEntities';
+import { parseJsonObject } from '../../libs/utils/functions';
+import { BALANCE_STRATEGY } from './ProxyApiUtils';
+import { WeightedRandom } from './WeightedRandom';
+import { WeightedRoundRobin } from './WeightedRoundRobin';
+import { IScheduleService } from '../../interface';
+import { WorkbenchService } from '../WorkbenchService';
+import { CommonException } from '../../libs/crud-pro/exceptions';
+import { GLOBAL_STATIC_CONFIG } from '@/libs/global-config/global-config';
+
+function toUpstreamInfo(config_content: any): IUpstreamInfo {
+  const obj = parseJsonObject(config_content);
+  if (!obj) {
+    return {
+      balanceStrategy: BALANCE_STRATEGY.ROUND_ROBIN,
+      targetList: [],
+    };
+  }
+  const targetList = _.get(obj, 'data.targetList', []);
+  const balanceStrategy = _.get(obj, 'data.baseInfo.balanceStrategy');
+  if (Array.isArray(targetList)) {
+    const targetListParsed = targetList
+      .map((item: any) => {
+        return {
+          origin: item.origin,
+          weight: item.weight || 1,
+        };
+      })
+      .filter(item => {
+        const origin: string = item?.origin || '';
+        return origin.startsWith('http://') || origin.startsWith('https://');
+      });
+
+    return {
+      balanceStrategy,
+      targetList: targetListParsed,
+    };
+  }
+
+  return {
+    balanceStrategy: BALANCE_STRATEGY.ROUND_ROBIN,
+    targetList: [],
+  };
+}
+
+/**
+ * 接口代理。 数据加载
+ */
+@Provide()
+export class ProxyApiLoadService extends BaseService implements IScheduleService {
+  @Inject()
+  protected ctx: Context;
+
+  @Inject()
+  private curdProService: CurdProService;
+
+  @Inject()
+  private workbenchService: WorkbenchService;
+
+  /**
+   * 创建路由树。刷新路由缓存
+   * @param workbench_code
+   */
+  public async buildRouteTrie(workbench_code: string): Promise<RouteTrie> {
+    const upstreamMap: Record<string, IUpstreamInfo> = await this.buildUpstreamMap();
+    const routeTrie = getRouteTrie(workbench_code);
+    routeTrie.clearRoute();
+    const entities = await this.loadProxyApiEntity(workbench_code, upstreamMap);
+    for (let i = 0; i < entities.length; i++) {
+      const entity = entities[i];
+      if (entity.status === 1) {
+        const path_prefix2 = '/' + entity.upstream_code + entity.path_prefix;
+        routeTrie.addRoute(path_prefix2, new RouteHandler(entity));
+      }
+    }
+    return routeTrie;
+  }
+
+  private async buildUpstreamMap() {
+
+    const { SystemDbName, SystemDbType } = GLOBAL_STATIC_CONFIG.getConfig();
+
+    //       biz_tag={'upstream'}
+    const res = await this.curdProService.executeCrudByCfg(
+      {
+        condition: {
+          biz_tag: 'upstream',
+        },
+      },
+      {
+        sqlTable: SystemTables.sys_configs,
+        sqlDatabase: SystemDbName,
+        sqlDbType: SystemDbType,
+        sqlSimpleName: KeysOfSimpleSQL.SIMPLE_QUERY,
+      }
+    );
+    const upstreamMap: Record<string, IUpstreamInfo> = {};
+    const rows = res.getResRows() as any[];
+    for (let i = 0; i < rows.length; i++) {
+      const row = rows[i];
+      const { config_code, config_content } = row || {};
+      upstreamMap[config_code] = toUpstreamInfo(config_content);
+    }
+    return upstreamMap;
+  }
+
+  private async loadProxyApiEntity(workbench_code: string, upstreamMap: Record<string, IUpstreamInfo>): Promise<IProxyApiEntity[]> {
+
+    const { SystemDbName, SystemDbType } = GLOBAL_STATIC_CONFIG.getConfig();
+
+
+    const res = await this.curdProService.executeCrudByCfg(
+      {
+        condition: {},
+      },
+      {
+        sqlTable: SystemTables.sys_proxyapi,
+        sqlDatabase: SystemDbName,
+        sqlDbType: SystemDbType,
+        sqlSimpleName: KeysOfSimpleSQL.SIMPLE_QUERY,
+      }
+    );
+
+    const rows0 = res.getResRows() as IProxyApiEntity[];
+
+    const rows = rows0.filter(s => {
+      if (!s.workbench_code_array) {
+        throw new CommonException('IS_SUPPORT_CURRENT_WORKBENCH', '未配置支持的站点字段');
+      }
+      return this.workbenchService.isMatchWorkbenchCode(s.workbench_code_array, workbench_code);
+    });
+
+    for (let i = 0; i < rows.length; i++) {
+      const row = rows[i];
+      const upstream_code = row.upstream_code;
+      this.addUpstreamInfo(row, upstream_code, upstreamMap);
+    }
+    return rows;
+  }
+
+  private addUpstreamInfo(row: IProxyApiEntity, upstream_code: string, upstreamMap: Record<string, IUpstreamInfo>) {
+    const upstreamInfo = upstreamMap[upstream_code];
+    if (!upstreamInfo) {
+      return;
+    }
+    row.targetIndex = 0;
+    row.targetList = upstreamInfo.targetList || [];
+    row.balanceStrategy = upstreamInfo.balanceStrategy || BALANCE_STRATEGY.ROUND_ROBIN;
+    row.weightedRandom = new WeightedRandom(upstreamInfo.targetList || []);
+    row.weightedRoundRobin = new WeightedRoundRobin(upstreamInfo.targetList || []);
+  }
+
+  public async runBySchedule(): Promise<any> {
+    const workbenchList = await this.workbenchService.getAllWorkbenchInfoList();
+    for (let i = 0; i < workbenchList.length; i++) {
+      const workbenchInfo = workbenchList[i];
+      try {
+        await this.buildRouteTrie(workbenchInfo.workbench_code);
+      } catch (e) {
+        this.logError('ProxyApiLoadService_runBySchedule', e);
+      }
+    }
+  }
+
+}