midway-fatcms 0.0.1-beta.30 → 0.0.1-beta.33

package/dist/libs/crud-pro/utils/ModelUtils.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ModelUtils = void 0;
+const MixinUtils_1 = require("./MixinUtils");
+const defaultConfigs_1 = require("../defaultConfigs");
+const ModelUtils = {
+    getColumnList(sqlCfg, reqCfg) {
+        const sqlCfgColumnList = sqlCfg.columns;
+        if (MixinUtils_1.MixinUtils.isNotEmpty(sqlCfgColumnList)) {
+            return sqlCfgColumnList;
+        }
+        return reqCfg.columns;
+    },
+    getSqlTable(sqlCfg, reqCfg) {
+        const s = sqlCfg.sqlTable;
+        if (MixinUtils_1.MixinUtils.isNotEmpty(s)) {
+            return s;
+        }
+        return reqCfg.sqlTable;
+    },
+    getSqlSchema(sqlCfg, reqCfg) {
+        const s = sqlCfg.sqlSchema;
+        if (MixinUtils_1.MixinUtils.isNotEmpty(s)) {
+            return s;
+        }
+        return reqCfg.sqlSchema;
+    },
+    getMaxLimit(sqlCfg, requestCfg) {
+        let s = sqlCfg.maxLimit;
+        if (typeof s === 'number' && s > 0) {
+            return s;
+        }
+        s = requestCfg.maxLimit;
+        if (typeof s === 'number' && s > 0)
+            return s;
+        return defaultConfigs_1.DEFAULT_MAX_LIMIT;
+    },
+    checkFuncCfgValid(cfgModel) {
+        const arr = [cfgModel.functionName, cfgModel.const, cfgModel.constString, cfgModel.constNumber, cfgModel.constBool, cfgModel.context, cfgModel.contextAsString, cfgModel.contextAsNumber, cfgModel.contextAsBool];
+        for (let i = 0; i < arr.length; i++) {
+            const arrElement = arr[i];
+            if (typeof arrElement !== 'undefined') {
+                return true;
+            }
+        }
+        return false;
+    },
+};
+exports.ModelUtils = ModelUtils;

package/dist/libs/crud-pro/utils/MultiKeyMap.d.ts

@@ -0,0 +1,11 @@
+declare class MultiKeyMap {
+    private readonly _multiMap;
+    private _rowsLength;
+    constructor(rows?: any[], keyName1?: string, keyName2?: string);
+    isEmpty(): boolean;
+    getValue(key1: string, key2: string): any;
+    getValue1(key1: string): Record<string, any>;
+    addRowsValue1(rows: any[], value1: string, keyName2: string): void;
+    addRows(rows: any[], keyName1: string, keyName2: string): void;
+}
+export { MultiKeyMap };

package/dist/libs/crud-pro/utils/MultiKeyMap.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MultiKeyMap = void 0;
+class MultiKeyMap {
+    constructor(rows, keyName1, keyName2) {
+        this._multiMap = {};
+        this._rowsLength = 0;
+        if (rows && keyName1 && keyName2) {
+            this.addRows(rows, keyName1, keyName2);
+        }
+    }
+    isEmpty() {
+        return this._rowsLength === 0;
+    }
+    getValue(key1, key2) {
+        const map1 = this._multiMap[key1];
+        if (!map1) {
+            return null;
+        }
+        return map1[key2];
+    }
+    getValue1(key1) {
+        return this._multiMap[key1];
+    }
+    addRowsValue1(rows, value1, keyName2) {
+        if (!Array.isArray(rows) || rows.length === 0) {
+            return;
+        }
+        this._rowsLength = this._rowsLength + rows.length;
+        const dictMap = 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);
+        }
+    }
+    addRows(rows, keyName1, keyName2) {
+        if (!Array.isArray(rows)) {
+            return;
+        }
+        this._rowsLength = this._rowsLength + rows.length;
+        const dictMap = 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;
+        }
+    }
+}
+exports.MultiKeyMap = MultiKeyMap;

package/dist/libs/crud-pro/utils/SqlFuncUtils.d.ts

@@ -0,0 +1,5 @@
+declare const sqlFuncUtils: {
+    isSqlFuncArg: (arg: any) => boolean;
+    toFuncSQL: (arg: any) => string;
+};
+export { sqlFuncUtils };

package/dist/libs/crud-pro/utils/SqlFuncUtils.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sqlFuncUtils = void 0;
+const SQL_FUNC_MAP = {
+    NOW: 'NOW()',
+};
+/**
+ * data: {
+ * 	xxTime: {$sqlFunc:"NOW"}
+ * }
+ * @param arg
+ */
+function getSqlFuncName(arg) {
+    if (arg && typeof arg === 'object' && typeof arg['$sqlFunc'] === 'string') {
+        const sqlFunKey = arg['$sqlFunc'];
+        return SQL_FUNC_MAP[sqlFunKey];
+    }
+    return null;
+}
+const sqlFuncUtils = {
+    isSqlFuncArg: (arg) => {
+        const sqlFuncName = getSqlFuncName(arg);
+        return !!sqlFuncName;
+    },
+    toFuncSQL: (arg) => {
+        return getSqlFuncName(arg);
+    },
+};
+exports.sqlFuncUtils = sqlFuncUtils;

package/dist/libs/crud-pro/utils/TypeUtils.d.ts

@@ -0,0 +1,40 @@
+declare const TypeUtils: {
+    assertJsonArray(value: any, errorCode: string): void;
+    assertBasicType(value: any, errorCode: string): void;
+    isBasicType(value: any): boolean;
+    isBoolean(itemValue: any): boolean;
+    isString(itemValue: any): boolean;
+    isInteger(x: any): boolean;
+    isNumber(x: any): boolean;
+    isNumeric(itemValue: any): boolean;
+    /**
+     * 是否是合法的name类型：以字母开头，只能包含（字母、数字、下划线）的非空字符串
+     * @param itemValue
+     */
+    isValidName(itemValue: any): boolean;
+    /**
+     * 是否是合法中文手机号
+     * @param itemValue
+     */
+    isChinesePhone(itemValue: string): boolean;
+    /**
+     * 是否是合法的email地址
+     * @param itemValue
+     */
+    isEmailStrValid(itemValue: string): boolean;
+    /**
+     * 从字符串中提取数字部分。
+     * @param s
+     */
+    pickNumber(s: string): number | null;
+    isNumberChar(c: string): boolean;
+    isNil(obj: any): boolean;
+    /**
+     * 判断数字是否满足范围表达式
+     * @param scaleExpress ：
+     *    范围表达式：(0,1) 开区间，[0,1] 闭区间，(0,1] 前开后闭，[0,1) 前闭后开; 若没有大小括号，则默认闭区间
+     * @param numberValue: 数字
+     */
+    isNumberScaleValid(scaleExpress: string, numberValue: number): boolean;
+};
+export { TypeUtils };

package/dist/libs/crud-pro/utils/TypeUtils.js

@@ -0,0 +1,166 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TypeUtils = void 0;
+const exceptions_1 = require("../exceptions");
+const TypeUtils = {
+    assertJsonArray(value, errorCode) {
+        if (!Array.isArray(value)) {
+            throw new exceptions_1.CommonException(errorCode, JSON.stringify(value));
+        }
+    },
+    assertBasicType(value, errorCode) {
+        if (!TypeUtils.isBasicType(value)) {
+            throw new exceptions_1.CommonException(errorCode, JSON.stringify(value));
+        }
+    },
+    isBasicType(value) {
+        if (value == null) {
+            return true;
+        }
+        const valueType = typeof value;
+        return valueType === 'boolean' || valueType === 'string' || valueType === 'number';
+    },
+    isBoolean(itemValue) {
+        return typeof itemValue === 'boolean';
+    },
+    isString(itemValue) {
+        return typeof itemValue === 'string';
+    },
+    isInteger(x) {
+        return typeof x === 'number' && Math.floor(x) === x;
+    },
+    isNumber(x) {
+        return typeof x === 'number';
+    },
+    isNumeric(itemValue) {
+        if (typeof itemValue === 'number') {
+            return true;
+        }
+        if (typeof itemValue === 'string' && itemValue.length > 0) {
+            return !isNaN(Number(itemValue));
+        }
+        return false;
+    },
+    /**
+     * 是否是合法的name类型：以字母开头，只能包含（字母、数字、下划线）的非空字符串
+     * @param itemValue
+     */
+    isValidName(itemValue) {
+        if (typeof itemValue === 'string' && itemValue.length > 0) {
+            const reg = /^\w+$/; // --已经验证OK
+            return reg.test(itemValue);
+        }
+        return false;
+    },
+    /**
+     * 是否是合法中文手机号
+     * @param itemValue
+     */
+    isChinesePhone(itemValue) {
+        if (typeof itemValue === 'string' && itemValue.length > 0) {
+            return TypeUtils.isNumeric(itemValue) && itemValue.length === 11;
+        }
+        return false;
+    },
+    /**
+     * 是否是合法的email地址
+     * @param itemValue
+     */
+    isEmailStrValid(itemValue) {
+        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) {
+        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) {
+        const charCode = c.charCodeAt(0);
+        return charCode >= 48 && charCode <= 57; // 0 ~ 9
+    },
+    isNil(obj) {
+        return typeof obj === 'undefined' || obj === null;
+    },
+    /**
+     * 判断数字是否满足范围表达式
+     * @param scaleExpress ：
+     *    范围表达式：(0,1) 开区间，[0,1] 闭区间，(0,1] 前开后闭，[0,1) 前闭后开; 若没有大小括号，则默认闭区间
+     * @param numberValue: 数字
+     */
+    isNumberScaleValid(scaleExpress, numberValue) {
+        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 exceptions_1.CommonException(exceptions_1.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;
+    },
+};
+exports.TypeUtils = TypeUtils;

package/dist/libs/crud-pro/utils/ValidateUtils.d.ts

@@ -0,0 +1,3 @@
+import { KeysOfValidators } from '../models/keys';
+declare function validateByCfgString(validateCfg: KeysOfValidators | string, itemValue: any, errPath: string): void;
+export { validateByCfgString };

package/dist/libs/crud-pro/utils/ValidateUtils.js

@@ -0,0 +1,165 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateByCfgString = void 0;
+const moment = require("moment");
+const keys_1 = require("../models/keys");
+const exceptions_1 = require("../exceptions");
+const MixinUtils_1 = require("./MixinUtils");
+const TypeUtils_1 = require("./TypeUtils");
+const { isEmpty } = MixinUtils_1.MixinUtils;
+const validatorUtils = {
+    /**
+     * 字符串长度
+     * @param itemCfg
+     * @param itemValue
+     */
+    isLengthValid(itemCfg, itemValue) {
+        if (typeof itemValue === 'string') {
+            const cfgPart = itemCfg.substring(keys_1.KeysOfValidators.LENGTH.length);
+            return TypeUtils_1.TypeUtils.isNumberScaleValid(cfgPart, itemValue.length);
+        }
+        return false;
+    },
+    /**
+     * 数字范围
+     * @param itemCfg
+     * @param itemValue
+     */
+    isNumberScaleValid(itemCfg, itemValue) {
+        if (typeof itemValue === 'number') {
+            const cfgPart = itemCfg.substring(keys_1.KeysOfValidators.SCALE.length).trim();
+            return TypeUtils_1.TypeUtils.isNumberScaleValid(cfgPart, itemValue);
+        }
+        else if (TypeUtils_1.TypeUtils.isNumeric(itemValue)) {
+            const cfgPart = itemCfg.substring(keys_1.KeysOfValidators.SCALE.length).trim();
+            return TypeUtils_1.TypeUtils.isNumberScaleValid(cfgPart, Number(itemValue));
+        }
+        return false;
+    },
+    /**
+     * 正则表达式
+     * @param itemCfg
+     * @param itemValue
+     */
+    isRegExpValid(itemCfg, itemValue) {
+        if (typeof itemValue === 'string') {
+            const cfgPart = itemCfg.substring(keys_1.KeysOfValidators.REG_EXP.length);
+            const regexp = new RegExp(cfgPart);
+            return regexp.test(itemValue);
+        }
+        return false;
+    },
+    isMomentValid(itemCfg, itemValue) {
+        const cfgPart = itemCfg.substring(keys_1.KeysOfValidators.ENUM.length).trim();
+        return moment(itemValue, cfgPart, true).isValid();
+    },
+    isEnumValid(itemCfg, itemValue) {
+        const cfgPart = itemCfg.substring(keys_1.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 exceptions_1.CommonException(exceptions_1.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, itemValue) {
+    if (keys_1.KeysOfValidators.ARRAY === validateCfg) {
+        return itemValue !== null && Array.isArray(itemValue);
+    }
+    else if (keys_1.KeysOfValidators.ARRAY_STRING === validateCfg) {
+        return (itemValue !== null &&
+            Array.isArray(itemValue) &&
+            MixinUtils_1.MixinUtils.isElementAllMatch(itemValue, e => {
+                return typeof e === 'string';
+            }));
+    }
+    else if (keys_1.KeysOfValidators.ARRAY_NUMBER === validateCfg) {
+        return (itemValue !== null &&
+            Array.isArray(itemValue) &&
+            MixinUtils_1.MixinUtils.isElementAllMatch(itemValue, e => {
+                return typeof e === 'number';
+            }));
+    }
+    else if (keys_1.KeysOfValidators.OBJECT === validateCfg) {
+        return itemValue !== null && typeof itemValue === 'object';
+    }
+    else if (keys_1.KeysOfValidators.BOOLEAN === validateCfg) {
+        return TypeUtils_1.TypeUtils.isBoolean(itemValue);
+    }
+    else if (keys_1.KeysOfValidators.STRING === validateCfg) {
+        return TypeUtils_1.TypeUtils.isString(itemValue);
+    }
+    else if (keys_1.KeysOfValidators.INTEGER === validateCfg) {
+        return TypeUtils_1.TypeUtils.isInteger(itemValue);
+    }
+    else if (keys_1.KeysOfValidators.NUMBER === validateCfg) {
+        return TypeUtils_1.TypeUtils.isNumber(itemValue);
+    }
+    else if (keys_1.KeysOfValidators.NUMERIC === validateCfg) {
+        return TypeUtils_1.TypeUtils.isNumeric(itemValue);
+    }
+    else if (keys_1.KeysOfValidators.NAME === validateCfg) {
+        return TypeUtils_1.TypeUtils.isValidName(itemValue);
+    }
+    else if (keys_1.KeysOfValidators.PHONE_CN === validateCfg) {
+        return TypeUtils_1.TypeUtils.isChinesePhone(itemValue.toString());
+    }
+    else if (keys_1.KeysOfValidators.EMAIL === validateCfg) {
+        return TypeUtils_1.TypeUtils.isEmailStrValid(itemValue);
+    }
+    else if (validateCfg.startsWith(keys_1.KeysOfValidators.LENGTH)) {
+        return validatorUtils.isLengthValid(validateCfg, itemValue);
+    }
+    else if (validateCfg.startsWith(keys_1.KeysOfValidators.REG_EXP)) {
+        return validatorUtils.isRegExpValid(validateCfg, itemValue);
+    }
+    else if (validateCfg.startsWith(keys_1.KeysOfValidators.SCALE)) {
+        return validatorUtils.isNumberScaleValid(validateCfg, itemValue);
+    }
+    else if (validateCfg.startsWith(keys_1.KeysOfValidators.ENUM)) {
+        return validatorUtils.isEnumValid(validateCfg, itemValue);
+    }
+    else if (validateCfg.startsWith(keys_1.KeysOfValidators.MOMENT)) {
+        return validatorUtils.isMomentValid(validateCfg, itemValue);
+    }
+    throw new exceptions_1.CommonException(exceptions_1.Exceptions.CFG_VALIDATE_NOT_SUPPORT, validateCfg);
+}
+function validateByCfgString(validateCfg, itemValue, errPath) {
+    if (isEmpty(validateCfg)) {
+        // 没有配置，不需要校验
+        return;
+    }
+    // 必填
+    if ('required' === validateCfg) {
+        if (isEmpty(itemValue)) {
+            throw new exceptions_1.CommonException(exceptions_1.Exceptions.VALIDATE_ERR, "'参数校验错误，字段 " + errPath + ' 不满足校验配置：' + validateCfg);
+        }
+        return;
+    }
+    // 没有填写的话，不需要校验。
+    if (isEmpty(itemValue)) {
+        return;
+    }
+    // 校验失败
+    if (!validateByCfgStringInner(validateCfg, itemValue)) {
+        throw new exceptions_1.CommonException(exceptions_1.Exceptions.VALIDATE_ERR, "'参数校验错误，字段 " + errPath + ' 不满足校验配置：' + validateCfg);
+    }
+}
+exports.validateByCfgString = validateByCfgString;

package/dist/libs/crud-pro/utils/pool/MySQLUtils.d.ts

@@ -0,0 +1,3 @@
+import { IConnectionPool } from '../../interfaces';
+declare function getConnectionPool(poolName: string, poolOptions: any): IConnectionPool;
+export { getConnectionPool };

package/dist/libs/crud-pro/utils/pool/MySQLUtils.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getConnectionPool = void 0;
+const promise_1 = require("mysql2/promise");
+const keys_1 = require("../../models/keys");
+const POOL_CACHE_MAP = {};
+function getConnectionPool(poolName, poolOptions) {
+    let pool = POOL_CACHE_MAP[poolName];
+    if (!pool) {
+        pool = {
+            dbType: keys_1.SqlDbType.mysql,
+            poolName: poolName,
+            poolInstance: (0, promise_1.createPool)(poolOptions),
+        };
+        POOL_CACHE_MAP[poolName] = pool;
+    }
+    return pool;
+}
+exports.getConnectionPool = getConnectionPool;

package/dist/libs/crud-pro/utils/pool/PostgresUtils.d.ts

@@ -0,0 +1,3 @@
+import { IConnectionPool } from '../../interfaces';
+declare function getConnectionPool(poolName: string, poolOptions: any): IConnectionPool;
+export { getConnectionPool };

package/dist/libs/crud-pro/utils/pool/PostgresUtils.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getConnectionPool = void 0;
+const pg_1 = require("pg");
+const keys_1 = require("../../models/keys");
+const POOL_CACHE_MAP = {};
+function getConnectionPool(poolName, poolOptions) {
+    let pool = POOL_CACHE_MAP[poolName];
+    if (!pool) {
+        const poolObj = new pg_1.Pool(poolOptions);
+        pool = {
+            dbType: keys_1.SqlDbType.postgres,
+            poolName: poolName,
+            poolInstance: poolObj,
+        };
+        POOL_CACHE_MAP[poolName] = pool;
+    }
+    return pool;
+}
+exports.getConnectionPool = getConnectionPool;

package/dist/libs/crud-pro/utils/pool/SqlServerUtils.d.ts

@@ -0,0 +1,3 @@
+import { IConnectionPool } from '../../interfaces';
+declare function getConnectionPool(poolName: string, poolOptions: any): IConnectionPool;
+export { getConnectionPool };

package/dist/libs/crud-pro/utils/pool/SqlServerUtils.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getConnectionPool = void 0;
+const mssql_1 = require("mssql");
+const keys_1 = require("../../models/keys");
+const POOL_CACHE_MAP = {};
+function getConnectionPool(poolName, poolOptions) {
+    let pool = POOL_CACHE_MAP[poolName];
+    if (!pool) {
+        const poolObj = new mssql_1.ConnectionPool(poolOptions);
+        pool = {
+            dbType: keys_1.SqlDbType.sqlserver,
+            poolName: poolName,
+            poolInstance: poolObj,
+        };
+        POOL_CACHE_MAP[poolName] = pool;
+    }
+    return pool;
+}
+exports.getConnectionPool = getConnectionPool;

package/dist/libs/crud-pro/utils/sqlConvert/convertColumnName.d.ts

@@ -0,0 +1,4 @@
+import { SqlCfgModel } from "../../models/SqlCfgModel";
+declare function toSqlColumnName(columnName: string, sqlCfgModel: SqlCfgModel): string;
+declare function toSqlColumnNamesJoin(columns: string[], sqlCfgModel: SqlCfgModel): string;
+export { toSqlColumnName, toSqlColumnNamesJoin };

package/dist/libs/crud-pro/utils/sqlConvert/convertColumnName.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toSqlColumnNamesJoin = exports.toSqlColumnName = void 0;
+const keys_1 = require("../../models/keys");
+function toSqlColumnName(columnName, sqlCfgModel) {
+    if (sqlCfgModel.sqlDbType === keys_1.SqlDbType.postgres) {
+        return '"' + columnName + '"';
+    }
+    if (sqlCfgModel.sqlDbType === keys_1.SqlDbType.sqlserver) {
+        return '[' + columnName + ']';
+    }
+    return '`' + columnName + '`';
+}
+exports.toSqlColumnName = toSqlColumnName;
+function toSqlColumnNamesJoin(columns, sqlCfgModel) {
+    const columns2 = columns.map(col => {
+        return toSqlColumnName(col.trim(), sqlCfgModel);
+    });
+    return columns2.join(',');
+}
+exports.toSqlColumnNamesJoin = toSqlColumnNamesJoin;

package/dist/libs/crud-pro/utils/sqlConvert/convertMix.d.ts

@@ -0,0 +1,3 @@
+import { SqlDbType } from "../../models/keys";
+declare function pickAndConvertRowsByMix(connectionQueryRes: any, sqlDbType: SqlDbType): any[] | any;
+export { pickAndConvertRowsByMix };

package/dist/libs/crud-pro/utils/sqlConvert/convertMix.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pickAndConvertRowsByMix = void 0;
+const keys_1 = require("../../models/keys");
+const convertPgType_1 = require("./convertPgType");
+const _ = require("lodash");
+function pickAndConvertRowsByMix(connectionQueryRes, sqlDbType) {
+    if (!connectionQueryRes) {
+        throw new Error('[pickAndConvertRowsByMix] error, connectionQueryRes is null ');
+    }
+    if (sqlDbType === keys_1.SqlDbType.postgres) {
+        return (0, convertPgType_1.pickAndConvertPgRows)(connectionQueryRes);
+    }
+    if (sqlDbType === keys_1.SqlDbType.mysql) {
+        return connectionQueryRes[0];
+    }
+    if (sqlDbType === keys_1.SqlDbType.sqlserver) {
+        return _.get(connectionQueryRes, 'recordsets[0]') || [];
+    }
+    throw new Error('[pickAndConvertRowsByMix] error sqlDbType, sqlDbType = ' + sqlDbType);
+}
+exports.pickAndConvertRowsByMix = pickAndConvertRowsByMix;

package/dist/libs/crud-pro/utils/sqlConvert/convertMsSql.d.ts

@@ -0,0 +1,2 @@
+declare function replaceQuestionMarksForMssql(sql: string): string;
+export { replaceQuestionMarksForMssql, };