tweak ConstantHashKey methods in RecordTemplate

Author: eiriktsarpalis

src/FSharp.DynamoDB/KeySchema.fs

@@ -51,6 +51,17 @@ with
 
         dict
 
+    /// Extract a KeyCondition for records that specify a default hashkey
+    static member TryExtractHashKeyCondition keyStructure keySchema =
+        match keyStructure with
+        | DefaultHashKey(attrName, value, pickler, _) ->
+            let av = pickler.PickleUntyped value |> Option.get
+            let cond = ConditionalExpr.mkHashKeyEqualityCondition keySchema av
+            let cexpr = new ConditionExpression<'TRecord>(cond)
+            Some cexpr
+
+        | _ -> None
+
     /// Extracts key from given record instance
     static member ExtractKey(keyStructure : KeyStructure, recordInfo : RecordInfo, record : 'Record) =
         let inline getValue (rp : RecordPropertyInfo) = rp.PropertyInfo.GetValue(record)

src/FSharp.DynamoDB/RecordTemplate.fs

@@ -19,10 +19,27 @@ type RecordTemplate<'TRecord> internal () =
     let pickler = Pickler.resolve<'TRecord>() :?> RecordPickler<'TRecord>
     let keyStructure = KeyStructure.FromRecordInfo pickler.RecordInfo
     let keySchema = TableKeySchema.OfKeyStructure keyStructure
+    let hkeyCond = KeyStructure.TryExtractHashKeyCondition<'TRecord> keyStructure keySchema
 
     /// Key schema used by the current record
     member __.KeySchema = keySchema
 
+    /// Gets the constant HashKey if specified by the record implementation
+    member __.ConstantHashKey : obj option =
+        match keyStructure with
+        | DefaultHashKey(_, value, _, _) -> Some value
+        | _ -> None
+
+    /// Gets the constant RangeKey if specified by the record implementation
+    member __.ConstantRangeKey : obj option =
+        match keyStructure with
+        | DefaultRangeKey(_, value, _, _) -> Some value
+        | _ -> None
+
+    /// Gets a condition expression that matches the constant HashKey,
+    /// if so specified.
+    member __.ConstantHashKeyCondition = hkeyCond
+
     /// Record property info
     member internal __.Info = pickler.RecordInfo
 
@@ -211,17 +228,6 @@ type RecordTemplate<'TRecord> internal () =
     /// Constructs a record instance from attribute values
     member internal __.OfAttributeValues(ro : RestObject) = pickler.ToRecord ro
 
-    /// <summary>
-    ///     Generates a HashKey equality condition used for queries
-    ///     that match given table key. Useful for generating query
-    ///     conditions in records that specify a ConstantHashKey attribute.
-    /// </summary>
-    /// <param name="key">Key that specifies the required HashKey.</param>
-    member __.GetHashKeyCondition(key : TableKey) =
-        let av = __.ToAttributeValues(key).[keySchema.HashKey.AttributeName]
-        let cond = mkHashKeyEqualityCondition keySchema av
-        new ConditionExpression<'TRecord>(cond)
-
 /// Record template factory methods
 [<Sealed; AbstractClass>]
 type RecordTemplate private () =

tests/FSharp.DynamoDB.Tests/ConditionalExpressionTests.fs

@@ -422,15 +422,6 @@ type ``Conditional Expression Tests`` () =
 
         results.Length |> should equal 50
 
-    [<Fact>]
-    let ``Extract Query expression from key`` () =
-        let item = mkItem()
-        let key = table.PutItem item
-        let kc = table.Template.GetHashKeyCondition key
-        let results = table.Query(kc)
-        results.Length |> should equal 1
-        results.[0] |> should equal item
-
     [<Fact>]
     let ``Detect incompatible key conditions`` () =
         let test outcome q = table.Template.PrecomputeConditionalExpr(q).IsKeyConditionCompatible |> should equal outcome