midway-fatcms 0.0.1-beta.6 → 0.0.1-beta.60

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

@@ -1,98 +1,106 @@
-import * as _ from 'lodash';
-import { ICurdProServiceHub } from '../models/ServiceHub';
-import {ICrudProCfg, ILogger, IPoolConnectionClient} from '../interfaces';
-import { SqlCfgModel } from '../models/SqlCfgModel';
-import { ExecuteContext } from '../models/ExecuteContext';
-import { MixinUtils } from '../utils/MixinUtils';
-import { TypeUtils } from '../utils/TypeUtils';
-import { CompareUtils } from '../utils/CompareUtils';
-import { DateTimeUtils } from '../utils/DateTimeUtils';
-import { IExecuteContextFunc } from '../models/ExecuteContextFunc';
-import { DEFAULT_MAX_LIMIT } from '../defaultConfigs';
-
-function createBuildInExecuteFuncMap() {
-  return {
-    ...DateTimeUtils,
-    ...CompareUtils,
-    ...MixinUtils,
-    ...TypeUtils,
-  };
-}
-
-interface ExecuteUnsafeQueryCtx {
-  tableName: string;
-  dbName: string;
-}
-
-const buildInExecuteFuncMap = createBuildInExecuteFuncMap();
-
-class CrudProServiceBase {
-  protected serviceHub: ICurdProServiceHub;
-
-  constructor(serviceHub: ICurdProServiceHub) {
-    this.serviceHub = serviceHub;
-  }
-
-  protected getExecuteContext(): ExecuteContext {
-    return this.serviceHub.getExecuteContext();
-  }
-
-  protected getContextFunc(): IExecuteContextFunc {
-    return this.getExecuteContext().contextFunc;
-  }
-
-  protected get logger(): ILogger {
-    return this.getExecuteContext().getLogger();
-  }
-
-  protected async getTxConnectionBySqlCfg(sqlCfgModel: SqlCfgModel): Promise<IPoolConnectionClient> {
-    const executeContext = this.getExecuteContext();
-    const transaction = executeContext.getTransaction();
-    const contextFunc = this.getContextFunc();
-    const pool = await contextFunc.getConnectionPool(sqlCfgModel);
-    return transaction.getTxConnection(pool);
-  }
-
-  /**
-   * 不做任何检验，直接执行SQL，只能CrudPro内部使用，不对外使用
-   * @param obj
-   * @param sql
-   * @param values
-   * @protected
-   */
-  protected async executeUnsafeQuery(obj: ExecuteUnsafeQueryCtx, sql: string, values?: any) {
-    const sqlCfgModel: any = {
-      sqlTable: obj.tableName,
-      sqlDatabase: obj.dbName,
-      columns: [],
-      columnsRelation: [],
-      maxLimit: DEFAULT_MAX_LIMIT,
-      resName: 'executeUnsafeQuery',
-      originSql: sql,
-      executeSql: sql,
-      executeSqlArgs: values,
-      crudType: null,
-    };
-    const connection = await this.getTxConnectionBySqlCfg(sqlCfgModel);
-    return await connection.query(sql, values);
-  }
-
-  protected getContextCfg(): ICrudProCfg {
-    return this.getExecuteContext().getContextCfg();
-  }
-
-  protected getExecuteFunction(funcName: string): any {
-    const contextFunc = this.getContextFunc();
-    const functionMap = contextFunc.getFunctionMap();
-    if (functionMap) {
-      const func = _.get(functionMap, funcName);
-      if (typeof func === 'function') {
-        return func;
-      }
-    }
-    console.log('buildInExecuteFuncMap', Object.keys(buildInExecuteFuncMap));
-    return _.get(buildInExecuteFuncMap, funcName);
-  }
-}
-
-export { CrudProServiceBase };
+import * as _ from 'lodash';
+import { ICurdProServiceHub } from '../models/ServiceHub';
+import { ICrudProCfg, IExecuteUnsafeQueryCtx, ILogger, IPoolConnectionClient } from '../interfaces';
+import { SqlCfgModel } from '../models/SqlCfgModel';
+import { ExecuteContext } from '../models/ExecuteContext';
+import { MixinUtils } from '../utils/MixinUtils';
+import { TypeUtils } from '../utils/TypeUtils';
+import { CompareUtils } from '../utils/CompareUtils';
+import { DateTimeUtils } from '../utils/DateTimeUtils';
+import { IExecuteContextFunc } from '../models/ExecuteContextFunc';
+import { DEFAULT_MAX_LIMIT } from '../defaultConfigs';
+import { SqlDbType } from '../models/keys';
+import { replaceQuestionMarks } from '../utils/sqlConvert/convertPgSql';
+import { replaceQuestionMarksForMssql } from '../utils/sqlConvert/convertMsSql';
+
+function createBuildInExecuteFuncMap() {
+  return {
+    ...DateTimeUtils,
+    ...CompareUtils,
+    ...MixinUtils,
+    ...TypeUtils,
+  };
+}
+
+const buildInExecuteFuncMap = createBuildInExecuteFuncMap();
+
+class CrudProServiceBase {
+  protected serviceHub: ICurdProServiceHub;
+
+  constructor(serviceHub: ICurdProServiceHub) {
+    this.serviceHub = serviceHub;
+  }
+
+  protected getExecuteContext(): ExecuteContext {
+    return this.serviceHub.getExecuteContext();
+  }
+
+  protected getContextFunc(): IExecuteContextFunc {
+    return this.getExecuteContext().contextFunc;
+  }
+
+  protected get logger(): ILogger {
+    return this.getExecuteContext().getLogger();
+  }
+
+  protected async getTxConnectionBySqlCfg(sqlCfgModel: SqlCfgModel): Promise<IPoolConnectionClient> {
+    const executeContext = this.getExecuteContext();
+    const transaction = executeContext.getTransaction();
+    const contextFunc = this.getContextFunc();
+    const pool = await contextFunc.getConnectionPool(sqlCfgModel);
+    return transaction.getTxConnection(pool);
+  }
+
+  /**
+   * 不做任何检验，直接执行SQL，只能CrudPro内部使用，不对外使用
+   * @param obj
+   * @param sql
+   * @param values
+   * @protected
+   */
+  protected async executeUnsafeQuery(obj: IExecuteUnsafeQueryCtx, sql: string, values?: any) {
+    const sqlCfgModel: any = {
+      sqlTable: obj.sqlTable,
+      sqlDatabase: obj.sqlDatabase,
+      sqlDbType: obj.sqlDbType,
+      columns: [],
+      columnsRelation: [],
+      maxLimit: DEFAULT_MAX_LIMIT,
+      resName: 'executeUnsafeQuery',
+      originSql: sql,
+      executeSql: sql,
+      executeSqlArgs: values,
+      crudType: null,
+    };
+
+    if (sqlCfgModel.sqlDbType === SqlDbType.postgres) {
+      const pgSql = replaceQuestionMarks(sqlCfgModel.executeSql);
+      sqlCfgModel.executeSql = pgSql;
+    } else if (sqlCfgModel.sqlDbType === SqlDbType.sqlserver) {
+      const mssql = replaceQuestionMarksForMssql(sqlCfgModel.executeSql);
+      sqlCfgModel.executeSql = mssql;
+    }
+
+    const connection = await this.getTxConnectionBySqlCfg(sqlCfgModel);
+    return await connection.query(sqlCfgModel.executeSql, values);
+  }
+
+  protected getContextCfg(): ICrudProCfg {
+    return this.getExecuteContext().getContextCfg();
+  }
+
+  protected getExecuteFunction(funcName: string): any {
+    const contextFunc = this.getContextFunc();
+    const functionMap = contextFunc.getFunctionMap();
+    if (functionMap) {
+      const func = _.get(functionMap, funcName);
+      if (typeof func === 'function') {
+        return func;
+      }
+    }
+    console.log('buildInExecuteFuncMap', Object.keys(buildInExecuteFuncMap));
+    return _.get(buildInExecuteFuncMap, funcName);
+  }
+}
+
+export { CrudProServiceBase };

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

@@ -1,59 +1,86 @@
-import { CrudProServiceBase } from './CrudProServiceBase';
-import { SqlCfgModel } from '../models/SqlCfgModel';
-import { ITableMeta } from '../interfaces';
-
-class CrudProTableMetaCache {
-  private cacheMap: Record<string, ITableMeta> = {};
-  private getCacheKey(sqlCfgModel: SqlCfgModel) {
-    return `${sqlCfgModel.sqlDatabase}:::${sqlCfgModel.sqlSchema}:::${sqlCfgModel.sqlTable}`;
-  }
-  public getMeta(sqlCfgModel: SqlCfgModel) {
-    const cacheKey = this.getCacheKey(sqlCfgModel);
-    const obj = this.cacheMap[cacheKey];
-    if (obj && obj.expiredTime < Date.now()) {
-      return obj;
-    }
-    return null;
-  }
-
-  public setMeta(sqlCfgModel: SqlCfgModel, metaObj: ITableMeta) {
-    const cacheKey = this.getCacheKey(sqlCfgModel);
-    this.cacheMap[cacheKey] = metaObj;
-  }
-}
-
-const metaCache = new CrudProTableMetaCache();
-
-class CrudProTableMetaService extends CrudProServiceBase {
-  async getTableMeta(sqlCfgModel: SqlCfgModel): Promise<ITableMeta> {
-    let obj = metaCache.getMeta(sqlCfgModel);
-    if (!obj) {
-      obj = await this.loadTableMeta(sqlCfgModel);
-      metaCache.setMeta(sqlCfgModel, obj);
-    }
-    return obj;
-  }
-
-  private async loadTableMeta(sqlCfgModel: SqlCfgModel): Promise<ITableMeta> {
-    const { tableMetaCacheTime } = this.getContextCfg();
-
-    const obj = {
-      expiredTime: Date.now() + tableMetaCacheTime || 1000 * 3600 * 24 * 365,
-      tableColumns: [],
-    };
-
-    const baseInfo = {
-      tableName: sqlCfgModel.sqlTable,
-      dbName: sqlCfgModel.sqlDatabase,
-    };
-
-    const [tableDescribe] = await this.executeUnsafeQuery(baseInfo, 'describe ' + sqlCfgModel.sqlTable);
-    const tableDescribe2 = JSON.parse(JSON.stringify(tableDescribe));
-    obj.tableColumns = tableDescribe2.map(fieldObj => {
-      return fieldObj['Field'];
-    });
-    return obj;
-  }
-}
-
-export { CrudProTableMetaService };
+import { CrudProServiceBase } from './CrudProServiceBase';
+import { SqlCfgModel } from '../models/SqlCfgModel';
+import { IExecuteUnsafeQueryCtx, ITableMeta } from '../interfaces';
+import { SqlDbType } from '../models/keys';
+import { pickAndConvertRowsByMix } from '../utils/sqlConvert/convertMix';
+
+class CrudProTableMetaCache {
+  private cacheMap: Record<string, ITableMeta> = {};
+  private getCacheKey(sqlCfgModel: SqlCfgModel) {
+    return `${sqlCfgModel.sqlDatabase}:::${sqlCfgModel.sqlSchema}:::${sqlCfgModel.sqlTable}`;
+  }
+  public getMeta(sqlCfgModel: SqlCfgModel) {
+    const cacheKey = this.getCacheKey(sqlCfgModel);
+    const obj = this.cacheMap[cacheKey];
+    if (obj && obj.expiredTime < Date.now()) {
+      return obj;
+    }
+    return null;
+  }
+
+  public setMeta(sqlCfgModel: SqlCfgModel, metaObj: ITableMeta) {
+    const cacheKey = this.getCacheKey(sqlCfgModel);
+    this.cacheMap[cacheKey] = metaObj;
+  }
+}
+
+const metaCache = new CrudProTableMetaCache();
+
+class CrudProTableMetaService extends CrudProServiceBase {
+  async getTableMeta(sqlCfgModel: SqlCfgModel): Promise<ITableMeta> {
+    let obj = metaCache.getMeta(sqlCfgModel);
+    if (!obj) {
+      obj = await this.loadTableMeta(sqlCfgModel);
+      metaCache.setMeta(sqlCfgModel, obj);
+    }
+    return obj;
+  }
+
+  private async loadTableMeta(sqlCfgModel: SqlCfgModel): Promise<ITableMeta> {
+    const { tableMetaCacheTime } = this.getContextCfg();
+
+    const obj = {
+      expiredTime: Date.now() + tableMetaCacheTime || 1000 * 3600 * 24 * 365,
+      tableColumns: [],
+    };
+
+    const baseInfo: IExecuteUnsafeQueryCtx = {
+      sqlTable: sqlCfgModel.sqlTable,
+      sqlDatabase: sqlCfgModel.sqlDatabase,
+      sqlDbType: sqlCfgModel.sqlDbType,
+    };
+
+    obj.tableColumns = await this.loadTableColumnInfo(baseInfo);
+
+    return obj;
+  }
+
+  private async loadTableColumnInfo(baseInfo: IExecuteUnsafeQueryCtx): Promise<string[]> {
+    if (baseInfo.sqlDbType === SqlDbType.mysql) {
+      const queryRes = await this.executeUnsafeQuery(baseInfo, 'describe ' + baseInfo.sqlTable);
+      const tableDescribe = pickAndConvertRowsByMix(queryRes, baseInfo.sqlDbType);
+      const tableDescribe2 = JSON.parse(JSON.stringify(tableDescribe));
+      return tableDescribe2.map(fieldObj => {
+        return fieldObj['Field'];
+      });
+    } else if (baseInfo.sqlDbType === SqlDbType.postgres) {
+      const schemaname = 'public';
+      const columnArraySql = `
+      SELECT
+        *
+        FROM information_schema.columns
+        WHERE table_schema = '${schemaname}' and table_name = '${baseInfo.sqlTable}'
+        ORDER BY ordinal_position;
+      `.trim();
+      const queryRes = await this.executeUnsafeQuery(baseInfo, columnArraySql);
+      const tableDescribe = pickAndConvertRowsByMix(queryRes, baseInfo.sqlDbType);
+      return tableDescribe.map(fieldObj => {
+        return fieldObj['column_name'];
+      });
+    }
+
+    throw new Error('暂不支持的数据库类型：' + baseInfo.sqlDbType);
+  }
+}
+
+export { CrudProTableMetaService };

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

@@ -1,92 +1,92 @@
-import { IFuncCfgModel, IRequestCfgModel, ITableMeta } from '../interfaces';
-import { RequestModel } from '../models/RequestModel';
-import { CrudProFieldValidateService } from './CrudProFieldValidateService';
-import { CrudProFieldUpdateService } from './CrudProFieldUpdateService';
-import { CrudProCachedCfgService } from './CrudProCachedCfgService';
-import { CrudProExecuteSqlService } from './CrudProExecuteSqlService';
-import { CrudProGenSqlService } from './CrudProGenSqlService';
-import { ExecuteContext } from '../models/ExecuteContext';
-import { CrudProOriginToExecuteSql } from './CrudProOriginToExecuteSql';
-import { SqlCfgModel } from '../models/SqlCfgModel';
-import { RequestCfgModel } from '../models/RequestCfgModel';
-import { ICurdProServiceHub } from '../models/ServiceHub';
-import { FuncContext } from '../models/FuncContext';
-import { CrudProExecuteFuncService } from './CrudProExecuteFuncService';
-import { CrudProTableMetaService } from './CrudProTableMetaService';
-
-class CurdProServiceHub implements ICurdProServiceHub {
-  private readonly executeContext: ExecuteContext;
-
-  private readonly fieldValidateService: CrudProFieldValidateService;
-  private readonly fieldUpdateService: CrudProFieldUpdateService;
-  private readonly cachedCfgService: CrudProCachedCfgService;
-  private readonly executeSqlService: CrudProExecuteSqlService;
-  private readonly genSqlService: CrudProGenSqlService;
-  private readonly originToExecuteSql: CrudProOriginToExecuteSql;
-  private readonly executeFuncService: CrudProExecuteFuncService;
-  private readonly tableMetaService: CrudProTableMetaService;
-
-  constructor(executeContext: ExecuteContext) {
-    this.executeContext = executeContext;
-    this.fieldValidateService = new CrudProFieldValidateService(this);
-    this.fieldUpdateService = new CrudProFieldUpdateService(this);
-    this.cachedCfgService = new CrudProCachedCfgService(this);
-    this.executeSqlService = new CrudProExecuteSqlService(this);
-    this.genSqlService = new CrudProGenSqlService(this);
-    this.originToExecuteSql = new CrudProOriginToExecuteSql(this);
-    this.executeFuncService = new CrudProExecuteFuncService(this);
-    this.tableMetaService = new CrudProTableMetaService(this);
-  }
-
-  getExecuteContext(): ExecuteContext {
-    return this.executeContext;
-  }
-
-  validateByAllow(cfgModel: RequestCfgModel, reqModel: RequestModel) {
-    return this.fieldValidateService.validateByAllow(cfgModel, reqModel);
-  }
-
-  validateByReject(cfgModel: RequestCfgModel, reqModel: RequestModel) {
-    return this.fieldValidateService.validateByReject(cfgModel, reqModel);
-  }
-
-  validateByCfg(cfgModel: RequestCfgModel, reqModel: RequestModel) {
-    return this.fieldValidateService.validateByCfg(cfgModel, reqModel);
-  }
-
-  async validateByAuthCfg(cfgModel: RequestCfgModel, reqModel: RequestModel): Promise<any> {
-    const contextFunc = this.executeContext.contextFunc;
-    if (contextFunc && contextFunc.validateByAuthCfg) {
-      return contextFunc.validateByAuthCfg(cfgModel, reqModel);
-    }
-  }
-
-  updateByCfg(cfgModel: RequestCfgModel, reqModel: RequestModel) {
-    return this.fieldUpdateService.updateByCfg(cfgModel, reqModel);
-  }
-  async getCachedCfgByMethod(method: string, isEnableCache: boolean): Promise<IRequestCfgModel> {
-    return this.cachedCfgService.getCachedCfgByMethod(method, isEnableCache);
-  }
-
-  async generateSQLList(): Promise<void> {
-    return this.genSqlService.generateSQLList();
-  }
-
-  async executeSqlCfgModels(): Promise<void> {
-    return this.executeSqlService.executeSqlCfgModels();
-  }
-
-  async convertOriginToExecuteSql(sqlCfgModel: SqlCfgModel): Promise<void> {
-    return this.originToExecuteSql.convertOriginToExecuteSql(sqlCfgModel);
-  }
-
-  executeFuncCfg(funCfg: IFuncCfgModel, funcContext: FuncContext): any {
-    return this.executeFuncService.executeFuncCfg(funCfg, funcContext);
-  }
-
-  async getTableMeta(sqlCfgModel: SqlCfgModel): Promise<ITableMeta> {
-    return await this.tableMetaService.getTableMeta(sqlCfgModel);
-  }
-}
-
-export { CurdProServiceHub };
+import { IFuncCfgModel, IRequestCfgModel, ITableMeta } from '../interfaces';
+import { RequestModel } from '../models/RequestModel';
+import { CrudProFieldValidateService } from './CrudProFieldValidateService';
+import { CrudProFieldUpdateService } from './CrudProFieldUpdateService';
+import { CrudProCachedCfgService } from './CrudProCachedCfgService';
+import { CrudProExecuteSqlService } from './CrudProExecuteSqlService';
+import { CrudProGenSqlService } from './CrudProGenSqlService';
+import { ExecuteContext } from '../models/ExecuteContext';
+import { CrudProOriginToExecuteSql } from './CrudProOriginToExecuteSql';
+import { SqlCfgModel } from '../models/SqlCfgModel';
+import { RequestCfgModel } from '../models/RequestCfgModel';
+import { ICurdProServiceHub } from '../models/ServiceHub';
+import { FuncContext } from '../models/FuncContext';
+import { CrudProExecuteFuncService } from './CrudProExecuteFuncService';
+import { CrudProTableMetaService } from './CrudProTableMetaService';
+
+class CurdProServiceHub implements ICurdProServiceHub {
+  private readonly executeContext: ExecuteContext;
+
+  private readonly fieldValidateService: CrudProFieldValidateService;
+  private readonly fieldUpdateService: CrudProFieldUpdateService;
+  private readonly cachedCfgService: CrudProCachedCfgService;
+  private readonly executeSqlService: CrudProExecuteSqlService;
+  private readonly genSqlService: CrudProGenSqlService;
+  private readonly originToExecuteSql: CrudProOriginToExecuteSql;
+  private readonly executeFuncService: CrudProExecuteFuncService;
+  private readonly tableMetaService: CrudProTableMetaService;
+
+  constructor(executeContext: ExecuteContext) {
+    this.executeContext = executeContext;
+    this.fieldValidateService = new CrudProFieldValidateService(this);
+    this.fieldUpdateService = new CrudProFieldUpdateService(this);
+    this.cachedCfgService = new CrudProCachedCfgService(this);
+    this.executeSqlService = new CrudProExecuteSqlService(this);
+    this.genSqlService = new CrudProGenSqlService(this);
+    this.originToExecuteSql = new CrudProOriginToExecuteSql(this);
+    this.executeFuncService = new CrudProExecuteFuncService(this);
+    this.tableMetaService = new CrudProTableMetaService(this);
+  }
+
+  getExecuteContext(): ExecuteContext {
+    return this.executeContext;
+  }
+
+  validateByAllow(cfgModel: RequestCfgModel, reqModel: RequestModel) {
+    return this.fieldValidateService.validateByAllow(cfgModel, reqModel);
+  }
+
+  validateByReject(cfgModel: RequestCfgModel, reqModel: RequestModel) {
+    return this.fieldValidateService.validateByReject(cfgModel, reqModel);
+  }
+
+  validateByCfg(cfgModel: RequestCfgModel, reqModel: RequestModel) {
+    return this.fieldValidateService.validateByCfg(cfgModel, reqModel);
+  }
+
+  async validateByAuthCfg(cfgModel: RequestCfgModel, reqModel: RequestModel): Promise<any> {
+    const contextFunc = this.executeContext.contextFunc;
+    if (contextFunc && contextFunc.validateByAuthCfg) {
+      return contextFunc.validateByAuthCfg(cfgModel, reqModel);
+    }
+  }
+
+  updateByCfg(cfgModel: RequestCfgModel, reqModel: RequestModel) {
+    return this.fieldUpdateService.updateByCfg(cfgModel, reqModel);
+  }
+  async getCachedCfgByMethod(method: string, isEnableCache: boolean): Promise<IRequestCfgModel> {
+    return this.cachedCfgService.getCachedCfgByMethod(method, isEnableCache);
+  }
+
+  async generateSQLList(): Promise<void> {
+    return this.genSqlService.generateSQLList();
+  }
+
+  async executeSqlCfgModels(): Promise<void> {
+    return this.executeSqlService.executeSqlCfgModels();
+  }
+
+  async convertOriginToExecuteSql(sqlCfgModel: SqlCfgModel): Promise<void> {
+    return this.originToExecuteSql.convertOriginToExecuteSql(sqlCfgModel);
+  }
+
+  executeFuncCfg(funCfg: IFuncCfgModel, funcContext: FuncContext): any {
+    return this.executeFuncService.executeFuncCfg(funCfg, funcContext);
+  }
+
+  async getTableMeta(sqlCfgModel: SqlCfgModel): Promise<ITableMeta> {
+    return await this.tableMetaService.getTableMeta(sqlCfgModel);
+  }
+}
+
+export { CurdProServiceHub };