@react-querybuilder/core 8.15.0 → 8.16.0

package/dist/formatQuery.mjs

@@ -82,7 +82,7 @@ const defaultRuleGroupProcessorCEL = (ruleGroup, options) => {
 //#endregion
 //#region src/utils/formatQuery/defaultRuleProcessorCEL.ts
 const shouldNegate$2 = (op) => op.startsWith("not") || op.startsWith("doesnot");
-const escapeDoubleQuotes = (v, escapeQuotes) => typeof v !== "string" || !escapeQuotes ? `${v}` : v.replaceAll(`"`, `\\"`);
+const escapeDoubleQuotes$1 = (v, escapeQuotes) => typeof v !== "string" || !escapeQuotes ? `${v}` : v.replaceAll(`"`, `\\"`);
 /**
 * Default rule processor used by {@link formatQuery} for "cel" format.
 *
@@ -124,19 +124,19 @@ const defaultRuleProcessorCEL = (rule, opts = {}) => {
 		case "==":
 		case "!=":
 		case ">":
-		case ">=": return `${field} ${operatorTL} ${valueIsField || useBareValue ? trimIfString(value) : `"${escapeDoubleQuotes(value, escapeQuotes)}"`}`;
+		case ">=": return `${field} ${operatorTL} ${valueIsField || useBareValue ? trimIfString(value) : `"${escapeDoubleQuotes$1(value, escapeQuotes)}"`}`;
 		case "contains":
-		case "doesnotcontain": return `${shouldNegate$2(operatorTL) ? "!" : ""}${field}.contains(${valueIsField ? trimIfString(value) : `"${escapeDoubleQuotes(value, escapeQuotes)}"`})`;
+		case "doesnotcontain": return `${shouldNegate$2(operatorTL) ? "!" : ""}${field}.contains(${valueIsField ? trimIfString(value) : `"${escapeDoubleQuotes$1(value, escapeQuotes)}"`})`;
 		case "beginswith":
-		case "doesnotbeginwith": return `${shouldNegate$2(operatorTL) ? "!" : ""}${field}.startsWith(${valueIsField ? trimIfString(value) : `"${escapeDoubleQuotes(value, escapeQuotes)}"`})`;
+		case "doesnotbeginwith": return `${shouldNegate$2(operatorTL) ? "!" : ""}${field}.startsWith(${valueIsField ? trimIfString(value) : `"${escapeDoubleQuotes$1(value, escapeQuotes)}"`})`;
 		case "endswith":
-		case "doesnotendwith": return `${shouldNegate$2(operatorTL) ? "!" : ""}${field}.endsWith(${valueIsField ? trimIfString(value) : `"${escapeDoubleQuotes(value, escapeQuotes)}"`})`;
+		case "doesnotendwith": return `${shouldNegate$2(operatorTL) ? "!" : ""}${field}.endsWith(${valueIsField ? trimIfString(value) : `"${escapeDoubleQuotes$1(value, escapeQuotes)}"`})`;
 		case "null": return `${field} == null`;
 		case "notnull": return `${field} != null`;
 		case "in":
 		case "notin": {
 			const [prefix, suffix] = shouldNegate$2(operatorTL) ? ["!(", ")"] : ["", ""];
-			return `${prefix}${field} in [${toArray(value).map((val) => valueIsField || shouldRenderAsNumber(val, parseNumbers) ? `${trimIfString(val)}` : `"${escapeDoubleQuotes(val, escapeQuotes)}"`).join(", ")}]${suffix}`;
+			return `${prefix}${field} in [${toArray(value).map((val) => valueIsField || shouldRenderAsNumber(val, parseNumbers) ? `${trimIfString(val)}` : `"${escapeDoubleQuotes$1(val, escapeQuotes)}"`).join(", ")}]${suffix}`;
 		}
 		case "between":
 		case "notbetween": {
@@ -146,8 +146,8 @@ const defaultRuleProcessorCEL = (rule, opts = {}) => {
 				const shouldParseNumbers = !(parseNumbers === false);
 				const firstNum = shouldRenderAsNumber(first, shouldParseNumbers) ? parseNumber(first, { parseNumbers: shouldParseNumbers }) : NaN;
 				const secondNum = shouldRenderAsNumber(second, shouldParseNumbers) ? parseNumber(second, { parseNumbers: shouldParseNumbers }) : NaN;
-				let firstValue = Number.isNaN(firstNum) ? valueIsField ? `${first}` : `"${escapeDoubleQuotes(first, escapeQuotes)}"` : firstNum;
-				let secondValue = Number.isNaN(secondNum) ? valueIsField ? `${second}` : `"${escapeDoubleQuotes(second, escapeQuotes)}"` : secondNum;
+				let firstValue = Number.isNaN(firstNum) ? valueIsField ? `${first}` : `"${escapeDoubleQuotes$1(first, escapeQuotes)}"` : firstNum;
+				let secondValue = Number.isNaN(secondNum) ? valueIsField ? `${second}` : `"${escapeDoubleQuotes$1(second, escapeQuotes)}"` : secondNum;
 				if (!preserveValueOrder && firstValue === firstNum && secondValue === secondNum && secondNum < firstNum) {
 					const tempNum = secondNum;
 					secondValue = firstNum;
@@ -403,7 +403,7 @@ const defaultRuleGroupProcessorSpEL = (ruleGroup, options) => {
 //#region src/utils/formatQuery/defaultRuleProcessorSpEL.ts
 const shouldNegate$1 = (op) => op.startsWith("not") || op.startsWith("doesnot");
 const wrapInNegation = (clause, negate) => negate ? `!(${clause})` : clause;
-const escapeSingleQuotes = (v, escapeQuotes) => typeof v !== "string" || !escapeQuotes ? `${v}` : v.replaceAll(`'`, `\\'`);
+const escapeSingleQuotes$2 = (v, escapeQuotes) => typeof v !== "string" || !escapeQuotes ? `${v}` : v.replaceAll(`'`, `\\'`);
 /**
 * Default rule processor used by {@link formatQuery} for "spel" format.
 *
@@ -444,20 +444,20 @@ const defaultRuleProcessorSpEL = (rule, opts = {}) => {
 		case "==":
 		case "!=":
 		case ">":
-		case ">=": return `${field} ${operatorTL} ${valueIsField || useBareValue ? trimIfString(value) : `'${escapeSingleQuotes(value, escapeQuotes)}'`}`;
+		case ">=": return `${field} ${operatorTL} ${valueIsField || useBareValue ? trimIfString(value) : `'${escapeSingleQuotes$2(value, escapeQuotes)}'`}`;
 		case "contains":
-		case "doesnotcontain": return wrapInNegation(`${field} matches ${valueIsField || useBareValue ? trimIfString(value) : `'${escapeSingleQuotes(value, escapeQuotes)}'`}`, shouldNegate$1(operatorTL));
+		case "doesnotcontain": return wrapInNegation(`${field} matches ${valueIsField || useBareValue ? trimIfString(value) : `'${escapeSingleQuotes$2(value, escapeQuotes)}'`}`, shouldNegate$1(operatorTL));
 		case "beginswith":
-		case "doesnotbeginwith": return wrapInNegation(`${field} matches ${valueIsField ? `'^'.concat(${trimIfString(value)})` : `'${typeof value === "string" && !value.startsWith("^") || useBareValue ? "^" : ""}${escapeSingleQuotes(value, escapeQuotes)}'`}`, shouldNegate$1(operatorTL));
+		case "doesnotbeginwith": return wrapInNegation(`${field} matches ${valueIsField ? `'^'.concat(${trimIfString(value)})` : `'${typeof value === "string" && !value.startsWith("^") || useBareValue ? "^" : ""}${escapeSingleQuotes$2(value, escapeQuotes)}'`}`, shouldNegate$1(operatorTL));
 		case "endswith":
-		case "doesnotendwith": return wrapInNegation(`${field} matches ${valueIsField ? `${trimIfString(value)}.concat('$')` : `'${escapeSingleQuotes(value, escapeQuotes)}${typeof value === "string" && !value.endsWith("$") || useBareValue ? "$" : ""}'`}`, shouldNegate$1(operatorTL));
+		case "doesnotendwith": return wrapInNegation(`${field} matches ${valueIsField ? `${trimIfString(value)}.concat('$')` : `'${escapeSingleQuotes$2(value, escapeQuotes)}${typeof value === "string" && !value.endsWith("$") || useBareValue ? "$" : ""}'`}`, shouldNegate$1(operatorTL));
 		case "null": return `${field} == null`;
 		case "notnull": return `${field} != null`;
 		case "in":
 		case "notin": {
 			const negate = shouldNegate$1(operatorTL) ? "!" : "";
 			const valueAsArray = toArray(value);
-			return valueAsArray.length > 0 ? `${negate}(${valueAsArray.map((val) => `${field} == ${valueIsField || shouldRenderAsNumber(val, parseNumbers) ? `${trimIfString(val)}` : `'${escapeSingleQuotes(val, escapeQuotes)}'`}`).join(" or ")})` : "";
+			return valueAsArray.length > 0 ? `${negate}(${valueAsArray.map((val) => `${field} == ${valueIsField || shouldRenderAsNumber(val, parseNumbers) ? `${trimIfString(val)}` : `'${escapeSingleQuotes$2(val, escapeQuotes)}'`}`).join(" or ")})` : "";
 		}
 		case "between":
 		case "notbetween": {
@@ -467,8 +467,8 @@ const defaultRuleProcessorSpEL = (rule, opts = {}) => {
 				const shouldParseNumbers = !(parseNumbers === false);
 				const firstNum = shouldRenderAsNumber(first, shouldParseNumbers) ? parseNumber(first, { parseNumbers: shouldParseNumbers }) : NaN;
 				const secondNum = shouldRenderAsNumber(second, shouldParseNumbers) ? parseNumber(second, { parseNumbers: shouldParseNumbers }) : NaN;
-				let firstValue = Number.isNaN(firstNum) ? valueIsField ? `${first}` : `'${escapeSingleQuotes(first, escapeQuotes)}'` : firstNum;
-				let secondValue = Number.isNaN(secondNum) ? valueIsField ? `${second}` : `'${escapeSingleQuotes(second, escapeQuotes)}'` : secondNum;
+				let firstValue = Number.isNaN(firstNum) ? valueIsField ? `${first}` : `'${escapeSingleQuotes$2(first, escapeQuotes)}'` : firstNum;
+				let secondValue = Number.isNaN(secondNum) ? valueIsField ? `${second}` : `'${escapeSingleQuotes$2(second, escapeQuotes)}'` : secondNum;
 				if (!preserveValueOrder && firstValue === firstNum && secondValue === secondNum && secondNum < firstNum) {
 					const tempNum = secondNum;
 					secondValue = firstNum;
@@ -536,6 +536,70 @@ const defaultValueProcessorByRule = ({ operator, value, valueSource }, { escapeQ
 	return valueIsField ? wrapFieldName(value) : shouldRenderAsNumber(value, parseNumbers) ? `${trimIfString(value)}` : `${wrapAndEscape(value)}`;
 };
 //#endregion
+//#region src/utils/formatQuery/defaultRuleGroupProcessorCypher.ts
+/**
+* Maps a {@link DefaultCombinatorName} to a Cypher combinator keyword.
+*
+* @group Export
+*/
+const cypherCombinatorMap = {
+	and: "AND",
+	or: "OR"
+};
+/**
+* Rule group processor used by {@link formatQuery} for "cypher" and "gql" formats.
+*
+* @group Export
+*/
+const defaultRuleGroupProcessorCypher = (ruleGroup, options) => {
+	const { fields, fallbackExpression, getParseNumberBoolean, placeholderFieldName, placeholderOperatorName, placeholderValueName, ruleProcessor, validateRule, validationMap } = options;
+	const processRuleGroup = (rg, outermost) => {
+		if (!isRuleOrGroupValid(rg, validationMap[rg.id ?? ""])) return outermost ? fallbackExpression : "";
+		const processedRules = [];
+		let precedingCombinator = "";
+		let firstRule = true;
+		for (const rule of rg.rules) {
+			if (typeof rule === "string") {
+				precedingCombinator = cypherCombinatorMap[rule];
+				continue;
+			}
+			if (isRuleGroup(rule)) {
+				const processedGroup = processRuleGroup(rule);
+				if (processedGroup) {
+					if (!firstRule && precedingCombinator) {
+						processedRules.push(precedingCombinator);
+						precedingCombinator = "";
+					}
+					firstRule = false;
+					processedRules.push(processedGroup);
+				}
+				continue;
+			}
+			const [validationResult, fieldValidator] = validateRule(rule);
+			if (!isRuleOrGroupValid(rule, validationResult, fieldValidator) || rule.field === placeholderFieldName || rule.operator === placeholderOperatorName || placeholderValueName !== void 0 && rule.value === placeholderValueName) continue;
+			const fieldData = getOption(fields, rule.field);
+			const processedRule = ruleProcessor(rule, {
+				...options,
+				parseNumbers: getParseNumberBoolean(fieldData?.inputType),
+				escapeQuotes: (rule.valueSource ?? "value") === "value",
+				fieldData
+			});
+			if (processedRule) {
+				if (!firstRule && precedingCombinator) {
+					processedRules.push(precedingCombinator);
+					precedingCombinator = "";
+				}
+				firstRule = false;
+				processedRules.push(processedRule);
+			}
+		}
+		const expression = processedRules.join(isRuleGroupType(rg) ? ` ${cypherCombinatorMap[rg.combinator]} ` : " ");
+		const [prefix, suffix] = rg.not || !outermost ? [`${rg.not ? "NOT " : ""}(`, ")"] : ["", ""];
+		return expression ? `${prefix}${expression}${suffix}` : fallbackExpression;
+	};
+	return processRuleGroup(ruleGroup, true);
+};
+//#endregion
 //#region src/utils/formatQuery/defaultRuleProcessorDrizzle.ts
 /**
 * Default rule processor used by {@link formatQuery} for the "drizzle" format.
@@ -703,6 +767,67 @@ const defaultRuleGroupProcessorElasticSearch = (ruleGroup, options) => {
 	return processedRuleGroup === false ? {} : processedRuleGroup;
 };
 //#endregion
+//#region src/utils/formatQuery/defaultRuleGroupProcessorGremlin.ts
+/**
+* Rule group processor used by {@link formatQuery} for "gremlin" format.
+*
+* At the top level, filter rules produce chained `.has()` steps (implicit AND).
+* Nested groups use `.and()` / `.or()` / `.not()` compound traversals with
+* `__` anonymous traversal prefixes.
+*
+* @group Export
+*/
+const defaultRuleGroupProcessorGremlin = (ruleGroup, options) => {
+	const { fields, fallbackExpression, getParseNumberBoolean, placeholderFieldName, placeholderOperatorName, placeholderValueName, ruleProcessor, validateRule, validationMap } = options;
+	const validateAndProcess = (rule) => {
+		// v8 ignore next -- @preserve
+		if (typeof rule === "string" || isRuleGroup(rule)) return void 0;
+		const [validationResult, fieldValidator] = validateRule(rule);
+		if (!isRuleOrGroupValid(rule, validationResult, fieldValidator) || rule.field === placeholderFieldName || rule.operator === placeholderOperatorName || placeholderValueName !== void 0 && rule.value === placeholderValueName) return;
+		const fieldData = getOption(fields, rule.field);
+		return ruleProcessor(rule, {
+			...options,
+			parseNumbers: getParseNumberBoolean(fieldData?.inputType),
+			escapeQuotes: (rule.valueSource ?? "value") === "value",
+			fieldData
+		});
+	};
+	/** Recursively processes a nested group into `.and()`/`.or()`/`.not()` form. */
+	const processNested = (rg) => {
+		if (!isRuleOrGroupValid(rg, validationMap[rg.id ?? ""])) return "";
+		const predicates = [];
+		for (const rule of rg.rules) {
+			if (typeof rule === "string") continue;
+			if (isRuleGroup(rule)) {
+				const nested = processNested(rule);
+				if (nested) predicates.push(nested);
+				continue;
+			}
+			const processed = validateAndProcess(rule);
+			if (processed) predicates.push(processed);
+		}
+		if (predicates.length === 0) return "";
+		const combinator = rg.combinator ?? "and";
+		const prefix = rg.not ? "not" : combinator;
+		if (predicates.length === 1 && !rg.not) return predicates[0];
+		return `.${prefix}(${predicates.map((p) => p.startsWith(".") ? `__${p}` : p).join(", ")})`;
+	};
+	if (!isRuleOrGroupValid(ruleGroup, validationMap[ruleGroup.id ?? ""])) return fallbackExpression;
+	const steps = [];
+	for (const rule of ruleGroup.rules) {
+		if (typeof rule === "string") continue;
+		if (isRuleGroup(rule)) {
+			const compound = processNested(rule);
+			if (compound) steps.push(compound);
+			continue;
+		}
+		const processed = validateAndProcess(rule);
+		if (processed) steps.push(processed);
+	}
+	if (steps.length === 0) return fallbackExpression;
+	return steps.join("");
+};
+//#endregion
 //#region src/utils/formatQuery/defaultRuleGroupProcessorJSONata.ts
 /**
 * Rule group processor used by {@link formatQuery} for "jsonata" format.
@@ -1090,6 +1215,63 @@ const defaultRuleGroupProcessorSequelize = (ruleGroup, options) => {
 	return processRuleGroup(convertFromIC(ruleGroup), true);
 };
 //#endregion
+//#region src/utils/formatQuery/defaultRuleGroupProcessorSPARQL.ts
+/**
+* Rule group processor used by {@link formatQuery} for "sparql" format.
+*
+* SPARQL uses the same combinators as CEL (`&&` / `||`) and `!()` for negation.
+*
+* @group Export
+*/
+const defaultRuleGroupProcessorSPARQL = (ruleGroup, options) => {
+	const { fields, fallbackExpression, getParseNumberBoolean, placeholderFieldName, placeholderOperatorName, placeholderValueName, ruleProcessor, validateRule, validationMap } = options;
+	const processRuleGroup = (rg, outermost) => {
+		if (!isRuleOrGroupValid(rg, validationMap[rg.id ?? ""])) return outermost ? fallbackExpression : "";
+		const processedRules = [];
+		let precedingCombinator = "";
+		let firstRule = true;
+		for (const rule of rg.rules) {
+			if (typeof rule === "string") {
+				precedingCombinator = celCombinatorMap[rule];
+				continue;
+			}
+			if (isRuleGroup(rule)) {
+				const processedGroup = processRuleGroup(rule);
+				if (processedGroup) {
+					if (!firstRule && precedingCombinator) {
+						processedRules.push(precedingCombinator);
+						precedingCombinator = "";
+					}
+					firstRule = false;
+					processedRules.push(processedGroup);
+				}
+				continue;
+			}
+			const [validationResult, fieldValidator] = validateRule(rule);
+			if (!isRuleOrGroupValid(rule, validationResult, fieldValidator) || rule.field === placeholderFieldName || rule.operator === placeholderOperatorName || placeholderValueName !== void 0 && rule.value === placeholderValueName) continue;
+			const fieldData = getOption(fields, rule.field);
+			const processedRule = ruleProcessor(rule, {
+				...options,
+				parseNumbers: getParseNumberBoolean(fieldData?.inputType),
+				escapeQuotes: (rule.valueSource ?? "value") === "value",
+				fieldData
+			});
+			if (processedRule) {
+				if (!firstRule && precedingCombinator) {
+					processedRules.push(precedingCombinator);
+					precedingCombinator = "";
+				}
+				firstRule = false;
+				processedRules.push(processedRule);
+			}
+		}
+		const expression = processedRules.join(isRuleGroupType(rg) ? ` ${celCombinatorMap[rg.combinator]} ` : " ");
+		const [prefix, suffix] = rg.not || !outermost ? [`${rg.not ? "!" : ""}(`, ")"] : ["", ""];
+		return expression ? `${prefix}${expression}${suffix}` : fallbackExpression;
+	};
+	return processRuleGroup(ruleGroup, true);
+};
+//#endregion
 //#region src/utils/formatQuery/defaultRuleGroupProcessorSQL.ts
 /**
 * Default rule processor used by {@link formatQuery} for "sql" format.
@@ -1465,6 +1647,59 @@ const getFieldValidatorReasons = (rule, fieldValidator) => {
 	}
 };
 //#endregion
+//#region src/utils/formatQuery/defaultRuleProcessorCypher.ts
+const escapeSingleQuotes$1 = (v, escapeQuotes) => typeof v !== "string" || !escapeQuotes ? `${v}` : v.replaceAll("'", "\\'");
+/**
+* Default rule processor used by {@link formatQuery} for "cypher" and "gql" formats.
+*
+* @group Export
+*/
+const defaultRuleProcessorCypher = (rule, opts = {}) => {
+	const { escapeQuotes, parseNumbers } = opts;
+	const { field, operator, value, valueSource } = rule;
+	const valueIsField = valueSource === "field";
+	const operatorTL = operator.toLowerCase();
+	const fmtVal = (v) => {
+		if (v === null || v === void 0) return "null";
+		if (typeof v === "boolean" || typeof v === "bigint") return String(v);
+		if (valueIsField) return trimIfString(v);
+		if (typeof v === "number" || shouldRenderAsNumber(v, parseNumbers)) return trimIfString(v);
+		return `'${escapeSingleQuotes$1(v, escapeQuotes)}'`;
+	};
+	switch (operatorTL) {
+		case "=": return `${field} = ${fmtVal(value)}`;
+		case "!=":
+		case "<>": return `${field} <> ${fmtVal(value)}`;
+		case "<":
+		case ">":
+		case "<=":
+		case ">=": return `${field} ${operatorTL} ${fmtVal(value)}`;
+		case "contains": return `${field} CONTAINS ${fmtVal(value)}`;
+		case "doesnotcontain": return `NOT ${field} CONTAINS ${fmtVal(value)}`;
+		case "beginswith": return `${field} STARTS WITH ${fmtVal(value)}`;
+		case "doesnotbeginwith": return `NOT ${field} STARTS WITH ${fmtVal(value)}`;
+		case "endswith": return `${field} ENDS WITH ${fmtVal(value)}`;
+		case "doesnotendwith": return `NOT ${field} ENDS WITH ${fmtVal(value)}`;
+		case "null": return `${field} IS NULL`;
+		case "notnull": return `${field} IS NOT NULL`;
+		case "in":
+		case "notin": {
+			const values = toArray(value).map(fmtVal);
+			if (!values.length) return "";
+			return `${operatorTL === "notin" ? "NOT " : ""}${field} IN [${values.join(", ")}]`;
+		}
+		case "between":
+		case "notbetween": {
+			const arr = toArray(value);
+			if (arr.length < 2) return "";
+			const [low, high] = [fmtVal(arr[0]), fmtVal(arr[1])];
+			const expr = `${low} <= ${field} AND ${field} <= ${high}`;
+			return operatorTL === "notbetween" ? `NOT (${expr})` : expr;
+		}
+		default: return `${field} ${operator} ${fmtVal(value)}`;
+	}
+};
+//#endregion
 //#region src/utils/formatQuery/defaultRuleProcessorElasticSearch.ts
 const rangeOperatorMap = {
 	"<": "lt",
@@ -1616,6 +1851,68 @@ const defaultRuleProcessorElasticSearch = (rule, options = {}) => {
 	return false;
 };
 //#endregion
+//#region src/utils/formatQuery/defaultRuleProcessorGremlin.ts
+const escapeSingleQuotes = (v, escapeQuotes) => typeof v !== "string" || !escapeQuotes ? `${v}` : v.replaceAll("'", "\\'");
+/**
+* Default rule processor used by {@link formatQuery} for "gremlin" format.
+*
+* Each rule becomes a `.has()` step (or `.hasNot()`/`.has()` for null checks).
+*
+* @group Export
+*/
+const defaultRuleProcessorGremlin = (rule, opts = {}) => {
+	const { escapeQuotes, parseNumbers } = opts;
+	const { field, operator, value, valueSource } = rule;
+	const valueIsField = valueSource === "field";
+	const operatorTL = operator.toLowerCase();
+	const prop = field.includes(".") ? field.split(".").pop() : field;
+	const fmtVal = (v) => {
+		if (v === null || v === void 0) return "null";
+		if (typeof v === "boolean" || typeof v === "bigint") return String(v);
+		if (valueIsField) return trimIfString(v);
+		if (typeof v === "number" || shouldRenderAsNumber(v, parseNumbers)) return trimIfString(v);
+		return `'${escapeSingleQuotes(v, escapeQuotes)}'`;
+	};
+	switch (operatorTL) {
+		case "=": return `.has('${prop}', ${fmtVal(value)})`;
+		case "!=":
+		case "<>": return `.has('${prop}', neq(${fmtVal(value)}))`;
+		case "<": return `.has('${prop}', lt(${fmtVal(value)}))`;
+		case ">": return `.has('${prop}', gt(${fmtVal(value)}))`;
+		case "<=": return `.has('${prop}', lte(${fmtVal(value)}))`;
+		case ">=": return `.has('${prop}', gte(${fmtVal(value)}))`;
+		case "contains": return `.has('${prop}', containing(${fmtVal(value)}))`;
+		case "doesnotcontain": return `.has('${prop}', notContaining(${fmtVal(value)}))`;
+		case "beginswith": return `.has('${prop}', startingWith(${fmtVal(value)}))`;
+		case "doesnotbeginwith": return `.has('${prop}', notStartingWith(${fmtVal(value)}))`;
+		case "endswith": return `.has('${prop}', endingWith(${fmtVal(value)}))`;
+		case "doesnotendwith": return `.has('${prop}', notEndingWith(${fmtVal(value)}))`;
+		case "null": return `.hasNot('${prop}')`;
+		case "notnull": return `.has('${prop}')`;
+		case "in": {
+			const items = toArray(value).map(fmtVal);
+			if (!items.length) return "";
+			return `.has('${prop}', within(${items.join(", ")}))`;
+		}
+		case "notin": {
+			const items = toArray(value).map(fmtVal);
+			if (!items.length) return "";
+			return `.has('${prop}', without(${items.join(", ")}))`;
+		}
+		case "between": {
+			const arr = toArray(value);
+			if (arr.length < 2) return "";
+			return `.has('${prop}', between(${fmtVal(arr[0])}, ${fmtVal(arr[1])}))`;
+		}
+		case "notbetween": {
+			const arr = toArray(value);
+			if (arr.length < 2) return "";
+			return `.has('${prop}', outside(${fmtVal(arr[0])}, ${fmtVal(arr[1])}))`;
+		}
+		default: return `.has('${prop}', ${fmtVal(value)})`;
+	}
+};
+//#endregion
 //#region src/utils/formatQuery/defaultRuleProcessorJSONata.ts
 const shouldNegate = (op) => op.startsWith("not") || op.startsWith("doesnot");
 const quote = (v, escapeQuotes) => `"${typeof v !== "string" || !escapeQuotes ? `${v}` : v.replaceAll(`"`, `\\"`)}"`;
@@ -2238,8 +2535,11 @@ const defaultRuleProcessorSequelize = (rule, { parseNumbers, preserveValueOrder,
 	const valueIsField = valueSource === "field";
 	const operatorLC = lc(operator);
 	if (!Op || valueIsField && (!col || !fn && [
+		"contains",
 		"doesnotcontain",
+		"beginswith",
 		"doesnotbeginwith",
+		"endswith",
 		"doesnotendwith"
 	].includes(operatorLC))) return;
 	switch (operatorLC) {
@@ -2259,9 +2559,9 @@ const defaultRuleProcessorSequelize = (rule, { parseNumbers, preserveValueOrder,
 			}[operatorLC];
 			return { [field]: valueIsField && operatorLC === "=" ? { [Op.col]: value } : { [sequelizeOperator]: valueIsField ? col(value) : shouldRenderAsNumber(value, parseNumbers) ? parseNumber(value, { parseNumbers: "strict" }) : value } };
 		}
-		case "contains": return { [field]: { [Op.substring]: valueIsField ? col(value) : `${value}` } };
-		case "beginswith": return { [field]: { [Op.startsWith]: valueIsField ? col(value) : `${value}` } };
-		case "endswith": return { [field]: { [Op.endsWith]: valueIsField ? col(value) : `${value}` } };
+		case "contains": return { [field]: { [valueIsField ? Op.like : Op.substring]: valueIsField ? fn("CONCAT", "%", col(value), "%") : `${value}` } };
+		case "beginswith": return { [field]: { [valueIsField ? Op.like : Op.startsWith]: valueIsField ? fn("CONCAT", col(value), "%") : `${value}` } };
+		case "endswith": return { [field]: { [valueIsField ? Op.like : Op.endsWith]: valueIsField ? fn("CONCAT", "%", col(value)) : `${value}` } };
 		case "doesnotcontain": return { [field]: { [Op.notLike]: valueIsField ? fn("CONCAT", "%", col(value), "%") : `%${value}%` } };
 		case "doesnotbeginwith": return { [field]: { [Op.notLike]: valueIsField ? fn("CONCAT", col(value), "%") : `${value}%` } };
 		case "doesnotendwith": return { [field]: { [Op.notLike]: valueIsField ? fn("CONCAT", "%", col(value)) : `%${value}` } };
@@ -2291,6 +2591,68 @@ const defaultRuleProcessorSequelize = (rule, { parseNumbers, preserveValueOrder,
 	}
 };
 //#endregion
+//#region src/utils/formatQuery/defaultRuleProcessorSPARQL.ts
+const escapeDoubleQuotes = (v, escapeQuotes) => typeof v !== "string" || !escapeQuotes ? `${v}` : v.replaceAll(`"`, `\\"`);
+/**
+* Default rule processor used by {@link formatQuery} for "sparql" format.
+*
+* @group Export
+*/
+const defaultRuleProcessorSPARQL = (rule, opts = {}) => {
+	const { escapeQuotes, parseNumbers } = opts;
+	const { field, operator, value, valueSource } = rule;
+	const valueIsField = valueSource === "field";
+	const operatorTL = operator.toLowerCase();
+	const fmtVal = (v) => {
+		if (v === null || v === void 0) return "\"\"";
+		if (typeof v === "boolean") return `"${v}"^^xsd:boolean`;
+		if (typeof v === "bigint") return String(v);
+		if (valueIsField) return trimIfString(v);
+		if (typeof v === "number" || shouldRenderAsNumber(v, parseNumbers)) return trimIfString(v);
+		const s = typeof v === "string" ? v : JSON.stringify(v) ?? "";
+		if (s.startsWith("?") || s.startsWith("<") || s.includes(":")) return s;
+		return `"${escapeDoubleQuotes(s, escapeQuotes)}"`;
+	};
+	switch (operatorTL) {
+		case "=":
+		case "!=":
+		case "<":
+		case ">":
+		case "<=":
+		case ">=": return `${field} ${operatorTL} ${fmtVal(value)}`;
+		case "<>": return `${field} != ${fmtVal(value)}`;
+		case "contains": return `CONTAINS(${field}, ${fmtVal(value)})`;
+		case "doesnotcontain": return `!CONTAINS(${field}, ${fmtVal(value)})`;
+		case "beginswith": return `STRSTARTS(${field}, ${fmtVal(value)})`;
+		case "doesnotbeginwith": return `!STRSTARTS(${field}, ${fmtVal(value)})`;
+		case "endswith": return `STRENDS(${field}, ${fmtVal(value)})`;
+		case "doesnotendwith": return `!STRENDS(${field}, ${fmtVal(value)})`;
+		case "null": return `!BOUND(${field})`;
+		case "notnull": return `BOUND(${field})`;
+		case "in": {
+			const items = toArray(value).map(fmtVal);
+			if (!items.length) return "";
+			return items.map((item) => `${field} = ${item}`).join(" || ");
+		}
+		case "notin": {
+			const items = toArray(value).map(fmtVal);
+			if (!items.length) return "";
+			return items.map((item) => `${field} != ${item}`).join(" && ");
+		}
+		case "between": {
+			const arr = toArray(value);
+			if (arr.length < 2) return "";
+			return `${field} >= ${fmtVal(arr[0])} && ${field} <= ${fmtVal(arr[1])}`;
+		}
+		case "notbetween": {
+			const arr = toArray(value);
+			if (arr.length < 2) return "";
+			return `(${field} < ${fmtVal(arr[0])} || ${field} > ${fmtVal(arr[1])})`;
+		}
+		default: return `${field} ${operator} ${fmtVal(value)}`;
+	}
+};
+//#endregion
 //#region src/utils/formatQuery/formatQuery.ts
 /**
 * A collection of option presets for {@link formatQuery}, specifically for SQL-based formats.
@@ -2338,6 +2700,10 @@ const defaultRuleProcessors = {
 	sequelize: defaultRuleProcessorSequelize,
 	spel: defaultRuleProcessorSpEL,
 	sql: defaultRuleProcessorSQL,
+	cypher: defaultRuleProcessorCypher,
+	gql: defaultRuleProcessorCypher,
+	sparql: defaultRuleProcessorSPARQL,
+	gremlin: defaultRuleProcessorGremlin,
 	diagnostics: defaultRuleProcessorSQL
 };
 /* v8 ignore next -- @preserve */
@@ -2360,6 +2726,10 @@ const defaultOperatorProcessors = {
 	sequelize: defaultOperatorProcessor,
 	spel: defaultOperatorProcessor,
 	sql: defaultOperatorProcessorSQL,
+	cypher: defaultOperatorProcessor,
+	gql: defaultOperatorProcessor,
+	sparql: defaultOperatorProcessor,
+	gremlin: defaultOperatorProcessor,
 	diagnostics: defaultOperatorProcessor
 };
 const defaultFallbackExpressions = {
@@ -2367,6 +2737,8 @@ const defaultFallbackExpressions = {
 	ldap: "",
 	mongodb: "\"$and\":[{\"$expr\":true}]",
 	natural_language: "1 is 1",
+	sparql: "1 = 1",
+	gremlin: "",
 	spel: "1 == 1",
 	sql: "(1 = 1)"
 };
@@ -2507,6 +2879,10 @@ function formatQuery(ruleGroup, optionParam = {}) {
 		case "prisma": return defaultRuleGroupProcessorPrisma(ruleGroup, finalOptions);
 		case "drizzle": return defaultRuleGroupProcessorDrizzle(ruleGroup, finalOptions);
 		case "sequelize": return defaultRuleGroupProcessorSequelize(ruleGroup, finalOptions);
+		case "cypher":
+		case "gql": return defaultRuleGroupProcessorCypher(ruleGroup, finalOptions);
+		case "sparql": return defaultRuleGroupProcessorSPARQL(ruleGroup, finalOptions);
+		case "gremlin": return defaultRuleGroupProcessorGremlin(ruleGroup, finalOptions);
 		case "diagnostics": return defaultRuleGroupProcessorDiagnostics(ruleGroup, finalOptions);
 		default: return "";
 	}
@@ -2562,6 +2938,6 @@ const defaultValueProcessorMongoDBByRule = defaultRuleProcessorMongoDB;
 */
 const defaultValueProcessorSpELByRule = defaultRuleProcessorSpEL;
 //#endregion
-export { bigIntJsonParseReviver, bigIntJsonStringifyReplacer, celCombinatorMap, defaultCELValueProcessor, defaultExportOperatorMap, defaultMongoDBValueProcessor, defaultNLTranslations, defaultOperatorProcessorNL, defaultOperatorProcessorSQL, defaultRuleGroupProcessorCEL, defaultRuleGroupProcessorDiagnostics, defaultRuleGroupProcessorDrizzle, defaultRuleGroupProcessorElasticSearch, defaultRuleGroupProcessorJSONata, defaultRuleGroupProcessorJsonLogic, defaultRuleGroupProcessorLDAP, defaultRuleGroupProcessorMongoDB, defaultRuleGroupProcessorMongoDBQuery, defaultRuleGroupProcessorNL, defaultRuleGroupProcessorParameterized, defaultRuleGroupProcessorPrisma, defaultRuleGroupProcessorSQL, defaultRuleGroupProcessorSequelize, defaultRuleGroupProcessorSpEL, defaultRuleProcessorCEL, defaultRuleProcessorDrizzle, defaultRuleProcessorElasticSearch, defaultRuleProcessorJSONata, defaultRuleProcessorJsonLogic, defaultRuleProcessorLDAP, defaultRuleProcessorMongoDB, defaultRuleProcessorMongoDBQuery, defaultRuleProcessorNL, defaultRuleProcessorParameterized, defaultRuleProcessorPrisma, defaultRuleProcessorSQL, defaultRuleProcessorSequelize, defaultRuleProcessorSpEL, defaultSpELValueProcessor, defaultValueProcessor, defaultValueProcessorByRule, defaultValueProcessorCELByRule, defaultValueProcessorMongoDBByRule, defaultValueProcessorNL, defaultValueProcessorSpELByRule, formatQuery, formatQueryOptionPresets, getNLTranslataion, getQuoteFieldNamesWithArray, getQuotedFieldName, isValidValue, isValueProcessorLegacy, jsonLogicAdditionalOperators, mapSQLOperator, mongoDbFallback, mongoOperators, normalizeConstituentWordOrder, numerifyValues, prismaFallback, prismaOperators, processMatchMode, shouldRenderAsNumber, sqlDialectPresets };
+export { bigIntJsonParseReviver, bigIntJsonStringifyReplacer, celCombinatorMap, cypherCombinatorMap, defaultCELValueProcessor, defaultExportOperatorMap, defaultMongoDBValueProcessor, defaultNLTranslations, defaultOperatorProcessorNL, defaultOperatorProcessorSQL, defaultRuleGroupProcessorCEL, defaultRuleGroupProcessorCypher, defaultRuleGroupProcessorDiagnostics, defaultRuleGroupProcessorDrizzle, defaultRuleGroupProcessorElasticSearch, defaultRuleGroupProcessorGremlin, defaultRuleGroupProcessorJSONata, defaultRuleGroupProcessorJsonLogic, defaultRuleGroupProcessorLDAP, defaultRuleGroupProcessorMongoDB, defaultRuleGroupProcessorMongoDBQuery, defaultRuleGroupProcessorNL, defaultRuleGroupProcessorParameterized, defaultRuleGroupProcessorPrisma, defaultRuleGroupProcessorSPARQL, defaultRuleGroupProcessorSQL, defaultRuleGroupProcessorSequelize, defaultRuleGroupProcessorSpEL, defaultRuleProcessorCEL, defaultRuleProcessorCypher, defaultRuleProcessorDrizzle, defaultRuleProcessorElasticSearch, defaultRuleProcessorGremlin, defaultRuleProcessorJSONata, defaultRuleProcessorJsonLogic, defaultRuleProcessorLDAP, defaultRuleProcessorMongoDB, defaultRuleProcessorMongoDBQuery, defaultRuleProcessorNL, defaultRuleProcessorParameterized, defaultRuleProcessorPrisma, defaultRuleProcessorSPARQL, defaultRuleProcessorSQL, defaultRuleProcessorSequelize, defaultRuleProcessorSpEL, defaultSpELValueProcessor, defaultValueProcessor, defaultValueProcessorByRule, defaultValueProcessorCELByRule, defaultValueProcessorMongoDBByRule, defaultValueProcessorNL, defaultValueProcessorSpELByRule, formatQuery, formatQueryOptionPresets, getNLTranslataion, getQuoteFieldNamesWithArray, getQuotedFieldName, isValidValue, isValueProcessorLegacy, jsonLogicAdditionalOperators, mapSQLOperator, mongoDbFallback, mongoOperators, normalizeConstituentWordOrder, numerifyValues, prismaFallback, prismaOperators, processMatchMode, shouldRenderAsNumber, sqlDialectPresets };
 
 //# sourceMappingURL=formatQuery.mjs.map