API Gateway as DynamoDB non-proxy integration with Integration Response for variable Map returns - amazon-dynamodb

Question

Given an AWS Service integration (DynamoDB) in API Gateway, I'm wondering if there's a way to dynamically parse DynamoDB-structured JSON and return it in standard JSON format WITHOUT a standalone Lambda function mapper? For easier demonstration, here's an example of two possible data elements existing in my DynamoDB table I'd like to return in standard JSON format using a single Integration Response mapping template, if possible:
Ex. 1
{
"id": "1",
"desc": "here's a string type at depth 1",
"info": {
"key1": "a string at depth 2"
}
}
Ex. 2
{
"id": "2",
"desc": "here's a string type at depth 1",
"info": {
"key1": "a string at depth 2"
"key2": {
"subkey1": "look, a string at depth 3"
}
}
}
Based on these two examples, we can see these are nested data structures that share top-level keys, but have a variable number of nested tiers.
I've noted the following in all of the answers to questions regarding Integration Mapping Templates WITHOUT using a separate Lambda function to resolve the mapping:
Parsing Integration Response mapping templates for "flat" DynamoDB data -- e.g. something like this, where there's effectively a data depth of 1 since all elements in the data are basic types like S or N:
{
"param1": "some stuff",
"param2": "other stuff"
}
Any answers dealing with more complex data types like M presume the question writer knows without a doubt exactly what the DynamoDB table elements look like. So, they'll say something like 'create the mapping template for each of the layers with the appropriate, expected return type for that field.' Using Ex. 1 to illustrate a solution Integration Response mapping template:
#set($inputRoot = $input.path('$'))
{
"id": "$input.Item.id.S",
"desc": "$input.Item.desc.S",
"info": {
"key1": "$input.Item.info.M.key1.S"
}
}
Now, this works if we actually know what the expected DynamoDB result fields will be for every depth and how many tiers each table element has -- i.e., the data in a NoSQL table should be structured? Barring there being some version of the AppSync VTL resolver $util.dynamodb.toJSON method that can effectively unwrap dynamically-shaped DynamoDB returns, is there a way to do this directly without having to utilize a standalone Lambda function? Is there a way to generalize the response mapping template to account for variably-nested M type data?
One idea I've had is to loop through all of the keys and sending the M types to a secondary loop, but this seems impractical given:
the number of iterations that could theoretically be required to unwrap a deeply-nested object (DynamoDB can support up to 32 layers, last I checked), and
the variability in the nesting from element to element in the table.
To point 1, #foreach has a hard limit on the number of iterations it's capped at: 1000 https://forums.aws.amazon.com/thread.jspa?threadID=225222
I'm dubious as to the prospect of a non-Lambda solution, but still curious. Thoughts?