@spectric/ui 0.0.21 → 0.0.22

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

@@ -28,22 +28,21 @@
  * under the License.
  */
 
-import { nodeTypes } from '../node_types/index';
-import { DQLSyntaxError } from '../kuery_syntax_error';
-import { KueryNode, DslQuery, KueryParseOptions } from '../types';
-
+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 '../../..';
+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');
+  if (typeof expression === "undefined") {
+    throw new Error("expression must be a string, got undefined instead");
   }
 
   return parse(expression, { ...parseOptions, helpers: { nodeTypes } });
@@ -57,7 +56,7 @@ export const fromLiteralExpression = (
     expression,
     {
       ...parseOptions,
-      startRule: 'Literal',
+      startRule: "Literal",
     },
     parseKuery
   );
@@ -70,7 +69,7 @@ export const fromKueryExpression = (
   try {
     return fromExpression(expression, parseOptions, parseKuery);
   } catch (error: any) {
-    if (error.name === 'SyntaxError') {
+    if (error.name === "SyntaxError") {
       throw new DQLSyntaxError(error, expression);
     } else {
       throw error;
@@ -85,7 +84,7 @@ export const doesKueryExpressionHaveLuceneSyntaxError = (
     fromExpression(expression, { errorOnLuceneSyntax: true }, parseKuery);
     return false;
   } catch (e: any) {
-    return (e).message.startsWith('Lucene');
+    return e.message.startsWith("Lucene");
   }
 };
 
@@ -104,10 +103,13 @@ export const toOpenSearchQuery = (
 ): 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);
+    return toOpenSearchQuery(
+      nodeTypes.function.buildNode("and", []),
+      indexPattern
+    );
   }
 
-  const nodeType = (nodeTypes[node.type] as unknown) as any;
+  const nodeType = nodeTypes[node.type] as unknown as any;
 
   return nodeType.toOpenSearchQuery(node, indexPattern, config, context);
 };

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

@@ -18,7 +18,8 @@ start
     if (trailing.type === 'cursor') {
       return {
         ...trailing,
-        suggestionTypes: ['conjunction']
+        suggestionTypes: ['conjunction'],
+        rule:"start"
       };
     }
     if (query !== null) return query;
@@ -26,8 +27,7 @@ start
   }
 
 OrQuery
-  = &{ return errorOnLuceneSyntax; } LuceneQuery
-  / left:AndQuery Or right:OrQuery {
+  = left:AndQuery Or right:OrQuery {
     const cursor = [left, right].find(node => node.type === 'cursor');
     if (cursor) return cursor;
     return buildFunctionNode('or', [left, right]);
@@ -54,7 +54,8 @@ SubQuery
     if (trailing.type === 'cursor') {
       return {
         ...trailing,
-        suggestionTypes: ['conjunction']
+        suggestionTypes: ['conjunction'],
+        rule:"SubQuery"
       };
     }
     return query;
@@ -81,19 +82,62 @@ NestedQuery
     / Expression
 
 Expression
-  = FieldRangeExpression
+  = FieldGeoSpatialExpression
+  / FieldMultiGeoSpatialExpression
+  / FieldRangeExpression
   / FieldValueExpression
   / ValueExpression
 
 Field "fieldName"
   = Literal
 
+FieldGeoSpatialExpression
+  = field:Field Space* operator:GeoSpatialOperator Space* value:Literal {
+    if (value.type === 'cursor') {
+      return {
+        ...value,
+        fieldName: field.value,
+        suggestionTypes: ['geo_value','conjunction'],
+        rule:"FieldGeoSpatialExpression"
+      };
+    }
+    return {
+      type: 'function',
+      function: 'geospatial',
+      arguments: [field,operator, value],
+    }
+   
+  }
+FieldMultiGeoSpatialExpression
+  = field:Field Space* operator:GeoSpatialOperator Space* partial:ListOfValues {
+    if (partial.type === 'cursor') {
+      return {
+        ...partial,
+        fieldName: field.value,
+        suggestionTypes: ['geo_value', 'conjunction'],
+        rule:"FieldMultiGeoSpatialExpression"
+      };
+    }
+    const range = buildNamedArgNode(operator, partial(field))
+    const listItems = partial(field)
+    if(listItems.function == "is"){
+    	//One Item in the list
+        return buildFunctionNode('geospatial', [field,operator, listItems.arguments[1]]);
+    }
+    return {...listItems,arguments:listItems.arguments.map(a=> buildFunctionNode('geospatial', {
+      type: 'function',
+      function: 'geospatial',
+      arguments: [field,operator, a.arguments[1]],
+    }))}
+  }
 FieldRangeExpression
-  = field:Field Space* operator:RangeOperator Space* value:Literal {
+  = field:Field Space* operator:RangeOperator Space* value:NumberOrQuotedString {
     if (value.type === 'cursor') {
       return {
         ...value,
-        suggestionTypes: ['conjunction']
+        fieldName: field.value,
+        suggestionTypes: ['value','conjunction'],
+        rule:"FieldRangeExpression"
       };
     }
     const range = buildNamedArgNode(operator, value);
@@ -103,10 +147,19 @@ FieldRangeExpression
 FieldValueExpression
   = field:Field Space* ':' Space* partial:ListOfValues {
     if (partial.type === 'cursor') {
+      if(partial.prefix.includes(wildcardSymbol)){
+        return {
+        ...partial,
+        fieldName: field.value,
+        suggestionTypes: ['conjunction'],
+        rule:"FieldValueExpression"
+      }
+      }
       return {
         ...partial,
         fieldName: field.value,
-        suggestionTypes: ['value', 'conjunction']
+        suggestionTypes: ['value', 'conjunction'],
+        rule:"FieldValueExpression"
       };
     }
     return partial(field);
@@ -119,7 +172,8 @@ ValueExpression
       return {
         ...partial,
         fieldName,
-        suggestionTypes: ['field', 'operator', 'conjunction']
+        suggestionTypes: ['field', 'operator', 'conjunction'],
+        rule:"ValueExpression"
       };
     }
     const field = buildLiteralNode(null);
@@ -131,7 +185,8 @@ ListOfValues
     if (trailing.type === 'cursor') {
       return {
         ...trailing,
-        suggestionTypes: ['conjunction']
+        suggestionTypes: ['conjunction'],
+        rule:"ListOfValues"
       };
     }
     return partial;
@@ -144,7 +199,8 @@ OrListOfValues
     if (cursor) {
       return {
         ...cursor,
-        suggestionTypes: ['value']
+        suggestionTypes: ['value'],
+        rule:"OrListOfValues"
       };
     }
     return (field) => buildFunctionNode('or', [partialLeft(field), partialRight(field)]);
@@ -157,7 +213,8 @@ AndListOfValues
     if (cursor) {
       return {
         ...cursor,
-        suggestionTypes: ['value']
+        suggestionTypes: ['value'],
+        rule:"AndListOfValues"
       };
     }
     return (field) => buildFunctionNode('and', [partialLeft(field), partialRight(field)]);
@@ -169,7 +226,8 @@ NotListOfValues
     if (partial.type === 'cursor') {
       return {
         ...list,
-        suggestionTypes: ['value']
+        suggestionTypes: ['value'],
+        rule:"NotListOfValues"
       };
     }
     return (field) => buildFunctionNode('not', [partial(field)]);
@@ -195,19 +253,25 @@ Value "value"
 
 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
 
+
+Number = Float / Integer
+
+Float = Integer "." [0-9]+ { return parseFloat(text()); }
+
+Integer = [0-9]+ { return parseInt(text(), 10); }
+
 QuotedString
   = '"' prefix:QuotedCharacter* cursor:Cursor suffix:QuotedCharacter* '"' {
     const { start, end } = location();
@@ -217,13 +281,14 @@ QuotedString
       end: end.offset - cursor.length,
       prefix: prefix.join(''),
       suffix: suffix.join(''),
-      text: text().replace(cursor, '')
+      text: text().replace(cursor, ''),
+      rule:"QuotedString"
     };
   }
   / '"' chars:QuotedCharacter* '"' {
     return buildLiteralNode(chars.join(''));
   }
-
+NumberOrQuotedString = Number/QuotedString/OptionalSpace
 QuotedCharacter
   = EscapedWhitespace
   / '\\' char:[\\"] { return char; }
@@ -238,7 +303,8 @@ UnquotedLiteral
       end: end.offset - cursor.length,
       prefix: prefix.join(''),
       suffix: suffix.join(''),
-      text: text().replace(cursor, '')
+      text: text().replace(cursor, ''),
+      rule:"UnquotedLiteral"
     };
   }
   / chars:UnquotedCharacter+ {
@@ -276,7 +342,8 @@ OptionalSpace
       end: end.offset - cursor.length,
       prefix: prefix.join(''),
       suffix: suffix.join(''),
-      text: text().replace(cursor, '')
+      text: text().replace(cursor, ''),
+      rule:"OptionalSpace"
     };
   }
   / Space*
@@ -298,120 +365,19 @@ Keyword
 SpecialCharacter
   = [\\():<>"*{}]
 
+GeoSpatialOperator
+ = '<@' { return 'within'; }
+
 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
-  = '[' / '{'
+  = &{ return parseCursor; } '©kuery-cursor©' { return cursorSymbol; }
 
-LuceneRangeEnd
-  = ']' / '}'

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

@@ -0,0 +1,25 @@
+import { wktToGeoJSON } from "@terraformer/wkt";
+import { KueryNode } from "../types";
+export function toOpenSearchQuery(node: KueryNode) {
+  const [fieldNameArg, operator, value] = node.arguments;
+
+  return {
+    bool: {
+      must: [
+        {
+          exists: {
+            field: fieldNameArg.value,
+          },
+        },
+        {
+          geo_shape: {
+            [fieldNameArg.value]: {
+              relation: operator,
+              shape: wktToGeoJSON(value.value),
+            },
+          },
+        },
+      ],
+    },
+  };
+}

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

@@ -28,13 +28,14 @@
  * under the License.
  */
 
-import * as is from './is';
-import * as and from './and';
-import * as or from './or';
-import * as not from './not';
-import * as range from './range';
-import * as exists from './exists';
-import * as nested from './nested';
+import * as is from "./is";
+import * as and from "./and";
+import * as or from "./or";
+import * as not from "./not";
+import * as range from "./range";
+import * as exists from "./exists";
+import * as nested from "./nested";
+import * as geospatial from "./geospatial";
 
 export const functions: any = {
   is,
@@ -44,4 +45,5 @@ export const functions: any = {
   range,
   exists,
   nested,
+  geospatial,
 };

package/src/components/query_bar/querylanguage/outputTypes/toCQL.ts

@@ -1,36 +1,42 @@
-
-import { FieldTypes, KueryNode } from '../..';
-import { wildcardSymbol } from '../kuery/node_types/wildcard';
+import { FieldTypes, KueryNode } from "../..";
+import { wildcardSymbol } from "../kuery/node_types/wildcard";
 
 export const KQL_WILDCARD_SYMBOL = wildcardSymbol;
-export const KQL_NODE_TYPE_WILDCARD = 'wildcard';
-export type FunctionName = 'is' | 'and' | 'or' | 'not' | 'range' | 'exists' | 'nested';
+export const KQL_NODE_TYPE_WILDCARD = "wildcard";
+export type FunctionName =
+  | "is"
+  | "and"
+  | "or"
+  | "not"
+  | "range"
+  | "exists"
+  | "nested";
 const and = (node: KueryNode, fields?: FieldTypes[]) => {
   const children = node.arguments || [];
   return (
-    '(' +
+    "(" +
     children
       .map((child: KueryNode) => {
         return toCql(child, fields);
       })
-      .join(' AND ') +
-    ')'
+      .join(" AND ") +
+    ")"
   );
 };
 const is = (node: KueryNode, fields?: FieldTypes[]) => {
   var {
     arguments: [fieldNameArg, valueArg, isValue],
   } = node;
-  let operator = '=';
-  if (valueArg.type === 'wildcard') {
-    operator = '';
+  let operator = "=";
+  if (valueArg.type === "wildcard") {
+    operator = "";
   }
   let value = toCql(valueArg);
   isValue = isValue.value || typeof value === "string";
-  if (valueArg.type === 'literal' && isValue) {
+  if (valueArg.type === "literal" && isValue) {
     value = `'${value}'`; //should be quoted
   }
-  if (valueArg.type === 'literal' && !isValue) {
+  if (valueArg.type === "literal" && !isValue) {
     value = `${value}`; //shouldn't be quoted
   }
   let fieldName = toCql(fieldNameArg);
@@ -38,12 +44,22 @@ const is = (node: KueryNode, fields?: FieldTypes[]) => {
     //this isn't possible if we don't have the names of all the fields.
     //if we have all the fields we can do a list of or statements (field ILIKE "%value%")
     if (fields && isValue) {
-      return `(${fields.filter(f => f.type === "string").map(field => `${field.name} ILIKE '%${valueArg.value}%'`).join(" OR ")})`
+      return `(${fields
+        .filter((f) => f.type === "string")
+        .map((field) => `${field.name} ILIKE '%${valueArg.value}%'`)
+        .join(" OR ")})`;
     }
-    if (fields && !isValue && (valueArg.value === true || valueArg.value === false)) {
-      return `(${fields.filter(f => f.type === "boolean").map(field => `${field.name}=${valueArg.value}`).join(" OR ")})`
+    if (
+      fields &&
+      !isValue &&
+      (valueArg.value === true || valueArg.value === false)
+    ) {
+      return `(${fields
+        .filter((f) => f.type === "boolean")
+        .map((field) => `${field.name}=${valueArg.value}`)
+        .join(" OR ")})`;
     }
-    return ""
+    return "";
   }
   return fieldName + operator + value;
 };
@@ -51,34 +67,33 @@ const is = (node: KueryNode, fields?: FieldTypes[]) => {
 const or = (node: KueryNode, fields?: FieldTypes[]) => {
   const children = node.arguments || [];
   return (
-    '(' +
+    "(" +
     children
       .map((child: KueryNode) => {
         return toCql(child, fields);
       })
-      .join(' OR ') +
-    ')'
+      .join(" OR ") +
+    ")"
   );
 };
 const not = (node: KueryNode, fields?: FieldTypes[]) => {
   const [argument] = node.arguments;
-  return 'NOT (' + toCql(argument, fields) + ')';
+  return "NOT (" + toCql(argument, fields) + ")";
 };
 
 const AST_TO_CQL = {
-  gt: '>',
-  lt: '<',
-  gte: '>=',
-  lte: '<=',
+  gt: ">",
+  lt: "<",
+  gte: ">=",
+  lte: "<=",
 };
-const range = (node: KueryNode,) => {
-
+const range = (node: KueryNode) => {
   const [fieldNameArg, operator] = node.arguments;
-  let valueArg = operator.value
+  let valueArg = operator.value;
   // @ts-ignore
   const opsign = AST_TO_CQL[operator.name];
   let value = toCql(valueArg);
-  if (valueArg.type === 'literal') {
+  if (valueArg.type === "literal") {
     value = `${value}`;
   }
   return `${fieldNameArg.value} ${opsign} ${value}`;
@@ -89,9 +104,15 @@ const exists = (node: KueryNode) => {
 };
 const nested = (node: KueryNode) => {
   //nested types don't exist in CQL
-  console.warn("Nested types dont exist in CQL", node)
-  return ""
-}
+  console.warn("Nested types dont exist in CQL", node);
+  return "";
+};
+const geospatial = (node: KueryNode) => {
+  const [fieldName, operator, value] = node.arguments;
+  console.log(fieldName, operator, value);
+  if (operator === "within") return `WITHIN(${fieldName.value},${value.value})`;
+  throw Error(`Unsupported GEO Operator:${operator}`);
+};
 export const functions = {
   is,
   and,
@@ -99,7 +120,8 @@ export const functions = {
   not,
   range,
   exists,
-  nested
+  nested,
+  geospatial,
 };
 const nodeTypes = {
   function: (node: KueryNode, fields?: FieldTypes[]) => {
@@ -111,7 +133,7 @@ const nodeTypes = {
   },
   wildcard: (node: KueryNode) => {
     const { value } = node;
-    return ` LIKE '${value.split(KQL_WILDCARD_SYMBOL).join('%')}'`;
+    return ` LIKE '${value.split(KQL_WILDCARD_SYMBOL).join("%")}'`;
   },
 };