WIP move parameter schema or content into parameter context

Author: mattpolzin

Sources/OpenAPIKit/Parameter/DereferencedParameter.swift

@@ -90,26 +90,59 @@ extension OpenAPI.Parameter: ExternallyDereferenceable {
         // next line:
 //        let (newSchemaOrContent, components) = try await schemaOrContent.externallyDereferenced(with: loader)
 
-        let newSchemaOrContent: Either<SchemaContext, OpenAPI.Content.Map>
+        let newContext: OpenAPI.Parameter.Context
         let newComponents: OpenAPI.Components
         let newMessages: [Loader.Message]
 
-        switch schemaOrContent {
-        case .a(let schemaContext):
-            let (context, components, messages) = try await schemaContext.externallyDereferenced(with: loader)
-            newSchemaOrContent = .a(context)
-            newComponents = components
-            newMessages = messages
-        case .b(let contentMap):
-            let (map, components, messages) = try await contentMap.externallyDereferenced(with: loader)
-            newSchemaOrContent = .b(map)
-            newComponents = components
-            newMessages = messages
+        switch context {
+        case .query(required: let required, allowEmptyValue: let allowEmptyValue, schemaOrContent: let schemaOrContent):
+            let newSchemaOrContent: Either<OpenAPI.Parameter.SchemaContext, OpenAPI.Content.Map>
+            (newSchemaOrContent, newComponents, newMessages) = try await externallyDereference(schemaOrContent: schemaOrContent, with: Loader.self)
+
+            newContext = .query(required: required, allowEmptyValue: allowEmptyValue, schemaOrContent: newSchemaOrContent)
+
+        case .header(required: let required, schemaOrContent: let schemaOrContent):
+            let newSchemaOrContent: Either<OpenAPI.Parameter.SchemaContext, OpenAPI.Content.Map>
+            (newSchemaOrContent, newComponents, newMessages) = try await externallyDereference(schemaOrContent: schemaOrContent, with: Loader.self)
+
+            newContext = .header(required: required, schemaOrContent: newSchemaOrContent)
+
+        case .path(schemaOrContent: let schemaOrContent):
+            let newSchemaOrContent: Either<OpenAPI.Parameter.SchemaContext, OpenAPI.Content.Map>
+            (newSchemaOrContent, newComponents, newMessages) = try await externallyDereference(schemaOrContent: schemaOrContent, with: Loader.self)
+
+            newContext = .path(schemaOrContent: newSchemaOrContent)
+
+        case .cookie(required: let required, schemaOrContent: let schemaOrContent):
+            let newSchemaOrContent: Either<OpenAPI.Parameter.SchemaContext, OpenAPI.Content.Map>
+            (newSchemaOrContent, newComponents, newMessages) = try await externallyDereference(schemaOrContent: schemaOrContent, with: Loader.self)
+
+            newContext = .cookie(required: required, schemaOrContent: newSchemaOrContent)
+
+        case .querystring(required: let required, content: let content):
+            let newContent: OpenAPI.Content.Map
+            (newContent, newComponents, newMessages) = try await content.externallyDereferenced(with: Loader.self)
+
+            newContext = .querystring(required: required, content: newContent)
         }
 
         var newParameter = self
-        newParameter.schemaOrContent = newSchemaOrContent
+        newParameter.context = newContext
 
         return (newParameter, newComponents, newMessages)
     }
 }
+
+fileprivate func externallyDereference<Loader: ExternalLoader>(
+    schemaOrContent: Either<OpenAPI.Parameter.SchemaContext, OpenAPI.Content.Map>,
+    with loader: Loader.Type
+) async throws -> (Either<OpenAPI.Parameter.SchemaContext, OpenAPI.Content.Map>, OpenAPI.Components, [Loader.Message]) {
+    switch schemaOrContent {
+    case .a(let schemaContext):
+        let (context, components, messages) = try await schemaContext.externallyDereferenced(with: loader)
+        return (.a(context), components, messages)
+    case .b(let contentMap):
+        let (map, components, messages) = try await contentMap.externallyDereferenced(with: loader)
+        return (.b(map), components, messages)
+    }
+}

Sources/OpenAPIKit/Parameter/Parameter.swift

@@ -25,22 +25,6 @@ extension OpenAPI {
         /// if unspecified and only gets encoded if true.
         public var deprecated: Bool // default is false
 
-        /// OpenAPI Spec "content" or "schema" properties.
-        ///
-        /// You can access the schema context (if it is in use for
-        /// this parameter) with `schemaOrContent.schemaContextValue`.
-        /// The schema context contains lots of information detailed in the
-        /// OpenAPI specification under the **Parameter Object** section.
-        ///
-        /// You can directly access the underlying `JSONSchema` with
-        /// `schemaOrContent.schemaValue`. If the schema is a reference
-        /// instead of an inline value, `schemaOrContent.schemaReference`
-        /// will get you the reference.
-        ///
-        /// You can access the content map (if it is in use for
-        /// this parameter) with `schemaOrContent.contentValue`.
-        public var schemaOrContent: Either<SchemaContext, OpenAPI.Content.Map>
-
         /// Dictionary of vendor extensions.
         ///
         /// These should be of the form:
@@ -58,88 +42,45 @@ extension OpenAPI {
         /// parameter.
         public var location: Context.Location { return context.location }
 
-        /// Create a parameter with an `Either<SchemaContext, OpenAPI.Content.Map>`.
-        public init(
-            name: String,
-            context: Context,
-            schemaOrContent: Either<SchemaContext, OpenAPI.Content.Map>,
-            description: String? = nil,
-            deprecated: Bool = false,
-            vendorExtensions: [String: AnyCodable] = [:]
-        ) {
-            self.name = name
-            self.context = context
-            self.schemaOrContent = schemaOrContent
-            self.description = description
-            self.deprecated = deprecated
-            self.vendorExtensions = vendorExtensions
-        }
-
-        /// Create a parameter with a `SchemaContext`.
-        public init(
-            name: String,
-            context: Context,
-            schema: SchemaContext,
-            description: String? = nil,
-            deprecated: Bool = false,
-            vendorExtensions: [String: AnyCodable] = [:]
-        ) {
-            self.name = name
-            self.context = context
-            self.schemaOrContent = .init(schema)
-            self.description = description
-            self.deprecated = deprecated
-            self.vendorExtensions = vendorExtensions
-        }
-
-        /// Create a parameter with a `JSONSchema` and the default
-        /// `style` for the given `Context`.
-        public init(
-            name: String,
-            context: Context,
-            schema: JSONSchema,
-            description: String? = nil,
-            deprecated: Bool = false,
-            vendorExtensions: [String: AnyCodable] = [:]
-        ) {
-            self.name = name
-            self.context = context
-            self.schemaOrContent = .init(SchemaContext(schema, style: .default(for: context)))
-            self.description = description
-            self.deprecated = deprecated
-            self.vendorExtensions = vendorExtensions
-        }
-
-        /// Create a parameter with a reference to a `JSONSchema`
-        /// and the default `style` for the given `Context`.
-        public init(
-            name: String,
-            context: Context,
-            schemaReference: OpenAPI.Reference<JSONSchema>,
-            description: String? = nil,
-            deprecated: Bool = false,
-            vendorExtensions: [String: AnyCodable] = [:]
-        ) {
-            self.name = name
-            self.context = context
-            self.schemaOrContent = .init(SchemaContext(schemaReference: schemaReference, style: .default(for: context)))
-            self.description = description
-            self.deprecated = deprecated
-            self.vendorExtensions = vendorExtensions
+        /// OpenAPI Spec "content" or "schema" properties.
+        ///
+        /// You can access the schema context (if it is in use for
+        /// this parameter) with `schemaOrContent.schemaContextValue`.
+        /// The schema context contains lots of information detailed in the
+        /// OpenAPI specification under the **Parameter Object** section.
+        ///
+        /// You can directly access the underlying `JSONSchema` with
+        /// `schemaOrContent.schemaValue`. If the schema is a reference
+        /// instead of an inline value, `schemaOrContent.schemaReference`
+        /// will get you the reference.
+        ///
+        /// You can access the content map (if it is in use for
+        /// this parameter) with `schemaOrContent.contentValue`.
+        public var schemaOrContent: Either<SchemaContext, OpenAPI.Content.Map> {
+              switch context {
+              case .query(required: _, allowEmptyValue: _, schemaOrContent: let schemaOrContent):
+                  return schemaOrContent
+              case .header(required: _, schemaOrContent: let schemaOrContent):
+                  return schemaOrContent
+              case .path(schemaOrContent: let schemaOrContent):
+                  return schemaOrContent
+              case .cookie(required: _, schemaOrContent: let schemaOrContent):
+                  return schemaOrContent
+              case .querystring(required: _, content: let content):
+                  return .content(content)
+              }
         }
 
-        /// Create a parameter with a `Content.Map`.
+        /// Create a parameter.
         public init(
             name: String,
             context: Context,
-            content: OpenAPI.Content.Map,
             description: String? = nil,
             deprecated: Bool = false,
             vendorExtensions: [String: AnyCodable] = [:]
         ) {
             self.name = name
             self.context = context
-            self.schemaOrContent = .init(content)
             self.description = description
             self.deprecated = deprecated
             self.vendorExtensions = vendorExtensions
@@ -173,32 +114,10 @@ extension OpenAPI.Parameter {
 // OpenAPI.PathItem.Array.Element =>
 extension Either where A == OpenAPI.Reference<OpenAPI.Parameter>, B == OpenAPI.Parameter {
 
-    /// Construct a parameter using a `JSONSchema`.
-    public static func parameter(
-        name: String,
-        context: OpenAPI.Parameter.Context,
-        schema: JSONSchema,
-        description: String? = nil,
-        deprecated: Bool = false,
-        vendorExtensions: [String: AnyCodable] = [:]
-    ) -> Self {
-        return .b(
-            .init(
-                name: name,
-                context: context,
-                schema: schema,
-                description: description,
-                deprecated: deprecated,
-                vendorExtensions: vendorExtensions
-            )
-        )
-    }
-
-    /// Construct a parameter using a `Content.Map`.
+    /// Construct a parameter.
     public static func parameter(
         name: String,
         context: OpenAPI.Parameter.Context,
-        content: OpenAPI.Content.Map,
         description: String? = nil,
         deprecated: Bool = false,
         vendorExtensions: [String: AnyCodable] = [:]
@@ -207,7 +126,6 @@ extension Either where A == OpenAPI.Reference<OpenAPI.Parameter>, B == OpenAPI.P
             .init(
                 name: name,
                 context: context,
-                content: content,
                 description: description,
                 deprecated: deprecated,
                 vendorExtensions: vendorExtensions
@@ -238,23 +156,23 @@ extension OpenAPI.Parameter: Encodable {
         let required: Bool
         let location: Context.Location
         switch context {
-        case .query(required: let req, allowEmptyValue: let allowEmptyValue):
+        case .query(required: let req, allowEmptyValue: let allowEmptyValue, schemaOrContent: _):
             required = req
             location = .query
 
             if allowEmptyValue {
                 try container.encode(allowEmptyValue, forKey: .allowEmptyValue)
             }
-        case .header(required: let req):
+        case .header(required: let req, schemaOrContent: _):
             required = req
             location = .header
-        case .path:
+        case .path(schemaOrContent: _):
             required = true
             location = .path
-        case .cookie(required: let req):
+        case .cookie(required: let req, schemaOrContent: _):
             required = req
             location = .cookie
-        case .querystring(required: let req):
+        case .querystring(required: let req, content: _):
             required = req
             location = .querystring
         }
@@ -266,7 +184,7 @@ extension OpenAPI.Parameter: Encodable {
 
         switch schemaOrContent {
         case .a(let schema):
-            try schema.encode(to: encoder, for: context)
+            try schema.encode(to: encoder, for: location)
         case .b(let contentMap):
             try container.encode(contentMap, forKey: .content)
         }
@@ -293,44 +211,16 @@ extension OpenAPI.Parameter: Decodable {
         let required = try container.decodeIfPresent(Bool.self, forKey: .required) ?? false
         let location = try container.decode(Context.Location.self, forKey: .parameterLocation)
 
-        switch location {
-        case .query:
-            let allowEmptyValue = try container.decodeIfPresent(Bool.self, forKey: .allowEmptyValue) ?? false
-            context = .query(required: required, allowEmptyValue: allowEmptyValue)
-        case .header:
-            context = .header(required: required)
-        case .path:
-            if !required {
-                throw GenericError(
-                    subjectName: name,
-                    details: "positional path parameters must be explicitly set to required",
-                    codingPath: decoder.codingPath
-                )
-            }
-            context = .path
-        case .cookie:
-            context = .cookie(required: required)
-        case .querystring:
-            context = .querystring(required: required)
-        }
-
         let maybeContent = try container.decodeIfPresent(OpenAPI.Content.Map.self, forKey: .content)
 
         let maybeSchema: SchemaContext?
         if container.contains(.schema) {
-            maybeSchema = try SchemaContext(from: decoder, for: context)
+            maybeSchema = try SchemaContext(from: decoder, for: location)
         } else {
             maybeSchema = nil
         }
 
-        if location == .querystring && maybeSchema != nil {
-            throw GenericError(
-                subjectName: name,
-                details: "`schema` and `style` are disallowed for `querystring` parameters",
-                codingPath: decoder.codingPath
-            )
-        }
-
+        let schemaOrContent: Either<SchemaContext, OpenAPI.Content.Map>
         switch (maybeContent, maybeSchema) {
         case (let content?, nil):
             schemaOrContent = .init(content)
@@ -350,6 +240,34 @@ extension OpenAPI.Parameter: Decodable {
             )
         }
 
+        switch location {
+        case .query:
+            let allowEmptyValue = try container.decodeIfPresent(Bool.self, forKey: .allowEmptyValue) ?? false
+            context = .query(required: required, allowEmptyValue: allowEmptyValue, schemaOrContent: schemaOrContent)
+        case .header:
+            context = .header(required: required, schemaOrContent: schemaOrContent)
+        case .path:
+            if !required {
+                throw GenericError(
+                    subjectName: name,
+                    details: "positional path parameters must be explicitly set to required",
+                    codingPath: decoder.codingPath
+                )
+            }
+            context = .path(schemaOrContent: schemaOrContent)
+        case .cookie:
+            context = .cookie(required: required, schemaOrContent: schemaOrContent)
+        case .querystring:
+            guard case .b(let content) = schemaOrContent else {
+                throw GenericError(
+                    subjectName: name,
+                    details: "`schema` and `style` are disallowed for `querystring` parameters",
+                    codingPath: decoder.codingPath
+                )
+            }
+            context = .querystring(required: required, content: content)
+        }
+
         description = try container.decodeIfPresent(String.self, forKey: .description)
 
         deprecated = try container.decodeIfPresent(Bool.self, forKey: .deprecated) ?? false