@elastic/esql 1.0.2 → 1.1.0

package/lib/index.js

@@ -75,12 +75,14 @@ __export(index_exports, {
   ParameterHole: () => ParameterHole,
   ParensExpressionVisitorContext: () => ParensExpressionVisitorContext,
   Parser: () => Parser4,
+  PromQLBasicPrettyPrinter: () => PromQLBasicPrettyPrinter,
   PromQLBuilder: () => PromQLBuilder,
   PromQLCstToAstConverter: () => PromQLCstToAstConverter,
   PromQLErrorListener: () => PromQLErrorListener,
   PromQLParser: () => PromQLParser,
   PromqlWalker: () => PromqlWalker,
   QueryVisitorContext: () => QueryVisitorContext,
+  RegisteredDomainCommandVisitorContext: () => RegisteredDomainCommandVisitorContext,
   RenameCommandVisitorContext: () => RenameCommandVisitorContext,
   RerankCommandVisitorContext: () => RerankCommandVisitorContext,
   RowCommandVisitorContext: () => RowCommandVisitorContext,
@@ -94,6 +96,7 @@ __export(index_exports, {
   TIME_SPAN_UNITS: () => TIME_SPAN_UNITS,
   TimeseriesCommandVisitorContext: () => TimeseriesCommandVisitorContext,
   UnaryExpressionGroup: () => UnaryExpressionGroup,
+  UriPartsCommandVisitorContext: () => UriPartsCommandVisitorContext,
   Visitor: () => Visitor,
   VisitorContext: () => VisitorContext,
   Walker: () => Walker,
@@ -128,6 +131,7 @@ __export(index_exports, {
   isParamLiteral: () => isParamLiteral,
   isParametrized: () => isParametrized,
   isParens: () => isParens,
+  isPromqlNode: () => isPromqlNode,
   isProperNode: () => isProperNode,
   isQuery: () => isQuery,
   isSource: () => isSource,
@@ -24396,6 +24400,301 @@ var LeafPrinter = {
   }
 };
 
+// src/embedded_languages/promql/pretty_print/helpers.ts
+var promqlBinaryPrecedenceGroup = (node) => {
+  if (node.type !== "binary-expression") {
+    return 0 /* none */;
+  }
+  switch (node.name) {
+    case "^":
+      return 6 /* power */;
+    case "*":
+    case "/":
+    case "%":
+      return 5 /* multiplicative */;
+    case "+":
+    case "-":
+      return 4 /* additive */;
+    case "==":
+    case "!=":
+    case "<":
+    case "<=":
+    case ">":
+    case ">=":
+      return 3 /* comparison */;
+    case "and":
+    case "unless":
+      return 2 /* andUnless */;
+    case "or":
+      return 1 /* or */;
+    default:
+      return 0 /* none */;
+  }
+};
+var isPromQLRightAssociative = (op) => op === "^";
+
+// src/embedded_languages/promql/pretty_print/basic_pretty_printer.ts
+var PromQLBasicPrettyPrinter = class _PromQLBasicPrettyPrinter {
+  /**
+   * Print any PromQL AST node.
+   */
+  static print = (node, opts) => {
+    const printer = new _PromQLBasicPrettyPrinter(opts);
+    return printer.print(node);
+  };
+  /**
+   * Print a PromQL query expression.
+   */
+  static query = (query2, opts) => {
+    const printer = new _PromQLBasicPrettyPrinter(opts);
+    return printer.printQuery(query2);
+  };
+  /**
+   * Print a PromQL expression.
+   */
+  static expression = (expr, opts) => {
+    const printer = new _PromQLBasicPrettyPrinter(opts);
+    return printer.printExpression(expr);
+  };
+  opts;
+  constructor(opts = {}) {
+    this.opts = {
+      lowercaseFunctions: opts.lowercaseFunctions ?? false,
+      lowercaseKeywords: opts.lowercaseKeywords ?? false,
+      lowercaseOperators: opts.lowercaseOperators ?? false
+    };
+  }
+  print(node) {
+    if (node.type === "query") {
+      return this.printQuery(node);
+    }
+    return this.printExpression(node);
+  }
+  printQuery(query2) {
+    if (!query2.expression) {
+      return "";
+    }
+    return this.printExpression(query2.expression);
+  }
+  printExpression(expr) {
+    if (!expr) {
+      return "";
+    }
+    switch (expr.type) {
+      case "function":
+        return this.printFunction(expr);
+      case "selector":
+        return this.printSelector(expr);
+      case "binary-expression":
+        return this.printBinaryExpression(expr);
+      case "unary-expression":
+        return this.printUnaryExpression(expr);
+      case "subquery":
+        return this.printSubquery(expr);
+      case "parens":
+        return this.printParens(expr);
+      case "literal":
+        return this.printLiteral(expr);
+      case "identifier":
+        return this.printIdentifier(expr);
+      case "unknown":
+        return "<unknown>";
+      default:
+        return "";
+    }
+  }
+  printFunction(node) {
+    const name = this.opts.lowercaseFunctions ? node.name.toLowerCase() : node.name;
+    const args = node.args.map((arg) => this.printExpression(arg)).join(", ");
+    const grouping = node.grouping ? this.printGrouping(node.grouping) : "";
+    if (grouping && node.groupingPosition === "before") {
+      return `${name} ${grouping} (${args})`;
+    } else if (grouping) {
+      return `${name}(${args}) ${grouping}`;
+    } else {
+      return `${name}(${args})`;
+    }
+  }
+  printGrouping(node) {
+    const keyword = this.opts.lowercaseKeywords ? node.name.toLowerCase() : node.name;
+    const labels = node.args.map((l) => this.printLabelName(l)).join(", ");
+    return `${keyword} (${labels})`;
+  }
+  printSelector(node) {
+    let result = "";
+    if (node.metric) {
+      result += this.printIdentifier(node.metric);
+    }
+    if (node.labelMap) {
+      result += this.printLabelMap(node.labelMap);
+    }
+    if (node.duration) {
+      result += `[${this.printExpression(node.duration)}]`;
+    }
+    if (node.evaluation) {
+      result += this.printEvaluation(node.evaluation);
+    }
+    return result;
+  }
+  printLabelMap(node) {
+    const labels = node.args.map((l) => this.printLabel(l)).join(", ");
+    return `{${labels}}`;
+  }
+  printLabel(node) {
+    const labelName = this.printLabelName(node.labelName);
+    const value = node.value ? this.printLiteral(node.value) : "";
+    return `${labelName}${node.operator}${value}`;
+  }
+  printLabelName(node) {
+    switch (node.type) {
+      case "identifier":
+        return this.printIdentifier(node);
+      case "literal":
+        return this.printLiteral(node);
+      default:
+        return "";
+    }
+  }
+  printEvaluation(node) {
+    let result = "";
+    if (node.offset) {
+      result += ` ${this.printOffset(node.offset)}`;
+    }
+    if (node.at) {
+      result += ` ${this.printAt(node.at)}`;
+    }
+    return result;
+  }
+  printOffset(node) {
+    const keyword = "offset";
+    const sign = node.negative ? "- " : "";
+    const duration = this.printExpression(node.duration);
+    return `${keyword} ${sign}${duration}`;
+  }
+  printAt(node) {
+    const sign = node.negative ? "- " : "";
+    if (typeof node.value === "string") {
+      return `@ ${sign}${node.value}`;
+    }
+    return `@ ${sign}${this.printLiteral(node.value)}`;
+  }
+  printBinaryExpression(node) {
+    const group = promqlBinaryPrecedenceGroup(node);
+    const leftGroup = promqlBinaryPrecedenceGroup(node.left);
+    const rightGroup = promqlBinaryPrecedenceGroup(node.right);
+    const operator = this.formatOperator(node.name);
+    const isRightAssociative = isPromQLRightAssociative(node.name);
+    let left = this.printExpression(node.left);
+    let right = this.printExpression(node.right);
+    if (leftGroup !== 0 /* none */ && (leftGroup < group || leftGroup === group && isRightAssociative)) {
+      left = `(${left})`;
+    }
+    if (rightGroup !== 0 /* none */ && (rightGroup < group || rightGroup === group && !isRightAssociative)) {
+      right = `(${right})`;
+    }
+    let modifiers = "";
+    if (node.bool) {
+      const boolKeyword = "bool";
+      modifiers += ` ${boolKeyword}`;
+    }
+    if (node.modifier) {
+      modifiers += ` ${this.printModifier(node.modifier)}`;
+    }
+    return `${left} ${operator}${modifiers} ${right}`;
+  }
+  printModifier(node) {
+    const keyword = this.opts.lowercaseKeywords ? node.name.toLowerCase() : node.name;
+    const labels = node.labels.map((l) => this.printLabelName(l)).join(", ");
+    let result = `${keyword}(${labels})`;
+    if (node.groupModifier) {
+      result += ` ${this.printGroupModifier(node.groupModifier)}`;
+    }
+    return result;
+  }
+  printGroupModifier(node) {
+    const keyword = this.opts.lowercaseKeywords ? node.name.toLowerCase() : node.name;
+    const labels = node.labels.map((l) => this.printLabelName(l)).join(", ");
+    if (labels) {
+      return `${keyword}(${labels})`;
+    }
+    return keyword;
+  }
+  formatOperator(op) {
+    if (op === "and" || op === "or" || op === "unless") {
+      return this.opts.lowercaseOperators ? op.toLowerCase() : op;
+    }
+    return op;
+  }
+  printUnaryExpression(node) {
+    const arg = this.printExpression(node.arg);
+    return `${node.name}${arg}`;
+  }
+  printSubquery(node) {
+    const expr = this.printExpression(node.expr);
+    const range = this.printExpression(node.range);
+    const resolution = node.resolution ? this.printExpression(node.resolution) : "";
+    let result = `${expr}[${range}:${resolution}]`;
+    if (node.evaluation) {
+      result += this.printEvaluation(node.evaluation);
+    }
+    return result;
+  }
+  printParens(node) {
+    const child = this.printExpression(node.child);
+    return `(${child})`;
+  }
+  printLiteral(node) {
+    switch (node.literalType) {
+      case "integer":
+        return this.printIntegerLiteral(node);
+      case "decimal":
+        return this.printDecimalLiteral(node);
+      case "hexadecimal":
+        return this.printHexLiteral(node);
+      case "string":
+        return this.printStringLiteral(node);
+      case "time":
+        return this.printTimeLiteral(node);
+      default:
+        return String(node.value);
+    }
+  }
+  printIntegerLiteral(node) {
+    return String(node.value);
+  }
+  printDecimalLiteral(node) {
+    const value = node.value;
+    if (Number.isNaN(value)) {
+      return "NaN";
+    }
+    if (!Number.isFinite(value)) {
+      return value > 0 ? "Inf" : "-Inf";
+    }
+    const str2 = String(value);
+    if (!str2.includes(".") && !str2.includes("e") && !str2.includes("E")) {
+      return str2 + ".0";
+    }
+    return str2;
+  }
+  printHexLiteral(node) {
+    return "0x" + node.value.toString(16);
+  }
+  printStringLiteral(node) {
+    const { value, valueUnquoted } = node;
+    if (value !== valueUnquoted) {
+      return value;
+    }
+    const escaped = valueUnquoted.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/\t/g, "\\t");
+    return `"${escaped}"`;
+  }
+  printTimeLiteral(node) {
+    return node.value;
+  }
+  printIdentifier(node) {
+    return node.name;
+  }
+};
+
 // src/ast/grouping.ts
 var BinaryExpressionGroup = /* @__PURE__ */ ((BinaryExpressionGroup2) => {
   BinaryExpressionGroup2[BinaryExpressionGroup2["none"] = 0] = "none";
@@ -24742,12 +25041,16 @@ var ForkCommandVisitorContext = class extends CommandVisitorContext {
 };
 var CompletionCommandVisitorContext = class extends CommandVisitorContext {
 };
+var RegisteredDomainCommandVisitorContext = class extends CommandVisitorContext {
+};
 var SampleCommandVisitorContext = class extends CommandVisitorContext {
 };
 var FuseCommandVisitorContext = class extends CommandVisitorContext {
 };
 var MmrCommandVisitorContext = class extends CommandVisitorContext {
 };
+var UriPartsCommandVisitorContext = class extends CommandVisitorContext {
+};
 var ExpressionVisitorContext = class extends VisitorContext {
 };
 var ColumnExpressionVisitorContext = class extends VisitorContext {
@@ -24975,6 +25278,14 @@ var GlobalVisitorContext = class {
           input
         );
       }
+      case "registered_domain": {
+        if (!this.methods.visitRegisteredDomainCommand) break;
+        return this.visitRegisteredDomainCommand(
+          parent,
+          commandNode,
+          input
+        );
+      }
       case "sample": {
         if (!this.methods.visitSampleCommand) break;
         return this.visitSampleCommand(parent, commandNode, input);
@@ -24987,6 +25298,14 @@ var GlobalVisitorContext = class {
         if (!this.methods.visitMmrCommand) break;
         return this.visitMmrCommand(parent, commandNode, input);
       }
+      case "uri_parts": {
+        if (!this.methods.visitUriPartsCommand) break;
+        return this.visitUriPartsCommand(
+          parent,
+          commandNode,
+          input
+        );
+      }
     }
     return this.visitCommandGeneric(parent, commandNode, input);
   }
@@ -25097,6 +25416,10 @@ var GlobalVisitorContext = class {
     const context = new CompletionCommandVisitorContext(this, node, parent);
     return this.visitWithSpecificContext("visitCompletionCommand", context, input);
   }
+  visitRegisteredDomainCommand(parent, node, input) {
+    const context = new RegisteredDomainCommandVisitorContext(this, node, parent);
+    return this.visitWithSpecificContext("visitRegisteredDomainCommand", context, input);
+  }
   visitSampleCommand(parent, node, input) {
     const context = new ForkCommandVisitorContext(this, node, parent);
     return this.visitWithSpecificContext("visitSampleCommand", context, input);
@@ -25109,6 +25432,10 @@ var GlobalVisitorContext = class {
     const context = new MmrCommandVisitorContext(this, node, parent);
     return this.visitWithSpecificContext("visitMmrCommand", context, input);
   }
+  visitUriPartsCommand(parent, node, input) {
+    const context = new UriPartsCommandVisitorContext(this, node, parent);
+    return this.visitWithSpecificContext("visitUriPartsCommand", context, input);
+  }
   // #endregion
   // #region Expression visiting -------------------------------------------------------
   visitExpressionGeneric(parent, node, input) {
@@ -25630,9 +25957,12 @@ var BasicPrettyPrinter = class _BasicPrettyPrinter {
     if (ctx.node.type === "unknown") {
       return this.decorateWithComments(ctx.node, ctx.node.text || "<UNKNOWN>");
     }
+    if (isPromqlNode(ctx.node)) {
+      const text = PromQLBasicPrettyPrinter.print(ctx.node);
+      return this.decorateWithComments(ctx.node, text || "<UNKNOWN>");
+    }
     if (ctx.node.text) {
-      let text = ctx.node.text;
-      text = text.replace(/<EOF>/g, "").trim();
+      const text = ctx.node.text.replace(/<EOF>/g, "").trim();
       return this.decorateWithComments(ctx.node, text || "<UNKNOWN>");
     }
     return "<EXPRESSION>";
@@ -26213,6 +26543,9 @@ var WrappingPrettyPrinter = class _WrappingPrettyPrinter {
     return { txt, indented };
   }
   visitor = new Visitor().on("visitExpression", (ctx, inp) => {
+    if (isPromqlNode(ctx.node)) {
+      return { txt: PromQLBasicPrettyPrinter.print(ctx.node) };
+    }
     let text = ctx.node.text ?? "<EXPRESSION>";
     if (text) {
       text = text.replace(/<EOF>/g, "").trim();
@@ -57634,11 +57967,11 @@ var PromQLCstToAstConverter = class {
       const joiningKind = joiningToken.text?.toLowerCase() === "group_left" ? "group_left" : "group_right";
       const groupLabelsCtx = ctx._groupLabels;
       const groupLabels = groupLabelsCtx ? this.fromLabelList(groupLabelsCtx) : [];
-      groupModifier = PromQLBuilder.groupModifier(joiningKind, groupLabels, {
-        text: joiningToken.text ?? "",
-        location: getPosition(joiningToken, joiningToken),
-        incomplete: false
-      });
+      groupModifier = PromQLBuilder.groupModifier(
+        joiningKind,
+        groupLabels,
+        this.createParserFieldsFromToken(joiningToken, joiningToken.text ?? "")
+      );
       for (const label of groupLabels) {
         if (label.incomplete) {
           groupModifier.incomplete = true;
@@ -57698,6 +58031,22 @@ var PromQLCstToAstConverter = class {
             timeValue,
             this.createParserFieldsFromToken(timeValueWithColon.symbol, timeValue)
           );
+          const opToken = resolutionCtx._op;
+          const rightCtx = resolutionCtx.expression();
+          if (opToken && rightCtx) {
+            const operator = this.toBinaryOperator(opToken.text ?? "");
+            const right = this.fromExpression(rightCtx) ?? PromQLBuilder.unknown(this.getParserFields(rightCtx));
+            resolution = PromQLBuilder.expression.binary(
+              operator,
+              resolution,
+              right,
+              {},
+              this.getParserFields(resolutionCtx)
+            );
+            if (right.incomplete) {
+              resolution.incomplete = true;
+            }
+          }
         }
       }
     }
@@ -58308,6 +58657,10 @@ var CstToAstConverter = class {
     if (completionCommandCtx) {
       return this.fromCompletionCommand(completionCommandCtx);
     }
+    const registeredDomainCommandCtx = ctx.registeredDomainCommand();
+    if (registeredDomainCommandCtx) {
+      return this.fromRegisteredDomainCommand(registeredDomainCommandCtx);
+    }
     const sampleCommandCtx = ctx.sampleCommand();
     if (sampleCommandCtx) {
       return this.fromSampleCommand(sampleCommandCtx);
@@ -58332,6 +58685,10 @@ var CstToAstConverter = class {
     if (mmrCommand) {
       return this.fromMmrCommand(mmrCommand);
     }
+    const uriPartsCommandCtx = ctx.uriPartsCommand();
+    if (uriPartsCommandCtx) {
+      return this.fromUriPartsCommand(uriPartsCommandCtx);
+    }
   }
   createCommand(name, ctx, partial) {
     const parserFields = this.getParserFields(ctx);
@@ -58990,6 +59347,10 @@ var CstToAstConverter = class {
     command2.inferenceId = inferenceId;
     return command2;
   }
+  // -------------------------------------------------------- REGISTERED_DOMAIN
+  fromRegisteredDomainCommand(ctx) {
+    return this.fromQualifiedNameAssignmentCommand("registered_domain", ctx);
+  }
   // ------------------------------------------------------------------- SAMPLE
   fromSampleCommand(ctx) {
     const command2 = this.createCommand("sample", ctx);
@@ -59578,6 +59939,38 @@ var CstToAstConverter = class {
       return withOption;
     }
   }
+  // --------------------------------------------------------------- URI_PARTS
+  fromUriPartsCommand(ctx) {
+    return this.fromQualifiedNameAssignmentCommand("uri_parts", ctx);
+  }
+  fromQualifiedNameAssignmentCommand(name, ctx) {
+    const command2 = this.createCommand(name, ctx);
+    const qualifiedNameCtx = ctx.qualifiedName();
+    if (qualifiedNameCtx && ctx.ASSIGN()) {
+      const targetField = this.toColumn(qualifiedNameCtx);
+      command2.targetField = targetField;
+      const expression2 = this.fromPrimaryExpressionStrict(ctx.primaryExpression());
+      command2.expression = expression2;
+      if (expression2.incomplete || expression2.type === "unknown") {
+        command2.incomplete = true;
+      }
+      const assignment = this.toFunction(
+        ctx.ASSIGN().getText(),
+        ctx,
+        void 0,
+        "binary-expression"
+      );
+      assignment.args.push(targetField, expression2);
+      assignment.location = this.extendLocationToArgs(assignment);
+      command2.args.push(assignment);
+    } else if (qualifiedNameCtx) {
+      const targetField = this.toColumn(qualifiedNameCtx);
+      command2.targetField = targetField;
+      command2.incomplete = true;
+      command2.args.push(targetField);
+    }
+    return command2;
+  }
   // -------------------------------------------------------------- expressions
   toColumnsFromCommand(ctx) {
     if (ctx instanceof MetadataContext) {
@@ -63311,12 +63704,14 @@ var EsqlQuery = class _EsqlQuery {
   ParameterHole,
   ParensExpressionVisitorContext,
   Parser,
+  PromQLBasicPrettyPrinter,
   PromQLBuilder,
   PromQLCstToAstConverter,
   PromQLErrorListener,
   PromQLParser,
   PromqlWalker,
   QueryVisitorContext,
+  RegisteredDomainCommandVisitorContext,
   RenameCommandVisitorContext,
   RerankCommandVisitorContext,
   RowCommandVisitorContext,
@@ -63330,6 +63725,7 @@ var EsqlQuery = class _EsqlQuery {
   TIME_SPAN_UNITS,
   TimeseriesCommandVisitorContext,
   UnaryExpressionGroup,
+  UriPartsCommandVisitorContext,
   Visitor,
   VisitorContext,
   Walker,
@@ -63364,6 +63760,7 @@ var EsqlQuery = class _EsqlQuery {
   isParamLiteral,
   isParametrized,
   isParens,
+  isPromqlNode,
   isProperNode,
   isQuery,
   isSource,