@dynatrace/strato-components 3.10.4 → 3.11.0

package/filters/filter-field/utils/conversion/dql-conversion/escape-dql.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Escapes the content of a double-quoted DQL literal without adding the surrounding quotes:
+ * backslash becomes `\\` and double quote becomes `\"` (backslash first). Nothing else is
+ * escaped — a `*` stays a literal wildcard and backtick, single quote and `$` are literal
+ * inside double quotes.
+ * @param value - Raw string content to escape.
+ * @returns Escaped string content, suitable for embedding between double quotes.
+ * @internal
+ */
+export declare function escapeDqlStringContent(value: string): string;
+/**
+ * Returns a DQL-ready identifier: unquoted when the name is a valid Grail bare
+ * identifier (`a-zA-Z_` start, `a-zA-Z0-9_.` body); otherwise backtick-wrapped, with any
+ * literal backtick or backslash inside escaped. Use in `overrides` callbacks to escape
+ * keys consistently with the default mapping.
+ * @param identifier - The field/key name to escape.
+ * @returns DQL-safe identifier string, either bare or backtick-wrapped.
+ * @public
+ */
+export declare function escapeDqlIdentifier(identifier: string): string;
+/**
+ * Returns a DQL-ready string literal: escapes `\` → `\\` and `"` → `\"` inside the
+ * value and wraps it in double quotes. Use in `overrides` callbacks to escape string
+ * values consistently with the default mapping.
+ * @param value - Raw string value to escape and quote.
+ * @returns DQL-safe double-quoted string literal.
+ * @public
+ */
+export declare function escapeDqlStringLiteral(value: string): string;
+//# sourceMappingURL=escape-dql.d.ts.map

package/filters/filter-field/utils/conversion/dql-conversion/escape-dql.js

@@ -0,0 +1,38 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var escape_dql_exports = {};
+__export(escape_dql_exports, {
+  escapeDqlIdentifier: () => escapeDqlIdentifier,
+  escapeDqlStringContent: () => escapeDqlStringContent,
+  escapeDqlStringLiteral: () => escapeDqlStringLiteral
+});
+module.exports = __toCommonJS(escape_dql_exports);
+const BARE_IDENTIFIER_REGEX = /^[a-zA-Z_][a-zA-Z0-9_.]*$/;
+function escapeDqlStringContent(value) {
+  return value.replaceAll("\\", String.raw`\\`).replaceAll('"', String.raw`\"`);
+}
+function escapeDqlIdentifier(identifier) {
+  if (BARE_IDENTIFIER_REGEX.test(identifier)) {
+    return identifier;
+  }
+  const escaped = identifier.replaceAll("\\", String.raw`\\`).replaceAll("`", String.raw`\``);
+  return `\`${escaped}\``;
+}
+function escapeDqlStringLiteral(value) {
+  return `"${escapeDqlStringContent(value)}"`;
+}

package/filters/filter-field/utils/conversion/dql-conversion/statement-to-dql-fragments.d.ts

@@ -0,0 +1,22 @@
+import type { SimpleFilterFieldStatementNode } from '../../../types/conversion-tree-nodes.js';
+import type { FilterFieldDqlOptions } from '../../../types/dql-conversion-nodes.js';
+/**
+ * Resolves a statement's filter fragment.
+ * Checks first if an override is defined, otherwise uses the built-in default.
+ * @param statement - The statement node.
+ * @param options - Optional conversion options including `keyMap` and `overrides`.
+ * @returns DQL filter fragment string, or `null` for search/unmappable statements.
+ * @internal
+ */
+export declare function buildFilterFragment(statement: SimpleFilterFieldStatementNode, options?: FilterFieldDqlOptions): string | null;
+/**
+ * Builds a global-search statement's `| search` term. Variables are emitted unquoted; all other
+ * values are quoted, preserving any wildcards the user entered.
+ * When `options.overrides` is provided it takes precedence over the default mapping.
+ * @param statement - A global-search (`* ~`) statement node.
+ * @param options - Optional conversion options including `overrides`.
+ * @returns DQL search term string, or `null` for missing/invalid values.
+ * @internal
+ */
+export declare function buildSearchTerm(statement: SimpleFilterFieldStatementNode, options?: FilterFieldDqlOptions): string | null;
+//# sourceMappingURL=statement-to-dql-fragments.d.ts.map

package/filters/filter-field/utils/conversion/dql-conversion/statement-to-dql-fragments.js

@@ -0,0 +1,257 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var statement_to_dql_fragments_exports = {};
+__export(statement_to_dql_fragments_exports, {
+  buildFilterFragment: () => buildFilterFragment,
+  buildSearchTerm: () => buildSearchTerm
+});
+module.exports = __toCommonJS(statement_to_dql_fragments_exports);
+var import_escape_dql = require("./escape-dql.js");
+const RELATIONAL_OPERATORS = /* @__PURE__ */ new Set(["<", "<=", ">", ">="]);
+const DQL_LITERAL_ASTERISK_WILDCARD = "\\uE001";
+function containsLiteralAsterisk(value) {
+  return Array.isArray(value) ? value.some((item) => item.includes("*")) : value.includes("*");
+}
+function getWildcardArgument(value) {
+  return containsLiteralAsterisk(value) ? `, wildcard: "${DQL_LITERAL_ASTERISK_WILDCARD}"` : "";
+}
+function isSingleValue(value) {
+  return value !== void 0 && value.type !== "List" && value.type !== "Error";
+}
+function buildKeyExpression(key, keyMap) {
+  if (!key || key.type === "Error") {
+    return null;
+  }
+  if (key.type === "JSONPath") {
+    const mappedRoot = keyMap?.[key.root];
+    const root = mappedRoot !== void 0 ? mappedRoot : (0, import_escape_dql.escapeDqlIdentifier)(key.root);
+    return `jsonPath(${root}, ${(0, import_escape_dql.escapeDqlStringLiteral)(key.path)})`;
+  }
+  const mappedKey = keyMap?.[key.value];
+  return mappedKey !== void 0 ? mappedKey : (0, import_escape_dql.escapeDqlIdentifier)(key.value);
+}
+function getValueLiteral(value) {
+  switch (value.type) {
+    case "String":
+      return (0, import_escape_dql.escapeDqlStringLiteral)(value.value);
+    case "Number":
+      return `${value.value}`;
+    case "BigInt":
+      return value.value;
+    case "Boolean":
+      return `${value.value}`;
+    case "Duration":
+      return value.value !== void 0 && value.unit ? `${value.value}${value.unit}` : null;
+    case "IPAddress":
+      return `toIp(${(0, import_escape_dql.escapeDqlStringLiteral)(value.value)})`;
+    case "UID":
+      return `toUid(${value.value})`;
+    case "Timestamp":
+      return `toTimestamp(${(0, import_escape_dql.escapeDqlStringLiteral)(value.value)})`;
+    case "SmartscapeId":
+      return `toSmartscapeId(${(0, import_escape_dql.escapeDqlStringLiteral)(value.value)})`;
+    case "Variable":
+      return value.value;
+    default:
+      return null;
+  }
+}
+function getTextValue(value) {
+  switch (value.type) {
+    case "String":
+    case "BigInt":
+    case "IPAddress":
+    case "UID":
+    case "Timestamp":
+    case "SmartscapeId":
+    case "Variable":
+      return value.value;
+    case "Number":
+    case "Boolean":
+      return `${value.value}`;
+    case "Duration":
+      return value.value !== void 0 && value.unit ? `${value.value}${value.unit}` : null;
+    default:
+      return null;
+  }
+}
+function buildDqlPattern(rawValue, operator, wildcard) {
+  const escapedValue = (0, import_escape_dql.escapeDqlStringContent)(rawValue);
+  switch (operator) {
+    case "contains":
+    case "not-contains":
+      return `"${wildcard}${escapedValue}${wildcard}"`;
+    case "starts-with":
+    case "not-starts-with":
+      return `"${escapedValue}${wildcard}"`;
+    case "ends-with":
+    case "not-ends-with":
+      return `"${wildcard}${escapedValue}"`;
+    default:
+      return `"${escapedValue}"`;
+  }
+}
+function buildStringFragment(key, operator, value) {
+  if (RELATIONAL_OPERATORS.has(operator)) {
+    return `${key} ${operator} ${(0, import_escape_dql.escapeDqlStringLiteral)(value)}`;
+  }
+  if (operator === "matches-phrase" || operator === "not-matches-phrase") {
+    return null;
+  }
+  const wildcardArgument = getWildcardArgument(value);
+  const wildcard = wildcardArgument ? DQL_LITERAL_ASTERISK_WILDCARD : "*";
+  const pattern = buildDqlPattern(value, operator, wildcard);
+  const fragment = `matchesValue(${key}, ${pattern}${wildcardArgument})`;
+  return operator === "!=" || operator.startsWith("not-") ? `not ${fragment}` : fragment;
+}
+function buildScalarFragment(key, operator, value) {
+  const literal = getValueLiteral(value);
+  if (literal === null) {
+    return null;
+  }
+  switch (operator) {
+    case "=":
+      return `${key} == ${literal}`;
+    case "!=":
+      return `${key} != ${literal}`;
+    case "<":
+    case "<=":
+    case ">":
+    case ">=":
+      return `${key} ${operator} ${literal}`;
+    default:
+      return null;
+  }
+}
+function buildInclusionFragment(key, operator, value) {
+  if (value?.type !== "List" || value.value.length === 0) {
+    return null;
+  }
+  const valueLiterals = [];
+  for (const item of value.value) {
+    const literal = getValueLiteral(item);
+    if (literal === null) {
+      return null;
+    }
+    valueLiterals.push(literal);
+  }
+  let fragment;
+  if (value.value.every((item) => item.type === "String")) {
+    const wildcardArgument = getWildcardArgument(valueLiterals);
+    fragment = `matchesValue(${key}, array(${valueLiterals.join(
+      ", "
+    )})${wildcardArgument})`;
+  } else {
+    fragment = `in(${key}, {${valueLiterals.join(", ")}})`;
+  }
+  return operator === "not in" ? `not ${fragment}` : fragment;
+}
+function buildComparisonFragment(key, operator, value) {
+  if (!isSingleValue(value)) {
+    return null;
+  }
+  if (operator === "matches-phrase" || operator === "not-matches-phrase") {
+    const phrase = getTextValue(value);
+    if (phrase === null) {
+      return null;
+    }
+    const wildcardArgument = getWildcardArgument(phrase);
+    const fragment = `matchesPhrase(${key}, ${(0, import_escape_dql.escapeDqlStringLiteral)(
+      phrase
+    )}${wildcardArgument})`;
+    return operator === "not-matches-phrase" ? `not ${fragment}` : fragment;
+  }
+  if (value.type === "String") {
+    return buildStringFragment(key, operator, value.value);
+  }
+  return buildScalarFragment(key, operator, value);
+}
+function buildDefaultFilterFragment(statement, keyMap) {
+  const { key, comparisonOperator, value } = statement;
+  if (!comparisonOperator) {
+    return null;
+  }
+  const keyExpression = buildKeyExpression(key, keyMap);
+  if (keyExpression === null) {
+    return null;
+  }
+  switch (comparisonOperator.type) {
+    // Existence checks are type-agnostic and need no value.
+    case "ExistsOperator":
+      return comparisonOperator.value ? `isNotNull(${keyExpression})` : `isNull(${keyExpression})`;
+    case "InclusionOperator":
+      return buildInclusionFragment(
+        keyExpression,
+        comparisonOperator.value,
+        value
+      );
+    case "ComparisonOperator":
+      return buildComparisonFragment(
+        keyExpression,
+        comparisonOperator.value,
+        value
+      );
+    // Global search is routed to `| search`, not to a filter fragment; missing/invalid (Error)
+    // and other non-operator nodes are not mappable.
+    default:
+      return null;
+  }
+}
+function buildFilterFragment(statement, options) {
+  if (statement.comparisonOperator?.type === "SearchOperator") {
+    return null;
+  }
+  if (options?.overrides) {
+    const override = options.overrides(
+      statement,
+      () => buildDefaultFilterFragment(statement, options.keyMap) ?? ""
+    );
+    if (override !== void 0) {
+      return override;
+    }
+  }
+  return buildDefaultFilterFragment(statement, options?.keyMap);
+}
+function buildDefaultSearchTerm(value, comparisonOperator) {
+  if (value.type === "Variable") {
+    return value.value;
+  }
+  const rawValue = getTextValue(value);
+  if (rawValue === null) {
+    return null;
+  }
+  const operator = comparisonOperator?.type === "ComparisonOperator" || comparisonOperator?.type === "SearchOperator" ? comparisonOperator.value : null;
+  const pattern = buildDqlPattern(rawValue, operator, "*");
+  return pattern;
+}
+function buildSearchTerm(statement, options) {
+  const { comparisonOperator, value } = statement;
+  if (!isSingleValue(value)) {
+    return null;
+  }
+  if (options?.overrides) {
+    const override = options.overrides(
+      statement,
+      () => buildDefaultSearchTerm(value, comparisonOperator) ?? ""
+    );
+    if (override !== void 0) {
+      return override;
+    }
+  }
+  return buildDefaultSearchTerm(value, comparisonOperator);
+}

package/filters/filter-field/utils/conversion/dql-conversion/tree-dql-conversion.d.ts

@@ -0,0 +1,24 @@
+import type { SimpleFilterFieldTree } from '../../../types/conversion-tree-nodes.js';
+import type { FilterFieldDqlOptions, FilterFieldDqlTree } from '../../../types/dql-conversion-nodes.js';
+/**
+ * Returns the input tree with `filterDql` added to every node and `searchDql` added to
+ * every group and the root. Statement nodes get `filterDql: null` when unmappable or
+ * when the statement is a global-search (`* ~`) — its term is aggregated into the
+ * enclosing groups' `searchDql` instead.
+ * @param tree - The source filter field tree.
+ * @param options - Optional `keyMap` and `overrides` to customize the DQL mapping.
+ * @returns The enriched tree, or `undefined` for an empty tree.
+ * @public
+ */
+export declare function enrichFilterFieldTreeWithDql(tree: SimpleFilterFieldTree, options?: FilterFieldDqlOptions): FilterFieldDqlTree;
+/**
+ * Returns a ready-to-use DQL statement: `| filter <expression>` for filter statements
+ * followed by `| search <terms>` for global-search (`* ~`) statements. Either command is
+ * omitted when it has no content; returns an empty string for an empty tree.
+ * @param tree - The source filter field tree.
+ * @param options - Optional `keyMap` and `overrides` to customize the DQL mapping.
+ * @returns A DQL pipeline fragment (e.g. `| filter … | search …`), or `''` for an empty tree.
+ * @public
+ */
+export declare function convertFilterFieldTreeToDql(tree: SimpleFilterFieldTree, options?: FilterFieldDqlOptions): string;
+//# sourceMappingURL=tree-dql-conversion.d.ts.map

package/filters/filter-field/utils/conversion/dql-conversion/tree-dql-conversion.js

@@ -0,0 +1,115 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var tree_dql_conversion_exports = {};
+__export(tree_dql_conversion_exports, {
+  convertFilterFieldTreeToDql: () => convertFilterFieldTreeToDql,
+  enrichFilterFieldTreeWithDql: () => enrichFilterFieldTreeWithDql
+});
+module.exports = __toCommonJS(tree_dql_conversion_exports);
+var import_statement_to_dql_fragments = require("./statement-to-dql-fragments.js");
+var import_logging = require("../../../../../core/utils/logging.js");
+var import_tree_node_guards = require("../../tree-node-guards.js");
+function isCompleteAndValidStatement(statement) {
+  const { key, comparisonOperator, value } = statement;
+  if (!key || key.type === "Error") {
+    return false;
+  }
+  if (!comparisonOperator || comparisonOperator.type === "Error") {
+    return false;
+  }
+  if (comparisonOperator.type === "ExistsOperator") {
+    return true;
+  }
+  if (!value || value.type === "Error") {
+    return false;
+  }
+  if (value.type === "List" && value.value.length === 0) {
+    return false;
+  }
+  return true;
+}
+function enrichStatement(statement, options) {
+  const filterDql = (0, import_statement_to_dql_fragments.buildFilterFragment)(statement, options);
+  if (filterDql === null && statement.comparisonOperator?.type !== "SearchOperator" && isCompleteAndValidStatement(statement)) {
+    (0, import_logging.devLog)(
+      "FilterField \u2192 DQL: a statement could not be mapped to a DQL fragment and was omitted.",
+      statement
+    );
+  }
+  return { ...statement, filterDql };
+}
+function getSearchTerm(child, options) {
+  if (child.type === "Group") {
+    return child.searchDql;
+  }
+  if (child.comparisonOperator?.type === "SearchOperator") {
+    return (0, import_statement_to_dql_fragments.buildSearchTerm)(child, options);
+  }
+  return null;
+}
+function enrichGroup(group, options) {
+  const children = group.children.map((child) => enrichNode(child, options)).filter((child) => child !== void 0);
+  const logicalOperator = ` ${group.logicalOperator.toLowerCase()} `;
+  const filterFragments = [];
+  const searchTerms = [];
+  for (const child of children) {
+    if (child.filterDql) {
+      filterFragments.push(child.filterDql);
+    }
+    const term = getSearchTerm(child, options);
+    if (term) {
+      searchTerms.push(term);
+    }
+  }
+  let filterDql = null;
+  if (filterFragments.length > 0) {
+    const joined = filterFragments.join(logicalOperator);
+    filterDql = group.explicit ? `(${joined})` : joined;
+  }
+  const searchDql = searchTerms.length > 0 ? searchTerms.join(logicalOperator) : null;
+  return { ...group, children, filterDql, searchDql };
+}
+function enrichNode(node, options) {
+  if ((0, import_tree_node_guards.isFilterFieldGroupNode)(node)) {
+    return enrichGroup(node, options);
+  }
+  if ((0, import_tree_node_guards.isFilterFieldStatementNode)(node)) {
+    return enrichStatement(node, options);
+  }
+  return void 0;
+}
+function enrichFilterFieldTreeWithDql(tree, options) {
+  if (!tree) {
+    return void 0;
+  }
+  return enrichGroup(tree, options);
+}
+function convertFilterFieldTreeToDql(tree, options) {
+  const dqlTree = enrichFilterFieldTreeWithDql(tree, options);
+  if (!dqlTree) {
+    return "";
+  }
+  const parts = [];
+  if (dqlTree.filterDql) {
+    parts.push(`| filter ${dqlTree.filterDql}`);
+  }
+  if (dqlTree.searchDql) {
+    parts.push(`| search ${dqlTree.searchDql}`);
+  }
+  return parts.join(" ");
+}

package/filters/filter-field/utils/conversion/lezer-tree-conversion/key/json-path.js

@@ -23,6 +23,7 @@ module.exports = __toCommonJS(json_path_exports);
 var import_get_text = require("../../../get-text.js");
 var import_escape_characters = require("../../escape-characters.js");
 var import_node_mutations = require("../node-mutations.js");
+var import_range_helpers = require("../utils/range-helpers.js");
 var import_identifier = require("../value/identifier.js");
 function convertJsonPath(node, doc, parserConfig) {
   const { from, to } = node;
@@ -49,14 +50,27 @@ function convertJsonPath(node, doc, parserConfig) {
     };
     let path = "$";
     let pushToPath = false;
+    let insideJsonPathNameSelector = false;
     cursor.iterate(
       (jsonPathChildNode) => {
         const nodeName = jsonPathChildNode.name;
+        if (nodeName === "JsonPathNameSelector") {
+          insideJsonPathNameSelector = true;
+        }
         if (nodeName === "JsonPathBase") {
           const text = (0, import_get_text.getTextFromRange)(jsonPathChildNode, doc);
           const cleanedUpRoot = (0, import_escape_characters.removeEscapeCharacters)(
             text.slice(0, -1).replace(/^"(.*(?<=^|[^\\])(?:\\\\)*)"$/, "$1")
           );
+          const invalidRootChars = (0, import_range_helpers.findSpecialCharsRanges)(cleanedUpRoot, from, [
+            "[",
+            "]",
+            "*",
+            "$"
+          ]);
+          if (invalidRootChars.length > 0) {
+            isValidJsonPath = false;
+          }
           convertedNode.root = cleanedUpRoot;
           return;
         }
@@ -67,6 +81,12 @@ function convertJsonPath(node, doc, parserConfig) {
           const text = (0, import_get_text.getTextFromRange)(jsonPathChildNode, doc);
           switch (nodeName) {
             case "JsonPathIdentifier":
+              if (insideJsonPathNameSelector) {
+                isValidJsonPath = false;
+              }
+              if ((0, import_range_helpers.findSpecialCharsRanges)(text, jsonPathChildNode.from, ["$", "*"]).length > 0) {
+                isValidJsonPath = false;
+              }
               path += `.${text}`;
               break;
             case "JsonPathArray":
@@ -77,6 +97,9 @@ function convertJsonPath(node, doc, parserConfig) {
               break;
           }
         }
+        if (nodeName === "PositionOperator" || nodeName === "InvalidPositionOperator") {
+          isValidJsonPath = false;
+        }
         if (nodeName === "\u26A0") {
           isValidJsonPath = false;
         }
@@ -85,6 +108,9 @@ function convertJsonPath(node, doc, parserConfig) {
         if (node2.name === "JsonPathBase") {
           pushToPath = true;
         }
+        if (node2.name === "JsonPathNameSelector") {
+          insideJsonPathNameSelector = false;
+        }
       }
     );
     convertedNode.path = path;

package/filters/filter-field/utils/conversion/lezer-tree-conversion/key/key.js

@@ -26,6 +26,7 @@ var import_decoration_marks = require("../../../../decorations/decoration-marks.
 var import_get_text = require("../../../get-text.js");
 var import_generic_node = require("../generic-node.js");
 var import_node_mutations = require("../node-mutations.js");
+var import_range_helpers = require("../utils/range-helpers.js");
 var import_identifier = require("../value/identifier.js");
 function convertFilterKey(node, doc, parserConfig) {
   const { from, to } = node;
@@ -61,7 +62,10 @@ function convertFilterKey(node, doc, parserConfig) {
           positionOperators: { endsWithOperator, startsWithOperator }
         } = (0, import_identifier.convertIdentifier)(childNode, doc, nodeName);
         (0, import_node_mutations.updateNodeValues)(convertedNode, textValue, value);
-        if (!isValidIdentifier || nodeName === "IncompleteString" || endsWithOperator || startsWithOperator) {
+        const embeddedWildcards = nodeName === "Identifier" ? (0, import_range_helpers.findSpecialCharsRanges)(textValue, childFrom, ["*"]) : [];
+        const squareBracketRanges = nodeName === "Identifier" ? (0, import_range_helpers.findSpecialCharsRanges)(textValue, childFrom, ["[", "]"]) : [];
+        const embeddedDollarSigns = nodeName === "Variable" ? (0, import_range_helpers.findSpecialCharsRanges)(textValue.slice(1), childFrom + 1, ["$"]) : [];
+        if (!isValidIdentifier || nodeName === "IncompleteString" || endsWithOperator || startsWithOperator || embeddedWildcards.length > 0 || squareBracketRanges.length > 0 || embeddedDollarSigns.length > 0) {
           (0, import_node_mutations.convertToErrorNode)(convertedNode);
           errors.push({ range: { from, to }, message: "invalidKey" });
         }
@@ -77,6 +81,12 @@ function convertFilterKey(node, doc, parserConfig) {
             message: "unsupportedPositionOperator"
           });
         }
+        for (const range of embeddedWildcards) {
+          errors.push({ range, message: "unsupportedPositionOperator" });
+        }
+        for (const range of embeddedDollarSigns) {
+          errors.push({ range, message: "invalidCharacterInIdentifier" });
+        }
         break;
       }
       case "InvalidIdentifier": {

package/filters/filter-field/utils/conversion/lezer-tree-conversion/parent-node/inclusion.js

@@ -62,7 +62,13 @@ function convertInclusionValue(node, doc, numberParser, customTypes, parserConfi
           convertedNode: valueNode,
           errors: valueErrors,
           positionOperators
-        } = (0, import_simple_value.convertSimpleValue)(childNode, doc, numberParser, customTypes, parserConfig);
+        } = (0, import_simple_value.convertSimpleValue)(
+          childNode,
+          doc,
+          numberParser,
+          customTypes,
+          parserConfig
+        );
         if (positionOperators) {
           (0, import_node_mutations.convertToErrorNode)(valueNode);
           for (const range of positionOperators.ranges) {
@@ -81,7 +87,8 @@ function convertInclusionValue(node, doc, numberParser, customTypes, parserConfi
       case "IncompleteString": {
         const {
           convertedNode: valueNode,
-          positionOperators: { endsWithOperator, startsWithOperator }
+          positionOperators: { endsWithOperator, startsWithOperator },
+          embeddedWildcards
         } = (0, import_identifier.convertIdentifier)(childNode, doc, nodeName);
         if (endsWithOperator) {
           (0, import_node_mutations.convertToErrorNode)(valueNode);
@@ -97,6 +104,10 @@ function convertInclusionValue(node, doc, numberParser, customTypes, parserConfi
             message: "unsupportedPositionOperator"
           });
         }
+        for (const range of embeddedWildcards) {
+          (0, import_node_mutations.convertToErrorNode)(valueNode);
+          errors.push({ range, message: "unsupportedPositionOperator" });
+        }
         convertedNode.value.push(valueNode);
         break;
       }