New CreateTransactWrite method enforces version check

[albert-vives]

Describe the bug

DynamoDB has undergone a lot of changes in the version 4 of the SDK, including separating the shared DynamoDBOperationConfig into new operation-specific objects (SaveConfig, LoadConfig, QueryConfig, etc.). See: #3421

The method IDynamoDBContext.CreateTransactWrite<T>(DynamoDBOperationConfig) is now marked as obsolete, and the suggested replacement is IDynamoDBContext.CreateTransactWrite<T>(TransactWriteConfig).

The new TransactWriteConfig doesn't have property SkipVersionCheck that the generic config class has, forcing it to have the default value false. This can cause conditional checks to fail when executing the transaction.

Regression Issue

• Select this option if this issue appears to be a regression.

Expected Behavior

Creating a transact write with disabled version check should be possible:

var updateTransaction = dbContext.CreateTransactWrite<Entity>(new TransactWriteConfig
{
    SkipVersionCheck = true
});

Current Behavior

The SkipVersionCheck property is not available:

var transaction = dbContext.CreateTransactWrite<Entity>(new TransactWriteConfig
{
    SkipVersionCheck = true // <-- Error
});

Using the obsolete method works:

var transaction = dbContext.CreateTransactWrite<Entity>(new DynamoDBOperationConfig
{
    SkipVersionCheck = true
}); // <-- Warning method obsolete

transaction.AddSaveItem(entity);

await transaction.ExecuteAsync(ct); // <-- Works

Reproduction Steps

var transaction = dbContext.CreateTransactWrite<Entity>();

transaction.AddSaveItem(entity); // <-- Item with wrong version

await transaction.ExecuteAsync(ct); // <-- Throws TransactionCanceledException with reason ConditionalCheckFailed

Possible Solution

Add the property SkipVersionCheck to the TransactWriteConfig class, and map it to the property with the same name in the method TransactWriteConfig.ToDynamoDBOperationConfig().

Additional Information/Context

No response

AWS .NET SDK and/or Package version used

AWSSDK.DynamoDBv2 4.0.10.4

Targeted .NET Platform

.NET Core 8

Operating System and version

Windows 11, AWS Lambda

[ashishdhingra]

@albert-vives Good morning. Thanks for opening the issue. The obsolete message 'IDynamoDBContext.CreateTransactWrite<T>(DynamoDBOperationConfig)' is obsolete: 'Use the CreateTransactWrite overload that takes TransactWriteConfig instead, since DynamoDBOperationConfig contains properties that are not applicable to CreateTransactWrite.' indicates that DynamoDBOperationConfig contains properties that are not applicable to CreateTransactWrite. SkipVersionCheck property is a common property that is not only used in CreateTransactWrite, but also in non-transactional scenarios.

If we try to explicitly create new instance of new DynamoDBContext(new AmazonDynamoDBClient()), it also gives obsolete message that 'DynamoDBContext.DynamoDBContext(IAmazonDynamoDB)' is obsolete: 'Use the DynamoDBContextBuilder to construct a DynamoDBContext with the recommended configuration.'.

So as a workaround, you could refactor your code to use DynamoDBContextBuilder. Below is the complete example that demonstrates use of DynamoDBContextBuilder:

using Amazon;
using Amazon.DynamoDBv2;
using Amazon.DynamoDBv2.DataModel;

var dynamoTransactionService = new TransactionService(new AmazonDynamoDBClient(RegionEndpoint.USWest2));
await dynamoTransactionService.UpdateProductStatusAsync($"testproduct");

[DynamoDBTable("Products")]
public class Product
{
    [DynamoDBHashKey]
    public string Id { get; set; }

    [DynamoDBVersion]
    public int? Version { get; set; }

    public string Status { get; set; }
}

public class TransactionService
{
    private readonly IDynamoDBContext _context;

    public TransactionService(IAmazonDynamoDB client)
    {
        // Modern initialization using the Builder (non-obsolete)
        _context = new DynamoDBContextBuilder()
            .WithDynamoDBClient(() => client)
            .ConfigureContext(config =>
            {
                // PREVENTS background DescribeTable calls (Performance)
                config.DisableFetchingTableMetadata = true;

                // GLOBALLY skips version checks for all operations in this context
                config.SkipVersionCheck = true;
            })
            .Build();
    }

    public async Task UpdateProductStatusAsync(string productId)
    {
        // Create the transaction
        var tx = _context.CreateTransactWrite<Product>();

        // Even though Product has a [DynamoDBVersion] property,
        // this 'Save' will NOT check the version because of SkipVersionCheck
        tx.AddSaveItem(new Product { Id = productId, Status = "Transacted" });

        try
        {
            await tx.ExecuteAsync();
            Console.WriteLine("Transaction completed without version checks.");
        }
        catch (Exception ex)
        {
            Console.WriteLine($"Transaction failed: {ex.Message}");
        }
    }
}

Please let me know if it works for you.

Thanks,
Ashish

[albert-vives]

Hi @ashishdhingra,

That's the only operation where we want to disable version check, so being able to disable it at operation level would be the ideal solution. But having two contexts, one with version enabled and one disabled, it's not a bad idea, I'll consider that. Thanks.

For now, we're using the obsolete method and just disabled the warning.

Like you said, the SkipVersionCheck property is a common property used in multiple scenarios, not just CreateTransactWrite, but other configuration objects do have it (for example SaveConfig). #3421 was meant to remove properties that were not applicable to specific operations, but this one is applicable so in my opinion this is still a bug.