• Do not cast the malloc value. It serves no purpose, and may mask a serious problem.

• Allocating sizeof(TreeNode) assumes the knowledge of the type of resTree.root, and results in the double maintenance. A preferred idiom is malloc(sizeof(*resTree.root)).

• As written, the node tests for validity of its (future) children. It is more natural for the node to test its own validity:

  if (size == 0) {
      return NULL;
  }
  
  halfSize = size/2;
  if (arr[halfSize == -1) {
      return NULL;
  }
  
  resTree.root = malloc(sizeof(*resTree.root));
  resTree.root->data = data;
  resTree.root->left = BuildTreeFromArray(....).root;
  resTree.root->right = BuildTreeFromArray(....).root;
  
  return resTree;
  

• I don see a reason why TreeNode is wrapped into Tree. More context would be nice.

Avoid using recursive function calls in c (or similar languages)

The available calls stack memory will always be a limited resource, and won't fit for an arbitrary depth of function calls (and thus your tree size would be also limited).

You can always avoid using recursion by providing a dynamic stack data structure and an appropriate loop.

Fix your indentation and always use a clear scope

Your indentation is broken and the scope of statements is unclear at several places (my comments starting with !!!):

Tree BuildTreeFromArray(int  *arr, int  size)
{
    // ...
    if (size == 1)
    {
        // ...
    }
    else
    {
        halfSize = size / 2;
    resTree.root->data = arr[halfSize]; // !!! Should be indented according the enclosing scope block
    // ...
    if (arr[halfSize/2] != -1)
    {//we check if there's a valid array data we can input to the tree
       // ...
    }
    else // !!! Missing scope block
        resTree.root->left = NULL; 

    if (arr[halfSize + (halfSize / 2) + 1] != -1)
    {
       // ...
    }
    else // !!! Missing scope block
        resTree.root->right = NULL;

    }
    return resTree;
}

Here's the fully fixed version (I'm not sure that will provide exactly the same logic as you currently have it):

Tree BuildTreeFromArray(int  *arr, int  size)
{
    Tree resTree;
    Tree right;
    Tree left;
    resTree.root = (TreeNode*)malloc(sizeof(TreeNode));
    checkMemoryAllocation(resTree.root);
    int halfSize;

    if (size == 1)
    {
        resTree.root->data = arr[0];
        resTree.root->left = NULL;
        resTree.root->right = NULL;
    }
    else
    {
        halfSize = size / 2;
        resTree.root->data = arr[halfSize];

        if (arr[halfSize/2] != -1)
        {//we check if there's a valid array data we can input to the tree
            left = BuildTreeFromArray(arr, halfSize);
            resTree.root->left = left.root;
        }
        else
        {
            resTree.root->left = NULL;
        }
        if (arr[halfSize + (halfSize / 2) + 1] != -1)
        {
            right = BuildTreeFromArray(arr + halfSize + 1, halfSize);
            resTree.root->right = right.root;
        }
        else
        {
            resTree.root->right = NULL;
        }
    }
    return resTree;
}