I'm not a professional, but I guess the only way is to receive 1 byte at a time, and copy it to a ring buffer or other buffer that can store multiple messages (or 1 if you can handle one message fast enough).

Than you have two possibilities:

1. If it is easy to find out if the end of a message is received (for example when it ends with a certain value, or if you store the expected number of bytes so you can check against that value), than verify this in the interrupt, and set a Boolean. This Boolean can be checked in the main (non interrupt) code to process the message and clear the message. A ring buffer is ideal for this.

2. If it is not easy to find out the end of a message, than set a Boolean that a new byte has been received, and in the main code verify if a complete message is received, if so, execute it and delete it.

Pseudo code for possibility 1:

Global

volatile uint8_t ringBuffer[MAX_BUFFFER]; 
volatile uint8_t … // Additional variables to keep track of ring buffer space
volatile bool uartMessageCompleted = false;

Initially:

HAL_UART_Receive_IT(1 byte)

Callback:

void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart)
{
    Store byte in ring buffer
    HAL_UART_Receive_IT(1 byte)

    if (isCompleteUartMessageReceived())
    {
       uartMessageCompleted = true;
    }
}

bool isCompleteUartMessageReceived
{
    return true if a complete message is received
}

In Main (or a function called from main):

void main()
{
   …
   if (uartMessageCompleted )
   {
      excecuteUartMessage(); // Implement yourself
      remove message from ring buffer
   }
   …
}

Well,the best way is two buffers and FreeRTOS. The problem is that you may not receive one by one, but can get number of bytes at one time. So you need two buffers: "receive buffer" and "data buffer". Also you may need some kind of "clear buffer" to empty your others buffers. That is faster then empty buffer in cycle.

So.Let's see. I write example for STM32F303. First of all create a task for FreeRTOS in CubeMX, let it be consoleTaskHandle. Then add or edit in stm32f3xx_it.c:

/* Private includes -----------------------------------------------------*/
/* USER CODE BEGIN Includes */
#include "cmsis_os.h"
/* USER CODE END Includes */

//........................
//........................

/* USER CODE BEGIN EV */
extern osThreadId consoleTaskHandle;
/* USER CODE END EV */

//........................
//........................

/**
* @brief This function handles USART2 global interrupt
*/
void USART2_IRQHandler(void) {
    /* USER CODE BEGIN USART2_IRQn 0 */
    BaseType_t xHigherPriorityTaskWoken;
    xHigherPriorityTaskWoken = pdFALSE;

    vTaskNotifyGiveFromISR(consoleTaskHandle, &xHigherPriorityTaskWoken);

    portYIELD_FROM_ISR(xHigherPriorityTaskWoken);
    /* USER CODE END USART2_IRQn 0 */
    HAL_UART_IRQHandler(&huart2);
    /* USER CODE BEGIN USART2_IRQn 1 */

    /* USER CODE END USART2_IRQn 1 */
}

That means, that every time IT executes we will send notification to FreeRTOS task.

Now, let's write task to work with our recieved data. So main.c:

/* Private includes ----------------------------------------------------------*/
/* USER CODE BEGIN Includes */
#include <string.h>
#include <stdio.h>
/* USER CODE END Includes */

//........................
//........................

/* Private define ------------------------------------------------------------*/
/* USER CODE BEGIN PD */
/* USART */
#define USART_CONSOLE_BUFFER_SIZE ((uint8_t)64)
/* USER CODE END PD */

//........................
//........................

/* USER CODE BEGIN PV */
/* USART */
static const char emptyBuffer[USART_CONSOLE_BUFFER_SIZE] = {0x00};
char consoleRxBuffer[USART_CONSOLE_BUFFER_SIZE] = {0x00};
char consoleTxBuffer[USART_CONSOLE_BUFFER_SIZE] = {0x00};
/* USER CODE END PV */

//........................
//........................

/* USER CODE BEGIN Header_StartConsoleTask */
/**
* @brief Function implementing the consoleTask thread.
* @param argument: Not used
* @retval None
*/
/* USER CODE END Header_StartConsoleTask */
void StartConsoleTask(void const * argument) {
    /* USER CODE BEGIN StartConsoleTask */
    uint32_t ulNotifiedValue     = 0;
    static uint8_t rxBufferLen   = 0; /*!< Current RX buffer length */ 
    static uint8_t txBufferLen   = 0; /*!< Current TX buffer length */
    static uint8_t lastBufferLen = 0; /*!< Last RX buffer length */


    static bool gotCommand = false;  /*!< Recieved command flag */

    char command[USART_CONSOLE_BUFFER_SIZE] = {0x00}; /*!< Command buffer */

    if (HAL_UART_Receive_IT(&huart2, (uint8_t *)consoleRxBuffer, USART_CONSOLE_BUFFER_SIZE) != HAL_OK) {
        // Uart error handle
    }

    for (;;) {
        ulNotifiedValue = ulTaskNotifyTake(pdFALSE, (TickType_t) ULONG_MAX);

        // Got notification from IT
        if (ulNotifiedValue > 0) {
            // Let's check the RX buffer first
            rxBufferLen = strlen(consoleRxBuffer);

            if (rxBufferLen > 0) {
                // Let's send data back to console
                // or we gonna print data blindly
                if (rxBufferLen > lastBufferLen) {
                    /*
                        If the last symbol is '\r', then:
                            - Stop RX
                            - Send '\n' next
                            - Copy RX buffer to command buffer
                            - Empty RX buffer and start IT again
                            - Set 'GotCommand flag'
                        ELSE
                            - Simply send data back to cosole
                     */

                    // Count amount of data to send back
                    txBufferLen = rxBufferLen - lastBufferLen;

                    // Copy data from RX buffer to TX buffer
                    strncpy(consoleTxBuffer, &consoleRxBuffer[lastBufferLen], txBufferLen);
                    consoleTxBuffer[txBufferLen] = '\0';

                    if (consoleRxBuffer[rxBufferLen - 1] == '\r') {
                        gotCommand = true;

                        HAL_UART_AbortReceive_IT(&huart2);

                        consoleTxBuffer[txBufferLen] = '\n';
                        consoleTxBuffer[txBufferLen + 1] = '\0';

                        /* Copy command from RX buffer to command buffer */
                        // Let's trim spaces from the beginning
                        uint8_t commandStartPos = 0;

                        for (int i = 0; i < USART_CONSOLE_BUFFER_SIZE; ++i) {
                            if (consoleRxBuffer[0] == ' ') {
                                commandStartPos++;
                            } else {
                                break;
                            }
                        }

                        strncpy(command, &consoleRxBuffer[commandStartPos], strlen(consoleRxBuffer) - commandStartPos + 1);

                        /*
                            Empty RX buffer
                            I clean it by copying empty buffer to RX. That increases memory 
                            consumption, but works faster. You can do it in cycle.
                         */
                        strncpy(consoleRxBuffer, emptyBuffer, USART_CONSOLE_BUFFER_SIZE);

                        lastBufferLen = 0;

                        // Start the UART IT again
                        if (HAL_UART_Receive_IT(&huart2, (uint8_t *)consoleRxBuffer, USART_CONSOLE_BUFFER_SIZE) != HAL_OK) {
                            // Uart error handle
                        }

                    } else {
                        lastBufferLen = rxBufferLen;
                    }

                    // Send data back to console through UART DMA (you must turn it on in settings)
                    if (HAL_UART_Transmit_DMA(&huart2, (uint8_t *)consoleTxBuffer, strlen(consoleTxBuffer)) != HAL_OK) {
                        // Uart error handle
                    }

                    while (__HAL_UART_GET_FLAG(&huart2, UART_FLAG_TC) == RESET) {
                        vTaskDelay(1);
                    }
                }

                /* If we got command in last condition */
                if (gotCommand == true) {
                    gotCommand = false; // Reset flag

                    // Do some work with recieved command/data
                }
            }
        }
    }
}