DynamoDB LowerCamelCaseProperties for Nested Objects

[dguisinger]

Is there a way with Object Persistence Model to get [DynamoDBTable()] to also apply the LowerCamelCaseProperties conversions to nested objects being stored to DynamoDB?

Currently all my root level objects apply correctly, but all of the nested objects are still in upper camel case, which throws me off when I either use different SDKs or mix in AppSync and am expecting everything in lower camel case.

I currently have to break from recommended .NET class styling and code my other classes with lower case names

[klaytaybai]

Hi @dguisinger, I've asked a few of the team members about this, but there are lingering doubts and knowledge gaps among the people I asked and myself. To the best of my knowledge, it is not possible at the moment, but we could consider looking into it as a feature request. However, some concern was voiced that it may be a breaking change.

To help us understand your ask better, could you please provide a short example of what you are trying to do?

[dguisinger]

Sure,

Say I had the following:

[DynamoDBTable("clients",true)]
public class Client
{
  public string Name { get; set; }
  public string Foo { get; set; }
  public string Bar { get; set; }
  public Address BillingAddress { get; set; }
  public Address MailingAddress { get; set; }
}

public class Address 
{
  public string Line1 { get; set; }
  public string Line2 { get; set; }
... etc
}

will output something like this:

{
  "name": "xyz",
  "foo": "",
  "bar": "",
  "billingAddress": {
    "Line1": "12341243",
    "Line2": "xyzxyzxyz"
  }
}

In this case, the root level object is lower-cased, whereas the nested objects continue to use upper case property names.

When I create an AppSync schema or javascript code, I'm assuming everything is named consistently, and get a broken schema... in the case of AppSync, capitalization matters and won't return the address if I request "line1", "line2", etc.

So, I'm looking for a way to force consistency. I was curious if there was a way to avoid this w/o changing naming schema on my classes and without an SDK change, but it sounds like maybe there isn't something built in I can use to do so. I'm kind of surprised this hasn't been asked.

If you are looking for feature suggestions in a way that is non-breaking, I could suggest two different paths.

1. A new attribute could be created to add to nested classes that your serializer could watch for (this requires the developer to be proactively keeping track of all the object types being used by root objects stored to DynamoDB)
   or
2. Add an enumeration for property case sensitivity mode to the DynamoDBTable attribute.... if none is specified, use the existing LowerCamelCase property specifying True or False would pick the correct values for backwards compatibility... but you could add options such as:

• AsDeclared
• LowerCamelCaseOnRootObject
• LowerCamelCaseOnAllObjects
  etc

[justcoding121]

+1

I would like to have this feature out of the box. I use document model. What I do currently as a quick fix is less efficient, as I do an additional serialize/de-serialize call as below to solve this problem.

public static class DynamoDbExtensions
{
    private static JsonSerializerOptions options = new JsonSerializerOptions
    {
        PropertyNamingPolicy = new SnakeCaseNamingPolicy()
    };

    public static T FromSnakeCaseDocument<T>(this Document snakeCaseDocument) where T : new()
    {
        var json = snakeCaseDocument.ToJson();
        return JsonSerializer.Deserialize<T>(json, options);
    }

    public static Document ToSnakeCaseDocument<T>(this T @object) where T: new()
    {
        var serialized = JsonSerializer.Serialize(@object, options);
        return Document.FromJson(serialized);
    }
}

public class SnakeCaseNamingPolicy : JsonNamingPolicy
{
    public override string ConvertName(string str)
    {
        return string.Join(".", str.Split(".").Select(s => string.Concat(
                s.Select(
                    (x, i) => i > 0 && char.IsUpper(x)
                        ? "_" + x
                        : x.ToString()
                )
            ).ToLower()))
    }
}

[dcsena]

+1 to this as well. This is something the Java DynamoDB SDK supports via the DynamoDBDocument annotation. See: https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/DynamoDBMapper.Annotations.html#DynamoDBMapper.Annotations.DynamoDBDocument. There doesn't appear to be an equivalent for the .net sdk though.