midway-fatcms 0.0.1-beta.1

package/src/libs/crud-pro/models/ServiceHub.ts

@@ -0,0 +1,32 @@
+import { RequestCfgModel } from './RequestCfgModel';
+import { RequestModel } from './RequestModel';
+import { SqlCfgModel } from './SqlCfgModel';
+import { ExecuteContext } from './ExecuteContext';
+import { IFuncCfgModel, IRequestCfgModel, ITableMeta } from '../interfaces';
+import { FuncContext } from './FuncContext';
+
+export interface ICurdProServiceHub {
+  getExecuteContext(): ExecuteContext;
+
+  validateByAllow(cfgModel: RequestCfgModel, reqModel: RequestModel);
+
+  validateByReject(cfgModel: RequestCfgModel, reqModel: RequestModel);
+
+  validateByCfg(cfgModel: RequestCfgModel, reqModel: RequestModel);
+
+  validateByAuthCfg(cfgModel: RequestCfgModel, reqModel: RequestModel): void;
+
+  updateByCfg(cfgModel: RequestCfgModel, reqModel: RequestModel);
+
+  getCachedCfgByMethod(method: string, isEnableCache: boolean): Promise<IRequestCfgModel>;
+
+  generateSQLList(exeCtx: ExecuteContext): Promise<void>;
+
+  executeSqlCfgModels(exeCtx: ExecuteContext): Promise<void>;
+
+  convertOriginToExecuteSql(sqlCfgModel: SqlCfgModel): Promise<void>;
+
+  executeFuncCfg(tmpFunCfg: IFuncCfgModel, exeFunCtx: FuncContext): string;
+
+  getTableMeta(sqlCfgModel: SqlCfgModel): Promise<ITableMeta>;
+}

package/src/libs/crud-pro/models/SqlCfgModel.ts

@@ -0,0 +1,52 @@
+import { ColumnRelation, IFuncCfgModel, ISqlCfgModel } from '../interfaces';
+import { MixinUtils } from '../utils/MixinUtils';
+import { KeyOfCrudTypes, KeysOfSqlResPicker, SqlDbType} from './keys';
+import { parseJsonObject } from '../../utils/functions';
+
+const { isEmpty } = MixinUtils;
+
+class SqlCfgModel {
+  columns: string[]; // "columns": "id,name,age,sex,addr",
+  columnsRelation?: ColumnRelation[]; //只能关联基本信息：如枚举值
+  sqlTable: string; // 可以为空. originSql中不包含@@table时可以为空
+  sqlSchema?: string; // 可以为空
+  sqlDatabase?: string; // 可以为空，用此字段进行connection的选择和切换。配合getBizConnectionPool使用
+  sqlDdType?: SqlDbType; // 数据库类型，mysql(默认) 、postgres
+  maxLimit: number; // 最大一次性返回的数量
+  resName: string;
+  resPicker: KeysOfSqlResPicker;
+  originSql: string; // 有特殊占位符的SQL, 原始的SQL constructor(resName: string, originSql: string) {}
+  validate: IFuncCfgModel; //执行前，进行校验，校验不通过就抛出异常. 校验函数可以返回 boolean或直接抛出异常
+  executeWhen: IFuncCfgModel; //满足表达式的结果，才能执行。 默认：true 校验函数必须返回 booleansetResPicker(resPicker: string) {}
+  executeSql: string; // 可以运行的SQL
+  executeSqlArgs: any[]; //可以运行的SQL的参数setExecuteWhen(executeWhenFunCfg: IFuncCfgModel) {}
+  crudType: KeyOfCrudTypes = null;
+
+  constructor(json: Partial<ISqlCfgModel>) {
+    Object.assign(this, json);
+    this.columns = MixinUtils.parseColumns(json.columns);
+    this.executeWhen = parseJsonObject(json.executeWhen);
+  }
+
+  public getCrudType(): KeyOfCrudTypes {
+    if (!this.crudType) {
+      const sql = this.executeSql.trim().toUpperCase();
+      if (isEmpty(sql)) {
+        this.crudType = KeyOfCrudTypes.EMPTY_SQL;
+      } else if (sql.startsWith(KeyOfCrudTypes.SELECT)) {
+        this.crudType = KeyOfCrudTypes.SELECT;
+      } else if (sql.startsWith(KeyOfCrudTypes.UPDATE)) {
+        this.crudType = KeyOfCrudTypes.UPDATE;
+      } else if (sql.startsWith(KeyOfCrudTypes.DELETE)) {
+        this.crudType = KeyOfCrudTypes.DELETE;
+      } else if (sql.startsWith(KeyOfCrudTypes.INSERT)) {
+        this.crudType = KeyOfCrudTypes.INSERT;
+      } else {
+        this.crudType = KeyOfCrudTypes.NOT_CRUD;
+      }
+    }
+    return this.crudType;
+  }
+}
+
+export { SqlCfgModel };

package/src/libs/crud-pro/models/SqlSegArg.ts

@@ -0,0 +1,13 @@
+class SqlSegArg {
+  sql: string;
+  args: any[];
+
+  constructor(sql: string, args?: any[]) {
+    this.sql = sql;
+    if (args) {
+      this.args = args;
+    }
+  }
+}
+
+export { SqlSegArg };

package/src/libs/crud-pro/models/Transaction.ts

@@ -0,0 +1,74 @@
+import {IConnectionPool, IPoolConnectionClient} from '../interfaces';
+import {SqlDbType} from "./keys";
+import {TransactionMySQL} from "./TransactionMySQL";
+import {TransactionPostgres} from "./TransactionPostgres";
+import {TransactionSqlServer} from "./TransactionSqlServer";
+
+class Transaction {
+
+  private transactionMySQL : TransactionMySQL = new TransactionMySQL();
+  private transactionPostgres : TransactionPostgres  = new TransactionPostgres();
+  private transactionSqlServer : TransactionSqlServer  = new TransactionSqlServer();
+
+  private getTxObj(pool: IConnectionPool): TransactionMySQL | TransactionPostgres | TransactionSqlServer {
+    if (pool.dbType === SqlDbType.postgres) {
+      return this.transactionPostgres;
+    }
+
+    if (pool.dbType === SqlDbType.sqlserver) {
+      return this.transactionSqlServer;
+    }
+
+    if (!pool.dbType || pool.dbType === SqlDbType.mysql) {
+      return this.transactionMySQL;
+    }
+    return null;
+  }
+
+  /**
+   * 获取链接对象
+   * @param pool
+   */
+  public async getTxConnection(pool: IConnectionPool): Promise<IPoolConnectionClient> {
+    const txObj = this.getTxObj(pool);
+    return txObj.getTxConnection(pool);
+  }
+
+  /**
+   * 开始事务
+   */
+  public beginTx() {
+    this.transactionMySQL.beginTx();
+    this.transactionPostgres.beginTx();
+    this.transactionSqlServer.beginTx();
+  }
+
+  /**
+   * 提交事务
+   */
+  public async commitTx() {
+    await this.transactionMySQL.commitTx();
+    await this.transactionPostgres.commitTx();
+    await this.transactionSqlServer.commitTx();
+  }
+
+  /**
+   * 事务回滚
+   */
+  public async rollbackTx() {
+    await this.transactionMySQL.rollbackTx();
+    await this.transactionPostgres.rollbackTx();
+    await this.transactionSqlServer.rollbackTx();
+  }
+
+  /**
+   * 释放连接
+   */
+  public async releaseTx() {
+    await this.transactionMySQL.releaseTx();
+    await this.transactionPostgres.releaseTx();
+    await this.transactionSqlServer.releaseTx();
+  }
+}
+
+export { Transaction };

package/src/libs/crud-pro/models/TransactionMySQL.ts

@@ -0,0 +1,79 @@
+import { PoolConnection, Pool } from 'mysql2/promise';
+import { IConnectionPool } from '../interfaces';
+
+class TransactionMySQL {
+  private isBeginTransaction = false;
+  private connectionMap: Record<string, PoolConnection> = {};
+
+  /**
+   * 获取链接对象
+   * @param pool
+   */
+  public async getTxConnection(pool: IConnectionPool): Promise<PoolConnection> {
+    let connection = this.connectionMap[pool.poolName];
+    if (!connection) {
+      const poolInstance: Pool = pool.poolInstance as any;
+      connection = await poolInstance.getConnection();
+      this.connectionMap[pool.poolName] = connection;
+      // 开启了事务
+      if (this.isBeginTransaction) {
+        await connection.beginTransaction();
+      }
+    }
+    return connection;
+  }
+
+  /**
+   * 开始事务
+   */
+  public beginTx() {
+    this.isBeginTransaction = true;
+  }
+
+  /**
+   * 提交事务
+   */
+  public async commitTx() {
+    if (!this.isBeginTransaction) {
+      return;
+    }
+    const connections = Object.values(this.connectionMap);
+    for (let i = 0; i < connections.length; i++) {
+      const connection = connections[i];
+      await connection.commit();
+    }
+  }
+
+  /**
+   * 事务回滚
+   */
+  public async rollbackTx() {
+    if (!this.isBeginTransaction) {
+      return;
+    }
+    const connections = Object.values(this.connectionMap);
+    for (let i = 0; i < connections.length; i++) {
+      const connection = connections[i];
+      await connection.rollback();
+    }
+  }
+
+  /**
+   * 释放连接
+   */
+  public async releaseTx() {
+    // 不管有没有开启事务，都要释放连接。
+    const connections = Object.values(this.connectionMap);
+    for (let i = 0; i < connections.length; i++) {
+      const connection = connections[i];
+      try {
+        await connection.release();
+      } catch (e) {
+        console.error(e);
+      }
+    }
+    this.connectionMap = {};
+  }
+}
+
+export { TransactionMySQL };

package/src/libs/crud-pro/models/TransactionPostgres.ts

@@ -0,0 +1,91 @@
+import { PoolClient, Pool } from 'pg';
+import { IConnectionPool } from '../interfaces';
+
+async function beginTransaction(connection: PoolClient) {
+  return await connection.query('BEGIN');
+}
+
+async function commit(connection: PoolClient) {
+  return await connection.query('COMMIT');
+}
+
+async function rollback(connection:PoolClient ) {
+  return await connection.query('ROLLBACK');
+}
+
+class TransactionPostgres {
+  private isBeginTransaction = false;
+  private connectionMap: Record<string, PoolClient> = {};
+
+  /**
+   * 获取链接对象
+   * @param pool
+   */
+  public async getTxConnection(pool: IConnectionPool): Promise<PoolClient> {
+    let connection = this.connectionMap[pool.poolName];
+    if (!connection) {
+      const poolInstance: Pool = pool.poolInstance as any;
+      connection = await poolInstance.connect();
+      this.connectionMap[pool.poolName] = connection;
+      // 开启了事务
+      if (this.isBeginTransaction) {
+        await beginTransaction(connection);
+      }
+    }
+    return connection;
+  }
+
+  /**
+   * 开始事务
+   */
+  public beginTx() {
+    this.isBeginTransaction = true;
+  }
+
+  /**
+   * 提交事务
+   */
+  public async commitTx() {
+    if (!this.isBeginTransaction) {
+      return;
+    }
+    const connections = Object.values(this.connectionMap);
+    for (let i = 0; i < connections.length; i++) {
+      const connection = connections[i];
+      await commit(connection);
+    }
+  }
+
+  /**
+   * 事务回滚
+   */
+  public async rollbackTx() {
+    if (!this.isBeginTransaction) {
+      return;
+    }
+    const connections = Object.values(this.connectionMap);
+    for (let i = 0; i < connections.length; i++) {
+      const connection = connections[i];
+      await rollback(connection);
+    }
+  }
+
+  /**
+   * 释放连接
+   */
+  public async releaseTx() {
+    // 不管有没有开启事务，都要释放连接。
+    const connections = Object.values(this.connectionMap);
+    for (let i = 0; i < connections.length; i++) {
+      const connection = connections[i];
+      try {
+        await connection.release();
+      } catch (e) {
+        console.error(e);
+      }
+    }
+    this.connectionMap = {};
+  }
+}
+
+export { TransactionPostgres };

package/src/libs/crud-pro/models/TransactionSqlServer.ts

@@ -0,0 +1,107 @@
+import { ConnectionPool, Request, Transaction } from 'mssql';
+import { IConnectionPool, IPoolConnectionClient } from '../interfaces';
+
+
+interface ISqlServerConnection extends IPoolConnectionClient {
+  originConnection: ConnectionPool
+}
+
+
+
+class TransactionSqlServer {
+  private isBeginTransaction = false;
+  private connectionMap: Record<string, ISqlServerConnection> = {};
+  private transactionMap: Record<string, Transaction> = {};
+
+  /**
+   * 获取链接对象
+   * @param pool
+   */
+  public async getTxConnection(pool: IConnectionPool): Promise<ISqlServerConnection> {
+    let connection = this.connectionMap[pool.poolName];
+    if (!connection) {
+      connection = await this.connectAndCreateConnection(pool);
+      this.connectionMap[pool.poolName] = connection;
+
+      // 开启了事务
+      if (this.isBeginTransaction) {
+        await this.beginTransaction(pool.poolName);
+      }
+    }
+    return connection;
+  }
+
+  private async connectAndCreateConnection(pool: IConnectionPool) : Promise<ISqlServerConnection> {
+    const poolInstance: ConnectionPool = pool.poolInstance as any;
+    const originConnection = await poolInstance.connect();
+    return {
+      originConnection,
+      query: (sql:string, values: any) : Promise<any> =>{
+        const request = new Request(originConnection);
+        if (Array.isArray(values)) {
+          for (let i = 0; i < values.length; i++) {
+            const index = i+1;
+            const value = values[i];
+            request.input(`fatcms_ms${index}`, value);
+          }
+        }
+        return request.query(sql);
+      }
+    }
+  }
+
+  /**
+   * 开始事务
+   */
+  public beginTx() {
+    this.isBeginTransaction = true;
+  }
+
+  /**
+   * 提交事务
+   */
+  public async commitTx() {
+    if (!this.isBeginTransaction) {
+      return;
+    }
+    const transactions = Object.values(this.transactionMap);
+    for (let i = 0; i < transactions.length; i++) {
+      const tmpTx = transactions[i];
+      await tmpTx.commit();
+    }
+  }
+
+  /**
+   * 事务回滚
+   */
+  public async rollbackTx() {
+    if (!this.isBeginTransaction) {
+      return;
+    }
+    const transactions = Object.values(this.transactionMap);
+    for (let i = 0; i < transactions.length; i++) {
+      const tmpTx = transactions[i];
+      await tmpTx.rollback();
+    }
+  }
+
+  /**
+   * 释放连接
+   */
+  public async releaseTx() {
+    this.connectionMap = {};
+    this.transactionMap = {};
+  }
+
+
+  private async beginTransaction(poolName: string) {
+    const connection = this.connectionMap[poolName];
+    const originConnection: ConnectionPool = connection.originConnection;
+    const tmpTx =  new Transaction(originConnection);
+    this.transactionMap[poolName] = tmpTx;
+    return await tmpTx.begin()
+  }
+
+}
+
+export { TransactionSqlServer };

package/src/libs/crud-pro/models/keys.ts

@@ -0,0 +1,159 @@
+export enum SqlDbType {
+  mysql = 'mysql',
+  postgres = 'postgres',
+  sqlserver = 'sqlserver', //微软 SQL Server
+}
+
+export enum KeysOfFunCtx {
+  FUNC_CTX = '$',
+  CURRENT_VALUE = '$current',
+  VISITOR = 'visitor',
+  VISITOR_ATTR = 'visitor.',
+  REQUEST = 'req.',
+  RESULT = 'res.',
+}
+
+//鉴权类型；free无需鉴权，login仅登录即可，byRoleCode校验角色，byFuncCode校验功能点
+export enum KeysOfAuthType {
+  free = 'free', // 无需任何校验
+  login = 'login', // 仅仅登录即可
+  byRoleCode = 'byRoleCode', // 根据角色校验
+  byFuncCode = 'byFuncCode', // 根据功能点校验
+}
+
+export enum KeysOfValidators {
+  REQUIRED = 'required',
+  BOOLEAN = 'boolean', // 布尔值类型
+  OBJECT = 'object', // 普通对象类型类型
+  ARRAY = 'array', // 数组
+  ARRAY_STRING = 'array:string', // 数组
+  ARRAY_NUMBER = 'array:number', // 数组
+  STRING = 'string', // 字符串类型
+  EMAIL = 'email',
+  NAME = 'name', //必须以字母开头,只能包含：字母/数字/下划线
+  PHONE_CN = 'phone:cn', // 中国手机号：11位
+  INTEGER = 'integer', // long,int,short,bigInteger
+  NUMBER = 'number', // long,int,short,float,double
+  NUMERIC = 'numeric', //long,int,short,float,double或只包含数字的字符串
+  MOMENT = 'moment:', // moment:YYYY-MM-DD HH:mm:ss  时间日期格式校验
+  SCALE = 'scale:', // 判断参数是否位于这个区间：scale:[1,3] ; scale:(1,3) ; scale:(1,3] ;
+  LENGTH = 'length:', // length:1,5 ; length >=1 and length <=5
+  REG_EXP = 'regexp:', // regexp:[a-zA-Z-_.]
+  ENUM = 'enum:', // enum : 1,2,3,4,5,6,aa,bb,cc ：比较时用字符串比较
+}
+
+export enum KeyOfCrudTypes {
+  SELECT = 'SELECT',
+  UPDATE = 'UPDATE',
+  INSERT = 'INSERT',
+  DELETE = 'DELETE',
+  NOT_CRUD = 'NOT_CRUD',
+  EMPTY_SQL = 'EMPTY_SQL',
+  SYS_QUERY = 'SYS_QUERY',
+}
+
+export enum KeysOfSimpleSQL {
+  SIMPLE_QUERY = 'SIMPLE_QUERY', // select * from xx where @condition limit 100,
+  SIMPLE_QUERY_ONE = 'SIMPLE_QUERY_ONE', //只查询一条 select * from xx where @condition limit 1,
+  SIMPLE_QUERY_PAGE = 'SIMPLE_QUERY_PAGE', //分页查询 select * from xx where @condition limit 100 offset 100,
+  SIMPLE_QUERY_COUNT = 'SIMPLE_QUERY_COUNT', //查询数量 select count(0) as totalCount from xx where @condition,
+  SIMPLE_UPDATE = 'SIMPLE_UPDATE', // update xx set @data where @condition limit 1
+  SIMPLE_INSERT = 'SIMPLE_INSERT', // insert into xx values @datas
+  SIMPLE_DELETE = 'SIMPLE_DELETE', // delete from  xx values where @condition limit 1
+  SIMPLE_INSERT_ON_DUPLICATE_UPDATE = 'SIMPLE_INSERT_ON_DUPLICATE_UPDATE',
+  SIMPLE_INSERT_OR_UPDATE = 'SIMPLE_INSERT_OR_UPDATE',
+  CUSTOM = 'CUSTOM',
+}
+
+export enum KeysOfSqlResPicker {
+  UPDATE_RESULT = 'UPDATE_RESULT', // update/insert/delete 产生影响的结果
+  RESULT_FIRST_ROW = 'RESULT_FIRST_ROW', // $ResultSet[0]， 只取第一行的数据返回。返回JSONObject
+  RESULT_TOTAL_COUNT = 'RESULT_TOTAL_COUNT', // $ResultSet[0].total_count ， 只取第一行的的total_count。返回long
+  RESULT_ONE_VALUE = 'RESULT_ONE_VALUE', //   $ResultSet[0].total_count ， 只取第一行的的total_count。返回long
+}
+
+export const KeysOfCustomSQL = {
+  SQL_COLUMNS: '@@columns',
+  SQL_TABLE: '@@table', // 只有简单查询才能用得到
+  SQL_OFFSET_LIMIT: '@@offsetLimit',
+  SQL_ORDER_BYS: '@@orderBys',
+
+  SQL_AS_WHERE: '@@asWhere:', // @@asWhere:condition ,  @@asWhere:condition_zhangsan
+  SQL_AS_UPDATE: '@@asUpdate:', // @@asUpdate:data,  @@asWhere:data_zhangsan
+  SQL_AS_INSERT_KEYS: '@@asInsertKeys:', // @@asInsertKeys:data,  @@asInsertKeys:data_zhangsan
+  SQL_AS_INSERT_VALUES: '@@asInsertValues:', // @@asInsertValues:data,  @@asInsertValues:data_zhangsan
+
+  // 从Req中取值：单独取Data中的某个字段：获取单个值。
+  SQL_GET_DATA_ATTR_START: '@@data', // // select * from fa_lang_faq where id = @@data.id
+  SQL_GET_CONDITION_ATTR_START: '@@condition', // select * from fa_lang_faq where id = @@condition.id
+
+  // 从Res中取值
+  SQL_PICK_RES_AS_NUMBER: '@@pickResAsNumber:', // select * from fa_lang_faq where id = @@pickResAsNumber:rows[0].id
+  SQL_PICK_RES_AS_STRING: '@@pickResAsString:', // select * from fa_lang_faq where lang_code = @@pickResAsString:row.lang_code
+
+  // 使用java函数：获取单个值
+  SQL_FUNCTION: '@@function:', // @@function:aaa
+};
+
+/**
+ * 查询条件中允许出现的关键词
+ * 与MongoDB的语法完全一致
+ */
+export const KeysOfConditions = {
+  $OR: '$or', //或
+
+  $NE: '$ne', //不等于
+  $LT: '$lt', //小于
+  $LTE: '$lte', //小于或等于
+  $GT: '$gt', //大于
+  $GTE: '$gte', //大于或等于
+  $IN: '$in', //in
+  $NIN: '$nin', // not in
+  $NOT_NULL: '$notNull', // is not null
+  $NULL: '$null', // is null
+  $RANGE: '$range', // between 1 and 2
+  $LIKE: '$like', // A% 以A开头 {age:1, name:{"$like":"张"} }
+  $NOT_LIKE: '$notLike', // A% 以A开头 {age:1, name:{"$notLike":"张"} }
+
+  $LIKE_INCLUDE: '$likeInclude', // %A% 包含A {age:1, name:{"$like":"张"} }
+  $NOT_LIKE_INCLUDE: '$notLikeInclude', // %A%  包含A {age:1, name:{"$notLike":"张"} }
+
+  $MATCH: '$match', // 全文索引 {age:1, name:{"$match":"张"} }
+  $MATCH_BOOL: '$matchBool', // 全文索引 {age:1, name:{"$matchBool":"张"} }
+
+  COMPARE_KEYS: new Set<string>([]),
+  ALL_KEYS: new Set<string>([]),
+};
+
+function initKeysOfConditions() {
+  const addIgnoreCase = (keys: Set<string>, key: string) => {
+    keys.add(key);
+    keys.add(key.toUpperCase());
+    keys.add(key.toLowerCase());
+  };
+
+  // 比较操作符, 支持忽略大小写
+  KeysOfConditions.COMPARE_KEYS = new Set([]);
+  addIgnoreCase(KeysOfConditions.COMPARE_KEYS, KeysOfConditions.$NE);
+  addIgnoreCase(KeysOfConditions.COMPARE_KEYS, KeysOfConditions.$LT);
+  addIgnoreCase(KeysOfConditions.COMPARE_KEYS, KeysOfConditions.$LTE);
+  addIgnoreCase(KeysOfConditions.COMPARE_KEYS, KeysOfConditions.$GT);
+  addIgnoreCase(KeysOfConditions.COMPARE_KEYS, KeysOfConditions.$GTE);
+  addIgnoreCase(KeysOfConditions.COMPARE_KEYS, KeysOfConditions.$IN);
+  addIgnoreCase(KeysOfConditions.COMPARE_KEYS, KeysOfConditions.$NIN);
+  addIgnoreCase(KeysOfConditions.COMPARE_KEYS, KeysOfConditions.$LIKE);
+  addIgnoreCase(KeysOfConditions.COMPARE_KEYS, KeysOfConditions.$LIKE_INCLUDE);
+  addIgnoreCase(KeysOfConditions.COMPARE_KEYS, KeysOfConditions.$NOT_LIKE);
+  addIgnoreCase(KeysOfConditions.COMPARE_KEYS, KeysOfConditions.$NOT_LIKE_INCLUDE);
+  addIgnoreCase(KeysOfConditions.COMPARE_KEYS, KeysOfConditions.$MATCH);
+  addIgnoreCase(KeysOfConditions.COMPARE_KEYS, KeysOfConditions.$MATCH_BOOL);
+  addIgnoreCase(KeysOfConditions.COMPARE_KEYS, KeysOfConditions.$RANGE);
+  addIgnoreCase(KeysOfConditions.COMPARE_KEYS, KeysOfConditions.$NULL);
+  addIgnoreCase(KeysOfConditions.COMPARE_KEYS, KeysOfConditions.$NOT_NULL);
+
+  // 所有操作符
+  KeysOfConditions.ALL_KEYS = new Set([...KeysOfConditions.COMPARE_KEYS]);
+  addIgnoreCase(KeysOfConditions.ALL_KEYS, KeysOfConditions.$OR);
+}
+
+initKeysOfConditions();

package/src/libs/crud-pro/services/CrudProCachedCfgService.ts

@@ -0,0 +1,75 @@
+import { camelizeKeys } from 'humps';
+import { CrudProServiceBase } from './CrudProServiceBase';
+import { IRequestCfgModel } from '../interfaces';
+import { MixinUtils } from '../utils/MixinUtils';
+import { ICurdProServiceHub } from '../models/ServiceHub';
+import MemoryRefreshCache from '../utils/MemoryRefreshCache';
+
+const methodCache = new MemoryRefreshCache();
+
+
+function parseMethodInfo(methodInfo: any): any {
+  const row: any = camelizeKeys(methodInfo as object); //转换成驼峰
+  const configObject = MixinUtils.parseJsonObject(row.moreConfig) || {};
+  const sqlCfgList = MixinUtils.parseJsonObject(row.sqlCfgList) || [];
+  return {...configObject, ...row, sqlCfgList};
+}
+
+
+
+class CrudProCachedCfgService extends CrudProServiceBase {
+  constructor(serviceHub: ICurdProServiceHub) {
+    super(serviceHub);
+  }
+
+  public async getCachedCfgByMethod(method: string, isEnableCache: boolean): Promise<IRequestCfgModel | null> {
+
+    // 不使用缓存
+    if (!isEnableCache) {
+      return await this.loadMethodInfo(method)
+    }
+
+    methodCache.setProps({
+      keepTime: 2000,
+      requestFn: () => this.loadMethodInfoList(),
+      getKeyFn: item => item.method,
+    });
+    return await methodCache.getItem(method);
+  }
+
+
+  private async loadMethodInfo(method: string): Promise<any> {
+    const {methodsTableName, sysDatabaseName} = this.getContextCfg();
+    const sql = `select *
+                 from ${methodsTableName}
+                 where method = ? `; // 全部加载到内存
+    const baseInfo = {
+      tableName: methodsTableName, // // 方法配置的表名，默认 sys_crud_pro_methods
+      dbName: sysDatabaseName,
+    };
+    const [rows] = await this.executeUnsafeQuery(baseInfo, sql, [method]);
+    const rows2: any[] = rows as object[];
+    if (rows2.length > 0) {
+      return parseMethodInfo(rows2[0]);
+    }
+    return null;
+  }
+
+
+
+  private async loadMethodInfoList(): Promise<any[]> {
+    const { methodsTableName, sysDatabaseName } = this.getContextCfg();
+    const sql = `select * from ${methodsTableName}`; // 全部加载到内存
+    const baseInfo = {
+      tableName: methodsTableName, // // 方法配置的表名，默认 sys_crud_pro_methods
+      dbName: sysDatabaseName,
+    };
+    const [rows] = await this.executeUnsafeQuery(baseInfo, sql);
+    const rows2: any[] = rows as object[];
+    return rows2.map(row => {
+      return parseMethodInfo(row);
+    });
+  }
+}
+
+export { CrudProCachedCfgService };