@react-querybuilder/core 8.20.2 → 8.21.0

package/dist/parseSQL.js

@@ -1,7 +1,7 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_utils = require("./utils-BpaOtylk.js");
-const require_objectUtils = require("./objectUtils-DBJI82bl.js");
-const require_prepareQueryObjects = require("./prepareQueryObjects-Bni5VgYM.js");
+const require_utils = require("./utils-DEwV7F6B.js");
+const require_isRuleGroup = require("./isRuleGroup-0JNiQgLg.js");
+const require_prepareQueryObjects = require("./prepareQueryObjects-C2-kTZvR.js");
 let _ts_jison_parser = require("@ts-jison/parser");
 let _ts_jison_lexer = require("@ts-jison/lexer");
 //#region src/utils/parseSQL/sqlParser.ts
@@ -5888,6 +5888,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}`;
@@ -5902,7 +5911,7 @@ const getFieldName = (f) => {
 	else if (fieldName.startsWith("[") && fieldName.endsWith("]")) return fieldName.replaceAll(/(^\[|]$)/g, "").replaceAll("]]", "]");
 	return fieldName;
 };
-const normalizeCombinator = (c) => require_objectUtils.lc(c.replace("&&", "and").replace("||", "or"));
+const normalizeCombinator = (c) => require_isRuleGroup.lc(c.replace("&&", "and").replace("||", "or"));
 const normalizeOperator = (op, flip) => {
 	if (flip) {
 		if (op === "<") return ">";
@@ -5918,7 +5927,7 @@ const evalSQLLiteralValue = (valueObj, { bigIntOnOverflow } = {}) => {
 		const valueString = valueObj.value;
 		if (valueString.startsWith(`'`) && valueString.endsWith(`'`) || valueString.startsWith(`"`) && valueString.endsWith(`"`)) return valueString.slice(1, -1).replaceAll(/''/gm, "'");
 		return valueString;
-	} else if (valueObj.type === "Boolean") return require_objectUtils.lc(valueObj.value) === "true";
+	} else if (valueObj.type === "Boolean") return require_isRuleGroup.lc(valueObj.value) === "true";
 	else if (isSQLSignedNumber(valueObj)) return require_utils.parseNumber(`${valueObj.prefix}${valueObj.value.value}`, {
 		parseNumbers: true,
 		bigIntOnOverflow
@@ -6026,8 +6035,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 = require_prepareQueryObjects.getFieldsArray(fields);
@@ -6045,6 +6108,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) => require_prepareQueryObjects.fieldIsValidUtil({
 		fieldName,
 		fieldsFlat,
@@ -6052,12 +6122,17 @@ 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 (require_objectUtils.isRuleGroup(rule)) return {
+					if (require_isRuleGroup.isRuleGroup(rule)) return {
 						...rule,
 						not: true
 					};
@@ -6124,7 +6199,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));
@@ -6136,6 +6210,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);
@@ -6147,6 +6241,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":
@@ -6195,6 +6313,30 @@ function parseSQL(sql, options = {}) {
 						value: options?.listsAsArrays ? valueArray : require_utils.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 : require_utils.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":
@@ -6258,7 +6400,7 @@ function parseSQL(sql, options = {}) {
 	if (where) {
 		const result = processSQLExpression(where);
 		if (result) {
-			if (require_objectUtils.isRuleGroup(result)) return prepare(result);
+			if (require_isRuleGroup.isRuleGroup(result)) return prepare(result);
 			return prepare({
 				rules: [result],
 				...ic ? {} : { combinator: "and" }
@@ -6271,6 +6413,17 @@ function parseSQL(sql, options = {}) {
 	});
 }
 //#endregion
+exports.evalSQLLiteralValue = evalSQLLiteralValue;
+exports.getFieldName = getFieldName;
+exports.isSQLBitExpression = isSQLBitExpression;
+exports.isSQLExpressionOperand = isSQLExpressionOperand;
+exports.isSQLFunctionCall = isSQLFunctionCall;
+exports.isSQLIdentifier = isSQLIdentifier;
+exports.isSQLLiteralOrSignedNumberValue = isSQLLiteralOrSignedNumberValue;
+exports.isSQLLiteralValue = isSQLLiteralValue;
+exports.isSQLPlaceHolder = isSQLPlaceHolder;
+exports.isSQLSignedNumber = isSQLSignedNumber;
+exports.normalizeOperator = normalizeOperator;
 exports.parseSQL = parseSQL;
 
 //# sourceMappingURL=parseSQL.js.map