sqlparser-devexpress 2.0.7 → 2.1.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sqlparser-devexpress",
-  "version": "2.0.7",
+  "version": "2.1.0",
   "main": "src/index.js",
   "type": "module",
   "scripts": {
@@ -10,6 +10,7 @@
     "import": "./src/index.js",
     "require": "./src/index.js"
   },
+  "types": "src/@types/default.d.ts",
   "keywords": [
     "sql",
     "parser",

package/src/@types/default.d.ts

@@ -0,0 +1,35 @@
+export type StateDataObject = Record<string, any>;
+
+export interface SanitizedQuery {
+    sanitizedSQL: string;
+    extractedVariables: string[];
+}
+
+export interface ParsedResult {
+    ast: any; // Define a more specific type if possible
+    variables: string[];
+}
+
+export interface ConvertToDevExpressFormatParams {
+    ast: any; // Define a more specific type if possible
+    variables: string[];
+    resultObject: StateDataObject;
+}
+
+export function sanitizeQuery(filterString: string): SanitizedQuery;
+
+export function parse(query: string, variables: string[]): ParsedResult;
+
+export function convertToDevExpressFormat(params: ConvertToDevExpressFormatParams): any;
+
+export function convertSQLToAst(
+    filterString: string,
+    SampleData?: StateDataObject | null,
+    enableConsoleLogs?: boolean
+): ParsedResult;
+
+export function convertAstToDevextreme(
+    ast: any, // Define a more specific type if possible
+    variables: string[],
+    state: StateDataObject
+): any;

package/src/core/converter.js

@@ -20,18 +20,19 @@ function DevExpressConverter() {
    * @param {Object} ast - The abstract syntax tree
    * @param {Array} vars - Array of variable names
    * @param {Object} ResultObject - Optional object for placeholder resolution
-   * @param {string} primaryEntity - Optional primary entity name
-   * @param {string} primaryKey - Optional primary key value
    * @returns {Array|null} DevExpress format filter
    */
-    function convert(ast, vars, ResultObject = null, PrimaryEntity = null, PrimaryKey = null) {
+    function convert(ast, vars, ResultObject = null) {
         // Set up global context
         variables = vars;
-        primaryKey = PrimaryKey;
-        primaryEntity = PrimaryEntity;
         resultObject = ResultObject;
 
         // Process the AST
+        let result = processAstNode(ast);
+
+        // Handle special cases for short circuit
+        if(result === true || result === false || result === null) return [];
+
         return processAstNode(ast);
     }
 
@@ -191,6 +192,16 @@ function DevExpressConverter() {
             }
         }
 
+        if(Array.isArray(resolvedValue) && resolvedValue.length){
+
+            return Array.prototype.concat
+             .apply(
+               [],
+               resolvedValue.map((i) => [[ast.field, '=', i], 'or']),
+             )
+             .slice(0, -1)
+        }
+
         return [ast.field, "in", resolvedValue];
     }
 
@@ -346,6 +357,6 @@ const devExpressConverter = DevExpressConverter();
  * @param {string} primaryKey - Optional primary key value
  * @returns {Array|null} DevExpress format filter
  */
-export function convertToDevExpressFormat({ ast, variables, resultObject = null, primaryEntity = null, primaryKey = null }) {
-    return devExpressConverter.init(ast, variables, resultObject, primaryEntity, primaryKey);
+export function convertToDevExpressFormat({ ast, variables, resultObject = null }) {
+    return devExpressConverter.init(ast, variables, resultObject);
 }

package/src/core/parser.js

@@ -1,186 +1,220 @@
 import { Tokenizer } from "./tokenizer.js";
 
 // Define operator precedence for parsing expressions
-const precedence = {
-  "OR": 1, "AND": 2, "=": 3, "!=": 3, ">": 3, "<": 3, ">=": 3, "<=": 3,
-  "IN": 3, "<>": 3, "LIKE": 3, "IS": 3, "BETWEEN": 3
+const OPERATOR_PRECEDENCE = {
+	"OR": 1, "AND": 2, "=": 3, "!=": 3, ">": 3, "<": 3, ">=": 3, "<=": 3,
+	"IN": 3, "<>": 3, "LIKE": 3, "IS": 3, "BETWEEN": 3
 };
 
+const LITERALS = ["number", "string", "null"];
+
 // Regular expression to check for unsupported SQL patterns (like SELECT-FROM or JOIN statements)
-const unsupportedPattern = /\bSELECT\b.*\bFROM\b|\bINNER\s+JOIN\b/i;
+const UNSUPPORTED_PATTERN = /\bSELECT\b.*\bFROM\b|\bINNER\s+JOIN\b/i;
 
 export function parse(input, variables = []) {
 
-  // Return null if the input contains unsupported SQL statements
-  if (unsupportedPattern.test(input)) {
-    return null;
-  }
-
-  const tokenizer = new Tokenizer(input);
-  let currentToken = tokenizer.nextToken();
-
-    // // Debugging: log the tokens
-    // const tokens = [];
-    // let tempToken = currentToken;
-    // while (tempToken) {
-    //   tokens.push(tempToken);
-    //   tempToken = tokenizer.peekNextToken();
-    //   tokenizer.nextToken();
-    // }
-  
-    // console.log("Tokens:", tokens);
-    
-    // // Reset the tokenizer
-    // tokenizer.reset();
-    // currentToken = tokenizer.nextToken();
-
-  // Moves to the next token in the input
-  function next() {
-    currentToken = tokenizer.nextToken();
-  }
-
-  // Parses logical expressions using operator precedence
-  function parseExpression(minPrecedence = 0) {
-    let left = parseTerm();
-
-    // Continue parsing while the current token is an operator with sufficient precedence
-    while (currentToken && currentToken.type === "operator" && precedence[currentToken.value.toUpperCase()] >= minPrecedence) {
-      const operator = currentToken.value.toUpperCase();
-      next(); // Move to the next token
-
-      // Recursively parse the right-hand expression with adjusted precedence
-      const right = parseExpression(precedence[operator]);
-      left = { type: "logical", operator, left, right };
-    }
-
-    return left;
-  }
-
-  // Parses individual terms, including literals, functions, and comparisons
-  function parseTerm() {
-    if (!currentToken) throw new Error("Unexpected end of input");
-
-    // Handle parenthesized expressions
-    if (currentToken.type === "paren" && currentToken.value === "(") {
-      next();
-      const expr = parseExpression();
-      if (!currentToken || currentToken.value !== ")") throw new Error("Missing closing parenthesis");
-      next();
-      return expr;
-    }
-
-    // Handle function calls like ISNULL(field)
-    if (currentToken.type === "function") {
-      const funcName = currentToken.value.toUpperCase();
-      next();
-      if (!currentToken || currentToken.value !== "(") throw new Error(`Expected ( after ${funcName}`);
-      next();
-
-      const args = [];
-      while (currentToken && currentToken.value !== ")") {
-        args.push(parseExpression());
-        if (currentToken && currentToken.value === ",") next();
-      }
-
-      next(); // Consume the closing parenthesis
-
-      // Check if the next token is an operator and process it
-    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
-
-      return {
-          type: "comparison",
-          left: { type: "function", name: funcName, args },
-          operator,
-          value
-      };
-  }
-
-      return { type: "function", name: funcName, args };
-    }
-
-    // Handle literal values (numbers, strings, null)
-    if (["number", "string", "null"].includes(currentToken.type)) {
-      const value = parseValue();
-      return { type: "value", value };
-    }
-
-    // Otherwise, assume it's a field name
-    const field = parseValue();
-
-    // Check if it's part of a comparison expression
-    if (currentToken && currentToken.type === "operator") {
-      const operator = currentToken.value.toLowerCase();
-      next();
-
-      if (operator === "between") {
-        // Parse BETWEEN operator which requires two values separated by AND
-        const firstValue = parseValue();
-
-        if (!currentToken || currentToken.value.toUpperCase() !== "AND") {
-          throw new Error("Expected AND after BETWEEN");
-        }
-        next(); // Consume AND
-
-        const secondValue = parseValue();
-
-        return {
-          type: "comparison",
-          field,
-          operator,
-          value: [firstValue, secondValue] // Store both values in an array
-        };
-      }
-
-      // For other comparison operators, parse a single right-hand value
-      const value = parseValue(operator);
-      return { type: "comparison", field, operator, value };
-    }
-
-    return { type: "field", value: field };
-  }
-
-  // Parses values including numbers, strings, placeholders, and IN lists
-  function parseValue(operatorToken) {
-    if (!currentToken) throw new Error("Unexpected end of input");
-
-    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;
-
-    // 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 };
-    }
-
-    // Handle IN operator which requires a list of values
-    if (operatorToken && operatorToken.toUpperCase() === "IN") {
-      if (!token || token.value !== "(") throw new Error("Expected ( after IN");
-
-      const values = [];
-      while (currentToken && currentToken.value !== ")") {
-        if (currentToken.type === "comma") {
-          next();
-          continue;
-        }
-        values.push(parseValue());
-      }
-
-      if (currentToken && currentToken.value === ")") next(); // Consume closing parenthesis
-      return { type: "value", value: values };
-    }
-
-    throw new Error(`Unexpected value: ${token.value}`);
-  }
-
-  // Start parsing and return the AST with extracted variables
-  return { ast: parseExpression(), variables };
+	// Return null if the input contains unsupported SQL statements
+	if (UNSUPPORTED_PATTERN.test(input)) {
+		return null;
+	}
+
+	const tokenizer = new Tokenizer(input);
+	let currentToken = tokenizer.nextToken();
+
+	// // Debugging: log the tokens
+	// const tokens = [];
+	// let tempToken = currentToken;
+	// while (tempToken) {
+	//   tokens.push(tempToken);
+	//   tempToken = tokenizer.peekNextToken();
+	//   tokenizer.nextToken();
+	// }
+
+	// console.log("Tokens:", tokens);
+
+	// // Reset the tokenizer
+	// tokenizer.reset();
+	// currentToken = tokenizer.nextToken();
+
+	// Moves to the next token in the input
+	function next() {
+		currentToken = tokenizer.nextToken();
+	}
+
+	// Validate the current token
+	const expectedToken = (token, expected, errorMessage) => {
+		if (!token || token.value.toUpperCase() !== expected) {
+			throw new Error(errorMessage);
+		}
+	};
+
+	// Parse IN list of values
+	function parseInList(token) {
+		expectedToken(token, "(", "Expected ( after IN");
+
+		const values = [];
+		while (currentToken && currentToken.value !== ")") {
+			if (currentToken.type === "comma") {
+				next();
+				continue;
+			}
+			values.push(parseValue());
+		}
+		expectedToken(currentToken, ")", "Expected ) after IN list");
+
+		next(); // Consume closing parenthesis
+
+		return { type: "value", value: values };
+	}
+
+
+	// Parse BETWEEN operator which requires two values separated by AND
+	function parseBetweenComparison(field, operator) {
+		const firstValue = parseValue();
+
+		expectedToken(currentToken, "AND", "Expected AND after BETWEEN");
+
+		next(); // Consume AND
+
+		const secondValue = parseValue();
+
+		return {
+			type: "comparison",
+			field,
+			operator,
+			value: [firstValue, secondValue] // Store both values in an array
+		};
+	}
+
+	function parseFunction() {
+		const funcName = currentToken.value.toUpperCase();
+		next();
+
+		expectedToken(currentToken, "(", `Expected ( after ${funcName}`);
+
+		next();
+
+		const args = [];
+		while (currentToken && currentToken.value !== ")") {
+			args.push(parseExpression());
+			if (currentToken && currentToken.value === ",") next();
+		}
+
+		expectedToken(currentToken, ")", `Expected ) after ${funcName}`);
+
+		next(); // Consume the closing parenthesis
+
+		// Check if the next token is an operator and process it
+		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
+
+			return {
+				type: "comparison",
+				left: { type: "function", name: funcName, args },
+				operator,
+				value
+			};
+		}
+
+		return { type: "function", name: funcName, args };
+	}
+
+	// Parses logical expressions using operator precedence
+	function parseExpression(minPrecedence = 0) {
+		let left = parseTerm();
+
+		// Continue parsing while the current token is an operator with sufficient precedence
+		while (currentToken && currentToken.type === "operator" && OPERATOR_PRECEDENCE[currentToken.value.toUpperCase()] >= minPrecedence) {
+			const operator = currentToken.value.toUpperCase();
+			next(); // Move to the next token
+
+			// Recursively parse the right-hand expression with adjusted precedence
+			const right = parseExpression(OPERATOR_PRECEDENCE[operator]);
+			left = { type: "logical", operator, left, right };
+		}
+
+		return left;
+	}
+
+	// Parses individual terms, including literals, functions, and comparisons
+	function parseTerm() {
+		if (!currentToken) throw new Error("Unexpected end of input");
+
+		// Handle parenthesized expressions
+		if (currentToken.type === "paren" && currentToken.value === "(") {
+			next();
+			const expr = parseExpression();
+
+			expectedToken(currentToken, ")", "Missing closing parenthesis");
+
+			next();
+
+			return expr;
+		}
+
+		// Handle function calls like ISNULL(field)
+		if (currentToken.type === "function") return parseFunction();
+
+		// Handle literal values (numbers, strings, null)
+		if (LITERALS.includes(currentToken.type)) {
+			const value = parseValue();
+			return { type: "value", value };
+		}
+
+		// Otherwise, assume it's a field name
+		const fieldType = currentToken.type;
+		const field = parseValue();
+
+		// Check if it's part of a comparison expression
+		if (currentToken && currentToken.type === "operator") {
+			const operator = currentToken.value.toLowerCase();
+			next();
+
+			if (operator === "between") return parseBetweenComparison(field, operator);
+
+			// For other comparison operators, parse a single right-hand value
+			const valueType = currentToken.type;
+			const value = parseValue(operator);
+
+			// Check for invalid comparisons between two identifiers
+			if (fieldType === "identifier" && valueType === "identifier") {
+				throw new Error(`Invalid comparison: ${field} ${operator} ${value}`);
+			}
+
+			return { type: "comparison", field, operator, value };
+		}
+
+		return { type: "field", value: field };
+	}
+
+	// Parses values including numbers, strings, placeholders, and IN lists
+	function parseValue(operatorToken) {
+		if (!currentToken) throw new Error("Unexpected end of input");
+
+		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;
+
+		// 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 };
+		}
+
+		// Handle IN operator which requires a list of values
+		if (operatorToken && operatorToken.toUpperCase() === "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/index.js

@@ -3,7 +3,7 @@ import { parse } from "./core/parser.js";
 import { sanitizeQuery } from "./core/sanitizer.js";
 
 
-export function convertSQLToAst(filterString, SampleData = null, enableConsoleLogs = false) {
+export function convertSQLToAst(filterString, enableConsoleLogs = false) {
     let { sanitizedSQL, extractedVariables } = sanitizeQuery(filterString);
     enableConsoleLogs && console.log("Sanitized SQL:", sanitizedSQL, "\n");
 
@@ -40,7 +40,7 @@ export function convertAstToDevextreme(ast, variables, state) {
 // const devExpressFilter = parseFilterString("FromDate <= '{TransferOutwardDocument.DocDate}' ", sampleResultObject, "TransferOutwardDocument", "789");
 // const devExpressFilter = parseFilterString("(RS2ID in ({SaleOrderStatusStmtGlobalRpt.StateID}) Or ({SaleOrderStatusStmtGlobalRpt.StateID} =0)) And (RS3ID  in (0,{SaleOrderStatusStmtGlobalRpt.RegionID}) Or {SaleOrderStatusStmtGlobalRpt.RegionID} =0 )", sampleResultObject,);
 
-// const devExpressFilter = convertSQLToAst("ISNULL(SourceID,0) = {ServiceOrderDocument.SourceID} OR ISNULL(SourceID,0) = 0");
+// const devExpressFilter = convertSQLToAst("CompanyID = CompanyID2 = {AccountingRule.CompanyID}");
 // const devExpressFilterresult = convertAstToDevextreme(devExpressFilter.ast, devExpressFilter.variables,{'ServiceOrderDocument.SourceID': 2});
 // console.log("DevExpress Filter:", JSON.stringify(devExpressFilter, null, 2));
 // console.log("DevExpress Result:", JSON.stringify(devExpressFilterresult, null, 2));

package/tests/parser.test.js

@@ -2,6 +2,7 @@ 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 = [
@@ -30,13 +31,13 @@ describe("Parser SQL to dx Filter Builder", () => {
             expected: [
                 ["ContactID", "=", 42],
                 "and",
-                ["AddressType", "in", [2, 4]],
+                [["AddressType", "=", 2], 'or', ["AddressType", "=", 4]],
             ],
         },
         {
             input: "ID IN ({WorkOrderLine.ApplicableUoms}) AND (CompanyID = {WorkOrderDocument.CompanyID} OR {WorkOrderDocument.CompanyID} = 0)",
             expected: [
-                ["ID", "in", ["UOM1", "UOM2", "UOM3"]],
+                [["ID", "=", "UOM1"] , 'or', ["ID", "=", "UOM2"], 'or', ["ID", "=", "UOM3"]],
                 "and",
                 // [
                 ["CompanyID", "=", 42],
@@ -62,7 +63,7 @@ describe("Parser SQL to dx Filter Builder", () => {
             expected: [
                 ["ID", "<>", 42],
                 'and',
-                ["ItemGroupType", "in", ["1", "2"]]
+                [["ItemGroupType", "=", "1"], 'or', ["ItemGroupType", "=", "2"]]
             ]
         },
         {
@@ -103,7 +104,7 @@ describe("Parser SQL to dx Filter Builder", () => {
         },
         {
             input: "NULL",
-            expected: null
+            expected: []
         },
         {
             input: "((ISNULL({0}, 0) = 0 AND CompanyID = {1}) OR CompanyID IS NULL) OR BranchID = {0} | [LeadDocument.BranchID] | [LeadDocument.CompanyID]",
@@ -146,6 +147,10 @@ describe("Parser SQL to dx Filter Builder", () => {
                 "or",
                 ["SourceID", "=", 0]
             ]
+        },
+        {
+            input: "CompanyID = CompanyID2 = {AccountingRule.CompanyID}",
+            expected: "Error: Invalid comparison: CompanyID = CompanyID2",
         }
     ];
 
@@ -156,25 +161,23 @@ describe("Parser SQL to dx Filter Builder", () => {
                 expected = null
             }
 
-            // Need to handle NULL as a special case
-            if (input.toLowerCase() === "null") {
-                expect(null).toEqual(null);
+            let astwithVariables;
+            try {
+                astwithVariables = convertSQLToAst(input);
+            } catch (error) {
+                expect(error.message).toEqual(expected.replace("Error: ",""));
                 return;
             }
 
-            let { sanitizedSQL, variables } = sanitizeQuery(input);
-
-            const astwithVariables = parse(sanitizedSQL, variables);
-
             if (astwithVariables == null) {
                 expect(null).toEqual(expected);
                 return;
             }
 
-            variables = astwithVariables.variables;
+            const variables = astwithVariables.variables;
             const ast = astwithVariables.ast;
 
-            const result = convertToDevExpressFormat({ ast, variables, resultObject: sampleData });
+            const result = convertAstToDevextreme(ast, variables, sampleData);
 
             if (result == null || result == true || result == false) {
                 expect([]).toEqual(expected);
@@ -183,7 +186,7 @@ describe("Parser SQL to dx Filter Builder", () => {
 
             expect(result).toEqual(expected);
         });
-    });
+      });
 });
 
 

package/src/utils.js

@@ -1,14 +0,0 @@
-export function replacePlaceholders(sql, staticValues = {}, dynamicValues = []) {
-    // Replace static placeholders (e.g., {0})
-    sql = sql.replace(/\{(\w+)\}/g, (_, key) => staticValues[key] ?? `{${key}}`);
-
-    // Replace dynamic placeholders (e.g., | [AccountTaxPaymentDocument.CompanyID])
-    sql = sql.replace(/\|\s*\[([^\]]+)\]/g, (_, keys) => {
-        const replacements = keys.split(",").map(key => dynamicValues.shift() ?? `{${key.trim()}}`);
-        return replacements.join(", ");
-    });
-
-    return sql;
-}
-
-module.exports = { replacePlaceholders };