Merge pull request #373 from mattpolzin/load-external-references-v4-take2-3_0-port

Port of `ExternallyDereferenceable` to `OpenAPIKit30` module

Author: mattpolzin

Sources/OpenAPIKit/Components Object/Components.swift

@@ -320,7 +320,7 @@ extension OpenAPI.Components {
 }
 
 extension OpenAPI.Components {
-    internal mutating func externallyDereference<Context: ExternalLoader>(in context: Context.Type, depth: ExternalDereferenceDepth = .iterations(1)) async throws {
+    internal mutating func externallyDereference<Loader: ExternalLoader>(with loader: Loader.Type, depth: ExternalDereferenceDepth = .iterations(1)) async throws {
         if case let .iterations(number) = depth,
            number <= 0 {
             return
@@ -336,15 +336,15 @@ extension OpenAPI.Components {
         let oldCallbacks = callbacks
         let oldPathItems = pathItems
 
-        async let (newSchemas, c1) = oldSchemas.externallyDereferenced(with: context)
-        async let (newResponses, c2) = oldResponses.externallyDereferenced(with: context)
-        async let (newParameters, c3) = oldParameters.externallyDereferenced(with: context)
-        async let (newExamples, c4) = oldExamples.externallyDereferenced(with: context)
-        async let (newRequestBodies, c5) = oldRequestBodies.externallyDereferenced(with: context)
-        async let (newHeaders, c6) = oldHeaders.externallyDereferenced(with: context)
-        async let (newSecuritySchemes, c7) = oldSecuritySchemes.externallyDereferenced(with: context)
-        async let (newCallbacks, c8) = oldCallbacks.externallyDereferenced(with: context)
-        async let (newPathItems, c9) = oldPathItems.externallyDereferenced(with: context)
+        async let (newSchemas, c1) = oldSchemas.externallyDereferenced(with: loader)
+        async let (newResponses, c2) = oldResponses.externallyDereferenced(with: loader)
+        async let (newParameters, c3) = oldParameters.externallyDereferenced(with: loader)
+        async let (newExamples, c4) = oldExamples.externallyDereferenced(with: loader)
+        async let (newRequestBodies, c5) = oldRequestBodies.externallyDereferenced(with: loader)
+        async let (newHeaders, c6) = oldHeaders.externallyDereferenced(with: loader)
+        async let (newSecuritySchemes, c7) = oldSecuritySchemes.externallyDereferenced(with: loader)
+        async let (newCallbacks, c8) = oldCallbacks.externallyDereferenced(with: loader)
+        async let (newPathItems, c9) = oldPathItems.externallyDereferenced(with: loader)
 
         schemas = try await newSchemas
         responses = try await newResponses
@@ -391,9 +391,9 @@ extension OpenAPI.Components {
 
         switch depth {
             case .iterations(let number):
-                try await externallyDereference(in: context, depth: .iterations(number - 1))
+                try await externallyDereference(with: loader, depth: .iterations(number - 1))
             case .full:
-                try await externallyDereference(in: context, depth: .full)
+                try await externallyDereference(with: loader, depth: .full)
         }
     }
 }

Sources/OpenAPIKit/Content/DereferencedContent.swift

@@ -77,7 +77,7 @@ extension OpenAPI.Content: LocallyDereferenceable {
 }
 
 extension OpenAPI.Content: ExternallyDereferenceable {
-    public func externallyDereferenced<Context: ExternalLoader>(with loader: Context.Type) async throws -> (Self, OpenAPI.Components) { 
+    public func externallyDereferenced<Loader: ExternalLoader>(with loader: Loader.Type) async throws -> (Self, OpenAPI.Components) { 
       let oldSchema = schema
 
       async let (newSchema, c1) = oldSchema.externallyDereferenced(with: loader)

Sources/OpenAPIKit/Content/DereferencedContentEncoding.swift

@@ -58,7 +58,7 @@ extension OpenAPI.Content.Encoding: LocallyDereferenceable {
 }
 
 extension OpenAPI.Content.Encoding: ExternallyDereferenceable {
-    public func externallyDereferenced<Context: ExternalLoader>(with loader: Context.Type) async throws -> (Self, OpenAPI.Components) { 
+    public func externallyDereferenced<Loader: ExternalLoader>(with loader: Loader.Type) async throws -> (Self, OpenAPI.Components) { 
         let newHeaders: OpenAPI.Header.Map?
         let newComponents: OpenAPI.Components
 

Sources/OpenAPIKit/Document/Document.swift

@@ -362,7 +362,7 @@ extension OpenAPI.Document {
         return try DereferencedDocument(self)
     }
 
-    public mutating func externallyDereference<Context: ExternalLoader>(in context: Context.Type, depth: ExternalDereferenceDepth = .iterations(1)) async throws {
+    public mutating func externallyDereference<Loader: ExternalLoader>(with loader: Loader.Type, depth: ExternalDereferenceDepth = .iterations(1)) async throws {
         if case let .iterations(number) = depth,
            number <= 0 {
             return
@@ -371,15 +371,15 @@ extension OpenAPI.Document {
         let oldPaths = paths
         let oldWebhooks = webhooks
 
-        async let (newPaths, c1) = oldPaths.externallyDereferenced(with: context)
-        async let (newWebhooks, c2) = oldWebhooks.externallyDereferenced(with: context) 
+        async let (newPaths, c1) = oldPaths.externallyDereferenced(with: loader)
+        async let (newWebhooks, c2) = oldWebhooks.externallyDereferenced(with: loader) 
 
         paths = try await newPaths
         webhooks = try await newWebhooks
         try await components.merge(c1)
         try await components.merge(c2)
 
-        try await components.externallyDereference(in: context, depth: depth)
+        try await components.externallyDereference(with: loader, depth: depth)
     }
 }
 

Sources/OpenAPIKit/Either/Either+ExternallyDereferenceable.swift

@@ -10,7 +10,7 @@ import OpenAPIKitCore
 // MARK: - ExternallyDereferenceable
 extension Either: ExternallyDereferenceable where A: ExternallyDereferenceable, B: ExternallyDereferenceable {
 
-    public func externallyDereferenced<Context: ExternalLoader>(with loader: Context.Type) async throws -> (Self, OpenAPI.Components) { 
+    public func externallyDereferenced<Loader: ExternalLoader>(with loader: Loader.Type) async throws -> (Self, OpenAPI.Components) { 
         switch self {
         case .a(let a):
            let (newA, components) = try await a.externallyDereferenced(with: loader)

Sources/OpenAPIKit/Example.swift

@@ -209,7 +209,7 @@ extension OpenAPI.Example: LocallyDereferenceable {
 }
 
 extension OpenAPI.Example: ExternallyDereferenceable {
-    public func externallyDereferenced<Context: ExternalLoader>(with loader: Context.Type) async throws -> (Self, OpenAPI.Components) { 
+    public func externallyDereferenced<Loader: ExternalLoader>(with loader: Loader.Type) async throws -> (Self, OpenAPI.Components) { 
         return (self, .init())
     }
 }

Sources/OpenAPIKit/ExternalLoader.swift

@@ -30,5 +30,5 @@ public protocol ExternalLoader {
 }
 
 public protocol ExternallyDereferenceable {
-    func externallyDereferenced<Context: ExternalLoader>(with loader: Context.Type) async throws -> (Self, OpenAPI.Components)
+    func externallyDereferenced<Loader: ExternalLoader>(with loader: Loader.Type) async throws -> (Self, OpenAPI.Components)
 }

Sources/OpenAPIKit/Header/DereferencedHeader.swift

@@ -84,7 +84,7 @@ extension OpenAPI.Header: LocallyDereferenceable {
 }
 
 extension OpenAPI.Header: ExternallyDereferenceable {
-    public func externallyDereferenced<Context: ExternalLoader>(with loader: Context.Type) async throws -> (Self, OpenAPI.Components) { 
+    public func externallyDereferenced<Loader: ExternalLoader>(with loader: Loader.Type) async throws -> (Self, OpenAPI.Components) { 
 
         // if not for a Swift bug, this whole next bit would just be the
         // next line:

Sources/OpenAPIKit/JSONReference.swift

@@ -538,7 +538,7 @@ extension JSONReference: LocallyDereferenceable where ReferenceType: LocallyDere
 }
 
 extension JSONReference: ExternallyDereferenceable where ReferenceType: ExternallyDereferenceable & Decodable & Equatable {
-    public func externallyDereferenced<Context: ExternalLoader>(with loader: Context.Type) async throws -> (Self, OpenAPI.Components) { 
+    public func externallyDereferenced<Loader: ExternalLoader>(with loader: Loader.Type) async throws -> (Self, OpenAPI.Components) { 
         switch self {
         case .internal(let ref):
             return (.internal(ref), .init())
@@ -580,7 +580,7 @@ extension OpenAPI.Reference: LocallyDereferenceable where ReferenceType: Locally
 }
 
 extension OpenAPI.Reference: ExternallyDereferenceable where ReferenceType: ExternallyDereferenceable & Decodable & Equatable {
-    public func externallyDereferenced<Context: ExternalLoader>(with loader: Context.Type) async throws -> (Self, OpenAPI.Components) { 
+    public func externallyDereferenced<Loader: ExternalLoader>(with loader: Loader.Type) async throws -> (Self, OpenAPI.Components) { 
         let (newRef, components) = try await jsonReference.externallyDereferenced(with: loader)
         return (.init(newRef), components)
     }

Sources/OpenAPIKit/Link.swift

@@ -290,7 +290,7 @@ extension OpenAPI.Link: LocallyDereferenceable {
 }
 
 extension OpenAPI.Link: ExternallyDereferenceable {
-    public func externallyDereferenced<Context: ExternalLoader>(with loader: Context.Type) async throws -> (Self, OpenAPI.Components) { 
+    public func externallyDereferenced<Loader: ExternalLoader>(with loader: Loader.Type) async throws -> (Self, OpenAPI.Components) { 
         let (newServer, newComponents) = try await server.externallyDereferenced(with: loader)
 
         var newLink = self