Add TransactWriteItems

Author: bartelink

RELEASE_NOTES.md

@@ -1,3 +1,7 @@
+### 0.11.0-beta
+* Added `Precondition.CheckFailed`
+* Added `TableContext.TransactWriteItems`, `TransactWrite` DU, `TransactWriteItemsRequest.TransactionCanceledConditionalCheckFailed`
+
 ### 0.10.1-beta
 * Fixed accidentally removed/renamed legacy factory methods (`TableContext.Create`/`TableContext.CreateAsync`) 
 

global.json

@@ -1,6 +1,6 @@
 {
   "sdk": {
-    "version": "6.0.201",
+    "version": "6.0.202",
     "rollForward": "latestMajor"
   }
 }

src/FSharp.AWS.DynamoDB/TableContext.fs

@@ -183,7 +183,7 @@ module internal Provisioning =
         run (client, tableName, template) None
 
 /// Represents the operation performed on the table, for metrics collection purposes
-type Operation = GetItem | PutItem | UpdateItem | DeleteItem | BatchGetItems | BatchWriteItems | Scan | Query
+type Operation = GetItem | PutItem | UpdateItem | DeleteItem | BatchGetItems | BatchWriteItems | TransactWriteItems | Scan | Query
 
 /// Represents metrics returned by the table operation, for plugging in to an observability framework
 type RequestMetrics =
@@ -209,6 +209,57 @@ type private LimitType = All | Default | Count of int
     static member AllOrCount (l : int option) = l |> Option.map Count |> Option.defaultValue All
     static member DefaultOrCount (l : int option) = l |> Option.map Count |> Option.defaultValue Default
 
+/// <summary>Represents an individual request that can be included in the <c>TransactItems</c> of a <c>TransactWriteItems</c> call.</summary>
+[<RequireQualifiedAccess>]
+type TransactWrite<'TRecord> =
+    /// Specify a Check to be run on a specified item.
+    /// If the condition does not hold, the overall TransactWriteItems request will be Canceled.
+    | Check  of key : TableKey  * condition : ConditionExpression<'TRecord>
+    /// Specify a PutItem operation to be performed, inserting or replacing an item in the Table.
+    /// If the (optional) precondition does not hold, the overall TransactWriteItems request will be Canceled.
+    | Put    of item : 'TRecord * precondition : ConditionExpression<'TRecord> option
+    /// Specify an UpdateItem operation to be performed, applying an updater expression on the item identified by the specified `key`, if it exists.
+    /// If the item exists and the (optional) precondition does not hold, the overall TransactWriteItems request will be Canceled.
+    | Update of key : TableKey  * precondition : ConditionExpression<'TRecord> option   * updater : UpdateExpression<'TRecord>
+    /// Specify a DeleteItem operation to be performed, removing the item identified by the specified `key` if it exists.
+    /// If the item exists and the (optional) precondition does not hold, the overall TransactWriteItems request will be Canceled.
+    | Delete of key : TableKey  * precondition : ConditionExpression<'TRecord> option
+
+/// Helpers for building a <c>TransactWriteItemsRequest</c> to supply to <c>TransactWriteItems</c>
+module TransactWriteItemsRequest =
+
+    let private toTransactWriteItem<'TRecord> tableName (template : RecordTemplate<'TRecord>) : TransactWrite<'TRecord> -> TransactWriteItem = function
+        | TransactWrite.Check (key, cond) ->
+            let req = ConditionCheck(TableName = tableName, Key = template.ToAttributeValues key)
+            let writer = AttributeWriter(req.ExpressionAttributeNames, req.ExpressionAttributeValues)
+            req.ConditionExpression <- cond.Conditional.Write writer
+            TransactWriteItem(ConditionCheck = req)
+        | TransactWrite.Put (item, maybeCond) ->
+            let req = Put(TableName = tableName, Item = template.ToAttributeValues item)
+            maybeCond |> Option.iter (fun cond ->
+                let writer = AttributeWriter(req.ExpressionAttributeNames, req.ExpressionAttributeValues)
+                req.ConditionExpression <- cond.Conditional.Write writer)
+            TransactWriteItem(Put = req)
+        | TransactWrite.Update (key, maybeCond, updater) ->
+            let req = Update(TableName = tableName, Key = template.ToAttributeValues key)
+            let writer = AttributeWriter(req.ExpressionAttributeNames, req.ExpressionAttributeValues)
+            req.UpdateExpression <- updater.UpdateOps.Write(writer)
+            maybeCond |> Option.iter (fun cond -> req.ConditionExpression <- cond.Conditional.Write writer)
+            TransactWriteItem(Update = req)
+        | TransactWrite.Delete (key, maybeCond) ->
+            let req = Delete(TableName = tableName, Key = template.ToAttributeValues key)
+            maybeCond |> Option.iter (fun cond ->
+                let writer = AttributeWriter(req.ExpressionAttributeNames, req.ExpressionAttributeValues)
+                req.ConditionExpression <- cond.Conditional.Write writer)
+            TransactWriteItem(Delete = req)
+    let internal toTransactItems<'TRecord> tableName template items = Seq.map (toTransactWriteItem<'TRecord> tableName template) items |> rlist
+
+    /// <summary>Exception filter to identify whether a <c>TransactWriteItems</c> call has failed due to
+    /// one or more of the supplied <c>precondition</c> checks failing.</summary>
+    let (|TransactionCanceledConditionalCheckFailed|_|) : exn -> unit option = function
+        | :? TransactionCanceledException as e when e.CancellationReasons.Exists(fun x -> x.Code = "ConditionalCheckFailed") -> Some ()
+        | _ -> None
+
 /// DynamoDB client object for performing table operations in the context of given F# record representations
 [<Sealed; AutoSerializable(false)>]
 type TableContext<'TRecord> internal
@@ -744,6 +795,26 @@ type TableContext<'TRecord> internal
     }
 
 
+    /// <summary>
+    ///     Atomically applies a set of 1-25 write operations to the table.<br/>
+    ///     NOTE requests are charged at twice the normal rate in Write Capacity Units.
+    ///     See the DynamoDB <a href="https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_TransactWriteItems.html"><c>TransactWriteItems</c> API documentation</a> for full details of semantics and charges.<br/>
+    /// </summary>
+    /// <param name="items">Operations to be performed.<br/>
+    /// Use <c>TransactWriteItemsRequest.TransactionCanceledConditionalCheckFailed</c> to identify any Precondition Check failures.</param>
+    /// <param name="clientRequestToken">The <c>ClientRequestToken</c> to supply as an idempotency key (10 minute window).</param>
+    member _.TransactWriteItems(items : seq<TransactWrite<'TRecord>>, ?clientRequestToken) : Async<unit> = async {
+        let reqs = TransactWriteItemsRequest.toTransactItems tableName template items
+        let req = TransactWriteItemsRequest(ReturnConsumedCapacity = returnConsumedCapacity, TransactItems = reqs)
+        clientRequestToken |> Option.iter (fun x -> req.ClientRequestToken <- x)
+        let! ct = Async.CancellationToken
+        let! response = client.TransactWriteItemsAsync(req, ct) |> Async.AwaitTaskCorrect
+        maybeReport |> Option.iter (fun r -> r TransactWriteItems (Seq.toList response.ConsumedCapacity) reqs.Count)
+        if response.HttpStatusCode <> HttpStatusCode.OK then
+            failwithf "TransactWriteItems request returned error %O" response.HttpStatusCode
+    }
+
+
     /// <summary>
     ///     Asynchronously queries table with given condition expressions.
     /// </summary>

tests/FSharp.AWS.DynamoDB.Tests/SimpleTableOperationTests.fs

@@ -125,4 +125,22 @@ type ``Simple Table Operation Tests`` (fixture : TableFixture) =
         test <@ None = deletedItem @>
         test <@ not (table.ContainsKey key) @>
 
+    let [<Theory; InlineData true; InlineData false>]
+        ``Condition Check outcome should affect sibling TransactWrite`` shouldFail = async {
+        let item, item2 = mkItem (), mkItem ()
+        let key = table.PutItem item
+
+        let requests = [
+            if shouldFail then  TransactWrite.Check (key, table.Template.PrecomputeConditionalExpr <@ fun t -> NOT_EXISTS t.Value @>)
+            else                TransactWrite.Check (key, table.Template.PrecomputeConditionalExpr <@ fun t -> EXISTS t.Value @>)
+                                TransactWrite.Put   (item2, None) ]
+        let mutable failed = false
+        try do! table.TransactWriteItems requests
+        with TransactWriteItemsRequest.TransactionCanceledConditionalCheckFailed -> failed <- true
+
+        let failed = failed
+        test <@ failed = shouldFail @>
+        let item2Found = table.ContainsKey (table.Template.ExtractKey item2)
+        test <@ not shouldFail = item2Found @> }
+
     interface IClassFixture<TableFixture>