Version 1.34.2 | Production Ready | Unreal Engine 5.5+
The Supabase UE5 Plugin provides robust, thread-safe JSON handling capabilities through the UAsyncParseJSON class and integrated JSON processing across all async operations. This system ensures reliable data serialization, parsing, and validation for all Supabase interactions.
The main JSON parsing engine providing:
All async operations (UAsyncInsertRow, UAsyncUpdateRow, UAsyncQuery, etc.) include:
FJsonObjectWrapper usage across all operations// C++ Example - Parse JSON String
UAsyncParseJSON* ParseTask = UAsyncParseJSON::ParseJSONAsync(
this,
TEXT("{\"name\":\"John\",\"level\":42}"),
nullptr
);
ParseTask->OnSuccess.AddDynamic(this, &AMyActor::OnJSONParseSuccess);
ParseTask->OnFailure.AddDynamic(this, &AMyActor::OnJSONParseFailure);
ParseTask->Activate();
// C++ Example - Strict Validation
UAsyncParseJSON* StrictParseTask = UAsyncParseJSON::ParseJSONValidatedAsync(
this,
JSONString,
EJSONValidationLevel::Strict,
UMyStruct::StaticStruct()
);
StrictParseTask->OnStructSuccess.AddDynamic(this, &AMyActor::OnStructParseSuccess);
StrictParseTask->Activate();
// C++ Example - Parse JSON Array
UAsyncParseJSON* ArrayParseTask = UAsyncParseJSON::ParseJSONWithModeAsync(
this,
TEXT("[{\"id\":1},{\"id\":2}]"),
EJSONParseMode::Array,
nullptr
);
ArrayParseTask->OnArraySuccess.AddDynamic(this, &AMyActor::OnArrayParseSuccess);
ArrayParseTask->Activate();
// Configure memory limits
Node->MaxJSONSize = 10 * 1024 * 1024; // 10MB limit
Node->MaxElements = 1000; // Array element limit
Node->MaxDepth = 100; // Nesting depth limit
Node->MaxParsingTime = 5.0f; // Timeout in seconds
The system provides detailed error reporting for common JSON issues:
void AMyActor::OnJSONParseFailure(const FString& Error)
{
UE_LOG(LogTemp, Warning, TEXT("JSON Parse Failed: %s"), *Error);
// Implement fallback logic
if (Error.Contains(TEXT("size exceeds")))
{
// Handle large JSON case
ProcessInChunks();
}
else if (Error.Contains(TEXT("Unbalanced")))
{
// Handle malformed JSON
RequestDataRefresh();
}
}
All Supabase operations automatically handle JSON serialization:
// Row data is automatically serialized to JSON
TMap<FString, FString> RowData;
RowData.Add(TEXT("name"), TEXT("John Doe"));
RowData.Add(TEXT("score"), TEXT("1250"));
UAsyncInsertRow* InsertTask = UAsyncInsertRow::InsertRowAsync(
this,
TEXT("players"),
RowData
);
// JSON is automatically generated: {"name":"John Doe","score":"1250"}
Supabase responses are automatically parsed with fallback handling:
// In AsyncInsertRow::HandleResponse()
if (FJsonSerializer::Deserialize(Reader, JsonObject) && JsonObject.IsValid())
{
// Parse as object
FJsonObjectWrapper Wrapper;
Wrapper.JsonObject = JsonObject;
HandleInsertSuccess(ResponseContent, Wrapper);
}
else if (FJsonSerializer::Deserialize(ArrayReader, JsonArray))
{
// Parse as array - wrap in object for consistency
TSharedPtr<FJsonObject> WrappedObject = MakeShared<FJsonObject>();
WrappedObject->SetArrayField(TEXT("data"), JsonArray);
FJsonObjectWrapper Wrapper;
Wrapper.JsonObject = WrappedObject;
HandleInsertSuccess(ResponseContent, Wrapper);
}
else
{
// Fallback - still report success with raw response
FJsonObjectWrapper EmptyWrapper;
HandleInsertSuccess(ResponseContent, EmptyWrapper);
}
SafeCleanup() ensures no memory leaksThe paranoid validation level checks for:
| Component | Requirement |
|---|---|
| Unreal Engine | 5.5.0+ |
| Platforms | Win64, Mac, Linux, Android, iOS |
| Dependencies | Core, JSON, HTTP |
| Memory | Configurable (10MB default) |
“JSON size exceeds maximum”
MaxJSONSize or process data in chunks“Unbalanced braces/brackets”
“JSON depth exceeds maximum”
MaxDepth or flatten data structureParsing timeout
MaxParsingTime for complex dataEnable verbose logging to track JSON operations:
UE_LOG(LogTemp, Verbose, TEXT("JSON Payload: %s"), *JsonString);
UE_LOG(LogTemp, Display, TEXT("JSON Parse Success: %d elements"), ElementCount);
Next Steps: