Fe/bugfix/ri 5681 search and query

redisinsight/ui/src/pages/workbench/components/query/Query/Query.tsx

@@ -1,4 +1,4 @@
-import React, { useContext, useEffect, useRef, useState } from 'react'
+import React, { useContext, useEffect, useMemo, useRef, useState } from 'react'
 import { useDispatch, useSelector } from 'react-redux'
 import { compact, first } from 'lodash'
 import cx from 'classnames'
@@ -32,7 +32,7 @@ import { addOwnTokenToArgs, findCurrentArgument, } from 'uiSrc/pages/workbench/u
 import { getRange, getRediSearchSignutureProvider, } from 'uiSrc/pages/workbench/utils/monaco'
 import { CursorContext } from 'uiSrc/pages/workbench/types'
 import { asSuggestionsRef, getCommandsSuggestions, isIndexComplete } from 'uiSrc/pages/workbench/utils/suggestions'
-import { COMMANDS_TO_GET_INDEX_INFO, COMPOSITE_ARGS, EmptySuggestionsIds, } from 'uiSrc/pages/workbench/constants'
+import { COMMANDS_TO_GET_INDEX_INFO, EmptySuggestionsIds, } from 'uiSrc/pages/workbench/constants'
 import { useDebouncedEffect } from 'uiSrc/services'
 import { fetchRedisearchInfoAction } from 'uiSrc/slices/browser/redisearch'
 import { findSuggestionsByArg } from 'uiSrc/pages/workbench/utils/searchSuggestions'
@@ -105,7 +105,16 @@ const Query = (props: Props) => {
   const { theme } = useContext(ThemeContext)
   const monacoObjects = useRef<Nullable<IEditorMount>>(null)
 
-  const REDIS_COMMANDS = commands.map((command) => ({ ...addOwnTokenToArgs(command.name!, command) }))
+  // TODO: need refactor to avoid this
+  const REDIS_COMMANDS = useMemo(
+    () => commands.map((command) => ({ ...addOwnTokenToArgs(command.name!, command) })),
+    [commands]
+  )
+
+  const COMPOSITE_ARGS = useMemo(() => commands
+    .filter((command) => command.name && command.name.includes(' '))
+    .map(({ name }) => name),
+  [commands])
 
   const { instanceId = '' } = useParams<{ instanceId: string }>()
 
@@ -328,7 +337,13 @@ const Query = (props: Props) => {
       return
     }
 
-    const command = findCompleteQuery(model, e.position, REDIS_COMMANDS_SPEC, REDIS_COMMANDS_ARRAY, COMPOSITE_ARGS)
+    const command = findCompleteQuery(
+      model,
+      e.position,
+      REDIS_COMMANDS_SPEC,
+      REDIS_COMMANDS_ARRAY,
+      COMPOSITE_ARGS as string[]
+    )
     handleSuggestions(editor, command)
     handleDslSyntax(e, command)
   }
@@ -538,11 +553,11 @@ const Query = (props: Props) => {
     if (position.column === 1) {
       helpWidgetRef.current.isOpen = false
       if (command) return asSuggestionsRef([])
-      return asSuggestionsRef(getCommandsSuggestions(REDIS_COMMANDS, range), false)
+      return asSuggestionsRef(getCommandsSuggestions(commands, range), false, false)
     }
 
     if (!command) {
-      return asSuggestionsRef(getCommandsSuggestions(REDIS_COMMANDS, range), false)
+      return asSuggestionsRef(getCommandsSuggestions(commands, range), false)
     }
 
     const { allArgs, args, cursor } = command
@@ -568,7 +583,8 @@ const Query = (props: Props) => {
       helpWidgetRef.current = {
         isOpen,
         parent: parent || helpWidgetRef.current.parent,
-        currentArg: currentArg || helpWidgetRef.current.currentArg }
+        currentArg: currentArg || helpWidgetRef.current.currentArg
+      }
     }
 
     return suggestions

redisinsight/ui/src/pages/workbench/components/query/QueryWrapper.tsx

@@ -1,4 +1,4 @@
-import React, { useEffect } from 'react'
+import React, { useEffect, useMemo } from 'react'
 import { useDispatch, useSelector } from 'react-redux'
 import { EuiLoadingContent } from '@elastic/eui'
 
@@ -40,7 +40,10 @@ const QueryWrapper = (props: Props) => {
   const { data: indexes = [] } = useSelector(redisearchListSelector)
   const { spec: COMMANDS_SPEC } = useSelector(appRedisCommandsSelector)
 
-  const REDIS_COMMANDS = mergeRedisCommandsSpecs(COMMANDS_SPEC, SEARCH_COMMANDS_SPEC)
+  const REDIS_COMMANDS = useMemo(
+    () => mergeRedisCommandsSpecs(COMMANDS_SPEC, SEARCH_COMMANDS_SPEC),
+    [COMMANDS_SPEC, SEARCH_COMMANDS_SPEC]
+  )
 
   const dispatch = useDispatch()
 

redisinsight/ui/src/pages/workbench/constants.ts

@@ -83,14 +83,6 @@ export const COMMANDS_WITHOUT_INDEX_PROPOSE = [
   'FT.CREATE'
 ]
 
-export const COMPOSITE_ARGS = [
-  'LOAD *',
-  'FT.CONFIG GET',
-  'FT.CONFIG SET',
-  'FT.CURSOR DEL',
-  'FT.CURSOR READ',
-]
-
 export enum DefinedArgumentName {
   index = 'index',
   query = 'query',

redisinsight/ui/src/pages/workbench/utils/helpers.ts

@@ -0,0 +1,17 @@
+import { ICommandTokenType, IRedisCommand } from 'uiSrc/constants'
+import { Maybe } from 'uiSrc/utils'
+
+export const isStringsEqual = (str1?: string, str2?: string) => str1?.toLowerCase() === str2?.toLowerCase()
+
+export const isTokenEqualsArg = (token: IRedisCommand, arg: string) => {
+  if (token.type === ICommandTokenType.OneOf) {
+    return token.arguments
+      ?.some((oneOfArg: IRedisCommand) => isStringsEqual(oneOfArg?.token, arg))
+  }
+  if (isStringsEqual(token.token, arg)) return true
+  if (token.type === ICommandTokenType.Block) return isStringsEqual(token.arguments?.[0]?.token, arg)
+  return false
+}
+
+export const findArgByToken = (list: IRedisCommand[], arg: string): Maybe<IRedisCommand> =>
+  list.find((command) => isTokenEqualsArg(command, arg))

redisinsight/ui/src/pages/workbench/utils/query.ts

@@ -3,6 +3,7 @@
 import { findLastIndex, isNumber, toNumber } from 'lodash'
 import { generateArgsNames, Maybe, Nullable } from 'uiSrc/utils'
 import { CommandProvider, IRedisCommand, IRedisCommandTree, ICommandTokenType } from 'uiSrc/constants'
+import { isStringsEqual } from './helpers'
 import { ArgName, FoundCommandArgument } from '../types'
 
 export const findCurrentArgument = (
@@ -20,8 +21,7 @@ export const findCurrentArgument = (
       return findCurrentArgument(currentArg.arguments, prev.slice(i), prev, currentWithParent)
     }
 
-    const tokenIndex = args.findIndex((cArg) =>
-      cArg.token?.toLowerCase() === arg.toLowerCase())
+    const tokenIndex = args.findIndex((cArg) => isStringsEqual(cArg.token, arg))
     const token = args[tokenIndex]
 
     if (token) {
@@ -79,9 +79,9 @@ const findStopArgumentInQuery = (
     }
 
     if (!isBlockedOnCommand && currentCommandArg?.optional) {
-      const isNotToken = currentCommandArg?.token && currentCommandArg.token !== arg.toUpperCase()
+      const isNotToken = currentCommandArg?.token && !isStringsEqual(currentCommandArg.token, arg)
       const isNotOneOfToken = !currentCommandArg?.token && currentCommandArg?.type === ICommandTokenType.OneOf
-        && currentCommandArg?.arguments?.every(({ token }) => token !== arg.toUpperCase())
+        && currentCommandArg?.arguments?.every(({ token }) => !isStringsEqual(token, arg))
 
       if (isNotToken || isNotOneOfToken) {
         moveToNextCommandArg()
@@ -99,8 +99,8 @@ const findStopArgumentInQuery = (
         blockArguments = Array(nArgs).fill(currentCommandArg.arguments).flat()
       }
 
-      const currentQueryArg = queryArgs.slice(i)?.[0]?.toUpperCase()
-      const isBlockHasToken = blockArguments?.[0]?.token === currentQueryArg
+      const currentQueryArg = queryArgs.slice(i)?.[0]
+      const isBlockHasToken = isStringsEqual(blockArguments?.[0]?.token, currentQueryArg)
 
       if (currentCommandArg.token && !isBlockHasToken && currentQueryArg) {
         blockArguments.unshift({
@@ -132,7 +132,7 @@ const findStopArgumentInQuery = (
     }
 
     // if we are on token - that requires one more argument
-    if (currentCommandArg?.token === arg.toUpperCase()) {
+    if (isStringsEqual(currentCommandArg?.token, arg)) {
       blockCommand()
       continue
     }
@@ -153,7 +153,7 @@ const findStopArgumentInQuery = (
 
     if (currentCommandArg?.type === ICommandTokenType.OneOf && currentCommandArg?.optional) {
       // if oneof is optional then we can switch to another argument
-      if (!currentCommandArg?.arguments?.some(({ token }) => token === arg)) {
+      if (!currentCommandArg?.arguments?.some(({ token }) => isStringsEqual(token, arg))) {
         moveToNextCommandArg()
       }
 
@@ -303,7 +303,7 @@ export const getAllRestArguments = (
   const currentToken = current?.type === ICommandTokenType.Block ? current?.arguments?.[0].token : current?.token
   const lastTokenIndex = findLastIndex(
     untilTokenArgs,
-    (arg) => arg?.toLowerCase() === currentToken?.toLowerCase()
+    (arg) => isStringsEqual(arg, currentToken)
   )
   const currentLvlNextArgs = removeNotSuggestedArgs(
     untilTokenArgs.slice(lastTokenIndex > 0 ? lastTokenIndex : 0),
@@ -331,7 +331,7 @@ export const removeNotSuggestedArgs = (args: string[], commandArgs: IRedisComman
     if (arg.type === ICommandTokenType.OneOf) {
       return !args
         .some((queryArg) => arg.arguments
-          ?.some((oneOfArg) => oneOfArg.token?.toUpperCase() === queryArg.toUpperCase()))
+          ?.some((oneOfArg) => isStringsEqual(oneOfArg.token, queryArg)))
     }
 
     if (arg.type === ICommandTokenType.Block) {
@@ -373,8 +373,8 @@ export const fillArgsByType = (args: IRedisCommand[], expandBlock = true): IRedi
 export const findArgByToken = (list: IRedisCommand[], arg: string): Maybe<IRedisCommand> =>
   list.find((cArg) =>
     (cArg.type === ICommandTokenType.OneOf
-      ? cArg.arguments?.some((oneOfArg: IRedisCommand) => oneOfArg?.token?.toLowerCase() === arg?.toLowerCase())
-      : cArg.arguments?.[0]?.token?.toLowerCase() === arg?.toLowerCase()))
+      ? cArg.arguments?.some((oneOfArg: IRedisCommand) => isStringsEqual(oneOfArg?.token, arg))
+      : isStringsEqual(cArg.arguments?.[0].token, arg)))
 
 export const generateDetail = (command: Maybe<IRedisCommand>) => {
   if (!command) return ''

redisinsight/ui/src/pages/workbench/utils/query_refactor.ts

@@ -0,0 +1,71 @@
+/* eslint-disable no-continue */
+import { ICommandTokenType, IRedisCommand } from 'uiSrc/constants'
+import { Maybe } from 'uiSrc/utils'
+import { isStringsEqual, isTokenEqualsArg } from './helpers'
+
+interface BlockTokensTree {
+  queryArgs: string[]
+  command?: IRedisCommand
+  parent?: BlockTokensTree
+}
+
+export const findSuggestionsByQueryArgs = (
+  commands: IRedisCommand[],
+  queryArgs: string[],
+) => {
+  const firstQueryArg = queryArgs[0]
+  const scopeCommand = firstQueryArg
+    ? commands.find((command) => isStringsEqual(command.token, firstQueryArg))
+    : undefined
+
+  const getLastBlock = (
+    args: string[],
+    command?: IRedisCommand,
+    parent?: any,
+  ): BlockTokensTree => {
+    for (let i = args.length - 1; i >= 0; i--) {
+      const arg = args[i]
+      const currentArg = findArgByToken(command?.arguments || [], arg)
+
+      if (currentArg?.type === ICommandTokenType.Block) {
+        return getLastBlock(args.slice(i), currentArg, { queryArgs: queryArgs.slice(i), command: currentArg, parent })
+      }
+    }
+
+    return parent
+  }
+
+  const blockToken: BlockTokensTree = { queryArgs: queryArgs.slice(scopeCommand ? 1 : 0), command: scopeCommand }
+  const currentBlock = getLastBlock(queryArgs, scopeCommand, blockToken)
+  const stopArgument = findStopArgumentWithSuggestions(currentBlock)
+
+  console.log(stopArgument)
+
+  return null
+}
+
+const getStopArgument = (
+  queryArgs: string[],
+  command: Maybe<IRedisCommand>
+) => {
+  let currentCommandArgIndex = 0
+
+  for (let i = 0; i < queryArgs.length; i++) {
+    const arg = queryArgs[i]
+    const currentCommandArg = command?.arguments?.[currentCommandArgIndex]
+
+    currentCommandArgIndex++
+  }
+
+  return null
+}
+
+const findStopArgumentWithSuggestions = (currentBlock: BlockTokensTree) => {
+  console.log(currentBlock)
+  const stopArgument = getStopArgument(currentBlock.queryArgs, currentBlock.command)
+
+  return null
+}
+
+const findArgByToken = (list: IRedisCommand[], arg: string): Maybe<IRedisCommand> =>
+  list.find((command) => isTokenEqualsArg(command, arg))

redisinsight/ui/src/pages/workbench/utils/searchSuggestions.ts

@@ -182,7 +182,7 @@ const handleCommonSuggestions = (
   const shouldHideSuggestions = isCursorInQuotes || nextCursorChar || (prevCursorChar && isEscaped)
   if (shouldHideSuggestions) {
     return {
-      helpWidget: { isOpen: true, parent: foundArg?.parent, currentArg: foundArg?.stopArg },
+      helpWidget: { isOpen: !!foundArg, parent: foundArg?.parent, currentArg: foundArg?.stopArg },
       suggestions: asSuggestionsRef([])
     }
   }

redisinsight/ui/src/pages/workbench/utils/tests/query.spec.ts

@@ -2,7 +2,6 @@ import { SearchCommand, TokenType } from 'uiSrc/pages/search/types'
 import { Maybe, splitQueryByArgs } from 'uiSrc/utils'
 import { MOCKED_REDIS_COMMANDS } from 'uiSrc/mocks/data/mocked_redis_commands'
 import { IRedisCommand } from 'uiSrc/constants'
-import { COMPOSITE_ARGS } from 'uiSrc/pages/workbench/constants'
 import {
   commonfindCurrentArgumentCases,
   findArgumentftAggreageTests,
@@ -16,6 +15,9 @@ const COMMANDS = Object.keys(MOCKED_REDIS_COMMANDS).map((name) => ({
   name,
   ...MOCKED_REDIS_COMMANDS[name]
 }))
+const COMPOSITE_ARGS = COMMANDS
+  .filter((command) => command.name && command.name.includes(' '))
+  .map(({ name }) => name)
 
 describe('findCurrentArgument', () => {
   describe('with list of commands', () => {