private getEntrySuggestions()

in web/frontend/src/app/shared/services/monaco-qql-config.service.ts [372:480]
99 lines of code
9 McCabe index (conditional complexity)

  private getEntrySuggestions(
    entry: string,
    stream: string,
    aliases: string[],
    range: IRange,
  ): Observable<CompletionItem[]> {
    if (['{limitExpression}', '{number}'].includes(entry)) {
      return of([]);
    }

    if (entry === QqlSequenceKeyWord.select) {
      return of([
        {
          label: QqlSequenceKeyWord.select,
          filterText: QqlSequenceKeyWord.select,
          kind: monaco.languages.CompletionItemKind.Snippet,
          insertText: `${QqlSequenceKeyWord.select} * FROM`,
          range,
        },
      ]);
    }

    if (entry.includes('({')) {
      const regExp = /(\(\{[a-z]+\}\))/g;
      const label = `${entry.replace(regExp, '')}()`.toUpperCase();
      const snippet = entry.replace(regExp, '(${1})').toUpperCase();
      return of([
        {
          label: label,
          filterText: label,
          kind: monaco.languages.CompletionItemKind.Snippet,
          insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
          insertText: snippet,
          range,
        },
      ]);
    }

    if (entry === '{stream}') {
      return this.getSteamsSuggestions(range);
    }

    if (entry === '{expressionList}') {
      const columns$ = stream ? this.getColumns(stream) : of([]);
      return combineLatest([
        columns$,
        this.getFunctions(),
        this.timeFormats(),
        this.globalFiltersService.getFilters(),
      ]).pipe(
        take(1),
        map(([cols, functions, timeFormats, filters]) => {
          const columns = [...cols, ...aliases].map((col) => ({
            label: col.split('.').pop().replace(/"/g, ''),
            filterText: col,
            kind: monaco.languages.CompletionItemKind.Field,
            insertText: col,
            range,
          }));

          const funcs = functions.map((func) => {
            const labelAppend = func.stateful ? '{}()' : '()';
            const insertAppend = func.stateful ? '{${1}}(${2})' : '(${1})';
            return {
              label: `${func.name}${labelAppend}`,
              filterText: `${func.name}`,
              kind: monaco.languages.CompletionItemKind.Function,
              insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
              insertText: `${func.name}${insertAppend}`,
              range,
            };
          });

          const timeFormatAutocomplete = timeFormats.map((format, formatIndex) => {
            const label = `'${format}'d`;
            let insertText = label;
            label.match(/(\{[a-z]+\})/gi).forEach((group, index) => {
              const fill = group.replace(/\{|\}/g, '');
              insertText = insertText.replace(group, `\${${index + 1}:${fill}}`);
            });

            const replaceTimeZone = (string) =>
              string.replace(/TIMEZONE/g, filters.timezone[0].name);

            return {
              label: replaceTimeZone(label),
              filterText: `'`,
              kind: monaco.languages.CompletionItemKind.Snippet,
              insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
              insertText: replaceTimeZone(insertText),
              range,
              sortText: this.numToSSColumn(formatIndex + 1),
            };
          });

          return [...columns, ...funcs, ...timeFormatAutocomplete];
        }),
      );
    }

    return of([
      {
        label: entry.toUpperCase(),
        kind: monaco.languages.CompletionItemKind.Keyword,
        insertText: entry.toUpperCase(),
        range: null,
      },
    ]);
  }