From 2b90c7c55e6d8ff38bfe9699b472b2c584271997 Mon Sep 17 00:00:00 2001
From: Mathew Polzin <matt.polzin@gmail.com>
Date: Sun, 7 Apr 2024 19:51:54 -0500
Subject: [PATCH] a bit more work towards external dereferencing
 implementations

---
 .../Operation/DereferencedOperation.swift     | 26 +++++++++++++++---
 .../Parameter/DereferencedParameter.swift     | 27 ++++++++++++++++---
 .../Request/DereferencedRequest.swift         |  9 ++++---
 3 files changed, 52 insertions(+), 10 deletions(-)

diff --git a/Sources/OpenAPIKit/Operation/DereferencedOperation.swift b/Sources/OpenAPIKit/Operation/DereferencedOperation.swift
index e39a3f975..4f7ccda18 100644
--- a/Sources/OpenAPIKit/Operation/DereferencedOperation.swift
+++ b/Sources/OpenAPIKit/Operation/DereferencedOperation.swift
@@ -127,8 +127,28 @@ extension OpenAPI.Operation: LocallyDereferenceable {
 
 extension OpenAPI.Operation: ExternallyDereferenceable {
     public func externallyDereferenced<Context: ExternalLoaderContext>(with loader: Context.Type) async throws -> (Self, OpenAPI.Components) { 
-        // TODO: externally dereference security, responses, requestBody, and parameters
-#warning("externally dereference security, responses, requestBody, and parameters")
-        return (self, .init())
+        let oldParameters = parameters
+        let oldRequestBody = requestBody
+        let oldResponses = responses
+
+        async let (newParameters, c1) = oldParameters.externallyDereferenced(with: loader)
+        async let (newRequestBody, c2) = oldRequestBody.externallyDereferenced(with: loader)
+        async let (newResponses, c3) = oldResponses.externallyDereferenced(with: loader)
+//        let (newCallbacks, c4) = try await callbacks.externallyDereferenced(with: loader)
+//        let (newSecurtiy, c5) = try await security.externallyDereferenced(with: loader)
+//        let (newServers, c6) = try await servers.externallyDereferenced(with: loader)
+
+        var newOperation = self
+        var newComponents = try await c1
+
+        newOperation.parameters = try await newParameters
+        newOperation.requestBody = try await newRequestBody
+        try await newComponents.merge(c2)
+        newOperation.responses = try await newResponses
+        try await newComponents.merge(c3)
+        
+        // TODO: externally dereference servers, callbacks, and security
+#warning("externally dereference servers, callbacks, and security")
+        return (newOperation, newComponents)
     }
 }
diff --git a/Sources/OpenAPIKit/Parameter/DereferencedParameter.swift b/Sources/OpenAPIKit/Parameter/DereferencedParameter.swift
index 5168ad22b..2d3153847 100644
--- a/Sources/OpenAPIKit/Parameter/DereferencedParameter.swift
+++ b/Sources/OpenAPIKit/Parameter/DereferencedParameter.swift
@@ -85,9 +85,28 @@ extension OpenAPI.Parameter: LocallyDereferenceable {
 
 extension OpenAPI.Parameter: ExternallyDereferenceable {
     public func externallyDereferenced<Context: ExternalLoaderContext>(with loader: Context.Type) async throws -> (Self, OpenAPI.Components) { 
-        
-        // TODO: externallyDerefence the schemaOrContent
-#warning("need to externally dereference the schemaOrContent here")
-        return (self, .init())
+
+        // if not for a Swift bug, this whole function would just be the
+        // next line:
+//        let (newSchemaOrContent, components) = try await schemaOrContent.externallyDereferenced(with: loader)
+
+        let newSchemaOrContent: Either<SchemaContext, OpenAPI.Content.Map>
+        let newComponents: OpenAPI.Components
+
+        switch schemaOrContent {
+        case .a(let schemaContext):
+            let (context, components) = try await schemaContext.externallyDereferenced(with: loader)
+            newSchemaOrContent = .a(context)
+            newComponents = components
+        case .b(let contentMap):
+            let (map, components) = try await contentMap.externallyDereferenced(with: loader)
+            newSchemaOrContent = .b(map)
+            newComponents = components
+        }
+
+        var newParameter = self
+        newParameter.schemaOrContent = newSchemaOrContent
+
+        return (newParameter, newComponents)
     }
 }
diff --git a/Sources/OpenAPIKit/Request/DereferencedRequest.swift b/Sources/OpenAPIKit/Request/DereferencedRequest.swift
index 97c947fde..27ee92d0b 100644
--- a/Sources/OpenAPIKit/Request/DereferencedRequest.swift
+++ b/Sources/OpenAPIKit/Request/DereferencedRequest.swift
@@ -64,8 +64,11 @@ extension OpenAPI.Request: LocallyDereferenceable {
 
 extension OpenAPI.Request: ExternallyDereferenceable {
     public func externallyDereferenced<Context: ExternalLoaderContext>(with loader: Context.Type) async throws -> (Self, OpenAPI.Components) { 
-        // TODO: externally dereference the content
-#warning("externally dereference the content")
-        return (self, .init())
+        var newRequest = self
+
+        let (newContent, components) = try await content.externallyDereferenced(with: loader)
+
+        newRequest.content = newContent
+        return (newRequest, components)
     }
 }