@spectric/ui 0.0.4

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

@@ -0,0 +1,47 @@
+/*
+ * 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 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';
+
+export const functions: any = {
+  is,
+  and,
+  or,
+  not,
+  range,
+  exists,
+  nested,
+};

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

@@ -0,0 +1,211 @@
+/*
+ * 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 { getFields } from './utils/get_fields';
+import { getTimeZoneFromSettings } from '../../utils';
+import { getFullFieldNameNode } from './utils/get_full_field_name_node';
+import { IIndexPattern, KueryNode, IFieldType } from '../../..';
+
+import * as ast from '../ast';
+
+import * as literal from '../node_types/literal';
+import * as wildcard from '../node_types/wildcard';
+
+export function buildNodeParams(fieldName: string, value: any, isPhrase: boolean = false) {
+  if (fieldName === undefined) {
+    throw new Error('fieldName is a required argument');
+  }
+  if (value === undefined) {
+    throw new Error('value is a required argument');
+  }
+  const fieldNode =
+    typeof fieldName === 'string'
+      ? ast.fromLiteralExpression(fieldName)
+      : literal.buildNode(fieldName);
+  const valueNode =
+    typeof value === 'string' ? ast.fromLiteralExpression(value) : literal.buildNode(value);
+  const isPhraseNode = literal.buildNode(isPhrase);
+  return {
+    arguments: [fieldNode, valueNode, isPhraseNode],
+  };
+}
+
+export function toOpenSearchQuery(
+  node: KueryNode,
+  indexPattern?: IIndexPattern,
+  config: Record<string, any> = {},
+  context: Record<string, any> = {}
+) {
+  const {
+    arguments: [fieldNameArg, valueArg, isPhraseArg],
+  } = node;
+  const fullFieldNameArg = getFullFieldNameNode(
+    fieldNameArg,
+    indexPattern,
+    context?.nested ? context.nested.path : undefined
+  );
+  const fieldName = ast.toOpenSearchQuery(fullFieldNameArg);
+  const value = !(valueArg === undefined) ? ast.toOpenSearchQuery(valueArg) : valueArg;
+  const type = isPhraseArg.value ? 'phrase' : 'best_fields';
+  if (fullFieldNameArg.value === null) {
+    if (valueArg.type === 'wildcard') {
+      return {
+        query_string: {
+          query: wildcard.toQueryStringQuery(valueArg),
+        },
+      };
+    }
+
+    return {
+      multi_match: {
+        type,
+        query: value,
+        lenient: true,
+      },
+    };
+  }
+
+  const fields = indexPattern ? getFields(fullFieldNameArg, indexPattern) : [];
+  // If no fields are found in the index pattern we send through the given field name as-is. We do this to preserve
+  // the behaviour of lucene on dashboards where there are panels based on different index patterns that have different
+  // fields. If a user queries on a field that exists in one pattern but not the other, the index pattern without the
+  // field should return no results. It's debatable whether this is desirable, but it's been that way forever, so we'll
+  // keep things familiar for now.
+  if (fields && fields.length === 0) {
+    fields.push({
+      name: (ast.toOpenSearchQuery(fullFieldNameArg) as unknown) as string,
+      scripted: false,
+      type: '',
+    });
+  }
+
+  const isExistsQuery = valueArg.type === 'wildcard' && (value as any) === '*';
+  const isAllFieldsQuery =
+    (fullFieldNameArg.type === 'wildcard' && ((fieldName as unknown) as string) === '*') ||
+    (fields && indexPattern && fields.length === indexPattern.fields.length);
+  const isMatchAllQuery = isExistsQuery && isAllFieldsQuery;
+
+  if (isMatchAllQuery) {
+    return { match_all: {} };
+  }
+
+  const queries = fields!.reduce((accumulator: any, field: IFieldType) => {
+    const wrapWithNestedQuery = (query: any) => {
+      // Wildcards can easily include nested and non-nested fields. There isn't a good way to let
+      // users handle this themselves so we automatically add nested queries in this scenario.
+      if (
+        !(fullFieldNameArg.type === 'wildcard') ||
+        !field.subType?.nested ||
+        context?.nested
+      ) {
+        return query;
+      } else {
+        return {
+          nested: {
+            path: field.subType!.nested!.path,
+            query,
+            score_mode: 'none',
+          },
+        };
+      }
+    };
+
+    if (field.scripted) {
+      return [] //don't support
+      // // Exists queries don't make sense for scripted fields
+      // if (!isExistsQuery) {
+      //   return [
+      //     ...accumulator,
+      //     {
+      //       script: {
+      //         ...getPhraseScript(field, value as any),
+      //       },
+      //     },
+      //   ];
+      // }
+    } else if (isExistsQuery) {
+      return [
+        ...accumulator,
+        wrapWithNestedQuery({
+          exists: {
+            field: field.name,
+          },
+        }),
+      ];
+    } else if (valueArg.type === 'wildcard') {
+      return [
+        ...accumulator,
+        wrapWithNestedQuery({
+          query_string: {
+            fields: [field.name],
+            query: wildcard.toQueryStringQuery(valueArg),
+          },
+        }),
+      ];
+    } else if (field.type === 'date') {
+      /*
+      If we detect that it's a date field and the user wants an exact date, we need to convert the query to both >= and <= the value provided to force a range query. This is because match and match_phrase queries do not accept a timezone parameter.
+      dateFormatTZ can have the value of 'Browser', in which case we guess the timezone using moment.tz.guess.
+    */
+      const timeZoneParam = config.dateFormatTZ
+        ? { time_zone: getTimeZoneFromSettings(config!.dateFormatTZ) }
+        : {};
+      return [
+        ...accumulator,
+        wrapWithNestedQuery({
+          range: {
+            [field.name]: {
+              gte: value,
+              lte: value,
+              ...timeZoneParam,
+            },
+          },
+        }),
+      ];
+    } else {
+      const queryType = type === 'phrase' ? 'match_phrase' : 'match';
+      return [
+        ...accumulator,
+        wrapWithNestedQuery({
+          [queryType]: {
+            [field.name]: value,
+          },
+        }),
+      ];
+    }
+  }, []);
+
+  return {
+    bool: {
+      should: queries || [],
+      minimum_should_match: 1,
+    },
+  };
+}

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

@@ -0,0 +1,63 @@
+/*
+ * 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 * as literal from '../node_types/literal';
+import { IIndexPattern, KueryNode } from '../../..';
+
+export function buildNodeParams(path: any, child: any) {
+  const pathNode =
+    typeof path === 'string' ? ast.fromLiteralExpression(path) : literal.buildNode(path);
+  return {
+    arguments: [pathNode, child],
+  };
+}
+
+export function toOpenSearchQuery(
+  node: KueryNode,
+  indexPattern?: IIndexPattern,
+  config: Record<string, any> = {},
+  context: Record<string, any> = {}
+) {
+  const [path, child] = node.arguments;
+  const stringPath = ast.toOpenSearchQuery(path);
+  const fullPath = context?.nested?.path ? `${context.nested.path}.${stringPath}` : stringPath;
+
+  return {
+    nested: {
+      path: fullPath,
+      query: ast.toOpenSearchQuery(child, indexPattern, config, {
+        ...context,
+        nested: { path: fullPath },
+      }),
+      score_mode: 'none',
+    },
+  };
+}

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

@@ -0,0 +1,53 @@
+/*
+ * 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(child: KueryNode) {
+  return {
+    arguments: [child],
+  };
+}
+
+export function toOpenSearchQuery(
+  node: KueryNode,
+  indexPattern?: IIndexPattern,
+  config: Record<string, any> = {},
+  context: Record<string, any> = {}
+) {
+  const [argument] = node.arguments;
+
+  return {
+    bool: {
+      must_not: ast.toOpenSearchQuery(argument, indexPattern, config, context),
+    },
+  };
+}

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

@@ -0,0 +1,56 @@
+/*
+ * 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: {
+      should: children.map((child: KueryNode) => {
+        return ast.toOpenSearchQuery(child, indexPattern, config, context);
+      }),
+      minimum_should_match: 1,
+    },
+  };
+}

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

@@ -0,0 +1,163 @@
+/*
+ * 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';
+import * as ast from '../ast';
+
+import { getFields } from './utils/get_fields';
+import { getTimeZoneFromSettings } from '../../utils';
+import { getFullFieldNameNode } from './utils/get_full_field_name_node';
+import { IIndexPattern, KueryNode, IFieldType } from '../../..';
+
+function pick(object: Record<string, any>, ...options: string[]) {
+  let out: Record<string, any> = {}
+  for (let op of options) {
+    out[op] = object[op]
+  }
+  return out
+}
+export function buildNodeParams(fieldName: string, params: any) {
+  const paramsToMap = pick(params, 'gt', 'lt', 'gte', 'lte', 'format');
+  const fieldNameArg =
+    typeof fieldName === 'string'
+      ? ast.fromLiteralExpression(fieldName)
+      : nodeTypes.literal.buildNode(fieldName);
+
+  const args = Object.entries(paramsToMap).map((input) => {
+    let [key, value]: [string, number | string] = input
+    return nodeTypes.namedArg.buildNode(key, value);
+  });
+
+  return {
+    arguments: [fieldNameArg, ...args],
+  };
+}
+
+export function toOpenSearchQuery(
+  node: KueryNode,
+  indexPattern?: IIndexPattern,
+  config: Record<string, any> = {},
+  context: Record<string, any> = {}
+) {
+  const [fieldNameArg, ...args] = node.arguments;
+  const fullFieldNameArg = getFullFieldNameNode(
+    fieldNameArg,
+    indexPattern,
+    context?.nested ? context.nested.path : undefined
+  );
+  const fields = indexPattern ? getFields(fullFieldNameArg, indexPattern) : [];
+  const namedArgs = extractArguments(args);
+  const queryParams = Object.fromEntries(Object.entries(namedArgs).map(([key, arg]) => {
+    return [key, ast.toOpenSearchQuery(arg as KueryNode)];
+  }));
+
+  // If no fields are found in the index pattern we send through the given field name as-is. We do this to preserve
+  // the behaviour of lucene on dashboards where there are panels based on different index patterns that have different
+  // fields. If a user queries on a field that exists in one pattern but not the other, the index pattern without the
+  // field should return no results. It's debatable whether this is desirable, but it's been that way forever, so we'll
+  // keep things familiar for now.
+  if (fields && fields.length === 0) {
+    fields.push({
+      name: (ast.toOpenSearchQuery(fullFieldNameArg) as unknown) as string,
+      scripted: false,
+      type: '',
+    });
+  }
+
+  const queries = fields!.map((field: IFieldType) => {
+    const wrapWithNestedQuery = (query: any) => {
+      // Wildcards can easily include nested and non-nested fields. There isn't a good way to let
+      // users handle this themselves so we automatically add nested queries in this scenario.
+      if (
+        !(fullFieldNameArg.type === 'wildcard') ||
+        !field.subType?.nested ||
+        context!.nested
+      ) {
+        return query;
+      } else {
+        return {
+          nested: {
+            path: field.subType!.nested!.path,
+            query,
+            score_mode: 'none',
+          },
+        };
+      }
+    };
+
+    if (field.scripted) {
+      return {} //Don't support this
+
+    } else if (field.type === 'date') {
+      const timeZoneParam = config.dateFormatTZ
+        ? { time_zone: getTimeZoneFromSettings(config!.dateFormatTZ) }
+        : {};
+      return wrapWithNestedQuery({
+        range: {
+          [field.name]: {
+            ...queryParams,
+            ...timeZoneParam,
+          },
+        },
+      });
+    }
+    return wrapWithNestedQuery({
+      range: {
+        [field.name]: queryParams,
+      },
+    });
+  });
+
+  return {
+    bool: {
+      should: queries,
+      minimum_should_match: 1,
+    },
+  };
+}
+
+function extractArguments(args: any) {
+  if ((args.gt && args.gte) || (args.lt && args.lte)) {
+    throw new Error('range ends cannot be both inclusive and exclusive');
+  }
+
+  const unnamedArgOrder = ['gte', 'lte', 'format'];
+
+  return args.reduce((acc: any, arg: any, index: number) => {
+    if (arg.type === 'namedArg') {
+      acc[arg.name] = arg.value;
+    } else {
+      acc[unnamedArgOrder[index]] = arg;
+    }
+
+    return acc;
+  }, {});
+}

package/src/components/query_bar/querylanguage/kuery/functions/utils/get_fields.ts

@@ -0,0 +1,49 @@
+/*
+ * 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 * as wildcard from '../../node_types/wildcard';
+import { KueryNode, IIndexPattern } from '../../../..';
+import { LiteralTypeBuildNode } from '../../node_types/types';
+
+export function getFields(node: KueryNode, indexPattern?: IIndexPattern) {
+  if (!indexPattern) return [];
+  if (node.type === 'literal') {
+    const fieldName = literal.toOpenSearchQuery(node as LiteralTypeBuildNode);
+    const field = indexPattern.fields.find((fld) => fld.name === fieldName);
+    if (!field) {
+      return [];
+    }
+    return [field];
+  } else if (node.type === 'wildcard') {
+    const fields = indexPattern.fields.filter((fld) => wildcard.test(node, fld.name));
+    return fields;
+  }
+}