baja-lite 1.0.4 → 1.0.6

package/es/convert-xml.js

@@ -0,0 +1,410 @@
+export const convert = function (childrens, param, parentIds, myBatisMapper) {
+    let statement = '';
+    for (let i = 0, children; children = childrens[i]; i++) {
+        // Convert SQL statement recursively
+        statement += convertChildren(children, param, parentIds, myBatisMapper);
+    }
+    // Check not converted Parameters
+    var regexList = ['\\#{\\S*}', '\\${\\S*}'];
+    for (var i = 0, regexString; regexString = regexList[i]; i++) {
+        var regex = new RegExp(regex, 'g');
+        var checkParam = statement.match(regexString);
+        if (checkParam != null && checkParam.length > 0) {
+            throw new Error("Parameter " + checkParam.join(",") + " is not converted.");
+        }
+    }
+    return statement;
+};
+const convertChildren = function (children, param, parentIds, myBatisMapper) {
+    param ?? (param = {});
+    if (!isDict(param)) {
+        throw new Error('Parameter argument should be Key-Value type or Null.');
+    }
+    if (children.type == 'text') {
+        // Convert Parameters
+        return convertParameters(children, param);
+    }
+    else if (children.type == 'tag') {
+        switch (children.name.toLowerCase()) {
+            case 'if':
+                return convertIf(children, param, parentIds, myBatisMapper);
+            case 'choose':
+                return convertChoose(children, param, parentIds, myBatisMapper);
+            case 'trim':
+            case 'where':
+                return convertTrimWhere(children, param, parentIds, myBatisMapper);
+            case 'set':
+                return convertSet(children, param, parentIds, myBatisMapper);
+            case 'foreach':
+                return convertForeach(children, param, parentIds, myBatisMapper);
+            case 'bind':
+                param = convertBind(children, param);
+                return '';
+            case 'include':
+                return convertInclude(children, param, parentIds, myBatisMapper);
+            default:
+                throw new Error('XML is not well-formed character or markup. Consider using CDATA section.');
+        }
+    }
+    else {
+        return '';
+    }
+};
+const convertParameters = function (children, param) {
+    let convertString = children.content;
+    try {
+        convertString = convertParametersInner('#', convertString, param);
+        convertString = convertParametersInner('$', convertString, param);
+    }
+    catch (err) {
+        throw new Error('Error occurred during convert parameters.');
+    }
+    try {
+        // convert CDATA string
+        convertString = convertString.replace(/(\&amp\;)/g, '&');
+        convertString = convertString.replace(/(\&lt\;)/g, '<');
+        convertString = convertString.replace(/(\&gt\;)/g, '>');
+        convertString = convertString.replace(/(\&quot\;)/g, '"');
+    }
+    catch (err) {
+        throw new Error('Error occurred during convert CDATA section.');
+    }
+    return convertString;
+};
+const isObject = function (variable) {
+    return typeof variable === 'object' && variable !== null;
+};
+const isArray = function (variable) {
+    return isObject(variable) && variable.hasOwnProperty('length');
+};
+const convertParametersInner = function (change, convertString, param) {
+    const stringReg = new RegExp('(\\' + change + '\\{[a-zA-Z0-9._\\$]+\\})', 'g');
+    let stringTarget = convertString.match(stringReg);
+    if (stringTarget != null && stringTarget.length > 0) {
+        const _stringTarget = uniqueArray(stringTarget);
+        let target;
+        for (let i = 0; i < _stringTarget.length; i++) {
+            target = _stringTarget[i];
+            const t = target.replace(change + '{', '').replace('}', '');
+            let tempParamKey = eval('param.' + t);
+            if (tempParamKey !== undefined) {
+                const reg = new RegExp('\\' + change + '{' + t + '}', 'g');
+                if (tempParamKey === null) {
+                    tempParamKey = 'NULL';
+                    convertString = convertString.replace(reg, tempParamKey);
+                }
+                else {
+                    if (change == '#') {
+                        // processing JSON fields structures
+                        if (isObject(tempParamKey) || isArray(tempParamKey)) {
+                            tempParamKey = JSON.stringify(tempParamKey);
+                        }
+                        else {
+                            tempParamKey = tempParamKey.toString().replace(/"/g, '\\\"');
+                            tempParamKey = mysqlRealEscapeParam(tempParamKey);
+                        }
+                        tempParamKey = tempParamKey.replace(/'/g, "''");
+                        const replaceWith = "'" + tempParamKey + "'";
+                        convertString = convertString.replace(reg, () => replaceWith);
+                    }
+                    else if (change == '$') {
+                        convertString = convertString.replace(reg, tempParamKey);
+                    }
+                }
+            }
+        }
+    }
+    return convertString;
+};
+const convertIf = function (children, param, parentIds, myBatisMapper) {
+    let evalString = children.attrs['test'];
+    try {
+        // Create Evaluate string
+        evalString = replaceEvalString(evalString, param);
+        evalString = evalString.replace(/ and /gi, ' && ');
+        evalString = evalString.replace(/ or /gi, ' || ');
+        // replace == to === for strict evaluate
+        // TODO: fix != null & != ''
+        // evalString = evalString.replace(/==/g, '===');
+        // evalString = evalString.replace(/!=/g, '!==');
+        evalString = evalString.replace(/^'(.*?)'\.equalsIgnoreCase\( ([a-zA-Z]+\.[a-zA-Z]+) \)/i, `($2 && $2.toUpperCase() === '$1'.toUpperCase())`);
+        evalString = evalString.replace(/\('(.*?)'\.equalsIgnoreCase\( ([a-zA-Z]+\.[a-zA-Z]+) \)/i, `(($2 && $2.toUpperCase() === '$1'.toUpperCase())`);
+    }
+    catch (err) {
+        throw new Error('Error occurred during convert <if> element.');
+    }
+    // Execute Evaluate string
+    try {
+        if (eval(evalString)) {
+            let convertString = '';
+            for (let i = 0, nextChildren; nextChildren = children['children'][i]; i++) {
+                convertString += convertChildren(nextChildren, param, parentIds, myBatisMapper);
+            }
+            return convertString;
+        }
+        else {
+            return '';
+        }
+    }
+    catch (e) {
+        return '';
+    }
+};
+const convertForeach = function (children, param, parentIds, myBatisMapper) {
+    try {
+        const collection = eval('param.' + children.attrs['collection']);
+        const item = children.attrs['item'];
+        const open = (children.attrs['open'] == null) ? '' : children.attrs['open'];
+        const close = (children.attrs['close'] == null) ? '' : children.attrs['close'];
+        const separator = (children.attrs['separator'] == null) ? '' : children.attrs['separator'];
+        const foreachTexts = [];
+        let coll = null;
+        for (let j = 0; j < collection.length; j++) {
+            coll = collection[j];
+            const foreachParam = param;
+            foreachParam[item] = coll;
+            let foreachText = '';
+            for (let k = 0, nextChildren; nextChildren = children.children[k]; k++) {
+                let fText = convertChildren(nextChildren, foreachParam, parentIds, myBatisMapper);
+                fText = fText.replace(/^\s*$/g, '');
+                if (fText != null && fText.length > 0) {
+                    foreachText += fText;
+                }
+            }
+            if (foreachText != null && foreachText.length > 0) {
+                foreachTexts.push(foreachText);
+            }
+        }
+        return (open + foreachTexts.join(separator) + close);
+    }
+    catch (err) {
+        throw new Error('Error occurred during convert <foreach> element.');
+    }
+};
+const convertChoose = function (children, param, parentIds, myBatisMapper) {
+    try {
+        for (let i = 0, whenChildren; whenChildren = children.children[i]; i++) {
+            if (whenChildren.type == 'tag' && whenChildren.name.toLowerCase() == 'when') {
+                let evalString = whenChildren.attrs.test;
+                // Create Evaluate string
+                evalString = replaceEvalString(evalString, param);
+                evalString = evalString.replace(/ and /gi, ' && ');
+                evalString = evalString.replace(/ or /gi, ' || ');
+                // Execute Evaluate string
+                try {
+                    if (eval(evalString)) {
+                        // If <when> condition is true, do it.
+                        let convertString = '';
+                        for (let k = 0, nextChildren; nextChildren = whenChildren.children[k]; k++) {
+                            convertString += convertChildren(nextChildren, param, parentIds, myBatisMapper);
+                        }
+                        return convertString;
+                    }
+                    else {
+                        continue;
+                    }
+                }
+                catch (e) {
+                    continue;
+                }
+            }
+            else if (whenChildren.type == 'tag' && whenChildren.name.toLowerCase() == 'otherwise') {
+                // If reached <otherwise> tag, do it.
+                let convertString = '';
+                for (let k = 0, nextChildren; nextChildren = whenChildren.children[k]; k++) {
+                    convertString += convertChildren(nextChildren, param, parentIds, myBatisMapper);
+                }
+                return convertString;
+            }
+        }
+        // If there is no suitable when and otherwise, just return null.
+        return '';
+    }
+    catch (err) {
+        throw new Error('Error occurred during convert <choose> element.');
+    }
+};
+const convertTrimWhere = function (children, param, parentIds, myBatisMapper) {
+    let convertString = '';
+    let prefix;
+    let prefixOverrides;
+    let suffix;
+    let suffixOverrides;
+    let globalSet;
+    try {
+        switch (children.name.toLowerCase()) {
+            case 'trim':
+                prefix = children.attrs["prefix"];
+                prefixOverrides = children.attrs["prefixOverrides"];
+                suffix = children.attrs["suffix"];
+                suffixOverrides = children.attrs["suffixOverrides"];
+                globalSet = 'g';
+                break;
+            case 'where':
+                prefix = 'WHERE';
+                prefixOverrides = 'and|or';
+                globalSet = 'gi';
+                break;
+            default:
+                throw new Error('Error occurred during convert <trim/where> element.');
+        }
+        // Convert children first.
+        for (let j = 0, nextChildren; nextChildren = children.children[j]; j++) {
+            convertString += convertChildren(nextChildren, param, parentIds, myBatisMapper);
+        }
+        // Remove prefixOverrides
+        let trimRegex = new RegExp('(^)([\\s]*?)(' + prefixOverrides + ')', globalSet);
+        convertString = convertString.replace(trimRegex, '');
+        // Remove suffixOverrides
+        trimRegex = new RegExp('(' + suffixOverrides + ')([\\s]*?)($)', globalSet);
+        convertString = convertString.replace(trimRegex, '');
+        if (children.name.toLowerCase() != 'trim') {
+            trimRegex = new RegExp('(' + prefixOverrides + ')([\\s]*?)($)', globalSet);
+            convertString = convertString.replace(trimRegex, '');
+        }
+        // Add Prefix if String is not empty.
+        trimRegex = new RegExp('([a-zA-Z])', 'g');
+        const w = convertString.match(trimRegex);
+        if (w != null && w.length > 0) {
+            convertString = prefix + ' ' + convertString;
+            if (suffix) {
+                convertString = convertString + ' ' + suffix;
+            }
+        }
+        // Remove comma(,) before WHERE
+        if (children.name.toLowerCase() != 'where') {
+            const regex = new RegExp('(,)([\\s]*?)(where)', 'gi');
+            convertString = convertString.replace(regex, ' WHERE ');
+        }
+        return convertString;
+    }
+    catch (err) {
+        throw new Error('Error occurred during convert <' + children.name.toLowerCase() + '> element.');
+    }
+};
+const convertSet = function (children, param, parentIds, myBatisMapper) {
+    let convertString = '';
+    try {
+        // Convert children first.
+        for (let j = 0, nextChildren; nextChildren = children.children[j]; j++) {
+            convertString += convertChildren(nextChildren, param, parentIds, myBatisMapper);
+        }
+        // Remove comma repeated more than 2.
+        let regex = new RegExp('(,)(,|\\s){2,}', 'g');
+        convertString = convertString.replace(regex, ',\n');
+        // Remove first comma if exists.
+        regex = new RegExp('(^)([\\s]*?)(,)', 'g');
+        convertString = convertString.replace(regex, '');
+        // Remove last comma if exists.
+        regex = new RegExp('(,)([\\s]*?)($)', 'g');
+        convertString = convertString.replace(regex, '');
+        convertString = ' SET ' + convertString;
+        return convertString;
+    }
+    catch (err) {
+        throw new Error('Error occurred during convert <set> element.');
+    }
+};
+const convertBind = function (children, param) {
+    let evalString = children.attrs["value"];
+    // Create Evaluate string
+    evalString = replaceEvalString(evalString, param);
+    param[children.attrs["name"]] = eval(evalString);
+    return param;
+};
+const convertInclude = function (children, param, parentIds, myBatisMapper) {
+    try {
+        // Add Properties to param
+        for (let j = 0, nextChildren; nextChildren = children.children[j]; j++) {
+            if (nextChildren.type == 'tag' && nextChildren.name == 'property') {
+                param[nextChildren.attrs['name']] = nextChildren.attrs['value'];
+            }
+        }
+    }
+    catch (err) {
+        throw new Error('Error occurred during read <property> element in <include> element.');
+    }
+    try {
+        let refid = convertParametersInner('#', children.attrs['refid'], param);
+        refid = convertParametersInner('$', refid, param);
+        let mapper;
+        for (const psqlid of parentIds) {
+            mapper = myBatisMapper[`${psqlid}.${refid}`];
+            if (mapper) {
+                break;
+            }
+        }
+        let statement = '';
+        for (let i = 0, children; children = mapper[i]; i++) {
+            statement += convertChildren(children, param, parentIds, myBatisMapper);
+        }
+        return statement;
+    }
+    catch (err) {
+        throw new Error('Error occurred during convert refid attribute in <include> element.');
+    }
+};
+const isDict = function (v) {
+    return typeof v === 'object' && v !== null && !(v instanceof Array) && !(v instanceof Date);
+};
+const replaceEvalString = function (evalString, param) {
+    const keys = Object.keys(param);
+    for (let i = 0; i < keys.length; i++) {
+        let replacePrefix = '';
+        let replacePostfix = '';
+        let paramRegex;
+        if (isDict(param[keys[i]])) {
+            replacePrefix = ' param.';
+            replacePostfix = '';
+            paramRegex = new RegExp('(^|[^a-zA-Z0-9_])(' + keys[i] + '\\.)([a-zA-Z0-9_]+)', 'g');
+        }
+        else {
+            replacePrefix = ' param.';
+            replacePostfix = ' ';
+            paramRegex = new RegExp('(^|[^a-zA-Z0-9_])(' + keys[i] + ')($|[^a-zA-Z0-9_])', 'g');
+        }
+        evalString = evalString.replace(paramRegex, ('$1' + replacePrefix + '$2' + replacePostfix + '$3'));
+    }
+    return evalString;
+};
+const uniqueArray = function (a) {
+    const seen = {};
+    const out = [];
+    const len = a.length;
+    let j = 0;
+    for (let i = 0; i < len; i++) {
+        const item = a[i];
+        if (seen[item] !== 1) {
+            seen[item] = 1;
+            out[j++] = item;
+        }
+    }
+    return out;
+};
+const mysqlRealEscapeParam = function (param) {
+    if (typeof param != 'string')
+        return param;
+    return param.replace(/[\0\x08\x09\x1a\n\r''\\\%]/g, function (char) {
+        switch (char) {
+            case '\0':
+                return '\\0';
+            case '\x08':
+                return '\\b';
+            case '\x09':
+                return '\\t';
+            case '\x1a':
+                return '\\z';
+            case '\n':
+                return '\\n';
+            case '\r':
+                return '\\r';
+            case '\'':
+            case `'`:
+            case '\\':
+            case '%':
+                return '\\' + char;
+            default:
+                return char;
+        }
+    });
+};

package/es/enum.d.ts

@@ -0,0 +1,10 @@
+export declare class Enum {
+    private _value;
+    private _desc;
+    private _config;
+    constructor(value: string, desc: string, ...config: string[]);
+    eq(value: string | number | undefined | null): boolean;
+    value(): string;
+    desc(): string;
+    config(): string[];
+}

package/es/enum.js

@@ -0,0 +1,28 @@
+export class Enum {
+    constructor(value, desc, ...config) {
+        this._value = value;
+        this._desc = desc;
+        this._config = config;
+    }
+    eq(value) {
+        if (value === undefined) {
+            return false;
+        }
+        if (value === null) {
+            return false;
+        }
+        if (typeof value === 'number') {
+            return this._value === `${value}`;
+        }
+        return this._value === `${value}`;
+    }
+    value() {
+        return this._value;
+    }
+    desc() {
+        return this._desc;
+    }
+    config() {
+        return this._config;
+    }
+}

package/es/error.js

@@ -9,5 +9,5 @@ export const Throw = {
     },
     now(message) {
         throw typeof message === 'string' ? new Error(message) : message;
-    },
+    }
 };

package/es/index.d.ts

@@ -1,3 +1,4 @@
+import 'reflect-metadata';
 export * from './error';
 export * from './fn';
 export * from './math';
@@ -5,3 +6,5 @@ export * from './object';
 export * from './set-ex';
 export * from './sql';
 export * from './string';
+export * from './enum';
+export * from './list';

package/es/index.js

@@ -1,3 +1,4 @@
+import 'reflect-metadata';
 export * from './error';
 export * from './fn';
 export * from './math';
@@ -5,3 +6,5 @@ export * from './object';
 export * from './set-ex';
 export * from './sql';
 export * from './string';
+export * from './enum';
+export * from './list';

package/es/list.d.ts

@@ -0,0 +1,10 @@
+export declare class ArrayList<T> extends Array<T> {
+    constructor(array?: Array<T> | T | undefined);
+    add(...items: T[]): void;
+    size(): number;
+    isEmpty(): boolean;
+    get(index: number): T | undefined;
+    clear(): void;
+    set(index: number, item: T): void;
+    remove(index: number): void;
+}

package/es/list.js

@@ -0,0 +1,32 @@
+export class ArrayList extends Array {
+    constructor(array) {
+        super();
+        if (array instanceof Array) {
+            super.push(...array);
+        }
+        else if (typeof array !== 'undefined') {
+            super.push(array);
+        }
+    }
+    add(...items) {
+        this.push(...items);
+    }
+    size() {
+        return this.length;
+    }
+    isEmpty() {
+        return this.length === 0;
+    }
+    get(index) {
+        return this[index];
+    }
+    clear() {
+        this.length = 0;
+    }
+    set(index, item) {
+        this[index] = item;
+    }
+    remove(index) {
+        this.splice(index, 1);
+    }
+}

package/es/object.d.ts

@@ -1,7 +1,7 @@
 /**
  * 对象对象（等同与convertBean）
  * 仅会将classType有的属性进行转换
- * 相当与一次属性过滤
+ * * 相当与一次属性过滤
  * @param source
  * @param classType
  */
@@ -75,3 +75,9 @@ export declare const arraySplit: <T = any>(datas: T[], { everyLength, groupCount
     everyLength?: number | undefined;
     groupCount?: number | undefined;
 }) => T[][];
+export declare const P2C: (pro: string, IF?: boolean) => string;
+export declare const C2P: (pro: string, IF?: boolean) => string;
+export declare function C2P2<T extends Object = any, L extends Object = T>(datas: L[]): T[];
+export declare function C2P2<T extends Object = any, L extends Object = T>(datas: L): T;
+export declare function P2C2<T extends Object = any, L extends Object = T>(datas: L[]): T[];
+export declare function P2C2<T extends Object = any, L extends Object = T>(datas: L): T;

package/es/object.js

@@ -1,7 +1,8 @@
+import iterate from "iterare";
 /**
  * 对象对象（等同与convertBean）
  * 仅会将classType有的属性进行转换
- * 相当与一次属性过滤
+ * * 相当与一次属性过滤
  * @param source
  * @param classType
  */
@@ -193,3 +194,29 @@ export const arraySplit = (datas, { everyLength = 0, groupCount = 0 } = {}) => {
         throw new Error('参数错误!');
     }
 };
+const P2CEX = /[A-Z]/g;
+export const P2C = (pro, IF = true) => IF ? pro.replace(P2CEX, (a) => `_${a.toLowerCase()}`) : pro;
+const C2PEX = /_([a-z])/g;
+export const C2P = (pro, IF = true) => IF ? pro.replace(C2PEX, (a, b) => `${b.toUpperCase()}`) : pro;
+export function C2P2(datas) {
+    if (datas instanceof Array) {
+        return iterate(datas).map((data) => Object.fromEntries(Object.entries(data).map(([K, V]) => [C2P(K), V]))).toArray();
+    }
+    else if (datas) {
+        return Object.fromEntries(Object.entries(datas).map(([K, V]) => [C2P(K), V]));
+    }
+    else {
+        return datas;
+    }
+}
+export function P2C2(datas) {
+    if (datas instanceof Array) {
+        return iterate(datas).map((data) => Object.fromEntries(Object.entries(data).map(([K, V]) => [P2C(K), V]))).toArray();
+    }
+    else if (datas) {
+        return Object.fromEntries(Object.entries(datas).map(([K, V]) => [P2C(K), V]));
+    }
+    else {
+        return datas;
+    }
+}

package/es/set-ex.d.ts

@@ -1,8 +1,11 @@
 export declare class SetEx<T> extends Set {
-    private uniqueKey;
-    private whenOnExist?;
-    private whenOnNotExist?;
-    private replaceItemWhenExits;
+    private _key;
+    private _onExist1?;
+    private _onNotExist1?;
+    private _replaceIfExits1;
+    private _onExist2?;
+    private _onNotExist2?;
+    private _replaceIfExits2;
     /**
      * @param key 识别是否存在的对象的属性名
      * @param onExist 当存在时作何操作? oldData/newData 哪个将添加到set,由replaceItemWhenExits决定,默认是oldData生效
@@ -10,13 +13,22 @@ export declare class SetEx<T> extends Set {
      * @param replaceWhenExits 当存在时是否覆盖？
      * @param values 初始数组
      */
-    constructor(key: keyof T | {
+    constructor(option: {
         key: keyof T;
-        onExist?: (oldData: T, newData: T) => void;
-        onNotExist?: (newData: T) => void;
-        replaceWhenExits?: boolean;
+        /** add&addAll触发 */
+        onExist1?: (oldData: T, newData: T) => void;
+        /** add&addAll触发 */
+        onNotExist1?: (newData: T) => void;
+        /** add&addAll触发 */
+        replaceIfExits1?: boolean;
+        /** add2&addAll2触发 */
+        onExist2?: (oldData: T, newData: T) => void;
+        /** add2&addAll2触发 */
+        onNotExist2?: (newData: T) => void;
+        /** add2&addAll2触发 */
+        replaceIfExits2?: boolean;
         values?: ReadonlyArray<T> | null;
-    }, onExist?: (oldData: T, newData: T) => void, replaceWhenExits?: boolean, values?: ReadonlyArray<T> | null, onNotExist?: (newData: T) => void);
+    });
     /**
      *
      * 添加返回
@@ -117,11 +129,21 @@ export declare class SetEx<T> extends Set {
      * @param {(oldData: T, newData: T) => void} [onExist]
      * @param {boolean} [replaceWhenExits=false]
      */
-    reset({ key, onExist, onNotExist, replaceWhenExits }: {
+    reset(option: {
         key?: keyof T;
-        onExist?: (oldData: T, newData: T) => void | null;
-        onNotExist?: (newData: T) => void | null;
-        replaceWhenExits?: boolean;
+        /** add&addAll触发 */
+        onExist1?: (oldData: T, newData: T) => void;
+        /** add&addAll触发 */
+        onNotExist1?: (newData: T) => void;
+        /** add&addAll触发 */
+        replaceIfExits1?: boolean;
+        /** add2&addAll2触发 */
+        onExist2?: (oldData: T, newData: T) => void;
+        /** add2&addAll2触发 */
+        onNotExist2?: (newData: T) => void;
+        /** add2&addAll2触发 */
+        replaceIfExits2?: boolean;
+        values?: ReadonlyArray<T> | null;
     }): this;
     /**
      *
@@ -165,7 +187,11 @@ export declare class SetEx<T> extends Set {
             name: T[keyof T];
         }[];
     };
-    set onExist(onExist: ((oldData: T, newData: T) => void) | undefined);
+    set onExist1(onExist1: ((oldData: T, newData: T) => void) | undefined);
+    set onExist2(onExist2: ((oldData: T, newData: T) => void) | undefined);
+    set onNotExist1(onNotExist1: ((newData: T) => void) | undefined);
+    set onNotExist2(onNotExist2: ((newData: T) => void) | undefined);
+    set replaceIfExits1(replaceIfExits1: boolean);
+    set replaceIfExits2(replaceIfExits2: boolean);
     set key(key: keyof T);
-    set replaceWhenExits(replaceWhenExits: boolean);
 }