midway-fatcms 0.0.1-beta.1

package/src/libs/crud-pro/utils/MultiKeyMap.ts

@@ -0,0 +1,72 @@
+class MultiKeyMap {
+  private readonly _multiMap: Record<string, Record<string, any>> = {};
+  private _rowsLength = 0;
+
+  constructor(rows?: any[], keyName1?: string, keyName2?: string) {
+    if (rows && keyName1 && keyName2) {
+      this.addRows(rows, keyName1, keyName2);
+    }
+  }
+
+  public isEmpty() {
+    return this._rowsLength === 0;
+  }
+
+  public getValue(key1: string, key2: string) {
+    const map1 = this._multiMap[key1];
+    if (!map1) {
+      return null;
+    }
+    return map1[key2];
+  }
+
+  public getValue1(key1: string): Record<string, any> {
+    return this._multiMap[key1];
+  }
+
+  public addRowsValue1(rows: any[], value1: string, keyName2: string) {
+    if (!Array.isArray(rows) || rows.length === 0) {
+      return;
+    }
+
+    this._rowsLength = this._rowsLength + rows.length;
+    const dictMap: Record<string, Record<string, any>> = this._multiMap;
+
+    for (let i = 0; i < rows.length; i++) {
+      const row = rows[i] || {};
+      const value2 = row[keyName2];
+      let dictItemMap = dictMap[value1];
+      if (!dictItemMap) {
+        dictItemMap = {};
+        dictMap[value1] = dictItemMap;
+      }
+      dictItemMap[value2] = row;
+
+      // 继续遍历children
+      this.addRowsValue1(row.children, value1, keyName2);
+    }
+  }
+
+  public addRows(rows: any[], keyName1: string, keyName2: string) {
+    if (!Array.isArray(rows)) {
+      return;
+    }
+
+    this._rowsLength = this._rowsLength + rows.length;
+    const dictMap: Record<string, Record<string, any>> = this._multiMap;
+
+    for (let i = 0; i < rows.length; i++) {
+      const row = rows[i] || {};
+      const value1 = row[keyName1];
+      const value2 = row[keyName2];
+      let dictItemMap = dictMap[value1];
+      if (!dictItemMap) {
+        dictItemMap = {};
+        dictMap[value1] = dictItemMap;
+      }
+      dictItemMap[value2] = row;
+    }
+  }
+}
+
+export { MultiKeyMap };

package/src/libs/crud-pro/utils/SqlFuncUtils.ts

@@ -0,0 +1,29 @@
+const SQL_FUNC_MAP = {
+  NOW: 'NOW()',
+};
+
+/**
+ * data: {
+ * 	xxTime: {$sqlFunc:"NOW"}
+ * }
+ * @param arg
+ */
+function getSqlFuncName(arg: any): string {
+  if (arg && typeof arg === 'object' && typeof arg['$sqlFunc'] === 'string') {
+    const sqlFunKey = arg['$sqlFunc'];
+    return SQL_FUNC_MAP[sqlFunKey];
+  }
+  return null;
+}
+
+const sqlFuncUtils = {
+  isSqlFuncArg: (arg: any): boolean => {
+    const sqlFuncName = getSqlFuncName(arg);
+    return !!sqlFuncName;
+  },
+  toFuncSQL: (arg: any): string => {
+    return getSqlFuncName(arg);
+  },
+};
+
+export { sqlFuncUtils };

package/src/libs/crud-pro/utils/TypeUtils.ts

@@ -0,0 +1,188 @@
+import { CommonException, Exceptions } from '../exceptions';
+
+const TypeUtils = {
+  assertJsonArray(value: any, errorCode: string) {
+    if (!Array.isArray(value)) {
+      throw new CommonException(errorCode, JSON.stringify(value));
+    }
+  },
+
+  assertBasicType(value: any, errorCode: string) {
+    if (!TypeUtils.isBasicType(value)) {
+      throw new CommonException(errorCode, JSON.stringify(value));
+    }
+  },
+
+  isBasicType(value: any): boolean {
+    if (value == null) {
+      return true;
+    }
+
+    const valueType = typeof value;
+    return valueType === 'boolean' || valueType === 'string' || valueType === 'number';
+  },
+  isBoolean(itemValue: any): boolean {
+    return typeof itemValue === 'boolean';
+  },
+  isString(itemValue: any) {
+    return typeof itemValue === 'string';
+  },
+  isInteger(x: any) {
+    return typeof x === 'number' && Math.floor(x) === x;
+  },
+  isNumber(x: any) {
+    return typeof x === 'number';
+  },
+
+  isNumeric(itemValue: any) {
+    if (typeof itemValue === 'number') {
+      return true;
+    }
+    if (typeof itemValue === 'string' && itemValue.length > 0) {
+      return !isNaN(Number(itemValue));
+    }
+    return false;
+  },
+
+  /**
+   * 是否是合法的name类型：以字母开头，只能包含（字母、数字、下划线）的非空字符串
+   * @param itemValue
+   */
+  isValidName(itemValue: any): boolean {
+    if (typeof itemValue === 'string' && itemValue.length > 0) {
+      const reg = /^\w+$/; // --已经验证OK
+      return reg.test(itemValue);
+    }
+    return false;
+  },
+
+  /**
+   * 是否是合法中文手机号
+   * @param itemValue
+   */
+  isChinesePhone(itemValue: string) {
+    if (typeof itemValue === 'string' && itemValue.length > 0) {
+      return TypeUtils.isNumeric(itemValue) && itemValue.length === 11;
+    }
+    return false;
+  },
+
+  /**
+   * 是否是合法的email地址
+   * @param itemValue
+   */
+  isEmailStrValid(itemValue: string) {
+    if (typeof itemValue === 'string' && itemValue.length > 0) {
+      const regExpStr = '^([a-z0-9A-Z]+[-|\\.]?)+[a-z0-9A-Z]@([a-z0-9A-Z]+(-[a-z0-9A-Z]+)?\\.)+[a-zA-Z]{2,}$';
+      const reg = new RegExp(regExpStr);
+      return reg.test(itemValue);
+    }
+    return false;
+  },
+
+  /**
+   * 从字符串中提取数字部分。
+   * @param s
+   */
+  pickNumber(s: string): number | null {
+    if (typeof s === 'undefined' || s === null) {
+      return null;
+    }
+
+    s = s.trim();
+
+    const length = s.length;
+
+    if (length === 0) {
+      return null;
+    }
+
+    const sb = [];
+
+    for (let i = 0; i < length; i++) {
+      const c = s.charAt(i);
+      // 0到9或小数点，或负号
+      if (TypeUtils.isNumberChar(c) || c === '.' || c === '-') {
+        sb.push(c);
+      }
+    }
+
+    const s2 = sb.join('');
+    if (s2.length === 0) {
+      return null;
+    }
+
+    const num = Number(s2);
+    if (isNaN(num)) {
+      return null;
+    }
+    return num;
+  },
+
+  isNumberChar(c: string): boolean {
+    const charCode = c.charCodeAt(0);
+    return charCode >= 48 && charCode <= 57; // 0 ~ 9
+  },
+
+  isNil(obj: any): boolean {
+    return typeof obj === 'undefined' || obj === null;
+  },
+
+  /**
+   * 判断数字是否满足范围表达式
+   * @param scaleExpress ：
+   *    范围表达式：(0,1) 开区间，[0,1] 闭区间，(0,1] 前开后闭，[0,1) 前闭后开; 若没有大小括号，则默认闭区间
+   * @param numberValue: 数字
+   */
+  isNumberScaleValid(scaleExpress: string, numberValue: number): boolean {
+    if (typeof numberValue !== 'number') {
+      return false;
+    }
+
+    const specials = ['(', ')', '[', ']', ' '];
+    const scale = scaleExpress.trim();
+
+    const scaleNumbersArray = (() => {
+      const scaleNumbers = [];
+      for (let i = 0; i < scale.length; i++) {
+        const char = scale[i];
+        if (specials.indexOf(char) < 0) {
+          scaleNumbers.push(char);
+        }
+      }
+      return scaleNumbers
+        .join('')
+        .split(',')
+        .map(s => {
+          return Number(s);
+        });
+    })();
+
+    if (scaleNumbersArray.length !== 2) {
+      throw new CommonException(Exceptions.CFG_VALIDATE_SCALE_ERROR, '范围匹配表达式不正确:' + scaleExpress);
+    }
+
+    const isStartOpen = scale.startsWith('(');
+    const isEndOpen = scale.endsWith(')');
+    const startNumber = scaleNumbersArray[0];
+    const endNumber = scaleNumbersArray[1];
+
+    let isStartOk = false;
+    let isEndOk = false;
+    if (isStartOpen) {
+      isStartOk = startNumber < numberValue;
+    } else {
+      isStartOk = startNumber <= numberValue;
+    }
+
+    if (isEndOpen) {
+      isEndOk = endNumber > numberValue;
+    } else {
+      isEndOk = endNumber >= numberValue;
+    }
+
+    return isStartOk && isEndOk;
+  },
+};
+
+export { TypeUtils };

package/src/libs/crud-pro/utils/ValidateUtils.ts

@@ -0,0 +1,167 @@
+import * as moment from 'moment';
+import { KeysOfValidators } from '../models/keys';
+import { CommonException, Exceptions } from '../exceptions';
+import { MixinUtils } from './MixinUtils';
+import { TypeUtils } from './TypeUtils';
+const { isEmpty } = MixinUtils;
+
+const validatorUtils = {
+  /**
+   * 字符串长度
+   * @param itemCfg
+   * @param itemValue
+   */
+  isLengthValid(itemCfg: string, itemValue: any): boolean {
+    if (typeof itemValue === 'string') {
+      const cfgPart = itemCfg.substring(KeysOfValidators.LENGTH.length);
+      return TypeUtils.isNumberScaleValid(cfgPart, itemValue.length);
+    }
+    return false;
+  },
+
+  /**
+   * 数字范围
+   * @param itemCfg
+   * @param itemValue
+   */
+  isNumberScaleValid(itemCfg: string, itemValue: any) {
+    if (typeof itemValue === 'number') {
+      const cfgPart = itemCfg.substring(KeysOfValidators.SCALE.length).trim();
+      return TypeUtils.isNumberScaleValid(cfgPart, itemValue);
+    } else if (TypeUtils.isNumeric(itemValue)) {
+      const cfgPart = itemCfg.substring(KeysOfValidators.SCALE.length).trim();
+      return TypeUtils.isNumberScaleValid(cfgPart, Number(itemValue));
+    }
+    return false;
+  },
+
+  /**
+   * 正则表达式
+   * @param itemCfg
+   * @param itemValue
+   */
+  isRegExpValid(itemCfg: string, itemValue: any): boolean {
+    if (typeof itemValue === 'string') {
+      const cfgPart = itemCfg.substring(KeysOfValidators.REG_EXP.length);
+      const regexp = new RegExp(cfgPart);
+      return regexp.test(itemValue);
+    }
+    return false;
+  },
+
+  isMomentValid(itemCfg: string, itemValue: any): boolean {
+    const cfgPart = itemCfg.substring(KeysOfValidators.ENUM.length).trim();
+    return moment(itemValue, cfgPart, true).isValid();
+  },
+
+  isEnumValid(itemCfg: string, itemValue: any): boolean {
+    const cfgPart = itemCfg.substring(KeysOfValidators.ENUM.length).trim();
+    const cfgArr = cfgPart.split(','); // 1,2,3,4
+    const enumStrArr = cfgArr.map(s => s.trim()).filter(s => !!s);
+
+    // 枚举值的配置不能为空
+    if (isEmpty(enumStrArr)) {
+      throw new CommonException(Exceptions.CFG_VALIDATE_ENUM_ERROR, itemCfg);
+    }
+
+    // 值：不能为空
+    if (itemValue == null) {
+      return false;
+    }
+
+    // 值：不能为空
+    const itemValueString = itemValue.toString();
+    if (isEmpty(itemValueString)) {
+      return false;
+    }
+
+    for (let i = 0; i < enumStrArr.length; i++) {
+      const enumStr = enumStrArr[i];
+      if (enumStr === itemValueString) {
+        return true;
+      }
+    }
+
+    return false;
+  },
+};
+
+function validateByCfgStringInner(validateCfg: KeysOfValidators | string, itemValue: any): boolean {
+  if (KeysOfValidators.ARRAY === validateCfg) {
+    return itemValue !== null && Array.isArray(itemValue);
+  } else if (KeysOfValidators.ARRAY_STRING === validateCfg) {
+    return (
+      itemValue !== null &&
+      Array.isArray(itemValue) &&
+      MixinUtils.isElementAllMatch(itemValue, e => {
+        return typeof e === 'string';
+      })
+    );
+  } else if (KeysOfValidators.ARRAY_NUMBER === validateCfg) {
+    return (
+      itemValue !== null &&
+      Array.isArray(itemValue) &&
+      MixinUtils.isElementAllMatch(itemValue, e => {
+        return typeof e === 'number';
+      })
+    );
+  } else if (KeysOfValidators.OBJECT === validateCfg) {
+    return itemValue !== null && typeof itemValue === 'object';
+  } else if (KeysOfValidators.BOOLEAN === validateCfg) {
+    return TypeUtils.isBoolean(itemValue);
+  } else if (KeysOfValidators.STRING === validateCfg) {
+    return TypeUtils.isString(itemValue);
+  } else if (KeysOfValidators.INTEGER === validateCfg) {
+    return TypeUtils.isInteger(itemValue);
+  } else if (KeysOfValidators.NUMBER === validateCfg) {
+    return TypeUtils.isNumber(itemValue);
+  } else if (KeysOfValidators.NUMERIC === validateCfg) {
+    return TypeUtils.isNumeric(itemValue);
+  } else if (KeysOfValidators.NAME === validateCfg) {
+    return TypeUtils.isValidName(itemValue);
+  } else if (KeysOfValidators.PHONE_CN === validateCfg) {
+    return TypeUtils.isChinesePhone(itemValue.toString());
+  } else if (KeysOfValidators.EMAIL === validateCfg) {
+    return TypeUtils.isEmailStrValid(itemValue);
+  } else if (validateCfg.startsWith(KeysOfValidators.LENGTH)) {
+    return validatorUtils.isLengthValid(validateCfg, itemValue);
+  } else if (validateCfg.startsWith(KeysOfValidators.REG_EXP)) {
+    return validatorUtils.isRegExpValid(validateCfg, itemValue);
+  } else if (validateCfg.startsWith(KeysOfValidators.SCALE)) {
+    return validatorUtils.isNumberScaleValid(validateCfg, itemValue);
+  } else if (validateCfg.startsWith(KeysOfValidators.ENUM)) {
+    return validatorUtils.isEnumValid(validateCfg, itemValue);
+  } else if (validateCfg.startsWith(KeysOfValidators.MOMENT)) {
+    return validatorUtils.isMomentValid(validateCfg, itemValue);
+  }
+  throw new CommonException(Exceptions.CFG_VALIDATE_NOT_SUPPORT, validateCfg);
+}
+
+function validateByCfgString(validateCfg: KeysOfValidators | string, itemValue: any, errPath: string) {
+  if (isEmpty(validateCfg)) {
+    // 没有配置，不需要校验
+    return;
+  }
+
+
+  // 必填
+  if ("required" === validateCfg) {
+    if (isEmpty(itemValue)) {
+      throw new CommonException(Exceptions.VALIDATE_ERR, "'参数校验错误，字段 " + errPath + ' 不满足校验配置：' + validateCfg);
+    }
+    return;
+  }
+
+  // 没有填写的话，不需要校验。
+  if (isEmpty(itemValue)) {
+    return;
+  }
+
+
+  // 校验失败
+  if (!validateByCfgStringInner(validateCfg, itemValue)) {
+    throw new CommonException(Exceptions.VALIDATE_ERR, "'参数校验错误，字段 " + errPath + ' 不满足校验配置：' + validateCfg);
+  }
+}
+
+export { validateByCfgString };

package/src/libs/crud-pro/utils/pool/MySQLUtils.ts

@@ -0,0 +1,20 @@
+import { createPool } from 'mysql2/promise';
+import { IConnectionPool } from '../../interfaces';
+import {SqlDbType} from "../../models/keys";
+
+const POOL_CACHE_MAP: Record<string, IConnectionPool> = {};
+
+function getConnectionPool(poolName: string, poolOptions: any): IConnectionPool {
+  let pool = POOL_CACHE_MAP[poolName];
+  if (!pool) {
+    pool = {
+      dbType: SqlDbType.mysql,
+      poolName: poolName,
+      poolInstance: createPool(poolOptions),
+    };
+    POOL_CACHE_MAP[poolName] = pool;
+  }
+  return pool;
+}
+
+export { getConnectionPool };

package/src/libs/crud-pro/utils/pool/PostgresUtils.ts

@@ -0,0 +1,22 @@
+import {Pool} from 'pg';
+import {IConnectionPool} from '../../interfaces';
+import {SqlDbType} from "../../models/keys";
+
+const POOL_CACHE_MAP: Record<string, IConnectionPool> = {};
+
+function getConnectionPool(poolName: string, poolOptions: any): IConnectionPool {
+  let pool = POOL_CACHE_MAP[poolName];
+  if (!pool) {
+    const poolObj = new Pool(poolOptions);
+
+    pool = {
+      dbType: SqlDbType.postgres,
+      poolName: poolName,
+      poolInstance: poolObj,
+    };
+    POOL_CACHE_MAP[poolName] = pool;
+  }
+  return pool;
+}
+
+export { getConnectionPool };

package/src/libs/crud-pro/utils/pool/SqlServerUtils.ts

@@ -0,0 +1,22 @@
+import {ConnectionPool} from 'mssql';
+import {IConnectionPool} from '../../interfaces';
+import {SqlDbType} from "../../models/keys";
+
+const POOL_CACHE_MAP: Record<string, IConnectionPool> = {};
+
+function getConnectionPool(poolName: string, poolOptions: any): IConnectionPool {
+  let pool = POOL_CACHE_MAP[poolName];
+  if (!pool) {
+    const poolObj = new ConnectionPool(poolOptions);
+
+    pool = {
+      dbType: SqlDbType.sqlserver,
+      poolName: poolName,
+      poolInstance: poolObj,
+    };
+    POOL_CACHE_MAP[poolName] = pool;
+  }
+  return pool;
+}
+
+export { getConnectionPool };

package/src/libs/crud-pro/utils/sqlConvert/convertColumnName.ts

@@ -0,0 +1,26 @@
+import {SqlCfgModel} from "../../models/SqlCfgModel";
+import {SqlDbType} from "../../models/keys";
+
+
+function toSqlColumnName(columnName: string, sqlCfgModel: SqlCfgModel): string {
+  if (sqlCfgModel.sqlDdType === SqlDbType.postgres) {
+    return '"' + columnName + '"';
+  }
+  if (sqlCfgModel.sqlDdType === SqlDbType.sqlserver) {
+    return '[' + columnName + ']';
+  }
+  return '`' + columnName + '`';
+}
+
+function toSqlColumnNamesJoin(columns: string[], sqlCfgModel: SqlCfgModel): string {
+  const columns2 = columns.map(col => {
+    return toSqlColumnName(col.trim(), sqlCfgModel);
+  });
+  return columns2.join(',');
+}
+
+
+export {
+  toSqlColumnName,
+  toSqlColumnNamesJoin
+}

package/src/libs/crud-pro/utils/sqlConvert/convertMsSql.ts

@@ -0,0 +1,11 @@
+function replaceQuestionMarksForMssql(sql:string): string {
+  let count = 0;
+  return sql.replace(/\?/g, () => {
+    count = count+ 1;
+    return `@fatcms_ms${count}`
+  });
+}
+
+export {
+  replaceQuestionMarksForMssql,
+}

package/src/libs/crud-pro/utils/sqlConvert/convertPgSql.ts

@@ -0,0 +1,11 @@
+function replaceQuestionMarks(sql:string): string {
+  let count = 0;
+  return sql.replace(/\?/g, () => {
+    count = count+ 1;
+    return `$${count}`
+  });
+}
+
+export {
+  replaceQuestionMarks,
+}