@kitmi/data/cjs/helpers.js

Jacaranda Framework Data Access Model

"use strict";
Object.defineProperty(exports, "__esModule", {
    value: true
});
function _export(target, all) {
    for(var name in all)Object.defineProperty(target, name, {
        enumerable: true,
        get: all[name]
    });
}
_export(exports, {
    concateParams: function() {
        return concateParams;
    },
    doDec: function() {
        return doDec;
    },
    doInc: function() {
        return doInc;
    },
    extractRawSql: function() {
        return extractRawSql;
    },
    extractTableAndField: function() {
        return extractTableAndField;
    },
    getValueFromAny: function() {
        return getValueFromAny;
    },
    hasValueInAny: function() {
        return hasValueInAny;
    },
    isRawSql: function() {
        return isRawSql;
    },
    isSelectAll: function() {
        return isSelectAll;
    },
    mergeWhere: function() {
        return mergeWhere;
    },
    xrAlias: function() {
        return xrAlias;
    },
    xrCall: function() {
        return xrCall;
    },
    xrCol: function() {
        return xrCol;
    },
    xrColumn: function() {
        return xrColumn;
    },
    xrDataSet: function() {
        return xrDataSet;
    },
    xrExpr: function() {
        return xrExpr;
    },
    xrExpression: function() {
        return xrExpression;
    },
    xrFunction: function() {
        return xrFunction;
    },
    xrGet: function() {
        return xrGet;
    },
    xrRaw: function() {
        return xrRaw;
    },
    xrRawValue: function() {
        return xrRawValue;
    },
    xrSet: function() {
        return xrSet;
    },
    xrSetAt: function() {
        return xrSetAt;
    },
    xrSetSlice: function() {
        return xrSetSlice;
    }
});
const _utils = require("@kitmi/utils");
const isRawSql = (value)=>(0, _utils.isWrappedWith)(value, 'r#"', '"#');
const extractRawSql = (value)=>(0, _utils.unwrap)(value, 'r#"', '"#');
const xrAlias = (xrValue, alias)=>({
        ...xrValue,
        alias
    });
const xrRawValue = (value, ...params)=>({
        $xr: 'Raw',
        value,
        params
    });
const xrRaw = xrRawValue;
const xrColumn = (name, alias)=>({
        $xr: 'Column',
        name,
        alias
    });
const xrCol = xrColumn;
const xrFunction = (name, ...args)=>({
        $xr: 'Function',
        name,
        args
    });
const xrCall = xrFunction;
const xrExpression = (left, op, right, alias)=>({
        $xr: 'BinExpr',
        left,
        op,
        right,
        alias
    });
const xrExpr = xrExpression;
const xrDataSet = (model, query, alias)=>({
        $xr: 'DataSet',
        model,
        query: {
            $skipOrm: true,
            ...query
        },
        alias
    });
const xrGet = (field, key, alias)=>({
        $xr: 'OpGet',
        field,
        key,
        alias
    });
const xrSet = (obj)=>({
        $set: obj
    });
const xrSetAt = (at, value)=>({
        $setAt: {
            at,
            value
        }
    });
const xrSetSlice = (begin, end, array)=>({
        $setSlice: {
            begin,
            end,
            value: array
        }
    });
const doInc = (field, increment)=>xrExpr(xrCol(field), '+', increment);
const doDec = (field, decrement)=>xrExpr(xrCol(field), '-', decrement);
const isSelectAll = (select)=>!select || select.size === 1 && select.has('*');
function mergeWhere(condition1, condition2, operator = '$and') {
    if ((0, _utils.isEmpty)(condition1)) {
        return condition2;
    }
    if ((0, _utils.isEmpty)(condition2)) {
        return condition1;
    }
    if (operator === '$and' && (0, _utils.isPlainObject)(condition1) && (0, _utils.isPlainObject)(condition2)) {
        return {
            ...condition1,
            ...condition2
        };
    }
    return {
        [operator]: [
            condition1,
            condition2
        ]
    };
}
function concateParams(...params) {
    const result = [];
    params.forEach((param)=>{
        if (param != null) {
            result.push(...param);
        }
    });
    return result;
}
const hasValueInAny = (arrayOfColl, key)=>getValueFromAny(arrayOfColl, key) != null;
const getValueFromAny = (arrayOfColl, key)=>_utils._.find(arrayOfColl, (coll)=>coll?.[key] != null)?.[key];
const extractTableAndField = (path)=>{
    let lastPos = path.lastIndexOf('.');
    let tablePath = path.substring(0, lastPos);
    let field = path.substring(lastPos + 1);
    return [
        tablePath,
        field
    ];
};

//# sourceMappingURL=helpers.js.map