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

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,102 @@
+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,83 @@
+import { camelizeKeys } from 'humps';
+import { CrudProServiceBase } from './CrudProServiceBase';
+import { IRequestCfgModel } from '../interfaces';
+import { MixinUtils } from '../utils/MixinUtils';
+import { ICurdProServiceHub } from '../models/ServiceHub';
+import { pickAndConvertRowsByMix } from '../utils/sqlConvert/convertMix';
+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> {
+    const methodInfo = await this.getCachedCfgByMethodInner(method, isEnableCache);
+    if (!methodInfo) {
+      return null;
+    }
+    return { ...methodInfo };
+  }
+
+  private async getCachedCfgByMethodInner(method: string, isEnableCache: boolean): Promise<IRequestCfgModel | null> {
+    // 不使用缓存
+    if (!isEnableCache) {
+      return await this.loadMethodInfo(method);
+    }
+
+    methodCache.setProps({
+      keepTime: 1000 * 60 * 2, // 2分钟
+      requestFn: () => this.loadMethodInfoList(),
+      getKeyFn: item => item.method,
+    });
+    const methodInfo = await methodCache.getItem(method);
+    if (methodInfo) {
+      return methodInfo;
+    }
+    return await this.loadMethodInfo(method);
+  }
+
+  private async loadMethodInfo(method: string): Promise<any> {
+    const { methodsTableName, sysDatabaseName, sysDatabaseDbType } = this.getContextCfg();
+    const sql = `select * from ${methodsTableName} where method = ? `; // 全部加载到内存
+
+    const baseInfo = {
+      sqlTable: methodsTableName,
+      sqlDatabase: sysDatabaseName,
+      sqlDbType: sysDatabaseDbType,
+    };
+
+    const queryRes = await this.executeUnsafeQuery(baseInfo, sql, [method]);
+    const rows2: any[] = pickAndConvertRowsByMix(queryRes, sysDatabaseDbType);
+    if (rows2.length > 0) {
+      return parseMethodInfo(rows2[0]);
+    }
+    return null;
+  }
+
+  private async loadMethodInfoList(): Promise<any[]> {
+    const { methodsTableName, sysDatabaseName, sysDatabaseDbType } = this.getContextCfg();
+    const sql = `select * from ${methodsTableName}`; // 全部加载到内存
+    const baseInfo = {
+      sqlTable: methodsTableName,
+      sqlDatabase: sysDatabaseName,
+      sqlDbType: sysDatabaseDbType,
+    };
+    const queryRes = await this.executeUnsafeQuery(baseInfo, sql);
+    const rows2: any[] = pickAndConvertRowsByMix(queryRes, sysDatabaseDbType);
+    return rows2.map(row => {
+      return parseMethodInfo(row);
+    });
+  }
+}
+
+export { CrudProCachedCfgService };

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

@@ -0,0 +1,128 @@
+import { CrudProServiceBase } from './CrudProServiceBase';
+import { IFuncCfgModel, IFunctionParam } from '../interfaces';
+import { FuncContext } from '../models/FuncContext';
+import { TypeUtils } from '../utils/TypeUtils';
+import { MixinUtils } from '../utils/MixinUtils';
+import * as _ from 'lodash';
+import { CommonException, Exceptions } from '../exceptions';
+import { KeysOfFunCtx } from '../models/keys';
+
+const { isNil, isNumeric } = TypeUtils;
+const { isEmpty } = MixinUtils;
+
+function isNotNil(obj: any): boolean {
+  return !isNil(obj);
+}
+
+class CrudProExecuteFuncService extends CrudProServiceBase {
+  executeFuncCfg(funCfg: IFuncCfgModel, funcContext: FuncContext) {
+    if (isNil(funCfg)) {
+      return null;
+    }
+
+    if (funCfg.___PLAIN_OBJECT___ === true) {
+      return funCfg;
+    }
+
+    if (isNotNil(funCfg.const)) {
+      return funCfg.const;
+    }
+    if (isNotNil(funCfg.constString)) {
+      return '' + funCfg.constString;
+    }
+    if (isNotNil(funCfg.constNumber) && isNumeric(funCfg.constNumber)) {
+      return Number(funCfg.constNumber);
+    }
+    if (isNotNil(funCfg.constBool)) {
+      return Boolean(funCfg.constBool);
+    }
+
+    if (isNotNil(funCfg.context)) {
+      return this.pickContextValue(funCfg.context, funcContext);
+    }
+    if (isNotNil(funCfg.contextAsString)) {
+      return '' + this.pickContextValue(funCfg.contextAsString, funcContext);
+    }
+    if (isNotNil(funCfg.contextAsNumber)) {
+      return Number(this.pickContextValue(funCfg.contextAsNumber, funcContext));
+    }
+    if (isNotNil(funCfg.contextAsBool)) {
+      return Boolean(this.pickContextValue(funCfg.contextAsBool, funcContext));
+    }
+
+    if (isNotNil(funCfg.functionName)) {
+      const func = this.getExecuteFunction(funCfg.functionName);
+      if (!func) {
+        throw new CommonException(Exceptions.RUN_FUNCTION_NOT_FOUND, funCfg.functionName);
+      }
+      const functionParamValues = this.getFunctionParamValues(funCfg.functionParams, funcContext);
+      return func.apply(funcContext, functionParamValues);
+    }
+    return null;
+  }
+
+  private pickContextValue(pickString: string, funcCtx: FuncContext) {
+    if (!pickString) {
+      return null;
+    }
+
+    if (pickString === KeysOfFunCtx.FUNC_CTX) {
+      return funcCtx;
+    }
+
+    if (pickString === KeysOfFunCtx.CURRENT_VALUE) {
+      return funcCtx.currentValue;
+    }
+
+    // 例如：accountId, 访问此变量，用户必须登录。
+    if (pickString.startsWith(KeysOfFunCtx.VISITOR_ATTR)) {
+      const reqModel = funcCtx?.reqModel;
+      const attrValue = _.get(reqModel, pickString); // visitor.nickName
+      if (isNil(attrValue)) {
+        throw new CommonException(Exceptions.RUN_PICK_ERR_VISITOR_NULL, '获取用户ID失败, 可能用户没有登陆');
+      }
+      return attrValue;
+    }
+
+    // 例如：accountId, 访问此变量，用户必须登录。
+    if (pickString === KeysOfFunCtx.VISITOR) {
+      const visitor = funcCtx?.reqModel?.visitor;
+      if (isNil(visitor)) {
+        throw new CommonException(Exceptions.RUN_PICK_ERR_VISITOR_NULL, '获取用户对象失败, 可能用户没有登陆');
+      }
+      return visitor;
+    }
+
+    // 例如： req.data.name
+    if (pickString.startsWith(KeysOfFunCtx.REQUEST)) {
+      const reqExpress = pickString.substring(KeysOfFunCtx.REQUEST.length);
+      return _.get(funcCtx.reqModel, reqExpress);
+    }
+
+    // 例如： res.total_count
+    if (pickString.startsWith(KeysOfFunCtx.RESULT)) {
+      const reqExpress = pickString.substring(KeysOfFunCtx.RESULT.length);
+      return _.get(funcCtx.resModel, reqExpress);
+    }
+
+    return null;
+  }
+
+  private getFunctionParamValues(functionParams: IFunctionParam[], funcContext: FuncContext): any[] {
+    if (isNil(functionParams) || isEmpty(functionParams)) {
+      return [];
+    }
+    return functionParams.map(p => {
+      if (typeof p === 'undefined' || p === null) {
+        return null;
+      }
+
+      if (typeof p === 'string' || typeof p === 'number' || typeof p === 'boolean') {
+        return p;
+      }
+      return this.executeFuncCfg(p, funcContext);
+    });
+  }
+}
+
+export { CrudProExecuteFuncService };