sqlparser-devexpress 2.3.10 → 2.3.12

package/package.json

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

package/src/@types/core/converter.d.ts

@@ -0,0 +1,22 @@
+import { ASTNode } from "./parser.js";
+
+export interface ResultObject {
+    [key: string]: any;
+}
+
+export type DevExpressFilter = any[] | null;
+
+export interface ConvertOptions {
+    ast: ASTNode;
+    resultObject?: ResultObject;
+    enableShortCircuit?: boolean;
+}
+
+/**
+ * Converts an abstract syntax tree (AST) to DevExpress filter format.
+ * This function uses short-circuit evaluation for optimization.
+ *
+ * @param options - The conversion options containing AST, result object, and short-circuit flag.
+ * @returns DevExpressFilter - The DevExpress compatible filter array or null.
+ */
+export function convertToDevExpressFormat(options: ConvertOptions): DevExpressFilter;

package/src/@types/core/parser.d.ts

@@ -0,0 +1,27 @@
+export interface ASTNode {
+    type: string;
+    operator?: string;
+    field?: string;
+    value?: any;
+    left?: ASTNode;
+    right?: ASTNode;
+    args?: ASTNode[];
+    name?: string;
+}
+
+/**
+ * Represents the result of the parse function.
+ */
+export interface ParseResult {
+    ast: ASTNode;
+    variables: string[];
+}
+
+/**
+ * The main parse function that converts SQL-like queries into AST.
+ *
+ * @param input - The SQL-like string to be parsed.
+ * @param variables - The list of extracted variables during parsing.
+ * @returns ParseResult - The resulting AST and extracted variables.
+ */
+export function parse(input: string, variables?: string[]): ParseResult;

package/src/@types/core/sanitizer.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Represents the result of sanitizing the SQL query.
+ */
+export interface SanitizeResult {
+    sanitizedSQL: string;
+    variables: string[];
+}
+
+/**
+ * Sanitizes the SQL query by replacing placeholders or pipe-separated variables
+ * with standardized `{placeholder}` format and extracts all variable names.
+ *
+ * Example Input:
+ * ```
+ * SELECT * FROM Orders WHERE CustomerID = {0} | [CustomerID]
+ * ```
+ *
+ * Output:
+ * ```
+ * {
+ *   sanitizedSQL: "SELECT * FROM Orders WHERE CustomerID = {CustomerID}",
+ *   variables: ["CustomerID"]
+ * }
+ *
+ * @param sql - The raw SQL query containing placeholders or pipes.
+ * @returns SanitizeResult - The cleaned SQL query and extracted variables.
+ */
+export function sanitizeQuery(sql: string): SanitizeResult;

package/src/@types/core/tokenizer.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Represents a single token from the tokenizer.
+ */
+export interface Token {
+    type: string;
+    value: string;
+    dataType?: string;
+}

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

@@ -1,35 +1,41 @@
-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
-    resultObject?: StateDataObject | null;
-    enableShortCircuit?: boolean;
-}
-
-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;
-
+import { DevExpressFilter, ResultObject } from "./core/converter";
+import { ASTNode, ParseResult } from "./core/parser";
+
+/**
+ * Converts an SQL-like filter string into an Abstract Syntax Tree (AST).
+ * It also extracts variables from placeholders like `{CustomerID}` or pipe-separated sections.
+ * Optionally logs the conversion process if `enableConsoleLogs` is `true`.
+ *
+ * Example:
+ * ```
+ * const { ast, variables } = convertSQLToAst("ID = {CustomerID} AND Status = {OrderStatus}");
+ * console.log(ast);
+ * console.log(variables);
+ * ```
+ *
+ * @param filterString - The raw SQL-like filter string.
+ * @param enableConsoleLogs - Whether to log the parsing and sanitization process.
+ * @returns ParseResult - The AST and extracted variables.
+ */
+export function convertSQLToAst(filterString: string, enableConsoleLogs?: boolean): ParseResult;
+
+/**
+ * Converts an Abstract Syntax Tree (AST) into a DevExpress-compatible filter format.
+ * Optionally supports a result object for dynamic value resolution and short-circuit evaluation.
+ *
+ * Example:
+ * ```
+ * const filter = convertAstToDevextreme(ast, state, true);
+ * console.log(filter);
+ * ```
+ *
+ * @param ast - The parsed AST from `convertSQLToAst`.
+ * @param state - An optional result object to resolve placeholders to actual values.
+ * @param enableShortCircuit - Whether to apply short-circuit evaluation.
+ * @returns DevExpressFilter - The DevExpress-compatible filter array or null.
+ */
 export function convertAstToDevextreme(
-    ast: any, // Define a more specific type if possible
-    state?: StateDataObject | null,
+    ast: ASTNode,
+    state?: ResultObject | null,
     enableShortCircuit?: boolean,
-): any;
+): DevExpressFilter;

package/src/core/converter.js

@@ -48,7 +48,7 @@ function DevExpressConverter() {
                 return handleFunction(ast);
             case "field":
             case "value":
-                return convertValue(ast.value);
+                return convertValue(ast.value, parentOperator);
             default:
                 return null;
         }
@@ -113,6 +113,7 @@ function DevExpressConverter() {
         if (shouldFlattenLogicalTree(parentOperator, operator, ast)) {
             return flattenLogicalTree(left, operator, right);
         }
+
         return [left, operator, right];
     }
 
@@ -205,22 +206,41 @@ function DevExpressConverter() {
             resolvedValue = resolvedValue.split(',').map(v => v.trim());
         }
 
+        // handle short circuit evaluation for IN operator
+        if (EnableShortCircuit && ast.field?.type === "value" && ast.value?.type === "value") {
+            const fieldVal = convertValue(ast.field);
+            if (Array.isArray(resolvedValue)) {
+                // normalize numeric strings if LHS is number
+                const list = resolvedValue.map(x =>
+                    (typeof x === "string" && !isNaN(x) && typeof fieldVal === "number")
+                        ? Number(x)
+                        : x
+                );
+
+                if (operator === "IN")
+                    return list.includes(fieldVal);
+                else if (operator === "NOT IN")
+                    return !list.includes(fieldVal);
+            }
+        }
+
         let operatorToken = operator === "IN" ? '=' : operator === "NOT IN" ? '!=' : operator;
         let joinOperatorToken = operator === "IN" ? 'or' : operator === "NOT IN" ? 'and' : operator;
-
+        let field = convertValue(ast.field);
         if (Array.isArray(resolvedValue) && resolvedValue.length) {
-            return resolvedValue.flatMap(i => [[ast.field, operatorToken, i], joinOperatorToken]).slice(0, -1);
+            return resolvedValue.flatMap(i => [[field, operatorToken, i], joinOperatorToken]).slice(0, -1);
         }
 
-        return [ast.field, operatorToken, resolvedValue];
+        return [field, operatorToken, resolvedValue];
     }
 
     /**
      * Converts a single value, resolving placeholders and handling special cases.
      * @param {*} val - The value to convert.
+     * @param {string} parentOperator - The operator of the parent logical node (if any).
      * @returns {*} Converted value.
      */
-    function convertValue(val) {
+    function convertValue(val, parentOperator = null) {
         if (val === null) return null;
 
         // Handle array values
@@ -251,6 +271,10 @@ function DevExpressConverter() {
             }
         }
 
+        if (parentOperator && parentOperator.toUpperCase() === "IN" && typeof val === "string") {
+            return val.split(',').map(v => v.trim());
+        }
+
         return val;
     }
 

package/src/core/parser.js

@@ -102,15 +102,15 @@ export function parse(input, variables = []) {
 			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  };
+			if (nodeType === "logical") {
+				return { type: "logical", operator, left: { type: "function", name: functionName, args: functionArgs }, right: rightOperand };
 			}
 
 			return {
 				type: "comparison",
 				left: { type: "function", name: functionName, args: functionArgs },
 				operator,
-				value: rightOperand 
+				value: rightOperand
 			};
 		}
 
@@ -126,9 +126,21 @@ export function parse(input, variables = []) {
 			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 };
+			if (operator === "IN" || operator === "NOT IN") {
+				const rightList = parseValue(operator);
+				left = {
+					type: "comparison",
+					field: left,
+					operator: operator,
+					value: rightList
+				};
+			}
+
+			if (LOGICAL_OPERATORS.includes(operator.toLowerCase())) {
+				// Recursively parse the right-hand expression with adjusted precedence
+				const right = parseExpression(OPERATOR_PRECEDENCE[operator]);
+				left = { type: "logical", operator, left, right };
+			}
 		}
 
 		return left;
@@ -173,7 +185,7 @@ export function parse(input, variables = []) {
 			if (currentToken.type === "function") {
 				const functionNode = parseFunction();
 
-				if(fieldType === "identifier" && functionNode.type === "function") {
+				if (fieldType === "identifier" && functionNode.type === "function") {
 					return {
 						type: "comparison",
 						field,
@@ -189,7 +201,7 @@ export function parse(input, variables = []) {
 					operator,
 					value: functionNode.left
 				};
-			
+
 				functionNode.left = leftComparison;
 				return functionNode;
 			}
@@ -237,7 +249,7 @@ export function parse(input, variables = []) {
 			case "placeholder": {
 				const val = token.value.slice(1, -1);
 				if (!variables.includes(val)) variables.push(val);
-				return {  ...token ,type: "placeholder", value: val };
+				return { ...token, type: "placeholder", value: val };
 			}
 
 			case "paren": {

package/tests/parser.test.js

@@ -214,6 +214,14 @@ describe("Parser SQL to dx Filter Builder", () => {
         {
             input: "(RS2ID in ({SaleOrderStatusStmtGlobalRpt.StateID}) Or (ISNULL({SaleOrderStatusStmtGlobalRpt.StateID},0) =0)) And (RS3ID  in (0,{SaleOrderStatusStmtGlobalRpt.RegionID}) Or ISNULL({SaleOrderStatusStmtGlobalRpt.RegionID},0) =0 )",
             expected: []
+        },
+        {
+            input: "ID IN ('1,2') AND 0 IN ('0,2')",
+            expected: [
+                ["ID", "=", "1"],
+                "or",
+                ["ID", "=", "2"]
+            ]
         }
     ];