@fc-components/monaco-editor 0.1.1

package/src/promql/types.ts

@@ -0,0 +1,35 @@
+export type LabelOperator = '=' | '!=' | '=~' | '!~';
+
+export type Label = {
+  name: string;
+  value: string;
+  op: LabelOperator;
+};
+
+export interface Metric {
+  name: string;
+  help: string;
+  type: string;
+}
+
+export interface PromMetricsMetadataItem {
+  type: string;
+  help: string;
+  unit?: string;
+}
+
+export interface PromMetricsMetadata {
+  [metric: string]: PromMetricsMetadataItem;
+}
+
+type FetchFn = (input: RequestInfo, init?: RequestInit) => Promise<Response>;
+
+export interface DataProviderParams {
+  url?: string;
+  lookbackInterval?: number;
+  variablesNames?: string[];
+  request: FetchFn;
+  httpMethod?: 'POST' | 'GET';
+  apiPrefix?: string;
+  httpErrorHandler?: (error: any) => void;
+}

package/src/promql/util.ts

@@ -0,0 +1,29 @@
+import { Label } from './types';
+
+export class NeverCaseError extends Error {
+  constructor(_value: never) {
+    super('should never happen');
+  }
+}
+
+// based on the openmetrics-documentation, the 3 symbols we have to handle are:
+// - \n ... the newline character
+// - \  ... the backslash character
+// - "  ... the double-quote character
+export function escapeLabelValueInExactSelector(labelValue: string): string {
+  return labelValue.replace(/\\/g, '\\\\').replace(/\n/g, '\\n').replace(/"/g, '\\"');
+}
+
+export function makeSelector(metricName: string, labels?: Label[], labelName?: string): string {
+  if (!labels || labels.length === 0) {
+    return metricName;
+  }
+
+  const allLabels = [...labels].filter((label) => label.name !== labelName && label.value !== '');
+
+  const allLabelTexts = allLabels.map((label) => {
+    return `${label.name}${label.op}"${escapeLabelValueInExactSelector(label.value)}"`;
+  });
+
+  return `{${allLabelTexts.join(',')}}`;
+}

package/src/promql/validation.ts

@@ -0,0 +1,93 @@
+import { SyntaxNode } from '@lezer/common';
+import { LRParser } from '@lezer/lr';
+
+export const ErrorId = 0;
+
+interface ParserErrorBoundary {
+  startLineNumber: number;
+  startColumn: number;
+  endLineNumber: number;
+  endColumn: number;
+  error: string;
+}
+
+interface ParseError {
+  text: string;
+  node: SyntaxNode;
+}
+
+export function validateQuery(query: string, interpolatedQuery: string, queryLines: string[], parser: LRParser): ParserErrorBoundary[] | false {
+  if (!query) {
+    return false;
+  }
+
+  const interpolatedErrors: ParseError[] = parseQuery(interpolatedQuery, parser);
+  if (!interpolatedErrors.length) {
+    return false;
+  }
+
+  let parseErrors: ParseError[] = interpolatedErrors;
+  if (query !== interpolatedQuery) {
+    const queryErrors: ParseError[] = parseQuery(query, parser);
+    parseErrors = interpolatedErrors.flatMap((interpolatedError) => queryErrors.filter((queryError) => interpolatedError.text === queryError.text) || interpolatedError);
+  }
+
+  return parseErrors.map((parseError) => findErrorBoundary(query, queryLines, parseError)).filter(isErrorBoundary);
+}
+
+function parseQuery(query: string, parser: LRParser) {
+  const parseErrors: ParseError[] = [];
+  const tree = parser.parse(query);
+  tree.iterate({
+    enter: (nodeRef): false | void => {
+      if (nodeRef.type.id === ErrorId) {
+        const node = nodeRef.node;
+        parseErrors.push({
+          node: node,
+          text: query.substring(node.from, node.to),
+        });
+      }
+    },
+  });
+  return parseErrors;
+}
+
+function findErrorBoundary(query: string, queryLines: string[], parseError: ParseError): ParserErrorBoundary | null {
+  if (queryLines.length === 1) {
+    const isEmptyString = parseError.node.from === parseError.node.to;
+    const errorNode = isEmptyString && parseError.node.parent ? parseError.node.parent : parseError.node;
+    const error = isEmptyString ? query.substring(errorNode.from, errorNode.to) : parseError.text;
+    return {
+      startLineNumber: 1,
+      startColumn: errorNode.from + 1,
+      endLineNumber: 1,
+      endColumn: errorNode.to + 1,
+      error,
+    };
+  }
+
+  let startPos = 0,
+    endPos = 0;
+  for (let line = 0; line < queryLines.length; line++) {
+    endPos = startPos + queryLines[line].length;
+
+    if (parseError.node.from > endPos) {
+      startPos += queryLines[line].length + 1;
+      continue;
+    }
+
+    return {
+      startLineNumber: line + 1,
+      startColumn: parseError.node.from - startPos + 1,
+      endLineNumber: line + 1,
+      endColumn: parseError.node.to - startPos + 1,
+      error: parseError.text,
+    };
+  }
+
+  return null;
+}
+
+function isErrorBoundary(boundary: ParserErrorBoundary | null): boundary is ParserErrorBoundary {
+  return boundary !== null;
+}