sqlparser-devexpress 2.3.1 → 2.3.3

package/package.json

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

package/src/core/converter.js

@@ -140,9 +140,9 @@ function DevExpressConverter() {
 
         let comparison = [left, operatorToken, right];
 
-        if (isFunctionNullCheck(ast.left, true)) {
+        if ((ast.left && isFunctionNullCheck(ast.left, true)) || (ast.value && isFunctionNullCheck(ast.value, false))) {
             comparison = [[left, operatorToken, right], 'or', [left, operatorToken, null]];
-        } else if (isFunctionNullCheck(ast.right, true)) {
+        } else if (ast.right && isFunctionNullCheck(ast.right, true)) {
             comparison = [[left, operatorToken, right], 'or', [right, operatorToken, null]];
         }
 
@@ -248,7 +248,7 @@ function DevExpressConverter() {
         if (!resultObject) return `{${placeholder}}`;
 
 
-        return resultObject.hasOwnProperty(placeholder) ? resultObject[placeholder] : `{${placeholder}}`;
+        return resultObject.hasOwnProperty(placeholder) ? resultObject[placeholder] : `{${placeholder.value ?? placeholder}}`;
     }
 
     /**

package/src/core/parser.js

@@ -1,4 +1,4 @@
-import { LITERALS, OPERATOR_PRECEDENCE, UNSUPPORTED_PATTERN } from "../constants.js";
+import { LITERALS, LOGICAL_OPERATORS, OPERATOR_PRECEDENCE, UNSUPPORTED_PATTERN } from "../constants.js";
 import { Tokenizer } from "./tokenizer.js";
 
 
@@ -78,20 +78,20 @@ export function parse(input, variables = []) {
 	}
 
 	function parseFunction() {
-		const funcName = currentToken.value.toUpperCase();
+		const functionName = currentToken.value.toUpperCase();
 		next();
 
-		expectedToken(currentToken, "(", `Expected ( after ${funcName}`);
+		expectedToken(currentToken, "(", `Expected ( after ${functionName}`);
 
 		next();
 
-		const args = [];
+		const functionArgs = [];
 		while (currentToken && currentToken.value !== ")") {
-			args.push(parseExpression());
+			functionArgs.push(parseExpression());
 			if (currentToken && currentToken.value === ",") next();
 		}
 
-		expectedToken(currentToken, ")", `Expected ) after ${funcName}`);
+		expectedToken(currentToken, ")", `Expected ) after ${functionName}`);
 
 		next(); // Consume the closing parenthesis
 
@@ -99,17 +99,22 @@ export function parse(input, variables = []) {
 		if (currentToken && currentToken.type === "operator") {
 			const operator = currentToken.value;
 			next(); // Move to the next token after the operator
-			const value = parseValue(); // Parse the value after the operator
+			const rightOperand = parseValue(); // Parse the value after the operator
+			const nodeType = LOGICAL_OPERATORS.includes(operator.toLowerCase()) ? "logical" : "comparison";
+
+			if(nodeType === "logical") {
+				return { type: "logical", operator, left: { type: "function", name: functionName, args: functionArgs }, right: rightOperand  };
+			}
 
 			return {
 				type: "comparison",
-				left: { type: "function", name: funcName, args },
+				left: { type: "function", name: functionName, args: functionArgs },
 				operator,
-				value
+				value: rightOperand 
 			};
 		}
 
-		return { type: "function", name: funcName, args };
+		return { type: "function", name: functionName, args: functionArgs };
 	}
 
 	// Parses logical expressions using operator precedence
@@ -165,6 +170,21 @@ export function parse(input, variables = []) {
 
 			if (operator === "between") return parseBetweenComparison(field, operator);
 
+			if (currentToken.type === "function") {
+				const functionNode = parseFunction();
+
+				// Wrap the function inside a comparison if it's directly after an operator
+				const leftComparison = {
+					type: "comparison",
+					field,
+					operator,
+					value: functionNode.left
+				};
+			
+				functionNode.left = leftComparison;
+				return functionNode;
+			}
+
 			// For other comparison operators, parse a single right-hand value
 			const valueType = currentToken.type;
 			const value = parseValue(operator);
@@ -184,30 +204,59 @@ export function parse(input, variables = []) {
 	function parseValue(operatorToken) {
 		if (!currentToken) throw new Error("Unexpected end of input");
 
+		// Handle function without consuming the token
+		if (currentToken.type === "function") {
+			return parseFunction();
+		}
+
 		const token = currentToken;
 		next(); // Move to the next token
 
-		if (token.type === "number") return Number(token.value);
-		if (token.type === "string") return token.value.slice(1, -1).replace(/''/g, "");
-		if (token.type === "identifier") return token.value;
-		if (token.type === "null") return null;
+		switch (token.type) {
+			case "number":
+				return Number(token.value);
 
-		// Handle placeholders like `{VariableName}`
-		if (token.type === "placeholder") {
-			const val = token.value.slice(1, -1);
-			if (!variables.includes(val)) variables.push(val);
-			return { type: "placeholder", value: val };
-		}
+			case "string":
+				return token.value.slice(1, -1).replace(/''/g, "");
 
-		operatorToken = operatorToken.toUpperCase();
+			case "identifier":
+				return token.value;
 
-		// Handle IN operator which requires a list of values
-		if (operatorToken && (operatorToken === "IN" || operatorToken === "NOT IN")) return parseInList(token);
+			case "null":
+				return null;
+
+			case "placeholder": {
+				const val = token.value.slice(1, -1);
+				if (!variables.includes(val)) variables.push(val);
+				return { type: "placeholder", value: val };
+			}
+
+			case "paren": {
+				if (currentToken.type === "function") {
+					return parseFunction();
+				}
+				// Handle ({Placeholder}) syntax for placeholders inside parentheses
+				const nextToken = tokenizer.peekNextToken();
+				if (currentToken && currentToken.type === "placeholder" &&
+					nextToken && nextToken.type === "paren") {
+					const val = parseValue();
+					return { type: "placeholder", value: val };
+				}
+				break;
+			}
+		}
+
+		// Handle IN or NOT IN operator (outside switch as intended)
+		operatorToken = operatorToken?.toUpperCase();
+		if (operatorToken === "IN" || operatorToken === "NOT IN") {
+			return parseInList(token);
+		}
 
 		throw new Error(`Unexpected value: ${token.value}`);
 	}
 
 
+
 	// Start parsing and return the AST with extracted variables
 	return { ast: parseExpression(), variables };
 }

package/src/debug.js

@@ -28,7 +28,7 @@
 //     return convertToDevExpressFormat({ ast: astTree, resultObject: sampleData });
 // }
 
-// const devexpress = parseFilterString("AddressType IN ('2', ('4')) OR AddressType =({ServiceOrderDocument .SourceID})", sampleData);
+// const devexpress = parseFilterString("(ISNULL(TicketID, 0) = ISNULL({CustomerOrders.OrderID}, 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/error.test.js

@@ -0,0 +1,66 @@
+import { describe, expect, it } from "vitest";
+import { convertToDevExpressFormat } from "../src/core/converter";
+import { parse } from "../src/core/parser";
+import { sanitizeQuery } from "../src/core/sanitizer";
+import { convertAstToDevextreme, convertSQLToAst } from "../src";
+
+describe("Parser SQL to dx Filter Builder", () => {
+    const testCases = [
+        {
+            input: "NULL",
+            expected: []
+        },
+        {
+            input: "SELECT DISTINCT O.OrderID AS ID, O.CustomerName, O.OrderType, O.CustomerName AS [Online Order], O.OrderDate AS OrderDate, D.DeliveryStatus, O.OrderDate AS [Online Order Date], O.CompanyID, CAST(CAST(O.OrderDate AS DATE) AS VARCHAR(10)) AS DocumentDate FROM Orders O INNER JOIN Payment P ON P.OrderID = O.OrderID INNER JOIN Shipment S ON S.PaymentID = P.PaymentID INNER JOIN Delivery D ON D.ShipmentID = S.ShipmentID ",
+            expect: null
+        },
+        {
+            input: "CompanyID = CompanyID2 = {AccountingRule.CompanyID}",
+            expected: "Error: Invalid comparison: CompanyID = CompanyID2",
+        },
+        {
+            input: "( CompanyID = {AccountingRule.CompanyID}",
+            expected: "Error: Missing closing parenthesis"
+        }
+
+    ];
+
+    testCases.forEach(({ input, expected }, index) => {
+        it(`Test Case ${index + 1}: ${input}`, () => {
+
+            if (expected == undefined) {
+                expected = null
+            }
+
+            let astwithVariables;
+            try {
+                astwithVariables = convertSQLToAst(input);
+            } catch (error) {
+                expect(error.message).toEqual(expected.replace("Error: ", ""));
+                return;
+            }
+
+            if (astwithVariables == null) {
+                expect(null).toEqual(expected);
+                return;
+            }
+
+            const variables = astwithVariables.variables;
+            const ast = astwithVariables.ast;
+
+            const result = convertAstToDevextreme(ast, sampleData);
+
+            if (result == null || result == true || result == false) {
+                expect([]).toEqual(expected);
+                return;
+            }
+
+            expect(result).toEqual(expected);
+        });
+    });
+});
+
+
+const sampleData = {
+    "AccountingRule.CompanyID": 42,
+};

package/tests/parser.test.js

@@ -102,10 +102,6 @@ describe("Parser SQL to dx Filter Builder", () => {
                 ["ItemGroupType", "=", ""]
             ]
         },
-        {
-            input: "NULL",
-            expected: []
-        },
         {
             input: "((ISNULL({0}, 0) = 0 AND CompanyID = {1}) OR CompanyID IS NULL) OR BranchID = {0} | [LeadDocument.BranchID] | [LeadDocument.CompanyID]",
             expected: [
@@ -122,10 +118,6 @@ describe("Parser SQL to dx Filter Builder", () => {
                 ["BranchID", "=", 42]
             ]
         },
-        {
-            input: "SELECT DISTINCT OP.DocID ID,OP.DocName,OP.DocType,OP.DocName [Work Purchase Order],OP.DocDate DocDate,SP.WoStatus,OP.DocDate [Work Purchase Order Date], OP.CompanyID,      cast(cast(OP.DocDate as date) as varchar(10)) DocumentDate        FROM OpenDocuments OP      inner join PurchaseHeader PH on PH.Id=op.DocID       inner JOIN PurchasePosting PP ON PP.DocID = PH.ID       inner JOIN SalePosting SP ON SP.PurchasePostingLineID = PP.ID",
-            expect: null
-        },
         {
             input: "FromDate Between '10-10-2021' AND '10-10-2022'",
             expected: [
@@ -152,10 +144,6 @@ describe("Parser SQL to dx Filter Builder", () => {
                 ["SourceID", "=", null]
             ]
         },
-        {
-            input: "CompanyID = CompanyID2 = {AccountingRule.CompanyID}",
-            expected: "Error: Invalid comparison: CompanyID = CompanyID2",
-        },
         {
             input: "(CompanyID = {LeadDocument.CompanyID} OR ISNULL(CompanyID,0) = 0) AND (ISNULL(IsSubdealer,0) = {LeadDocument.AllowSubDealer})",
             expected: [
@@ -193,6 +181,27 @@ describe("Parser SQL to dx Filter Builder", () => {
                 "or",
                 ["AddressType", "=", 2]
             ]
+        },
+        {
+            input: "(ISNULL(TicketID, 0) = ISNULL({SupportResolution.TicketID}, 0))",
+            expected: [
+                ["TicketID", "=", 123],
+                "or",
+                ["TicketID", "=", null]
+            ]
+        },
+        {
+            input: "CompanyID = ISNULL({LeadDocument.CompanyID},0) OR (ISNULL(CompanyID,0) = 0))",
+            expected: [
+                ["CompanyID", "=", 7],
+                "or",
+                ["CompanyID", "=", null],
+                "or",
+                ["CompanyID", "=", 0],
+                "or",
+                ["CompanyID", "=", null]
+                
+            ]
         }
     ];
 
@@ -204,12 +213,8 @@ describe("Parser SQL to dx Filter Builder", () => {
             }
 
             let astwithVariables;
-            try {
-                astwithVariables = convertSQLToAst(input);
-            } catch (error) {
-                expect(error.message).toEqual(expected.replace("Error: ", ""));
-                return;
-            }
+            astwithVariables = convertSQLToAst(input);
+
 
             if (astwithVariables == null) {
                 expect(null).toEqual(expected);
@@ -256,5 +261,6 @@ const sampleData = {
     "LeadDocument.BranchID": 42,
     "LeadDocument.CompanyID": 7,
     "ServiceOrderDocument.SourceID": 2,
-    "LeadDocument.AllowSubDealer": true
+    "LeadDocument.AllowSubDealer": true,
+    "SupportResolution.TicketID": 123
 };