Version 1.6.1 | 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:
The USupabaseJsonObjectWrapper provides Blueprint-friendly typed access to JSON fields, avoiding manual string parsing.
| Method | Returns | Description |
|---|---|---|
GetStringField(FString Key) |
FString | Get a string value by key |
GetIntField(FString Key) |
int32 | Get an integer value by key |
GetBoolField(FString Key) |
bool | Get a boolean value by key |
GetObjectField(FString Key) |
USupabaseJsonObjectWrapper* | Get a nested object as wrapper |
GetArrayField(FString Key) |
TArray<USupabaseJsonObjectWrapper*> | Get a JSON array as wrapper array |
| Method | Description |
|---|---|
SetStringField(FString Key, FString Value) |
Set a string field |
SetIntField(FString Key, int32 Value) |
Set an integer field |
SetBoolField(FString Key, bool Value) |
Set a boolean field |
SetArrayField(FString Key, TArray Value) |
Set an array field |
SetObjectField(FString Key, UObject* Value) |
Set a nested object field |
| Method | Description |
|---|---|
PrettifyJson() |
Return formatted/indented JSON string |
AsyncParseJSON -> On Success (JsonObject)
-> JsonObject.GetStringField("name") -> "Player1"
-> JsonObject.GetIntField("score") -> 1500
-> JsonObject.GetBoolField("is_active") -> true
-> JsonObject.PrettifyJson() -> Formatted string for debugging
Async Blueprint node for parsing JSON strings with validation.
| Method | Description |
|---|---|
ParseJSONValidatedAsync(String) |
Parse with validation enabled |
ParseJSONArrayAsync(String) |
Parse as JSON array |
ParseJSONWithSchemaAsync(String, Schema) |
Parse against a JSON schema |
| Mode | Description |
|---|---|
| Standard | Parse JSON with basic validation |
| Strict | Enforce strict JSON spec compliance |
| Lenient | Allow trailing commas, comments, etc. |
| Level | Description |
|---|---|
| None | No validation, parse only |
| Basic | Check for required fields |
| Full | Deep validation against schema |
Convert JSON data into a UPrimaryDataAsset for use as game data.
Parse To Data Asset Async
- JSON String: FString
- Data Asset Class: TSubclassOf<UPrimaryDataAsset>
-> On Success: UPrimaryDataAsset*
-> On Error: FString
This is useful for loading configuration data from Supabase and converting it to Unreal's data asset system for use in gameplay.