@spectric/ui 0.0.4

package/src/components/query_bar/querylanguage/kuery/ast/ast.ts

@@ -0,0 +1,113 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ *
+ * Any modifications Copyright OpenSearch Contributors. See
+ * GitHub history for details.
+ */
+
+/*
+ * Licensed to Elasticsearch B.V. under one or more contributor
+ * license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright
+ * ownership. Elasticsearch B.V. licenses this file to you under
+ * the Apache License, Version 2.0 (the "License"); you may
+ * not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+import { nodeTypes } from '../node_types/index';
+import { DQLSyntaxError } from '../kuery_syntax_error';
+import { KueryNode, DslQuery, KueryParseOptions } from '../types';
+
+
+// @ts-ignore
+import { parse as parseKuery } from './_generated_/kuery';
+import { JsonObject, IIndexPattern, FieldTypes } from '../../..';
+
+const fromExpression = (
+  expression: string | DslQuery,
+  parseOptions: Partial<KueryParseOptions> = {},
+  parse: Function = parseKuery
+): KueryNode => {
+  if (typeof expression === 'undefined') {
+    throw new Error('expression must be a string, got undefined instead');
+  }
+
+  return parse(expression, { ...parseOptions, helpers: { nodeTypes } });
+};
+
+export const fromLiteralExpression = (
+  expression: string | DslQuery,
+  parseOptions: Partial<KueryParseOptions> = {}
+): KueryNode => {
+  return fromExpression(
+    expression,
+    {
+      ...parseOptions,
+      startRule: 'Literal',
+    },
+    parseKuery
+  );
+};
+
+export const fromKueryExpression = (
+  expression: string | DslQuery,
+  parseOptions: Partial<KueryParseOptions> = {}
+): KueryNode => {
+  try {
+    return fromExpression(expression, parseOptions, parseKuery);
+  } catch (error: any) {
+    if (error.name === 'SyntaxError') {
+      throw new DQLSyntaxError(error, expression);
+    } else {
+      throw error;
+    }
+  }
+};
+
+export const doesKueryExpressionHaveLuceneSyntaxError = (
+  expression: string | DslQuery
+): boolean => {
+  try {
+    fromExpression(expression, { errorOnLuceneSyntax: true }, parseKuery);
+    return false;
+  } catch (e: any) {
+    return (e).message.startsWith('Lucene');
+  }
+};
+
+/**
+ * @params {String} indexPattern
+ * @params {Object} config - contains the dateFormatTZ
+ *
+ * IndexPattern isn't required, but if you pass one in, we can be more intelligent
+ * about how we craft the queries (e.g. scripted fields)
+ */
+export const toOpenSearchQuery = (
+  node: KueryNode,
+  indexPattern?: IIndexPattern | FieldTypes[],
+  config?: Record<string, any>,
+  context?: Record<string, any>
+): JsonObject => {
+  indexPattern = undefined; //for now lets just set this to undefined until we can refactor to not need the rest of open search
+  if (!node || !node.type || !nodeTypes[node.type]) {
+    return toOpenSearchQuery(nodeTypes.function.buildNode('and', []), indexPattern);
+  }
+
+  const nodeType = (nodeTypes[node.type] as unknown) as any;
+
+  return nodeType.toOpenSearchQuery(node, indexPattern, config, context);
+};

package/src/components/query_bar/querylanguage/kuery/ast/index.ts

@@ -0,0 +1,31 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ *
+ * Any modifications Copyright OpenSearch Contributors. See
+ * GitHub history for details.
+ */
+
+/*
+ * Licensed to Elasticsearch B.V. under one or more contributor
+ * license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright
+ * ownership. Elasticsearch B.V. licenses this file to you under
+ * the Apache License, Version 2.0 (the "License"); you may
+ * not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+export * from './ast';

package/src/components/query_bar/querylanguage/kuery/ast/kuery.peg

@@ -0,0 +1,417 @@
+/**
+ * To generate the parsing module (kuery.js), run `grunt peg`
+ * To watch changes and generate on file change, run `grunt watch:peg`
+ */
+
+// Initialization block
+{
+  const { errorOnLuceneSyntax, parseCursor, cursorSymbol, allowLeadingWildcards = true, helpers: { nodeTypes } } = options;
+  const buildFunctionNode = nodeTypes.function.buildNodeWithArgumentNodes;
+  const buildLiteralNode = nodeTypes.literal.buildNode;
+  const buildWildcardNode = nodeTypes.wildcard.buildNode;
+  const buildNamedArgNode = nodeTypes.namedArg.buildNode;
+  const { wildcardSymbol } = nodeTypes.wildcard;
+}
+
+start
+  = Space* query:OrQuery? trailing:OptionalSpace {
+    if (trailing.type === 'cursor') {
+      return {
+        ...trailing,
+        suggestionTypes: ['conjunction']
+      };
+    }
+    if (query !== null) return query;
+    return nodeTypes.function.buildNode('is', '*', '*');
+  }
+
+OrQuery
+  = &{ return errorOnLuceneSyntax; } LuceneQuery
+  / left:AndQuery Or right:OrQuery {
+    const cursor = [left, right].find(node => node.type === 'cursor');
+    if (cursor) return cursor;
+    return buildFunctionNode('or', [left, right]);
+  }
+  / AndQuery
+
+AndQuery
+  = left:NotQuery And right:AndQuery {
+    const cursor = [left, right].find(node => node.type === 'cursor');
+    if (cursor) return cursor;
+    return buildFunctionNode('and', [left, right]);
+  }
+  / NotQuery
+
+NotQuery
+  = Not query:SubQuery {
+    if (query.type === 'cursor') return query;
+    return buildFunctionNode('not', [query]);
+  }
+  / SubQuery
+
+SubQuery
+  = '(' Space* query:OrQuery trailing:OptionalSpace ')' {
+    if (trailing.type === 'cursor') {
+      return {
+        ...trailing,
+        suggestionTypes: ['conjunction']
+      };
+    }
+    return query;
+  }
+  / NestedQuery
+
+NestedQuery
+  = field:Field Space* ':' Space* '{' Space* query:OrQuery trailing:OptionalSpace '}' {
+      if (query.type === 'cursor') {
+        return {
+          ...query,
+          nestedPath: query.nestedPath ? `${field.value}.${query.nestedPath}` : field.value,
+        }
+      };
+
+      if (trailing.type === 'cursor') {
+        return {
+          ...trailing,
+          suggestionTypes: ['conjunction']
+        };
+      }
+      return buildFunctionNode('nested', [field, query]);
+    }
+    / Expression
+
+Expression
+  = FieldRangeExpression
+  / FieldValueExpression
+  / ValueExpression
+
+Field "fieldName"
+  = Literal
+
+FieldRangeExpression
+  = field:Field Space* operator:RangeOperator Space* value:Literal {
+    if (value.type === 'cursor') {
+      return {
+        ...value,
+        suggestionTypes: ['conjunction']
+      };
+    }
+    const range = buildNamedArgNode(operator, value);
+    return buildFunctionNode('range', [field, range]);
+  }
+
+FieldValueExpression
+  = field:Field Space* ':' Space* partial:ListOfValues {
+    if (partial.type === 'cursor') {
+      return {
+        ...partial,
+        fieldName: field.value,
+        suggestionTypes: ['value', 'conjunction']
+      };
+    }
+    return partial(field);
+  }
+
+ValueExpression
+  = partial:Value {
+    if (partial.type === 'cursor') {
+      const fieldName = `${partial.prefix}${partial.suffix}`.trim();
+      return {
+        ...partial,
+        fieldName,
+        suggestionTypes: ['field', 'operator', 'conjunction']
+      };
+    }
+    const field = buildLiteralNode(null);
+    return partial(field);
+  }
+
+ListOfValues
+  = '(' Space* partial:OrListOfValues trailing:OptionalSpace ')' {
+    if (trailing.type === 'cursor') {
+      return {
+        ...trailing,
+        suggestionTypes: ['conjunction']
+      };
+    }
+    return partial;
+  }
+  / Value
+
+OrListOfValues
+  = partialLeft:AndListOfValues Or partialRight:OrListOfValues {
+    const cursor = [partialLeft, partialRight].find(node => node.type === 'cursor');
+    if (cursor) {
+      return {
+        ...cursor,
+        suggestionTypes: ['value']
+      };
+    }
+    return (field) => buildFunctionNode('or', [partialLeft(field), partialRight(field)]);
+  }
+  / AndListOfValues
+
+AndListOfValues
+  = partialLeft:NotListOfValues And partialRight:AndListOfValues {
+    const cursor = [partialLeft, partialRight].find(node => node.type === 'cursor');
+    if (cursor) {
+      return {
+        ...cursor,
+        suggestionTypes: ['value']
+      };
+    }
+    return (field) => buildFunctionNode('and', [partialLeft(field), partialRight(field)]);
+  }
+  / NotListOfValues
+
+NotListOfValues
+  = Not partial:ListOfValues {
+    if (partial.type === 'cursor') {
+      return {
+        ...list,
+        suggestionTypes: ['value']
+      };
+    }
+    return (field) => buildFunctionNode('not', [partial(field)]);
+  }
+  / ListOfValues
+
+Value "value"
+  = value:QuotedString {
+    if (value.type === 'cursor') return value;
+    const isPhrase = buildLiteralNode(true);
+    return (field) => buildFunctionNode('is', [field, value, isPhrase]);
+  }
+  / value:UnquotedLiteral {
+    if (value.type === 'cursor') return value;
+
+    if (!allowLeadingWildcards && value.type === 'wildcard' && nodeTypes.wildcard.hasLeadingWildcard(value)) {
+      error('Leading wildcards are disabled. See query:allowLeadingWildcards in Advanced Settings.');
+    }
+
+    const isPhrase = buildLiteralNode(false);
+    return (field) => buildFunctionNode('is', [field, value, isPhrase]);
+  }
+
+Or "OR"
+  = Space+ 'or'i Space+
+  / &{ return errorOnLuceneSyntax; } LuceneOr
+
+And "AND"
+  = Space+ 'and'i Space+
+  / &{ return errorOnLuceneSyntax; } LuceneAnd
+
+Not "NOT"
+  = 'not'i Space+
+  / &{ return errorOnLuceneSyntax; } LuceneNot
+
+Literal "literal"
+  = QuotedString / UnquotedLiteral
+
+QuotedString
+  = '"' prefix:QuotedCharacter* cursor:Cursor suffix:QuotedCharacter* '"' {
+    const { start, end } = location();
+    return {
+      type: 'cursor',
+      start: start.offset,
+      end: end.offset - cursor.length,
+      prefix: prefix.join(''),
+      suffix: suffix.join(''),
+      text: text().replace(cursor, '')
+    };
+  }
+  / '"' chars:QuotedCharacter* '"' {
+    return buildLiteralNode(chars.join(''));
+  }
+
+QuotedCharacter
+  = EscapedWhitespace
+  / '\\' char:[\\"] { return char; }
+  / !Cursor char:[^"] { return char; }
+
+UnquotedLiteral
+  = prefix:UnquotedCharacter* cursor:Cursor suffix:UnquotedCharacter* {
+    const { start, end } = location();
+    return {
+      type: 'cursor',
+      start: start.offset,
+      end: end.offset - cursor.length,
+      prefix: prefix.join(''),
+      suffix: suffix.join(''),
+      text: text().replace(cursor, '')
+    };
+  }
+  / chars:UnquotedCharacter+ {
+    const sequence = chars.join('').trim();
+    if (sequence === 'null') return buildLiteralNode(null);
+    if (sequence === 'true') return buildLiteralNode(true);
+    if (sequence === 'false') return buildLiteralNode(false);
+    if (chars.includes(wildcardSymbol)) return buildWildcardNode(sequence);
+    const isNumberPattern = /^(-?[1-9]+\d*([.]\d+)?)$|^(-?0[.]\d*[1-9]+)$|^0$|^0.0$|^[.]\d{1,}$/;
+    return buildLiteralNode(
+      isNumberPattern.test(sequence)
+        ? isFinite(sequence) && (sequence > Number.MAX_SAFE_INTEGER || sequence < Number.MIN_SAFE_INTEGER)
+          ? BigInt(sequence)
+          : Number(sequence)
+        : sequence
+    );
+  }
+
+UnquotedCharacter
+  = EscapedWhitespace
+  / EscapedSpecialCharacter
+  / EscapedKeyword
+  / Wildcard
+  / !SpecialCharacter !Keyword !Cursor char:. { return char; }
+
+Wildcard
+  = '*' { return wildcardSymbol; }
+
+OptionalSpace
+  = prefix:Space* cursor:Cursor suffix:Space* {
+    const { start, end } = location();
+    return {
+      type: 'cursor',
+      start: start.offset,
+      end: end.offset - cursor.length,
+      prefix: prefix.join(''),
+      suffix: suffix.join(''),
+      text: text().replace(cursor, '')
+    };
+  }
+  / Space*
+
+EscapedWhitespace
+  = '\\t' { return '\t'; }
+  / '\\r' { return '\r'; }
+  / '\\n' { return '\n'; }
+
+EscapedSpecialCharacter
+  = '\\' char:SpecialCharacter { return char; }
+
+EscapedKeyword
+  = '\\' keyword:('or'i / 'and'i / 'not'i) { return keyword; }
+
+Keyword
+  = Or / And / Not
+
+SpecialCharacter
+  = [\\():<>"*{}]
+
+RangeOperator
+  = '<=' { return 'lte'; }
+  / '>=' { return 'gte'; }
+  / '<' { return 'lt'; }
+  / '>' { return 'gt'; }
+
+Space "whitespace"
+  = [\ \t\r\n]
+
+Cursor
+  = &{ return parseCursor; } '@kuery-cursor@' { return cursorSymbol; }
+
+// Temporary error rules (to help users transition from Lucene... should be removed at some point)
+
+LuceneOr
+  =  Space* '||' Space* {
+    error('LuceneOr');
+  }
+
+LuceneAnd
+  = Space* '&&' Space* {
+    error('LuceneAnd');
+  }
+  / '+' {
+    error('LuceneAnd');
+  }
+
+LuceneNot
+  = '-' {
+    error('LuceneNot');
+  }
+  / '!' {
+    error('LuceneNot');
+  }
+
+LuceneQuery
+  = LuceneFieldQuery
+  / LuceneValue
+  / LuceneExists
+
+LuceneFieldQuery
+  = LuceneLiteral Space* ':' Space* LuceneValue
+
+LuceneValue
+  = LuceneRange
+  / LuceneWildcard
+  / LuceneRegex
+  / LuceneFuzzy
+  / LuceneProximity
+  / LuceneBoost
+
+LuceneExists
+  = '_exists_' Space* ':' Space* LuceneLiteral {
+    error('LuceneExists');
+  }
+
+LuceneRange
+  = RangeOperator Space* LuceneLiteral {
+    error('LuceneRange');
+  }
+  / LuceneRangeStart Space* LuceneLiteral LuceneTo LuceneLiteral LuceneRangeEnd {
+    error('LuceneRange');
+  }
+
+LuceneWildcard
+  = (LuceneUnquotedCharacter / '*')* '?' LuceneWildcard* {
+    error('LuceneWildcard');
+  }
+
+LuceneRegex
+  = '/' [^/]* '/' {
+    error('LuceneRegex');
+  }
+
+LuceneFuzzy
+  = LuceneUnquotedLiteral '~' [0-9]* {
+    error('LuceneFuzzy');
+  }
+
+LuceneProximity
+  = QuotedString '~' [0-9]* {
+    error('LuceneProximity');
+  }
+
+LuceneBoost
+  = LuceneLiteral '^' [0-9]* {
+    error('LuceneBoost');
+  }
+
+LuceneLiteral
+  = QuotedString / LuceneUnquotedLiteral
+
+LuceneUnquotedLiteral
+  = LuceneUnquotedCharacter+
+
+LuceneUnquotedCharacter
+  = EscapedWhitespace
+  / EscapedLuceneSpecialCharacter
+  / !LuceneSpecialCharacter !LuceneKeyword .
+
+LuceneKeyword
+  = Or / And / LuceneOr / LuceneAnd / LuceneNot / LuceneTo
+
+EscapedLuceneSpecialCharacter
+  = '\\' LuceneSpecialCharacter { return char; }
+
+LuceneSpecialCharacter
+  = '+' / '-' / '=' / '>' / '<' / '!' / '(' / ')' / '{' / '}' / '[' / ']' / '^' / '"' / '~' / '*' / '?' / ':' / '\\' / '/'
+
+LuceneTo
+  = Space+ 'TO' Space+
+
+LuceneRangeStart
+  = '[' / '{'
+
+LuceneRangeEnd
+  = ']' / '}'

package/src/components/query_bar/querylanguage/kuery/functions/and.ts

@@ -0,0 +1,55 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ *
+ * Any modifications Copyright OpenSearch Contributors. See
+ * GitHub history for details.
+ */
+
+/*
+ * Licensed to Elasticsearch B.V. under one or more contributor
+ * license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright
+ * ownership. Elasticsearch B.V. licenses this file to you under
+ * the Apache License, Version 2.0 (the "License"); you may
+ * not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+import * as ast from '../ast';
+import { IIndexPattern, KueryNode } from '../../..';
+
+export function buildNodeParams(children: KueryNode[]) {
+  return {
+    arguments: children,
+  };
+}
+
+export function toOpenSearchQuery(
+  node: KueryNode,
+  indexPattern?: IIndexPattern,
+  config: Record<string, any> = {},
+  context: Record<string, any> = {}
+) {
+  const children = node.arguments || [];
+
+  return {
+    bool: {
+      filter: children.map((child: KueryNode) => {
+        return ast.toOpenSearchQuery(child, indexPattern, config, context);
+      }),
+    },
+  };
+}

package/src/components/query_bar/querylanguage/kuery/functions/exists.ts

@@ -0,0 +1,62 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ *
+ * Any modifications Copyright OpenSearch Contributors. See
+ * GitHub history for details.
+ */
+
+/*
+ * Licensed to Elasticsearch B.V. under one or more contributor
+ * license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright
+ * ownership. Elasticsearch B.V. licenses this file to you under
+ * the Apache License, Version 2.0 (the "License"); you may
+ * not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+import * as literal from '../node_types/literal';
+import { IIndexPattern, KueryNode, IFieldType } from '../../../';
+
+export function buildNodeParams(fieldName: string) {
+  return {
+    arguments: [literal.buildNode(fieldName)],
+  };
+}
+
+export function toOpenSearchQuery(
+  node: KueryNode,
+  indexPattern?: IIndexPattern,//@ts-ignore
+  config: Record<string, any> = {},
+  context: Record<string, any> = {}
+) {
+  const {
+    arguments: [fieldNameArg],
+  } = node;
+  const fullFieldNameArg = {
+    ...fieldNameArg,
+    value: context?.nested ? `${context.nested.path}.${fieldNameArg.value}` : fieldNameArg.value,
+  };
+  const fieldName = literal.toOpenSearchQuery(fullFieldNameArg);
+  const field = (indexPattern?.fields || []).find((fld: IFieldType) => fld.name === fieldName);
+
+  if (field && (field as IFieldType).scripted) {
+    throw new Error(`Exists query does not support scripted fields`);
+  }
+  return {
+    exists: { field: fieldName },
+  };
+}