Null String when inserting characters (C)

At least these problems:

Not a string

new_row[] is not a string as it lacks a null character. Later code relies on that.
Result: undefined behavior (UB).

char* new_row = (char*)malloc(sizeof(char) * (strlen(row->data) + 2));
if (idx < strlen(row->data)) {
  ...
} else {
    row->data[strlen(row->data)] = '\0';
    strncpy(new_row, row->data, strlen(row->data));
    // At this point `new_row[]` lacks a '\0'
    new_row[strlen(row->data)-1] = c;
}

It is unclear exactly what OP's wants in the else block, but I think it may be:

} else {
    size_t len = strlen(row->data);
    strcpy(new_row, row->data);
    new_row[len++] = c;
    new_row[len] = '\0';
}

Minor: conceptually wrong size

The below works OK because (sizeof(char) is 1.

char* data2 = (char*) malloc((sizeof(char) * strlen(data))+1);

But should be:

char* data2 = (char*) malloc(sizeof(char) * (strlen(data) + 1));

Even better, drop the unneeded cast and size to the referenced object, not the type.

char* data2 = malloc(sizeof *data2 * (strlen(data) + 1u));
// or
char* data2 = malloc(sizeof data2[0] * (strlen(data) + 1u));

Untested alternate code

typedef struct {
  char *data; // pointer to Malloc()'d char array.
  //int datalen;
  size_t datalen;
} Row;

// Row* insert_char(Row *row, int idx, char c) {
Row* insert_char(Row *row, size_t idx, char c) {
  assert(c != 0);  // Unclear what OP wants in this case

  //char *new_row = (char*) malloc(sizeof(char) * (strlen(row->data) + 2));
  // Why use strlen(row->data) when the length is in row->datalen ?
  // Since row->data was getting free'd later in OP's code,
  // let us just re-allocate instead and re-use the old row node.
  char *new_row = realloc(row->data, row->datalen + 2);
  assert(new_row); // TBD code to handle out-of-memory

  // When idx large, simply append
  if (idx > row->datalen) {
    idx = row->datalen;
  }

  // Shift the right side over 1
  memmove(new_row + idx + 1, new_row + idx, row->datalen - idx + 1);  // Moves \0 too
  new_row[idx] = c;

  row->data = new_row;
  row->datalen++;
  return row;
}

I tried the following code and it works (I modified certain things to print it directly and corrected some of your suggestions on how to call the function):

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

typedef struct {
    char* data; // pointer to Malloc()'d char array.
    int datalen;
} Row;

char* insert_char(Row* row, int idx, char c)
{
    char* new_row = (char*)malloc(sizeof(char) * (strlen(row->data) + 2)); // 1 char for null, char for the appended data
    if (idx < strlen(row->data)) {
        for (int i = 0; i < strlen(row->data)+1; i++) {
            if (i < idx) new_row[i] = row->data[i];
            if (i == idx) new_row[idx] = c;
            if (i > idx) new_row[i] = row->data[i-1];
        }
    } else {
        row->data[strlen(row->data)] = '\0';
        strncpy(new_row, row->data, strlen(row->data));
        new_row[strlen(row->data)-1] = c;
    }
    return new_row;
}


int main()
{
    printf("%s\n", insert_char(&(Row) {.data = "Hello", .datalen=5}, 2, 'A'));

    return 0;
}

However, I think that your problem is in the for where you need +2 instead of +1 in the ending condition (since you are copying the entire array and malloc doesn't necessarly set the last char as '\0' [although calloc could do that]).

Using some of your great ideas, I have come up with the following sample which uses calloc() to initialise a section of memory to 0. I believe my issue was in fact a missing NULL byte, and I have also cleaned things significantly. Here is my improved snippet:

Row* insert_char(Row* row, int idx, char* str)
{
    char* new_row = calloc(row->datalen + strlen(str) + 1, sizeof(char));
    strncpy(new_row, row->data, idx);
    strcat(new_row, str);
    strcat(new_row, row->data + idx);

    return resize_row(row, new_row);
}

NOTE: I have modified the input from a char to a char* because I plan to be inserting strings in the future, and not just single characters.

The same resize_row() method is used as in the original:

Row* resize_row(Row* oldrow, char* data)
{
    Row* new_row = (Row*) malloc(sizeof(Row));
    new_row->data = data;
    new_row->datalen = strlen(data);

    // free() the old row
    free(oldrow->data);
    free(oldrow);

    return new_row;
}