@react-querybuilder/core 8.20.1 → 8.21.0

package/dist/parseSQL.mjs

@@ -1,6 +1,6 @@
-import { E as joinWith, T as parseNumber } from "./utils-CJRGiPb-.mjs";
-import { r as isRuleGroup, s as lc } from "./objectUtils-ZvPkF6u6.mjs";
-import { n as fieldIsValidUtil, r as getFieldsArray, t as prepareRuleGroup } from "./prepareQueryObjects-Cd_tt4oy.mjs";
+import { A as parseNumber, j as joinWith } from "./utils-Dt0D_DMV.mjs";
+import { a as lc, t as isRuleGroup } from "./isRuleGroup-CqLThsbu.mjs";
+import { n as fieldIsValidUtil, r as getFieldsArray, t as prepareRuleGroup } from "./prepareQueryObjects-Q18lHCKl.mjs";
 import { JisonParser } from "@ts-jison/parser";
 import { JisonLexer } from "@ts-jison/lexer";
 //#region src/utils/parseSQL/sqlParser.ts
@@ -5887,6 +5887,15 @@ const isSQLLiteralValue = (v) => v?.type === "String" || v?.type === "Number" ||
 const isSQLSignedNumber = (v) => v?.type === "Prefix" && (v.prefix === "+" || v.prefix === "-") && v.value.type === "Number";
 const isSQLLiteralOrSignedNumberValue = (v) => isSQLLiteralValue(v) || isSQLSignedNumber(v);
 const isSQLIdentifier = (v) => v?.type === "Identifier";
+const isSQLBitExpression = (v) => v?.type === "BitExpression";
+const isSQLFunctionCall = (v) => v?.type === "FunctionCall";
+const isSQLPlaceHolder = (v) => v?.type === "PlaceHolder";
+/** An operand that is neither a bare identifier nor a (signed) literal nor a placeholder. */
+const isSQLExpressionOperand = (v) => {
+	if (isSQLBitExpression(v) || isSQLFunctionCall(v)) return true;
+	if (v?.type === "SimpleExprParentheses") return isSQLExpressionOperand(v.value?.value?.[0]);
+	return false;
+};
 const getParamString = (param) => {
 	switch (typeof param) {
 		case "number": return `${param}`;
@@ -6025,8 +6034,62 @@ const generateMixedAndXorOrList = (expr) => {
 };
 //#endregion
 //#region src/utils/parseSQL/parseSQL.ts
+/**
+* Rewrites named (`:name`, or any configured prefix) and positional (`?`) parameter
+* placeholders into the grammar's native `${name}` form so they surface as `PlaceHolder`
+* nodes. Positional placeholders are named by 1-based ordinal. Skips string/quoted-identifier
+* literals so placeholder-like text inside them is preserved.
+*/
+// v8 ignore next -- @preserve
+const normalizeParameterPlaceholders = (str, prefixes, positional) => {
+	let out = "";
+	let quote = "";
+	let ordinal = 0;
+	for (let i = 0; i < str.length;) {
+		const c = str[i];
+		if (quote) {
+			out += c;
+			if (c === quote) {
+				if (str[i + 1] === quote) {
+					out += str[i + 1];
+					i += 2;
+					continue;
+				}
+				quote = "";
+			}
+			i++;
+			continue;
+		}
+		if (c === `'` || c === `"` || c === "`") {
+			quote = c;
+			out += c;
+			i++;
+			continue;
+		}
+		if (positional && c === "?") {
+			ordinal++;
+			out += `\${${ordinal}}`;
+			i++;
+			continue;
+		}
+		let matched = false;
+		for (const p of prefixes) if (p.length > 0 && str.startsWith(p, i)) {
+			const m = /^([A-Za-z_$][\w$]*)/.exec(str.slice(i + p.length));
+			if (m) {
+				out += `\${${m[1]}}`;
+				i += p.length + m[1].length;
+				matched = true;
+				break;
+			}
+		}
+		if (matched) continue;
+		out += c;
+		i++;
+	}
+	return out;
+};
 function parseSQL(sql, options = {}) {
-	const { params, paramPrefix, independentCombinators, fields, getValueSources, bigIntOnOverflow } = options;
+	const { params, paramPrefix, independentCombinators, fields, getValueSources, bigIntOnOverflow, getExpression, parseParameters } = options;
 	let sqlString = /^\s*select\b/i.test(sql) ? sql : /^\s*where\b/i.test(sql) ? `SELECT * FROM t ${sql}` : `SELECT * FROM t WHERE ${sql}`;
 	let ic = false;
 	const fieldsFlat = getFieldsArray(fields);
@@ -6044,6 +6107,13 @@ function parseSQL(sql, options = {}) {
 		const prefix = paramPrefix ?? ":";
 		for (const p of keys) sqlString = sqlString.replaceAll(new RegExp(`\\${prefix}${p}\\b`, "ig"), getParamString(params[p]));
 	}
+	if (parseParameters) {
+		const cfg = parseParameters === true ? {} : parseParameters;
+		const pre = cfg.prefix ?? ":";
+		const prefixes = Array.isArray(pre) ? pre : [pre];
+		const positional = cfg.positional ?? true;
+		sqlString = normalizeParameterPlaceholders(sqlString, prefixes, positional);
+	}
 	const fieldIsValid = (fieldName, operator, subordinateFieldName) => fieldIsValidUtil({
 		fieldName,
 		fieldsFlat,
@@ -6051,10 +6121,15 @@ function parseSQL(sql, options = {}) {
 		subordinateFieldName,
 		getValueSources
 	});
+	const exprCtx = {
+		bigIntOnOverflow,
+		fieldExists: (fieldName) => fieldsFlat.length === 0 || fieldsFlat.some((f) => f.name === fieldName)
+	};
 	const processSQLExpression = (expr) => {
 		switch (expr.type) {
 			case "NotExpression": {
-				const rule = processSQLExpression(expr.value.type === "SimpleExprParentheses" ? expr.value.value.value[0] : expr.value);
+				const val = expr.value.type === "SimpleExprParentheses" ? expr.value.value.value[0] : expr.value;
+				const rule = processSQLExpression(val);
 				if (rule) {
 					if (isRuleGroup(rule)) return {
 						...rule,
@@ -6123,7 +6198,6 @@ function parseSQL(sql, options = {}) {
 				}
 				break;
 			case "ComparisonBooleanPrimary":
-				/* v8 ignore else -- @preserve */
 				if (isSQLIdentifier(expr.left) && !isSQLIdentifier(expr.right) || !isSQLIdentifier(expr.left) && isSQLIdentifier(expr.right)) {
 					const identifier = isSQLIdentifier(expr.left) ? expr.left.value : expr.right.value;
 					const valueObj = [expr.left, expr.right].find((t) => !isSQLIdentifier(t));
@@ -6135,6 +6209,26 @@ function parseSQL(sql, options = {}) {
 							operator,
 							value: evalSQLLiteralValue(valueObj, { bigIntOnOverflow })
 						};
+					} else if (parseParameters && isSQLPlaceHolder(valueObj)) {
+						const f = getFieldName(identifier);
+						const operator = normalizeOperator(expr.operator, isSQLIdentifier(expr.right));
+						if (fieldIsValid(f, operator)) return {
+							field: f,
+							operator,
+							value: valueObj.param,
+							valueSource: "parameter"
+						};
+					} else if (getExpression && isSQLExpressionOperand(valueObj)) {
+						const node = getExpression(valueObj, exprCtx);
+						if (!node) return null;
+						const f = getFieldName(identifier);
+						const operator = normalizeOperator(expr.operator, isSQLIdentifier(expr.right));
+						if (fieldIsValid(f, operator)) return {
+							field: f,
+							operator,
+							value: node,
+							valueSource: "expression"
+						};
 					}
 				} else if (isSQLIdentifier(expr.left) && isSQLIdentifier(expr.right)) {
 					const f = getFieldName(expr.left);
@@ -6146,6 +6240,30 @@ function parseSQL(sql, options = {}) {
 						value: sf,
 						valueSource: "field"
 					};
+				} else if (getExpression && isSQLExpressionOperand(expr.left) && isSQLExpressionOperand(expr.right)) {
+					const lhs = getExpression(expr.left, exprCtx);
+					const rhs = getExpression(expr.right, exprCtx);
+					if (!lhs || !rhs) return null;
+					return {
+						field: "",
+						operator: normalizeOperator(expr.operator),
+						lhs,
+						value: rhs,
+						valueSource: "expression"
+					};
+				} else if (getExpression && (isSQLExpressionOperand(expr.left) || isSQLExpressionOperand(expr.right))) {
+					const exprOnLeft = isSQLExpressionOperand(expr.left);
+					const exprSide = exprOnLeft ? expr.left : expr.right;
+					const otherSide = exprOnLeft ? expr.right : expr.left;
+					const lhs = getExpression(exprSide, exprCtx);
+					if (!lhs) return null;
+					if (isSQLLiteralOrSignedNumberValue(otherSide)) return {
+						field: "",
+						operator: normalizeOperator(expr.operator, !exprOnLeft),
+						lhs,
+						value: evalSQLLiteralValue(otherSide, { bigIntOnOverflow })
+					};
+					return null;
 				}
 				break;
 			case "InExpressionListPredicate":
@@ -6194,6 +6312,30 @@ function parseSQL(sql, options = {}) {
 						value: options?.listsAsArrays ? valueArray : joinWith(valueArray, ", "),
 						valueSource: "field"
 					};
+				} else if (parseParameters && isSQLIdentifier(expr.left) && isSQLPlaceHolder(expr.right.left) && isSQLPlaceHolder(expr.right.right)) {
+					const f = getFieldName(expr.left);
+					const operator = expr.hasNot ? "notBetween" : "between";
+					if (fieldIsValid(f, operator)) {
+						const valueArray = [expr.right.left.param, expr.right.right.param];
+						return {
+							field: f,
+							operator,
+							value: options?.listsAsArrays ? valueArray : joinWith(valueArray, ", "),
+							valueSource: "parameter"
+						};
+					}
+				} else if (getExpression && isSQLIdentifier(expr.left) && (isSQLExpressionOperand(expr.right.left) || isSQLExpressionOperand(expr.right.right))) {
+					const rhs = getExpression(expr.right.left, exprCtx);
+					const rhs2 = getExpression(expr.right.right, exprCtx);
+					if (!rhs || !rhs2) return null;
+					const f = getFieldName(expr.left);
+					const operator = expr.hasNot ? "notBetween" : "between";
+					if (fieldIsValid(f, operator)) return {
+						field: f,
+						operator,
+						value: [rhs, rhs2],
+						valueSource: "expression"
+					};
 				}
 				break;
 			case "LikePredicate":
@@ -6270,6 +6412,6 @@ function parseSQL(sql, options = {}) {
 	});
 }
 //#endregion
-export { parseSQL };
+export { evalSQLLiteralValue, getFieldName, isSQLBitExpression, isSQLExpressionOperand, isSQLFunctionCall, isSQLIdentifier, isSQLLiteralOrSignedNumberValue, isSQLLiteralValue, isSQLPlaceHolder, isSQLSignedNumber, normalizeOperator, parseSQL };
 
 //# sourceMappingURL=parseSQL.mjs.map