and now to conditionally apply sendable more broadly

Author: mattpolzin

Sources/JSONAPI/Document/APIDescription.swift

@@ -21,6 +21,8 @@ public struct APIDescription<Meta: JSONAPI.Meta>: APIDescriptionType {
     }
 }
 
+extension APIDescription: Sendable where Meta: Sendable {}
+
 /// Can be used as `APIDescriptionType` for Documents that do not
 /// have any API Description (a.k.a. "JSON:API Object").
 public struct NoAPIDescription: APIDescriptionType, CustomStringConvertible {
@@ -33,6 +35,8 @@ public struct NoAPIDescription: APIDescriptionType, CustomStringConvertible {
     public var description: String { return "No JSON:API Object" }
 }
 
+extension NoAPIDescription: Sendable {}
+
 extension APIDescription {
     private enum CodingKeys: String, CodingKey {
         case version

Sources/JSONAPI/Document/Document.swift

@@ -186,6 +186,10 @@ public struct Document<PrimaryResourceBody: JSONAPI.EncodableResourceBody, MetaT
     }
 }
 
+extension Document: Sendable where
+  APIDescription: Sendable,
+  Body: Sendable {}
+
 extension Document {
     public enum Body: DocumentBody, Equatable {
         case errors([Error], meta: MetaType?, links: LinksType?)
@@ -260,6 +264,17 @@ extension Document {
     }
 }
 
+extension Document.Body: Sendable where
+  MetaType: Sendable,
+  LinksType: Sendable,
+  Data: Sendable {}
+
+extension Document.Body.Data: Sendable where
+  PrimaryResourceBody: Sendable,
+  IncludeType: Sendable,
+  MetaType: Sendable,
+  LinksType: Sendable {}
+
 extension Document.Body.Data where PrimaryResourceBody: ResourceBodyAppendable {
     public func merging<OtherDescription, OtherError>(_ other: Document<PrimaryResourceBody, MetaType, LinksType, IncludeType, OtherDescription, OtherError>.Body.Data,
                         combiningMetaWith metaMerge: (MetaType, MetaType) -> MetaType,

Sources/JSONAPI/Document/Includes.swift

@@ -45,6 +45,8 @@ public struct Includes<I: Include>: Encodable, Equatable {
     }
 }
 
+extension Includes: Sendable where I: Sendable {}
+
 extension Includes: Decodable where I: Decodable {
     public init(from decoder: Decoder) throws {
         var container = try decoder.unkeyedContainer()

Sources/JSONAPI/Document/ResourceBody.swift

@@ -65,6 +65,8 @@ public struct SingleResourceBody<PrimaryResource: JSONAPI.OptionalEncodablePrima
     }
 }
 
+extension SingleResourceBody: Sendable where PrimaryResource: Sendable {}
+
 public protocol ManyResourceBodyProtocol: EncodableResourceBody {
     var values: [PrimaryResource] { get }
 
@@ -84,6 +86,8 @@ public struct ManyResourceBody<PrimaryResource: JSONAPI.EncodablePrimaryResource
     }
 }
 
+extension ManyResourceBody: Sendable where PrimaryResource: Sendable {}
+
 /// Use NoResourceBody to indicate you expect a JSON API document to not
 /// contain a "data" top-level key.
 public struct NoResourceBody: CodableResourceBody {
@@ -92,6 +96,8 @@ public struct NoResourceBody: CodableResourceBody {
     public static var none: NoResourceBody { return NoResourceBody() }
 }
 
+extension NoResourceBody: Sendable {}
+
 // MARK: Codable
 extension SingleResourceBody {
     public func encode(to encoder: Encoder) throws {

Sources/JSONAPI/Meta/Links.swift

@@ -9,7 +9,7 @@
 public protocol Links: Codable, Equatable {}
 
 /// Use NoLinks where no links should belong to a JSON API component
-public struct NoLinks: Links, CustomStringConvertible {
+public struct NoLinks: Links, CustomStringConvertible, Sendable {
     public static var none: NoLinks { return NoLinks() }
     public init() {}
 
@@ -28,6 +28,8 @@ public struct Link<URL: JSONAPI.JSONAPIURL, Meta: JSONAPI.Meta>: Equatable, Coda
     }
 }
 
+extension Link: Sendable where Meta: Sendable, URL: Sendable {}
+
 extension Link where Meta == NoMetadata {
     public init(url: URL) {
         self.init(url: url, meta: .none)

Sources/JSONAPI/Meta/Meta.swift

@@ -21,7 +21,7 @@ extension Optional: Meta where Wrapped: Meta {}
 
 /// Use this type when you want to specify not to encode or decode any metadata
 /// for a type.
-public struct NoMetadata: Meta, CustomStringConvertible {
+public struct NoMetadata: Meta, CustomStringConvertible, Sendable {
     public static var none: NoMetadata { return NoMetadata() }
 
     public init() { }

Sources/JSONAPI/Resource/Attribute.swift

@@ -34,6 +34,8 @@ public struct TransformedAttribute<RawValue: Codable, Transformer: JSONAPI.Trans
     }
 }
 
+extension TransformedAttribute: Sendable where RawValue: Sendable, Transformer.To: Sendable {}
+
 extension TransformedAttribute where Transformer == IdentityTransformer<RawValue> {
     // If we are using the identity transform, we can skip the transform and guarantee no
     // error is thrown.
@@ -82,6 +84,8 @@ public struct Attribute<RawValue: Codable>: AttributeType {
     }
 }
 
+extension Attribute: Sendable where RawValue: Sendable {}
+
 extension Attribute: CustomStringConvertible {
     public var description: String {
         return "Attribute<\(String(describing: RawValue.self))>(\(String(describing: value)))"

Sources/JSONAPI/Resource/Id.swift

@@ -97,6 +97,8 @@ public struct Id<RawType: MaybeRawId, IdentifiableType: JSONAPI.JSONTyped>: Equa
     }
 }
 
+extension Id: Sendable where RawType: Sendable {}
+
 extension Id: Hashable where RawType: RawIdType {
     public func hash(into hasher: inout Hasher) {
         hasher.combine(ObjectIdentifier(Self.self))

Sources/JSONAPI/Resource/Poly+PrimaryResource.swift

@@ -15,7 +15,7 @@ import Poly
 /// disparate types under one roof for
 /// the purposes of JSON API compliant
 /// encoding or decoding.
-public typealias EncodableJSONPoly = Poly & EncodablePrimaryResource & Sendable
+public typealias EncodableJSONPoly = Poly & EncodablePrimaryResource
 
 public typealias EncodablePolyWrapped = Encodable & Equatable
 public typealias CodablePolyWrapped = EncodablePolyWrapped & Decodable

Sources/JSONAPI/Resource/Relationship.swift

@@ -60,6 +60,12 @@ public struct ToOneRelationship<Identifiable: JSONAPI.JSONAPIIdentifiable, IdMet
     }
 }
 
+extension ToOneRelationship: Sendable where
+  Identifiable.ID: Sendable,
+  IdMetaType: Sendable,
+  MetaType: Sendable,
+  LinksType: Sendable {}
+
 extension ToOneRelationship where IdMetaType == NoIdMetadata {
     public init(id: Identifiable.ID, meta: MetaType, links: LinksType) {
         self.id = id
@@ -167,6 +173,15 @@ public struct ToManyRelationship<Relatable: JSONAPI.Relatable, IdMetaType: JSONA
     }
 }
 
+extension ToManyRelationship.ID: Sendable where
+  Relatable.ID: Sendable,
+  IdMetaType: Sendable {}
+
+extension ToManyRelationship: Sendable where
+  ID: Sendable,
+  MetaType: Sendable,
+  LinksType: Sendable {}
+
 extension ToManyRelationship where IdMetaType == NoIdMetadata {
     public init(ids: [Relatable.ID], meta: MetaType, links: LinksType) {
         self.idsWithMeta = ids.map { .init(id: $0, meta: .none) }