sqlparser-devexpress 2.0.1

package/LISCENSE.md

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2025 Rohit Mahajan
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

package/README.md

@@ -0,0 +1,29 @@
+# SQLParser
+
+SQLParser is a JavaScript library that converts SQL-like filter strings into DevExpress format filters. It provides utilities for parsing, sanitizing, and converting SQL-like expressions into a format that can be used with DevExpress components.
+
+## Usage
+
+### Convert SQL to AST
+
+To convert a SQL-like filter string to an Abstract Syntax Tree (AST):
+
+```javascript
+const filterString= "(ID <> {Item.ID}) AND (ItemGroupType IN ({Item.AllowedItemGroupType}))";
+const parsedResult = convertSQLToAst(filterString);
+```
+
+### Convert AST to DevExpress Format
+
+To convert an AST to DevExpress format:
+
+```javascript
+const ast = { /* your AST here */ };
+const variables = [/* your variables here */];
+const state = { /* your state here */ };
+
+const devExpressFilter = convertAstToDevextreme(ast, variables, state);
+
+console.log(devExpressFilter);
+```
+

package/package.json

@@ -0,0 +1,16 @@
+{
+  "name": "sqlparser-devexpress",
+  "version": "2.0.1",
+  "main": "index.js",
+  "type": "module",
+  "scripts": {
+    "test": "vitest"
+  },
+  "keywords": [],
+  "author": "Rohit Mahajan",
+  "license": "MIT",
+  "description": "",
+  "dependencies": {
+    "vitest": "^3.0.5"
+  }
+}

package/src/core/converter.js

@@ -0,0 +1,351 @@
+const logicalOperators = ['and', 'or'];
+
+/**
+ * Main conversion function that sets up the global context
+ * @param {Object} ast - The abstract syntax tree
+ * @param {Array} vars - Array of variable names
+ * @param {Object} results - Optional object for placeholder resolution
+ * @returns {Array|null} DevExpress format filter
+ */
+function DevExpressConverter() {
+    // Global variables accessible throughout the converter
+    let resultObject = null;
+    let primaryEntity = null;
+    let primaryKey = null;
+    let variables = [];
+    const EnableShortCircuit = true;
+
+    /**
+   * Main conversion function that sets up the global context
+   * @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) {
+        // Set up global context
+        variables = vars;
+        primaryKey = PrimaryKey;
+        primaryEntity = PrimaryEntity;
+        resultObject = ResultObject;
+
+        // Process the AST
+        return processAstNode(ast);
+    }
+
+    /**
+     * Process an AST node based on its type
+     * @param {Object} ast - The AST node to process
+     * @param {string} parentOperator - The operator of the parent logical node (if any)
+     * @returns {Array|null|boolean} DevExpress format filter or boolean for short-circuit
+     */
+    function processAstNode(ast, parentOperator = null) {
+        if (!ast) return null; // Return null if the AST is empty
+
+        switch (ast.type) {
+            case "logical":
+                return handleLogicalOperator(ast, parentOperator);
+            case "comparison":
+                return handleComparisonOperator(ast);
+            case "function":
+                return handleFunction(ast);
+            case "field":
+            case "value":
+                return convertValue(ast.value);
+            default:
+                return null;
+        }
+    }
+
+    /**
+     * Handles logical operators (AND, OR) and applies short-circuit optimizations.
+     * @param {Object} ast - The logical operator AST node.
+     * @param {string} parentOperator - The operator of the parent logical node.
+     * @returns {Array|boolean} DevExpress format filter or boolean for short-circuit.
+     */
+    function handleLogicalOperator(ast, parentOperator) {
+        const operator = ast.operator.toLowerCase();
+
+        // Special case: Handle ISNULL comparison with a value
+        if (isNullCheck(ast.left, ast.right)) {
+            const resolvedValue = convertValue(ast.right);
+
+            // Short-circuit: If left argument is a placeholder, return boolean result directly
+            if (EnableShortCircuit && ast.left.args[0]?.value?.type === "placeholder") {
+                return resolvedValue == null;
+            }
+
+            return [processAstNode(ast.left), operator, null];
+        }
+        if (isNullCheck(ast.right, ast.left)) {
+            const resolvedValue = convertValue(ast.left);
+
+            // Short-circuit: If right argument is a placeholder, return boolean result directly
+            if (EnableShortCircuit && ast.right.args[0]?.value?.type === "placeholder") {
+                return resolvedValue == null;
+            }
+
+            return [null, operator, processAstNode(ast.right)];
+        }
+
+        // Recursively process left and right operands
+        const left = processAstNode(ast.left, operator);
+        const right = processAstNode(ast.right, operator);
+
+        if (EnableShortCircuit) {
+            // Short-circuit: always-true conditions
+            if (left === true || right === true) {
+                if (operator === 'or') return true;
+                return left === true ? right : left;
+            }
+
+            // Short-circuit: always-false conditions
+            if (left === false || right === false) {
+                return left === false ? right : left;
+            }
+
+        }
+
+        // Detect and flatten nested logical expressions
+        if (parentOperator === null) {
+            if (left.length === 3 && logicalOperators.includes(left[1])) parentOperator = left[1];
+            if (right.length === 3 && logicalOperators.includes(right[1])) parentOperator = right[1];
+        }
+
+        // Flatten nested logical expressions if applicable
+        if (shouldFlattenLogicalTree(parentOperator, operator, ast)) {
+            return flattenLogicalTree(left, operator, right);
+        }
+        return [left, operator, right];
+    }
+
+    /**
+     * Handles comparison operators (=, <>, IN, IS) and applies optimizations.
+     * @param {Object} ast - The comparison operator AST node.
+     * @returns {Array|boolean} DevExpress format filter or boolean for short-circuit.
+     */
+    function handleComparisonOperator(ast) {
+        const operator = ast.operator.toUpperCase();
+
+        // Handle "IS NULL" condition
+        if (operator === "IS" && ast.value === null) {
+            return [ast.field, "=", null];
+        }
+
+        // Handle "IN" condition, including comma-separated values
+        if (operator === "IN") {
+            return handleInOperator(ast);
+        }
+
+        const left = convertValue(ast.field);
+        const right = convertValue(ast.value);
+        const comparison = [left, ast.operator.toLowerCase(), right];
+
+        // Apply short-circuit evaluation if enabled
+        if (EnableShortCircuit) {
+            if (isAlwaysTrue(comparison)) return true;
+            if (isAlwaysFalse(comparison)) return false;
+        }
+
+        return comparison;
+    }
+
+    /**
+     * Handles function calls, focusing on ISNULL.
+     * @param {Object} ast - The function AST node.
+     * @returns {*} Resolved function result.
+     */
+    function handleFunction(ast) {
+        if (ast.name === "ISNULL" && ast.args && ast.args.length >= 2) {
+            const firstArg = ast.args[0];
+
+            // Resolve placeholders
+            if (firstArg.type === "placeholder") {
+                return resolvePlaceholderFromResultObject(firstArg.value);
+            }
+            return convertValue(firstArg);
+        }
+
+        // this should never happen as we are only handling ISNULL and should throw an error
+        throw new Error(`Unsupported function: ${ast.name}`);
+    }
+
+
+    /**
+     * Handles the IN operator specifically.
+     * @param {Object} ast - The comparison operator AST node.
+     * @returns {Array} DevExpress format filter.
+     */
+    function handleInOperator(ast) {
+        let resolvedValue = convertValue(ast.value);
+
+        // Handle comma-separated values in a string
+        if (Array.isArray(resolvedValue) && resolvedValue.length === 1) {
+            const firstValue = resolvedValue[0];
+            if (typeof firstValue === 'string' && firstValue.includes(',')) {
+                resolvedValue = firstValue.split(',').map(v => v.trim());
+            } else {
+                resolvedValue = firstValue;
+            }
+        }
+
+        return [ast.field, "in", resolvedValue];
+    }
+
+    /**
+     * Converts a single value, resolving placeholders and handling special cases.
+     * @param {*} val - The value to convert.
+     * @returns {*} Converted value.
+     */
+    function convertValue(val) {
+        if (val === null) return null;
+
+        // Handle array values
+        if (Array.isArray(val)) {
+            return val.map(item => convertValue(item));
+        }
+
+        // Handle object-based values
+        if (typeof val === "object") {
+            if (val.type === "placeholder") {
+                return resolvePlaceholderFromResultObject(val.value);
+            }
+
+            // Special handling for ISNULL function
+            if (val.type === "function" && val.name === "ISNULL" && val.args?.length >= 2) {
+                return convertValue(val.args[0]);
+            }
+
+            // Handle nested AST nodes
+            if (val.type) {
+                return processAstNode(val);
+            }
+        }
+
+        return val;
+    }
+
+    /**
+     * Resolves placeholder values from the result object.
+     * @param {string} placeholder - The placeholder to resolve.
+     * @returns {*} Resolved placeholder value.
+     */
+    function resolvePlaceholderFromResultObject(placeholder) {
+        if (!resultObject) return `{${placeholder}}`;
+
+
+        return resultObject.hasOwnProperty(placeholder) ? resultObject[placeholder] : `{${placeholder}}`;
+    }
+
+    /**
+     * Checks if a node is an ISNULL function check.
+     * @param {Object} node - The node to check.
+     * @param {Object} valueNode - The value node.
+     * @returns {boolean} True if this is an ISNULL check.
+     */
+    function isNullCheck(node, valueNode) {
+        return node?.type === "function" && node.name === "ISNULL" && valueNode?.type === "value";
+    }
+
+    /**
+     * Determines whether the logical tree should be flattened.
+     * This is based on the parent operator and the current operator.
+     * @param {string} parentOperator - The operator of the parent logical node.
+     * @param {string} operator - The operator of the current logical node.
+     * @param {Object} ast - The current AST node.
+     * @returns {boolean} True if the tree should be flattened, false otherwise.
+     */
+    function shouldFlattenLogicalTree(parentOperator, operator, ast) {
+        return parentOperator !== null && operator === parentOperator || ast.operator === ast.right?.operator;
+    }
+
+    /**
+     * Flattens a logical tree by combining nested logical nodes.
+     * @param {Array} left - The left side of the logical expression.
+     * @param {string} operator - The logical operator.
+     * @param {Array} right - The right side of the logical expression.
+     * @returns {Array} The flattened logical tree.
+     */
+    function flattenLogicalTree(left, operator, right) {
+        const parts = [];
+
+        // Flatten left side if it has the same operator
+        if (Array.isArray(left) && left[1] === operator) {
+            parts.push(...left);
+        } else {
+            parts.push(left);
+        }
+
+        // Add the operator
+        parts.push(operator);
+
+        // Flatten right side if it has the same operator
+        if (Array.isArray(right) && right[1] === operator) {
+            parts.push(...right);
+        } else {
+            parts.push(right);
+        }
+
+        return parts;
+    }
+
+
+    /**
+     * Checks if a condition is always true.
+     * @param {Array} condition - The condition to check.
+     * @returns {boolean} True if the condition is always true.
+     */
+    function isAlwaysTrue(condition) {
+        return Array.isArray(condition) && condition.length === 3 && evaluateExpression(...condition) == true;
+    }
+
+    /**
+     * Checks if a condition is always false.
+     * @param {Array} condition - The condition to check.
+     * @returns {boolean} True if the condition is always false.
+     */
+    function isAlwaysFalse(condition) {
+        return Array.isArray(condition) && condition.length === 3 && evaluateExpression(...condition) == false;
+    }
+
+    /**
+     * Evaluates a simple expression.
+     * @param {*} left - The left operand.
+     * @param {string} operator - The operator.
+     * @param {*} right - The right operand.
+     * @returns {boolean|null} The result of the evaluation or null if not evaluable.
+     */
+    function evaluateExpression(left, operator, right) {
+        if (isNaN(left) || isNaN(right) || left === null || right === null) return null;
+        switch (operator) {
+            case '=': case '==': return left === right;
+            case '<>': case '!=': return left !== right;
+            case '>': return left > right;
+            case '>=': return left >= right;
+            case '<': return left < right;
+            case '<=': return left <= right;
+            default: return false;
+        }
+    }
+
+    return { init: convert };
+
+}
+
+// Create a global instance
+const devExpressConverter = DevExpressConverter();
+
+/**
+ * Converts an abstract syntax tree to DevExpress format
+ * @param {Object} ast - The abstract syntax tree
+ * @param {Array} variables - 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
+ */
+export function convertToDevExpressFormat({ ast, variables, resultObject = null, primaryEntity = null, primaryKey = null }) {
+    return devExpressConverter.init(ast, variables, resultObject, primaryEntity, primaryKey);
+}

package/src/core/parser.js

@@ -0,0 +1,156 @@
+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
+};
+
+// 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;
+
+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();
+
+  // 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
+      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 };
+}

package/src/core/sanitizer.js

@@ -0,0 +1,43 @@
+function sanitizeQuery(sql) {
+    // First check if the SQL has the pipe format for placeholders
+    if (sql.includes("|")) {
+        const [mainQuery, ...placeholderSections] = sql.split("|").map(s => s.trim());
+        const variables = [];
+
+        // Extract placeholders from | [arg1] | [arg2] sections
+        placeholderSections.forEach(section => {
+            if (section.startsWith("[") && section.endsWith("]")) {
+                const placeholders = section
+                    .slice(1, -1) // Remove [ and ]
+                    .split(",")
+                    .map(s => s.trim());
+                variables.push(...placeholders);
+            }
+        });
+
+        // Replace {0}, {1}, etc., with variable names
+        const sanitizedSQL = mainQuery.replace(/\{(\d+)\}/g, (_, index) => {
+            return variables[index] ? `{${variables[index]}}` : `{placeholder${index}}`;
+        });
+
+        return { sanitizedSQL, variables };
+    } 
+    // Handle SQL with directly embedded placeholders like {WorkOrderLine.ApplicableUoms}
+    else {
+        const variables = [];
+        const placeholderRegex = /\{([^}]+)\}/g;
+        let match;
+        
+        // Extract all placeholders
+        while ((match = placeholderRegex.exec(sql)) !== null) {
+            const placeholder = match[1];
+            if (!variables.includes(placeholder)) {
+                variables.push(placeholder);
+            }
+        }
+        
+        return { sanitizedSQL: sql, variables };
+    }
+}
+
+export { sanitizeQuery };

package/src/core/tokenizer.js

@@ -0,0 +1,58 @@
+// Define regex patterns for different token types
+const tokenPatterns = {
+  whitespace: "\\s+", // Matches spaces, tabs, and newlines
+  function: "\\b(ISNULL)\\b", // Matches function names like ISNULL (case-insensitive)
+  null: "\\bNULL\\b", // Matches NULL as a keyword
+  number: "\\d+", // Matches numerical values
+  placeholder: "'?\\{[^}]+\\}'?", // Matches placeholders like {variable} or '{variable}'
+  string: "'(?:''|[^'])*'", // Matches strings, allowing for escaped single quotes ('')
+  operator: "=>|<=|!=|>=|=|<>|>|<|AND|OR|BETWEEN|IN|LIKE|IS", // Matches SQL operators and logical keywords
+  identifier: "[\\w.]+", // Matches identifiers, including table.column format
+  paren: "[()]", // Matches parentheses
+  comma: "," // Matches commas
+};
+
+// Create a Map for O(1) token type lookup
+const tokenTypeMap = new Map(Object.entries(tokenPatterns));
+
+// Combine all token patterns into a single regular expression using named capture groups
+const combinedRegex = new RegExp(
+  [...tokenTypeMap.keys()].map(name => `(?<${name}>${tokenPatterns[name]})`).join("|"),
+  "iy" // 'i' makes it case-insensitive, 'y' ensures it matches from the current index
+);
+
+class Tokenizer {
+  constructor(input) {
+    this.input = input; // The input SQL-like string to be tokenized
+    this.index = 0; // Tracks the current position in the input
+  }
+
+  nextToken() {
+    if (this.index >= this.input.length) return null; // Stop if we've reached the end
+
+    combinedRegex.lastIndex = this.index; // Ensure regex starts from the current index
+    const match = combinedRegex.exec(this.input); // Execute regex to find the next token
+
+    if (match) {
+      this.index = combinedRegex.lastIndex; // Move index to the end of the matched token
+
+      // Find the first matched token type in O(1) time using the tokenTypeMap
+      const type = [...tokenTypeMap.keys()].find(name => match.groups[name] !== undefined);
+
+      // Skip whitespace tokens
+      if (!type || type === "whitespace") return this.nextToken(); 
+
+      let value = match.groups[type];
+
+      // Remove surrounding single quotes from placeholders
+      if (type === "placeholder") value = value.replace(/^['"]|['"]$/g, "");
+
+      return { type, value };
+    }
+
+    // If no valid token is found, throw an error with the remaining input for debugging
+    throw new Error(`Unexpected token at: ${this.input.slice(this.index)}`);
+  }
+}
+
+export { Tokenizer };

package/src/index.js

@@ -0,0 +1,43 @@
+import { convertToDevExpressFormat } from "./core/converter.js";
+import { parse } from "./core/parser.js";
+import { sanitizeQuery } from "./core/sanitizer.js";
+
+
+export function convertSQLToAst(filterString, SampleData = null, enableConsoleLogs = false) {
+    let { sanitizedSQL, extractedVariables } = sanitizeQuery(filterString);
+    enableConsoleLogs && console.log("Sanitized SQL:", sanitizedSQL, "\n");
+
+    const parsedResult = parse(sanitizedSQL, extractedVariables);
+
+    enableConsoleLogs && console.log("Extracted Variables:", JSON.stringify(parsedResult.variables, null, 2), "\n");
+    enableConsoleLogs && console.log("AST Tree:", JSON.stringify(parsedResult.ast, null, 2), "\n");
+
+    return parsedResult;
+}
+
+export function convertAstToDevextreme(ast, variables, state) {
+    return convertToDevExpressFormat({ ast, variables, resultObject: state })
+}
+
+// export function parseFilterString(filterString, sampleData = null) {
+//     if (filterString.toUpperCase().startsWith("SELECT")) return null; // Skip full SQL queries
+
+//     let { sanitizedSQL, extractedVariables } = sanitizeQuery(filterString);
+//     console.log("Sanitized SQL:", sanitizedSQL, "\n");
+
+//     const parsedResult = parse(sanitizedSQL, extractedVariables);
+//     extractedVariables = parsedResult.variables;
+//     console.log("Extracted Variables:", JSON.stringify(extractedVariables, null, 2), "\n");
+
+//     const astTree = parsedResult.ast;
+//     console.log("AST Tree:", JSON.stringify(astTree, null, 2), "\n");
+
+//     return convertToDevExpressFormat({ ast: astTree, variables: extractedVariables, resultObject: sampleData });
+// }
+
+// Example usage
+// const devExpressFilter = parseFilterString("((ISNULL({0}, 0) = 0 AND CompanyID = {1}) OR CompanyID IS NULL) OR BranchID = {0} | [LeadDocument.BranchID] | [LeadDocument.CompanyID]", sampleResultObject);
+// 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,);
+
+// console.log("DevExpress Filter:", JSON.stringify(devExpressFilter, null, 2));

package/src/utils.js

@@ -0,0 +1,14 @@
+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 };

package/tests/parser.test.js

@@ -0,0 +1,197 @@
+import { describe, expect, it } from "vitest";
+import { convertToDevExpressFormat } from "../src/core/converter";
+import { parse } from "../src/core/parser";
+import { sanitizeQuery } from "../src/core/sanitizer";
+
+describe("Parser SQL to dx Filter Builder", () => {
+    const testCases = [
+        {
+            input: "(ID = {CoreEntity0022.CompanyGroupID} OR ISNULL({CoreEntity0022.CompanyGroupID},0) = 0)",
+            expected: [
+                // [
+                "ID", "=", 42
+                // ],
+                // "or",
+                // [42, "=", null], 
+            ],
+        },
+        {
+            input: "GroupNo = {Employee.District} OR ISNULL(GroupNo,0) = 0 OR {Employee.District} = 0",
+            expected: [
+                // ["GroupNo", "=", 0],
+                // "or",
+                // ["GroupNo", "=", null],
+                // "or",
+                // [0, "=", 0],
+            ],
+        },
+        {
+            input: "ContactID = {SaleInvoiceDocument.ContactID} AND AddressType IN (2, 4)",
+            expected: [
+                ["ContactID", "=", 42],
+                "and",
+                ["AddressType", "in", [2, 4]],
+            ],
+        },
+        {
+            input: "ID IN ({WorkOrderLine.ApplicableUoms}) AND (CompanyID = {WorkOrderDocument.CompanyID} OR {WorkOrderDocument.CompanyID} = 0)",
+            expected: [
+                ["ID", "in", ["UOM1", "UOM2", "UOM3"]],
+                "and",
+                // [
+                ["CompanyID", "=", 42],
+                // "or",
+                // [42, "=", 0],
+                // ],
+            ],
+        },
+        {
+            input: "CompanyID = {AccountingRule.CompanyID}",
+            expected: [
+                "CompanyID", "=", 42,
+            ],
+        },
+        {
+            input: "(Level > {Area.AreaType})",
+            expected: [
+                "Level", ">", 42
+            ]
+        },
+        {
+            input: "(ID <> {Item.ID}) AND (ItemGroupType IN ({Item.AllowedItemGroupType}))",
+            expected: [
+                ["ID", "<>", 42],
+                'and',
+                ["ItemGroupType", "in", ["1", "2"]]
+            ]
+        },
+        {
+            input: "((FromDate <= '{TransferOutwardDocument.DocDate}' AND ToDate >= '{TransferOutwardDocument.DocDate}') OR ToDate is NULL) AND (BranchID = {TransferOutwardDocument.RefBranchID} OR RefBranchID is NULL) AND (CompanyID = {TransferOutwardDocument.CompanyID}  OR {TransferOutwardDocument.CompanyID} = 0 OR CompanyID is NULL)",
+            expected: [
+                [
+                    [
+                        ["FromDate", "<=", "2022-01-01"],
+                        'and',
+                        ["ToDate", ">=", "2022-01-01"]
+                    ],
+                    'or',
+                    ["ToDate", "=", null]
+                ],
+                "and",
+                [
+                    ["BranchID", "=", 42],
+                    "or",
+                    ["RefBranchID", "=", null]
+                ],
+                "and",
+                [
+                    ["CompanyID", "=", 7],
+                    // "or",
+                    // [7,"=",0],
+                    "or",
+                    ["CompanyID", "=", null]
+                ]
+            ]
+        },
+        {
+            input: "(ID <> {Item.ID}) AND ( ItemGroupType = '''')",
+            expected: [
+                ["ID", "<>", 42],
+                'and',
+                ["ItemGroupType", "=", ""]
+            ]
+        },
+        {
+            input: "NULL",
+            expected: null
+        },
+        {
+            input: "((ISNULL({0}, 0) = 0 AND CompanyID = {1}) OR CompanyID IS NULL) OR BranchID = {0} | [LeadDocument.BranchID] | [LeadDocument.CompanyID]",
+            expected: [
+                // [
+                // [
+                // [42,"=",null],
+                // "and",
+                ["CompanyID", "=", 7],
+                // ],
+                "or",
+                ["CompanyID", "=", null],
+                // ],
+                'or',
+                ["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: [
+                "FromDate", "between", ["10-10-2021", "10-10-2022"]
+            ]
+        }
+    ];
+
+    testCases.forEach(({ input, expected }, index) => {
+        it(`Test Case ${index + 1}: ${input}`, () => {
+
+            if (expected == undefined) {
+                expected = null
+            }
+
+            // Need to handle NULL as a special case
+            if (input.toLowerCase() === "null") {
+                expect(null).toEqual(null);
+                return;
+            }
+
+            let { sanitizedSQL, variables } = sanitizeQuery(input);
+
+            const astwithVariables = parse(sanitizedSQL, variables);
+
+            if (astwithVariables == null) {
+                expect(null).toEqual(expected);
+                return;
+            }
+
+            variables = astwithVariables.variables;
+            const ast = astwithVariables.ast;
+
+            const result = convertToDevExpressFormat({ ast, variables, resultObject: sampleData });
+
+            if (result == null || result == true || result == false) {
+                expect([]).toEqual(expected);
+                return;
+            }
+
+            expect(result).toEqual(expected);
+        });
+    });
+});
+
+
+const sampleData = {
+    "CoreEntity0022.CompanyGroupID": 42,
+    "CoreEntity0022.BranchID": 7,
+    "Employee.District": 0,
+    "Employee.BranchID": 7,
+    "SaleInvoiceDocument.ContactID": 42,
+    "SaleInvoiceDocument.BranchID": 7,
+    "AccountingRule.CompanyID": 42,
+    "AccountingRule.BranchID": 7,
+    "Area.AreaType": 42,
+    "Area.BranchID": 7,
+    "Item.ID": 42,
+    "Item.BranchID": 7,
+    "Item.AllowedItemGroupType": "1,2",
+    "WorkOrderLine.ApplicableUoms": ["UOM1", "UOM2", "UOM3"],
+    "WorkOrderLine.CompanyID": 2,
+    "WorkOrderDocument.CompanyID": 42,
+    "WorkOrderDocument.BranchID": 7,
+    "TransferOutwardDocument.DocDate": "2022-01-01",
+    "TransferOutwardDocument.RefBranchID": 42,
+    "TransferOutwardDocument.CompanyID": 7,
+    "LeadDocument.BranchID": 42,
+    "LeadDocument.CompanyID": 7
+};