Remove requirement that payload types are Sendable. (#59)

* Remove requirement that payload types are Sendable.

* Refactor InMemoryDynamoDBCompositePrimaryKeyTable into several extensions.

Author: tachyonics

README.md

@@ -120,7 +120,7 @@ An item can be retrieved from the DynamoDB table using the following-
 let retrievedItem: StandardTypedDatabaseItem<PayloadType>? = try await table.getItem(forKey: key)
 ```
 
-The `getItem` operation return an optional `TypedDatabaseItem` which will be nil if the item doesn't exist in the table. These operations will also fail if the *RowType* recorded in the database row doesn't match the type being requested.
+The `getItem` operation return an optional `TypedTTLDatabaseItem` which will be nil if the item doesn't exist in the table. These operations will also fail if the *RowType* recorded in the database row doesn't match the type being requested.
 
 ## Update
 
@@ -623,7 +623,7 @@ By default, this operation will fail if an item with the same partition key and
 The main entities provided by this package are
 * *CompositePrimaryKey*: a struct that stores the partition and sort values for a composite primary key.
 * *TimeToLive*: a struct that stores TTL timestamp for a database item.
-* *TypedDatabaseItemWithTimeToLive*: a struct that manages decoding and encoding rows of a particular type along with any TTL settings from polymorphic database tables.
+* *TypedTTLDatabaseItem*: a struct that manages decoding and encoding rows of a particular type along with any TTL settings from polymorphic database tables.
 * *TypedDatabaseItem*: a typealias that points to `TypedDatabaseItemWithTimeToLive` with default `StandardTimeToLiveAttributes` generic type for backwards compatibility.
 * *PolymorphicDatabaseItem*: a struct that manages decoding rows that are one out of a number of types from polymorphic database tables.
 * *DynamoDBCompositePrimaryKeyTable*: a protocol for interacting with a DynamoDB database table.
@@ -647,15 +647,15 @@ The TimeToLive struct defines the TTL timestamp value for a row in the database.
 let timeToLive = StandardTimeToLive(timeToLiveTimestamp: 123456789)
 ```
 
-## TypedDatabaseItemWithTimeToLive
+## TypedTTLDatabaseItem
 
-The TypedDatabaseItemWithTimeToLive struct manages a number of attributes in the database table to enable decoding and encoding rows to and from the correct type. In addition it also manages other conveniences such as versioning. The attributes this struct will add to a database row are-
+The TypedTTLDatabaseItem struct manages a number of attributes in the database table to enable decoding and encoding rows to and from the correct type. In addition it also manages other conveniences such as versioning. The attributes this struct will add to a database row are-
 * *CreateDate*: The timestamp when the row was created.
 * *RowType*: Specifies the schema used by the other attributes of this row.
 * *RowVersion*: A version number for the values currently in this row. Used to enable optimistic locking.
 * *LastUpdatedDate*: The timestamp when the row was last updated.
 
-Similar to CompositePrimaryKey, this package provides a typealias called `StandardTypedDatabaseItem` that expects the standard partition, sort key, and TTL attribute names.
+Similar to CompositePrimaryKey, this package provides a typealias called `TypedDatabaseItem` that expects the standard partition, sort key, and TTL attribute names.
 
 This struct can be instantiated as shown-
 
@@ -683,7 +683,7 @@ or with TTL-
 let updatedDatabaseItem = newDatabaseItem.createUpdatedItem(withValue: updatedValue, andTimeToLive: updatedTimeToLive)
 ```
 
-This function will create a new instance of TypedDatabaseItemWithTimeToLive with the same key and updated LastUpdatedDate and RowVersion values. By default, performing a **PutItem** operation with this item on a table where this row already exists and the RowVersion isn't equal to the value of the original row will fail.
+This function will create a new instance of TypedTTLDatabaseItem with the same key and updated LastUpdatedDate and RowVersion values. By default, performing a **PutItem** operation with this item on a table where this row already exists and the RowVersion isn't equal to the value of the original row will fail.
 
 ## DynamoDBCompositePrimaryKeyTable
 
@@ -703,7 +703,7 @@ Internally `AWSDynamoDBCompositePrimaryKeyTable` uses a custom Decoder and Encod
 
 ## PrimaryKeyAttributes
 
-`CompositePrimaryKey`, `TypedDatabaseItemWithTimeToLive` and `PolymorphicDatabaseItem` are all generic to a type conforming to the `PrimaryKeyAttributes` protocol. This protocol can be used to use custom attribute names for the partition and sort keys.
+`CompositePrimaryKey`, `TypedTTLDatabaseItem` and `PolymorphicDatabaseItem` are all generic to a type conforming to the `PrimaryKeyAttributes` protocol. This protocol can be used to use custom attribute names for the partition and sort keys.
 
 ```swift
 public struct MyPrimaryKeyAttributes: PrimaryKeyAttributes {
@@ -718,7 +718,7 @@ public struct MyPrimaryKeyAttributes: PrimaryKeyAttributes {
 
 ## TimeToLiveAttributes
 
-`TimeToLive`, `TypedDatabaseItemWithTimeToLive` and `PolymorphicDatabaseItem` are all generic to a type conforming to the `TimeToLiveAttributes` protocol. This protocol can be used to use custom attribute names for the TTL timestamp.
+`TimeToLive`, `TypedTTLDatabaseItem` and `PolymorphicDatabaseItem` are all generic to a type conforming to the `TimeToLiveAttributes` protocol. This protocol can be used to use custom attribute names for the TTL timestamp.
 
 ```swift
 public struct MyTimeToLiveAttributes: TimeToLiveAttributes {

Sources/DynamoDBTables/AWSDynamoDBCompositePrimaryKeyTable+DynamoDBTableAsync.swift

@@ -30,13 +30,13 @@ import Logging
 
 /// DynamoDBTable conformance async functions
 public extension AWSDynamoDBCompositePrimaryKeyTable {
-    func insertItem(_ item: TypedDatabaseItem<some Any, some Any>) async throws {
+    func insertItem(_ item: TypedTTLDatabaseItem<some Any, some Any, some Any>) async throws {
         let putItemInput = try getInputForInsert(item)
 
         try await putItem(forInput: putItemInput, withKey: item.compositePrimaryKey)
     }
 
-    func clobberItem(_ item: TypedDatabaseItem<some Any, some Any>) async throws {
+    func clobberItem(_ item: TypedTTLDatabaseItem<some Any, some Any, some Any>) async throws {
         let attributes = try getAttributes(forItem: item)
 
         let putItemInput = AWSDynamoDB.PutItemInput(item: attributes,
@@ -45,16 +45,17 @@ public extension AWSDynamoDBCompositePrimaryKeyTable {
         try await self.putItem(forInput: putItemInput, withKey: item.compositePrimaryKey)
     }
 
-    func updateItem<AttributesType, ItemType>(newItem: TypedDatabaseItem<AttributesType, ItemType>,
-                                              existingItem: TypedDatabaseItem<AttributesType, ItemType>) async throws
+    func updateItem<AttributesType, ItemType, TimeToLiveAttributesType>(
+        newItem: TypedTTLDatabaseItem<AttributesType, ItemType, TimeToLiveAttributesType>,
+        existingItem: TypedTTLDatabaseItem<AttributesType, ItemType, TimeToLiveAttributesType>) async throws
     {
         let putItemInput = try getInputForUpdateItem(newItem: newItem, existingItem: existingItem)
 
         try await putItem(forInput: putItemInput, withKey: newItem.compositePrimaryKey)
     }
 
-    func getItem<AttributesType, ItemType>(forKey key: CompositePrimaryKey<AttributesType>) async throws
-        -> TypedDatabaseItem<AttributesType, ItemType>?
+    func getItem<AttributesType, ItemType, TimeToLiveAttributesType>(forKey key: CompositePrimaryKey<AttributesType>) async throws
+        -> TypedTTLDatabaseItem<AttributesType, ItemType, TimeToLiveAttributesType>?
     {
         let getItemInput = try getInputForGetItem(forKey: key)
 
@@ -66,7 +67,7 @@ public extension AWSDynamoDBCompositePrimaryKeyTable {
             self.logger.trace("Value returned from DynamoDB.")
 
             do {
-                let decodedItem: TypedDatabaseItem<AttributesType, ItemType>? =
+                let decodedItem: TypedTTLDatabaseItem<AttributesType, ItemType, TimeToLiveAttributesType>? =
                     try DynamoDBDecoder().decode(DynamoDBClientTypes.AttributeValue.m(item))
                 return decodedItem
             } catch {
@@ -86,7 +87,7 @@ public extension AWSDynamoDBCompositePrimaryKeyTable {
         _ = try await self.dynamodb.deleteItem(input: deleteItemInput)
     }
 
-    func deleteItem(existingItem: TypedDatabaseItem<some Any, some Any>) async throws {
+    func deleteItem(existingItem: TypedTTLDatabaseItem<some Any, some Any, some Any>) async throws {
         let deleteItemInput = try getInputForDeleteItem(existingItem: existingItem)
 
         let logMessage = "dynamodb.deleteItem with key: \(existingItem.compositePrimaryKey), "
@@ -230,10 +231,10 @@ public extension AWSDynamoDBCompositePrimaryKeyTable {
         }
     }
 
-    func query<AttributesType, ItemType>(forPartitionKey partitionKey: String,
-                                         sortKeyCondition: AttributeCondition?,
-                                         consistentRead: Bool) async throws
-        -> [TypedDatabaseItem<AttributesType, ItemType>]
+    func query<AttributesType, ItemType, TimeToLiveAttributesType>(forPartitionKey partitionKey: String,
+                                                                   sortKeyCondition: AttributeCondition?,
+                                                                   consistentRead: Bool) async throws
+        -> [TypedTTLDatabaseItem<AttributesType, ItemType, TimeToLiveAttributesType>]
     {
         try await self.partialQuery(forPartitionKey: partitionKey,
                                     sortKeyCondition: sortKeyCondition,
@@ -242,13 +243,13 @@ public extension AWSDynamoDBCompositePrimaryKeyTable {
     }
 
     // function to return a future with the results of a query call and all future paginated calls
-    private func partialQuery<AttributesType, ItemType>(
+    private func partialQuery<AttributesType, ItemType, TimeToLiveAttributesType>(
         forPartitionKey partitionKey: String,
         sortKeyCondition: AttributeCondition?,
-        exclusiveStartKey: String?,
-        consistentRead: Bool) async throws -> [TypedDatabaseItem<AttributesType, ItemType>]
+        exclusiveStartKey _: String?,
+        consistentRead: Bool) async throws -> [TypedTTLDatabaseItem<AttributesType, ItemType, TimeToLiveAttributesType>]
     {
-        let paginatedItems: ([TypedDatabaseItem<AttributesType, ItemType>], String?) =
+        let paginatedItems: ([TypedTTLDatabaseItem<AttributesType, ItemType, TimeToLiveAttributesType>], String?) =
             try await query(forPartitionKey: partitionKey,
                             sortKeyCondition: sortKeyCondition,
                             limit: nil,
@@ -259,7 +260,7 @@ public extension AWSDynamoDBCompositePrimaryKeyTable {
         // if there are more items
         if let lastEvaluatedKey = paginatedItems.1 {
             // returns a future with all the results from all later paginated calls
-            let partialResult: [TypedDatabaseItem<AttributesType, ItemType>] = try await self.partialQuery(
+            let partialResult: [TypedTTLDatabaseItem<AttributesType, ItemType, TimeToLiveAttributesType>] = try await self.partialQuery(
                 forPartitionKey: partitionKey,
                 sortKeyCondition: sortKeyCondition,
                 exclusiveStartKey: lastEvaluatedKey,
@@ -273,13 +274,13 @@ public extension AWSDynamoDBCompositePrimaryKeyTable {
         }
     }
 
-    func query<AttributesType, ItemType>(forPartitionKey partitionKey: String,
-                                         sortKeyCondition: AttributeCondition?,
-                                         limit: Int?,
-                                         scanIndexForward: Bool,
-                                         exclusiveStartKey: String?,
-                                         consistentRead: Bool) async throws
-        -> (items: [TypedDatabaseItem<AttributesType, ItemType>], lastEvaluatedKey: String?)
+    func query<AttributesType, ItemType, TimeToLiveAttributesType>(forPartitionKey partitionKey: String,
+                                                                   sortKeyCondition: AttributeCondition?,
+                                                                   limit: Int?,
+                                                                   scanIndexForward: Bool,
+                                                                   exclusiveStartKey: String?,
+                                                                   consistentRead: Bool) async throws
+        -> (items: [TypedTTLDatabaseItem<AttributesType, ItemType, TimeToLiveAttributesType>], lastEvaluatedKey: String?)
     {
         let queryInput = try AWSDynamoDB.QueryInput.forSortKeyCondition(
             partitionKey: partitionKey, targetTableName: targetTableName,
@@ -310,7 +311,7 @@ public extension AWSDynamoDBCompositePrimaryKeyTable {
         }
 
         if let outputAttributeValues = queryOutput.items {
-            let items: [TypedDatabaseItem<AttributesType, ItemType>]
+            let items: [TypedTTLDatabaseItem<AttributesType, ItemType, TimeToLiveAttributesType>]
 
             do {
                 items = try outputAttributeValues.map { values in

Sources/DynamoDBTables/AWSDynamoDBCompositePrimaryKeyTable+deleteItems.swift

@@ -52,7 +52,7 @@ public extension AWSDynamoDBCompositePrimaryKeyTable {
         try throwOnBatchExecuteStatementErrors(response: response)
     }
 
-    private func deleteChunkedItems(_ existingItems: [some DatabaseItem]) async throws {
+    private func deleteChunkedItems(_ existingItems: [TypedTTLDatabaseItem<some Any, some Any, some Any>]) async throws {
         // if there are no items, there is nothing to update
         guard existingItems.count > 0 else {
             return
@@ -80,7 +80,7 @@ public extension AWSDynamoDBCompositePrimaryKeyTable {
         }
     }
 
-    func deleteItems(existingItems: [some DatabaseItem]) async throws {
+    func deleteItems(existingItems: [TypedTTLDatabaseItem<some Any, some Any, some Any>]) async throws {
         // BatchExecuteStatement has a maximum of 25 statements
         // This function handles pagination internally.
         let chunkedItems = existingItems.chunked(by: maximumUpdatesPerExecuteStatement)

Sources/DynamoDBTables/AWSDynamoDBCompositePrimaryKeyTable+execute.swift

@@ -128,11 +128,11 @@ public extension AWSDynamoDBCompositePrimaryKeyTable {
         return itemLists.flatMap { $0 }
     }
 
-    func execute<AttributesType, ItemType>(
+    func execute<AttributesType, ItemType, TimeToLiveAttributesType>(
         partitionKeys: [String],
         attributesFilter: [String]?,
         additionalWhereClause: String?, nextToken: String?) async throws
-        -> (items: [TypedDatabaseItem<AttributesType, ItemType>], lastEvaluatedKey: String?)
+        -> (items: [TypedTTLDatabaseItem<AttributesType, ItemType, TimeToLiveAttributesType>], lastEvaluatedKey: String?)
     {
         // if there are no partitions, there will be no results to return
         // succeed immediately with empty results
@@ -158,7 +158,7 @@ public extension AWSDynamoDBCompositePrimaryKeyTable {
         let nextToken = executeOutput.nextToken
 
         if let outputAttributeValues = executeOutput.items {
-            let items: [TypedDatabaseItem<AttributesType, ItemType>]
+            let items: [TypedTTLDatabaseItem<AttributesType, ItemType, TimeToLiveAttributesType>]
 
             do {
                 items = try outputAttributeValues.map { values in
@@ -176,16 +176,17 @@ public extension AWSDynamoDBCompositePrimaryKeyTable {
         }
     }
 
-    func execute<AttributesType, ItemType>(
+    func execute<AttributesType, ItemType, TimeToLiveAttributesType>(
         partitionKeys: [String],
         attributesFilter: [String]?,
         additionalWhereClause: String?) async throws
-        -> [TypedDatabaseItem<AttributesType, ItemType>]
+        -> [TypedTTLDatabaseItem<AttributesType, ItemType, TimeToLiveAttributesType>]
     {
         // ExecuteStatement API has a maximum limit on the number of decomposed read operations per request.
         // This function handles pagination internally.
         let chunkedPartitionKeys = partitionKeys.chunked(by: maximumKeysPerExecuteStatement)
-        let itemLists = try await chunkedPartitionKeys.concurrentMap { chunk -> [TypedDatabaseItem<AttributesType, ItemType>] in
+        let itemLists = try await chunkedPartitionKeys.concurrentMap { chunk
+            -> [TypedTTLDatabaseItem<AttributesType, ItemType, TimeToLiveAttributesType>] in
             try await self.partialExecute(partitionKeys: chunk,
                                           attributesFilter: attributesFilter,
                                           additionalWhereClause: additionalWhereClause,
@@ -225,14 +226,14 @@ public extension AWSDynamoDBCompositePrimaryKeyTable {
         }
     }
 
-    private func partialExecute<AttributesType, ItemType>(
+    private func partialExecute<AttributesType, ItemType, TimeToLiveAttributesType>(
         partitionKeys: [String],
         attributesFilter: [String]?,
         additionalWhereClause: String?,
         nextToken: String?) async throws
-        -> [TypedDatabaseItem<AttributesType, ItemType>]
+        -> [TypedTTLDatabaseItem<AttributesType, ItemType, TimeToLiveAttributesType>]
     {
-        let paginatedItems: ([TypedDatabaseItem<AttributesType, ItemType>], String?) =
+        let paginatedItems: ([TypedTTLDatabaseItem<AttributesType, ItemType, TimeToLiveAttributesType>], String?) =
             try await execute(partitionKeys: partitionKeys,
                               attributesFilter: attributesFilter,
                               additionalWhereClause: additionalWhereClause,
@@ -241,7 +242,7 @@ public extension AWSDynamoDBCompositePrimaryKeyTable {
         // if there are more items
         if let returnedNextToken = paginatedItems.1 {
             // returns a future with all the results from all later paginated calls
-            let partialResult: [TypedDatabaseItem<AttributesType, ItemType>] = try await self.partialExecute(
+            let partialResult: [TypedTTLDatabaseItem<AttributesType, ItemType, TimeToLiveAttributesType>] = try await self.partialExecute(
                 partitionKeys: partitionKeys,
                 attributesFilter: attributesFilter,
                 additionalWhereClause: additionalWhereClause,