sqlparser-devexpress 2.4.2 → 2.5.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sqlparser-devexpress",
-  "version": "2.4.2",
+  "version": "2.5.1",
   "main": "src/index.js",
   "type": "module",
   "scripts": {

package/src/core/converter.js

@@ -33,7 +33,10 @@ function DevExpressConverter() {
         // Handle special cases for short circuit
         if (result === true || result === false || result === null) return [];
 
-        return processAstNode(ast);
+        if (result.length == 1) {
+            return result[0];
+        }
+        return result;
     }
 
     /**
@@ -164,27 +167,60 @@ function DevExpressConverter() {
         if (includeExtradata)
             comparison = [left, operatorToken, right, { type: originalOperator }, right];
 
-        // Last null because of special case when using dropdown it https://github.com/DevExpress/DevExtreme/blob/25_1/packages/devextreme/js/__internal/data/m_utils.ts#L18 it takes last value as null
-        if ((ast.left && isFunctionNullCheck(ast.left, true)) || (ast.value && isFunctionNullCheck(ast.value, false))) {
+        let isLeftNullCheck = isFunctionNullCheck(ast.left, true);
+        let isRightNullCheck = isFunctionNullCheck(ast.right, false) || (ast.value && isFunctionNullCheck(ast.value, false));
+        let isBothNullChecks = isLeftNullCheck && isRightNullCheck;
+        let isdestructured = false;
+        // Last null because of special case when using dropdown it https://github.com/DevExpress/DevExtreme/blob/25_1/packages/devextreme/js/__internal/data/m_utils.ts#L18 it takes last value.
+        if (!isBothNullChecks && isLeftNullCheck) {
             const nullCheckArg = (ast.left ?? ast.value).args[1]?.value;
+            let valueRight = null
+
             let baseComparison = comparison;
 
             if (Array.isArray(right) && (right.includes("or") || right.includes("and"))) {
-                const valueRight = right.shift();
+                isdestructured = true;
+                valueRight = right.shift();
                 baseComparison = [[left, operatorToken, valueRight], ...right];
             }
+            const _val = !isdestructured ? baseComparison[2] : valueRight;
+            if (normalizeBool(_val) == normalizeBool(nullCheckArg))
+                comparison = [[...baseComparison], 'or', [left, operatorToken, null, { type: "ISNULL", position: "column", defaultValue: nullCheckArg }, null]];
+            else
+                comparison = [...baseComparison, { type: "ISNULL", position: "column", defaultValue: nullCheckArg }, _val];
 
-            comparison = [baseComparison, 'or', [left, operatorToken, null, { type: "ISNULL", defaultValue: nullCheckArg }, null]];
-        } else if (ast.right && isFunctionNullCheck(ast.right, true)) {
-            const nullCheckArg = ast.right.args[1]?.value;
+
+        } else if (!isBothNullChecks && isRightNullCheck) {
+            const nullCheckArg = (ast.right ?? ast.value).args[1]?.value;
+            let valueLeft = null
             let baseComparison = comparison;
 
-            if (Array.isArray(right) && (right.includes("or") || right.includes("and"))) {
-                const valueRight = right.shift();
-                baseComparison = [[left, operatorToken, valueRight], ...right];
+            if (Array.isArray(left) && (left.includes("or") || left.includes("and"))) {
+                isdestructured = true;
+                valueLeft = left.shift();
+                baseComparison = [[valueLeft, operatorToken, right], ...left];
             }
+            const _val = !isdestructured ? baseComparison[2] : valueRight;
+
+            comparison = [...baseComparison, { type: "ISNULL", position: "value", defaultValue: nullCheckArg }, _val];
+        } else if (isBothNullChecks) {
+            const nullCheckArgleft = (ast.left ?? ast.value).args[1]?.value;
+            const nullCheckArgright = (ast.right ?? ast.value).args[1]?.value;
+            let valueLeft = null;
+            let baseComparison = comparison;
 
-            comparison = [baseComparison, 'or', [right, operatorToken, null, { type: "ISNULL", defaultValue: nullCheckArg }, null]];
+            if (Array.isArray(left) && (left.includes("or") || left.includes("and"))) {
+                isdestructured = true;
+                valueLeft = left.shift();
+                baseComparison = [[valueLeft, operatorToken, right], ...left];
+            }
+
+            const _val = !isdestructured ? baseComparison[2] : valueLeft;
+
+            if (normalizeBool(nullCheckArgleft) == normalizeBool(nullCheckArgright))
+                comparison = [[...baseComparison, { type: "ISNULL", position: "both", defaultValue: nullCheckArgleft, defaultValueRight: nullCheckArgright }, _val], 'or', [left, operatorToken, null]];
+            else
+                comparison = [[...baseComparison, { type: "ISNULL", position: "both", defaultValue: nullCheckArgleft, defaultValueRight: nullCheckArgright }, _val]];
         }
 
         // Apply short-circuit evaluation if enabled
@@ -217,6 +253,20 @@ function DevExpressConverter() {
         return comparison;
     }
 
+    /**
+     * Normalizes numeric boolean-like values to actual booleans.
+     *
+     * Converts the number `0` to `false` and `1` to `true`.
+     * If the input is not exactly `0` or `1`, it returns the value unchanged.
+     *
+     * @param {*} value - The value to normalize. Can be of any type.
+     * @returns {*} - Returns `false` if `value` is `0`, `true` if `value` is `1`, otherwise returns the original value.
+     */
+    function normalizeBool(value) {
+        return value === 0 || value === 1 ? Boolean(value) : value;
+    }
+
+
     /**
      * Handles function calls, focusing on ISNULL.
      * @param {Object} ast - The function AST node.

package/src/core/parser.js

@@ -106,6 +106,21 @@ export function parse(input, variables = []) {
 				return { type: "logical", operator, left: { type: "function", name: functionName, args: functionArgs }, right: rightOperand };
 			}
 
+			if (rightOperand.type === "logical" && nodeType === "comparison") {
+				return {
+					type: "logical",
+					left: {
+						type: "comparison",
+						left: { type: "function", name: functionName, args: functionArgs },
+						operator: operator,
+						right: rightOperand.left
+					},
+					operator: rightOperand.operator,
+					right: rightOperand.right
+
+				}
+			}
+
 			return {
 				type: "comparison",
 				left: { type: "function", name: functionName, args: functionArgs },
@@ -134,11 +149,10 @@ export function parse(input, variables = []) {
 					operator: operator,
 					value: rightList
 				};
-			}
-
-			if (LOGICAL_OPERATORS.includes(operator.toLowerCase())) {
+			} else if (LOGICAL_OPERATORS.includes(operator.toLowerCase())) {
 				// Recursively parse the right-hand expression with adjusted precedence
-				const right = parseExpression(OPERATOR_PRECEDENCE[operator]);
+				// Add 1 to ensure left-associativity for operators of the same precedence
+				const right = parseExpression(OPERATOR_PRECEDENCE[operator] + 1);
 				left = { type: "logical", operator, left, right };
 			} else if (currentToken?.type == "identifier") {
 				const right = parseValue(operator);
@@ -173,7 +187,32 @@ export function parse(input, variables = []) {
 		}
 
 		// Handle function calls like ISNULL(field)
-		if (currentToken.type === "function") return parseFunction();
+		if (currentToken.type === "function") {
+			const functionNode = parseFunction();
+
+			// Check if the function is followed by a comparison operator
+			if (currentToken && currentToken.type === "operator" && !LOGICAL_OPERATORS.includes(currentToken.value.toLowerCase())) {
+				const operator = currentToken.value.toLowerCase();
+				const originalOperator = currentToken.originalValue;
+				next();
+
+				if (operator === "between") {
+					return parseBetweenComparison(functionNode, operator);
+				}
+
+				const value = parseValue(operator);
+
+				return {
+					type: "comparison",
+					field: functionNode,
+					operator,
+					value,
+					originalOperator
+				};
+			}
+
+			return functionNode;
+		}
 
 		// Handle literal values (numbers, strings, null)
 		if (LITERALS.includes(currentToken.type)) {
@@ -186,7 +225,7 @@ export function parse(input, variables = []) {
 		const field = parseValue();
 
 		// Check if it's part of a comparison expression
-		if (currentToken && currentToken.type === "operator") {
+		if (currentToken && currentToken.type === "operator" && !LOGICAL_OPERATORS.includes(currentToken.value.toLowerCase())) {
 			const operator = currentToken.value.toLowerCase();
 			const originalOperator = currentToken.originalValue;
 			next();

package/src/debug.js

@@ -11,7 +11,8 @@
 //     'LeadStatementGlobalRpt.StateID': null,
 //     'LeadStatementGlobalRpt.RegionID': null,
 //     'ServiceOrderDocument.SourceID': 2,
-//     'CustomerOrders.OrderID': 76548
+//     'CustomerOrders.OrderID': 76548,
+//     "TransferOutwardDocument.CompanyID": 7,
 // }
 
 // export function parseFilterString(filterString, sampleData = null) {
@@ -25,10 +26,10 @@
 //     const astTree = parsedResult.ast;
 //     console.log("AST Tree:", JSON.stringify(astTree, null, 2), "\n");
 
-//     return convertToDevExpressFormat({ ast: astTree, resultObject: sampleData, isValueNullShortCircuit: true });
+//     return convertToDevExpressFormat({ ast: astTree, resultObject: sampleData, options: { isValueNullShortCircuit: true, treatNumberAsNullableBit: true } });
 // }
 
-// const devexpress = parseFilterString("ISNULL(CompanyID,0) = ISNULL({CustomerOrders.OrderID},0) OR (ISNULL(CompanyID,0) = 0)", sampleData);
+// const devexpress = parseFilterString("ISNULL(CompanyID,0) = ISNULL({TransferOutwardDocument.CompanyID},0) OR ISNULL(CompanyID,0) = 0", sampleData);
 // console.log("DevExpress Filter:", JSON.stringify(devexpress, null, 2));
 // // const devexpress = parseFilterString("(RS2ID in ({LeadStatementGlobalRpt.StateID}) Or ({LeadStatementGlobalRpt.StateID} =0)) And (RS3ID  in (0,{LeadStatementGlobalRpt.RegionID}) Or {LeadStatementGlobalRpt.RegionID} =0 )", sampleData);
 

package/tests/parser.test.js

@@ -71,18 +71,20 @@ describe("Parser SQL to dx Filter Builder", () => {
             expected: [
                 [
                     [
-                        ["FromDate", "<=", "2022-01-01"],
-                        'and',
-                        ["ToDate", ">=", "2022-01-01"]
+                        [
+                            ["FromDate", "<=", "2022-01-01"],
+                            'and',
+                            ["ToDate", ">=", "2022-01-01"]
+                        ],
+                        'or',
+                        ["ToDate", "=", null, { "type": "IS" }, null]
                     ],
-                    'or',
-                    ["ToDate", "=", null, { "type": "IS" }, null]
-                ],
-                "and",
-                [
-                    ["BranchID", "=", 42],
-                    "or",
-                    ["RefBranchID", "=", null, { "type": "IS" }, null]
+                    "and",
+                    [
+                        ["BranchID", "=", 42],
+                        "or",
+                        ["RefBranchID", "=", null, { "type": "IS" }, null]
+                    ]
                 ],
                 "and",
                 [
@@ -135,15 +137,15 @@ describe("Parser SQL to dx Filter Builder", () => {
         {
             input: "ISNULL(SourceID,0) = {ServiceOrderDocument.SourceID} OR ISNULL(SourceID,0) = 0",
             expected: [
-                ["SourceID", "=", 2],
-                "or",
-                ["SourceID", "=", null, { "defaultValue": 0, "type": "ISNULL" }, null],
-                "or",
-                ["SourceID", "=", 0],
+                ["SourceID", "=", 2, { "defaultValue": 0, "position": "column", "type": "ISNULL" }, 2],
                 "or",
-                ["SourceID", "=", null, { "defaultValue": 0, "type": "ISNULL" }, null],
-                "or",
-                ["SourceID", "=", false]
+                [
+                    ["SourceID", "=", 0],
+                    "or",
+                    ["SourceID", "=", null, { "defaultValue": 0, "position": "column", "type": "ISNULL" }, null],
+                    "or",
+                    ["SourceID", "=", false]
+                ]
             ]
         },
         {
@@ -155,17 +157,19 @@ describe("Parser SQL to dx Filter Builder", () => {
                     [
                         ["CompanyID", "=", 0],
                         "or",
-                        ["CompanyID", "=", null, { "defaultValue": 0, "type": "ISNULL" }, null],
+                        ["CompanyID", "=", null, { "defaultValue": 0, "position": "column", "type": "ISNULL" }, null],
                         "or",
                         ["CompanyID", "=", false]
                     ]
                 ],
                 "and",
-                [
-                    ["IsSubdealer", "=", true],
-                    "or",
-                    ["IsSubdealer", "=", null, { "defaultValue": 0, "type": "ISNULL" }, null]
-                ]
+                // [
+                // ["IsSubdealer", "=", 0],
+                // "or",
+                // ["IsSubdealer", "=", null, { "defaultValue": 0, "position": "column", "type": "ISNULL" }, null],
+                // "or",
+                ["IsSubdealer", "=", true, { "defaultValue": 0, "position": "column", "type": "ISNULL" }, true],
+                // ]
             ]
         },
         {
@@ -189,24 +193,23 @@ describe("Parser SQL to dx Filter Builder", () => {
         {
             input: "(ISNULL(TicketID, 0) = ISNULL({SupportResolution.TicketID}, 0))",
             expected: [
-                ["TicketID", "=", 123],
+                ["TicketID", "=", 123, { "type": "ISNULL", "position": "both", "defaultValue": 0, "defaultValueRight": 0 }, 123],
                 "or",
-                ["TicketID", "=", null, { "defaultValue": 0, "type": "ISNULL" }, null]
+                ["TicketID", "=", null]
             ]
         },
         {
             input: "CompanyID = ISNULL({LeadDocument.CompanyID},0) OR (ISNULL(CompanyID,0) = 0))",
             expected: [
-                ["CompanyID", "=", 7],
-                "or",
-                ["CompanyID", "=", null, { "defaultValue": 0, "type": "ISNULL" }, null],
-                "or",
-                ["CompanyID", "=", 0],
+                ["CompanyID", "=", 7, { "type": "ISNULL", "position": "value", "defaultValue": 0 }, 7],
                 "or",
-                ["CompanyID", "=", null, { "defaultValue": 0, "type": "ISNULL" }, null],
-                "or",
-                ["CompanyID", "=", false]
-
+                [
+                    ["CompanyID", "=", 0],
+                    "or",
+                    ["CompanyID", "=", null, { "type": "ISNULL", "position": "column", "defaultValue": 0 }, null],
+                    "or",
+                    ["CompanyID", "=", false]
+                ]
             ]
         },
         {
@@ -306,31 +309,85 @@ describe("Parser SQL to dx Filter Builder", () => {
         {
             input: "ISNULL(CompanyID,0) = ISNULL({TransferOutwardDocument.CompanyID},0) OR (ISNULL(CompanyID,0) = 0)",
             expected: [
-                [
-
-                    ["CompanyID", "=", 7],
-                    "or",
-                    [
-                        ["CompanyID", "=", 0],
-                        "or",
-                        ["CompanyID", "=", null,
-                            {
-                                "type": "ISNULL",
-                                "defaultValue": 0
-                            }, null
-                        ],
-                        "or",
-                        ["CompanyID", "=", false]
-                    ]
-                ],
+                ["CompanyID", "=", 7, { "type": "ISNULL", "position": "both", "defaultValue": 0, "defaultValueRight": 0 }, 7],
                 "or",
-                [
-                    "CompanyID", "=", null,
-                    {
-                        "type": "ISNULL",
-                        "defaultValue": 0
-                    }, null
-                ]
+                ["CompanyID", "=", null],
+                "or",
+                ["CompanyID", "=", 0],
+                "or",
+                ["CompanyID", "=", null, { "type": "ISNULL", "position": "column", "defaultValue": 0 }, null],
+                "or",
+                ["CompanyID", "=", false]
+            ]
+        },
+        {
+            input: "ISNULL(CompanyID,0) = ISNULL({TransferOutwardDocument.CompanyID},0) OR (ISNULL(CompanyID,1) = 0)",
+            expected: [
+                ["CompanyID", "=", 7, { "type": "ISNULL", "position": "both", "defaultValue": 0, "defaultValueRight": 0 }, 7],
+                "or",
+                ["CompanyID", "=", null],
+                "or",
+                ["CompanyID", "=", 0, { "type": "ISNULL", "position": "column", "defaultValue": 1 }, 0],
+                "or",
+                ["CompanyID", "=", false]
+            ]
+        },
+        {
+            input: "ISNULL(CompanyID,0) = {LeadDocument.CompanyID}",
+            expected: [
+                "CompanyID", "=", 7, { "type": "ISNULL", "position": "column", "defaultValue": 0 }, 7
+            ]
+        },
+        {
+            input: "ISNULL(CompanyID,0) = ISNULL({LeadDocument.CompanyID},0)",
+            expected: [
+                ["CompanyID", "=", 7, { "type": "ISNULL", "position": "both", "defaultValue": 0, "defaultValueRight": 0 }, 7],
+                "or",
+                ["CompanyID", "=", null]
+            ]
+        },
+        {
+            input: "ISNULL(CompanyID,1) = ISNULL({LeadDocument.CompanyID},2)",
+            expected: [
+                "CompanyID", "=", 7, { "type": "ISNULL", "position": "both", "defaultValue": 1, "defaultValueRight": 2 }, 7
+            ]
+        },
+        {
+            input: "CompanyID = ISNULL({LeadDocument.CompanyID},0)",
+            expected: [
+                "CompanyID", "=", 7, { "type": "ISNULL", "position": "value", "defaultValue": 0 }, 7
+            ]
+        },
+        {
+            input: "AllowSubDealer = ISNULL({LeadDocument.AllowSubDealer},0)",
+            expected: [
+                "AllowSubDealer", "=", true, { "type": "ISNULL", "position": "value", "defaultValue": 0 }, true
+            ]
+        },
+        {
+            input: "AllowSubDealer = ISNULL({LeadDocument.AllowSubDealer},1)",
+            expected: [
+                "AllowSubDealer", "=", true, { "type": "ISNULL", "position": "value", "defaultValue": 1 }, true
+            ]
+        },
+        {
+            input: "ISNULL(AllowSubDealer,0) = ISNULL({LeadDocument.AllowSubDealer},1)",
+            expected: [
+                "AllowSubDealer", "=", true, { "type": "ISNULL", "position": "both", "defaultValue": 0, "defaultValueRight": 1 }, true
+            ]
+        },
+        {
+            input: "ISNULL(AllowSubDealer,0) = {LeadDocument.AllowSubDealer}",
+            expected: [
+                "AllowSubDealer", "=", true, { "type": "ISNULL", "position": "column", "defaultValue": 0 }, true
+            ]
+        },
+        {
+            input: "ISNULL(AllowSubDealer,1) = {LeadDocument.AllowSubDealer}",
+            expected: [
+                ["AllowSubDealer", "=", true],
+                'or',
+                ["AllowSubDealer", "=", null, { "type": "ISNULL", "position": "column", "defaultValue": 1 }, null]
             ]
         }
     ];