Merge pull request #8 from RohitM-IN/development

Refactor and bug fixes

Author: RohitM-IN

README.md

@@ -1,29 +1,142 @@
 # 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.
+SQLParser is a JavaScript library that converts SQL `WHERE` clauses into a structured **Abstract Syntax Tree (AST)** and transforms them into DevExpress filter format. It removes inline parameters while preserving them as dynamic variables for flexible query processing.
 
-## Usage
+## Features
 
-### Convert SQL to AST
+- **AST-Based Query Processing**: Parses `WHERE` clauses and generates a structured AST.
+- **Supports Dynamic Parameters**: Identifies and extracts placeholders (`{param}`) for dynamic resolution.
+- **Parameter Cleanup**: Removes inline parameters while maintaining their structure.
+- **DevExpress-Compatible Output**: Converts parsed SQL conditions into the DevExpress filter format.
+- **Short-Circuit Optimization**: By default, eliminates `value = value` expressions for DevExpress compatibility (can be disabled for performance optimization).
+- **Separation of Concerns**: Generate AST once, then use it for multiple state updates.
 
-To convert a SQL-like filter string to an Abstract Syntax Tree (AST):
+## Example Workflow
+
+### **Step 1: Input SQL**
+
+```sql
+WHERE OrderID = {CustomerOrders.OrderID} AND Status IN (1, 3)
+```
+
+### **Step 2: Generate AST**
 
 ```javascript
-const filterString= "(ID <> {Item.ID}) AND (ItemGroupType IN ({Item.AllowedItemGroupType}))";
-const parsedResult = convertSQLToAst(filterString);
+import { convertSQLToAst } from "sqlparser-devexpress";
+
+const sqlQuery = "OrderID = {CustomerOrders.OrderID} AND Status IN (1, 3)";
+const { ast, variables } = convertSQLToAst(sqlQuery, true); // Enable logs
+```
+
+#### **AST Output**
+
+```json
+{
+  "type": "logical",
+  "operator": "AND",
+  "left": {
+    "type": "comparison",
+    "field": "OrderID",
+    "operator": "=",
+    "value": {
+      "type": "placeholder",
+      "value": "CustomerOrders.OrderID"
+    }
+  },
+  "right": {
+    "type": "comparison",
+    "field": "Status",
+    "operator": "in",
+    "value": {
+      "type": "value",
+      "value": [1, 3]
+    }
+  }
+}
 ```
 
-### Convert AST to DevExpress Format
+#### Extracted Variables  
 
-To convert an AST to DevExpress format:
+The parser identifies placeholders within the SQL query and extracts them for dynamic value resolution.  
+
+#### **Example Output:**  
+```json
+[
+  "CustomerOrders.OrderID"
+]
+```  
+
+These extracted variables can be used to fetch the corresponding state values in the application. You can store them in a `Record<string, any>`, where the key is the placeholder name, and the value is the resolved data from the application's state.
+
+
+
+### **Step 3: Convert AST to DevExpress Format**
 
 ```javascript
-const ast = { /* your AST here */ };
-const variables = [/* your variables here */];
-const state = { /* your state here */ };
+import { convertAstToDevextreme } from "sqlparser-devexpress";
+
+const sampleState = {
+    "CustomerOrders.OrderID": 76548
+};
+
+const devexpressFilter = convertAstToDevextreme(ast, sampleState, true); // Short-circuit enabled (default)
 
-const devExpressFilter = convertAstToDevextreme(ast, variables, state);
+console.log("DevExpress Filter:", JSON.stringify(devexpressFilter, null, 2));
+```
+
+#### **DevExpress Filter Output**
+
+```json
+[
+  ["OrderID", "=", 76548],
+  "and",
+  [
+    ["Status", "=", 1],
+    "or",
+    ["Status", "=", 3]
+  ]
+]
+```
 
-console.log(devExpressFilter);
+## Installation
+
+```sh
+npm install sqlparser-devexpress
 ```
 
+## API Reference
+
+### `convertSQLToAst(filterString, enableConsoleLogs = false)`
+
+- **Input:** SQL `WHERE` clause as a string.
+- **Output:** An object `{ ast }` where:
+  - `ast`: The parsed Abstract Syntax Tree.
+- **Example:**
+  ```javascript
+  const { ast } = convertSQLToAst("OrderID = {CustomerOrders.OrderID} AND Status IN (1, 3)");
+  ```
+
+### `convertAstToDevextreme(ast, state, shortCircuit = true)`
+
+- **Input:**
+  - `ast`: The AST generated from `convertSQLToAst()`.
+  - `state`: An object containing values for placeholders.
+  - `shortCircuit`: (Optional, default `true`) Enables short-circuiting of `value = value` expressions for DevExpress compatibility.
+- **Output:** DevExpress filter array.
+- **Example:**
+  ```javascript
+  const devexpressFilter = convertAstToDevextreme(ast, sampleState, false); // Disables short-circuiting
+  ```
+
+## Roadmap
+
+- Support for additional SQL operators and functions.
+- Improved error handling and validation.
+
+## Contributing
+
+Contributions are welcome! Feel free to open issues or submit pull requests.
+
+## License
+
+MIT

package.json

@@ -1,6 +1,6 @@
 {
   "name": "sqlparser-devexpress",
-  "version": "2.1.0",
+  "version": "2.2.0",
   "main": "src/index.js",
   "type": "module",
   "scripts": {
@@ -11,6 +11,10 @@
     "require": "./src/index.js"
   },
   "types": "src/@types/default.d.ts",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/RohitM-IN/SQLParser.git"
+  },
   "keywords": [
     "sql",
     "parser",

src/constants.js

@@ -0,0 +1,13 @@
+// 
+export const LITERALS = ["number", "string", "null"];
+
+// Define operator precedence for parsing expressions
+export const OPERATOR_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)
+export const UNSUPPORTED_PATTERN = /\bSELECT\b.*\bFROM\b|\bINNER\s+JOIN\b/i;
+
+export const LOGICAL_OPERATORS = ['and', 'or'];

src/core/converter.js

@@ -1,37 +1,31 @@
-const logicalOperators = ['and', 'or'];
+import { LOGICAL_OPERATORS } from "../constants.js";
 
 /**
  * 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 {boolean} enableShortCircuit - Optional enabling and disabling the shortcircuit ie evaluating value = value scenario 
    * @returns {Array|null} DevExpress format filter
    */
-    function convert(ast, vars, ResultObject = null) {
+    function convert(ast, ResultObject = null, enableShortCircuit = true) {
         // Set up global context
-        variables = vars;
         resultObject = ResultObject;
+        EnableShortCircuit = enableShortCircuit;
 
         // Process the AST
         let result = processAstNode(ast);
 
         // Handle special cases for short circuit
-        if(result === true || result === false || result === null) return [];
+        if (result === true || result === false || result === null) return [];
 
         return processAstNode(ast);
     }
@@ -111,8 +105,8 @@ function DevExpressConverter() {
 
         // 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];
+            if (left.length === 3 && LOGICAL_OPERATORS.includes(left[1])) parentOperator = left[1];
+            if (right.length === 3 && LOGICAL_OPERATORS.includes(right[1])) parentOperator = right[1];
         }
 
         // Flatten nested logical expressions if applicable
@@ -136,13 +130,21 @@ function DevExpressConverter() {
         }
 
         // Handle "IN" condition, including comma-separated values
-        if (operator === "IN") {
-            return handleInOperator(ast);
+        if (operator === "IN" || operator === "NOT IN") {
+            return handleInOperator(ast, operator);
         }
 
         const left = ast.left !== undefined ? processAstNode(ast.left) : convertValue(ast.field);
         const right = ast.right !== undefined ? processAstNode(ast.right) : convertValue(ast.value);
-        const comparison = [left, ast.operator.toLowerCase(), right];
+        const operatorToken = ast.operator.toLowerCase();
+
+        let comparison = [left, operatorToken, right];
+
+        if (isFunctionNullCheck(ast.left, true)) {
+            comparison = [[left, operatorToken, right], 'or', [left, operatorToken, null]];
+        } else if (isFunctionNullCheck(ast.right, true)) {
+            comparison = [[left, operatorToken, right], 'or', [right, operatorToken, null]];
+        }
 
         // Apply short-circuit evaluation if enabled
         if (EnableShortCircuit) {
@@ -179,7 +181,7 @@ function DevExpressConverter() {
      * @param {Object} ast - The comparison operator AST node.
      * @returns {Array} DevExpress format filter.
      */
-    function handleInOperator(ast) {
+    function handleInOperator(ast, operator) {
         let resolvedValue = convertValue(ast.value);
 
         // Handle comma-separated values in a string
@@ -190,19 +192,18 @@ function DevExpressConverter() {
             } else {
                 resolvedValue = firstValue;
             }
+        } else if (typeof resolvedValue === 'string' && resolvedValue.includes(',')) {
+            resolvedValue = resolvedValue.split(',').map(v => v.trim());
         }
 
-        if(Array.isArray(resolvedValue) && resolvedValue.length){
+        let operatorToken = operator === "IN" ? '=' : operator === "NOT IN" ? '!=' : operator;
+        let joinOperatorToken = operator === "IN" ? 'or' : operator === "NOT IN" ? 'and' : operator;
 
-            return Array.prototype.concat
-             .apply(
-               [],
-               resolvedValue.map((i) => [[ast.field, '=', i], 'or']),
-             )
-             .slice(0, -1)
+        if (Array.isArray(resolvedValue) && resolvedValue.length) {
+            return resolvedValue.flatMap(i => [[ast.field, operatorToken, i], joinOperatorToken]).slice(0, -1);
         }
 
-        return [ast.field, "in", resolvedValue];
+        return [ast.field, operatorToken, resolvedValue];
     }
 
     /**
@@ -225,7 +226,7 @@ function DevExpressConverter() {
             }
 
             // Special handling for ISNULL function
-            if (val.type === "function" && val.name === "ISNULL" && val.args?.length >= 2) {
+            if (isFunctionNullCheck(val)) {
                 return convertValue(val.args[0]);
             }
 
@@ -260,6 +261,18 @@ function DevExpressConverter() {
         return node?.type === "function" && node.name === "ISNULL" && valueNode?.type === "value";
     }
 
+    /**
+     * Checks if a node is a ISNULL function without value
+     * @param {Object} node 
+     * @returns {boolean} True if this is an ISNULL check.
+     */
+    function isFunctionNullCheck(node, isPlaceholderCheck = false) {
+        const isValidFunction = node?.type === "function" && node?.name === "ISNULL" && node?.args?.length >= 2;
+
+        return isPlaceholderCheck ? isValidFunction && node?.args[0]?.value?.type !== "placeholder" : isValidFunction;
+    }
+
+
     /**
      * Determines whether the logical tree should be flattened.
      * This is based on the parent operator and the current operator.
@@ -329,15 +342,22 @@ function DevExpressConverter() {
      * @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;
+        if ((left !== null && isNaN(left)) || (right !== null && isNaN(right))) return null;
+
+        if (left === null || right === null) {
+            if (operator === '=' || operator === '==') return left === right;
+            if (operator === '<>' || operator === '!=') return left !== right;
+            return null; // Any comparison with null should 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;
+            default: return null; // Invalid operator
         }
     }
 
@@ -351,12 +371,10 @@ 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
+ * @param {string} enableShortCircuit - Optional enabling and disabling the shortcircuit ie evaluating value = value scenario 
  * @returns {Array|null} DevExpress format filter
  */
-export function convertToDevExpressFormat({ ast, variables, resultObject = null }) {
-    return devExpressConverter.init(ast, variables, resultObject);
+export function convertToDevExpressFormat({ ast, resultObject = null, enableShortCircuit = true }) {
+    return devExpressConverter.init(ast, resultObject,enableShortCircuit);
 }