Passing unnamed query parameters to a struct

[sbwilson]

Thanks for another great library. This one seems to be making my life a little easier, but I have a question about using unnamed queries.

I'm implementing a router for the FHIR API for health care interoperability to use in a client application. This API has a huge number of resource types we can access like https://<host>/<base>/Patient/<identifier>, but also provides the ability to search for these resources.

The API defines a number of common search parameters that are all passed as queries, such as _type to limit the resource types to search, and _content to search in all fields of the resource. But for each resource, the API permits other fields to search on, which are also passed as queries (given or surname for a Patient, or ingredient for a Medication). R4 of the API defines 145 different resources, and each can have a number of search fields, and these numbers keep growing with later versions.

Currently, I define the following as my routes:

public enum FHIRRoute: Equatable {
    // ....
    case search(SearchParameters)
    // ....

    public struct SearchParameters: Equatable {
        public var type: String? 
        // ... and other types 
        public init(type: String? = nil, ... ) {
           //  ... setters
        }
    }
}

and the parser body as:

OneOf {
    // ... other routes
    Route(.case(FHIRRoute.search)) {
        Parse(.memberwise(FHIRRoute.SearchParameters.init(/*all parameters*/))) {
            // Set the parameters with the named fields
            Optionally { Field("_type", .string) } 
            // ... 
            // ? Can I pass other arguments here ?
        }
    }
}

Question: Is there a way to pass the unparsed query parameters, or the entire list of query parameters, to my SearchParameters struct?

Thanks!

[sbwilson]

Having spent some more time pondering this, I've created the following, which seems to do what I needed (ie returns the entire query dictionary):

/// Returns all the provided queries as a raw Fields object: 
public struct AllQueries: Parser {
	@inlinable
	public func parse(_ input: inout URLRequestData) throws -> URLRequestData.Fields {
		input.query
	}
}

extension AllQueries: ParserPrinter {
	public func print(_ output: URLRouting.URLRequestData.Fields, into input: inout URLRouting.URLRequestData) throws {
		// Merge the two query lists, replacing existing values with the new ones: 
		input.query.fields.merge(output) { (_,new) in new }
	}
}

Have I made any blunders here?

[kamcma]

I believe a fundamental aspect of parsers is that they consume their input. Any query fields you are going to return from the parser, you should remove from the inout URLRequestData's query property. If you are going to return all of them, then you should empty out the property. I believe it is ExpressibleByDictionaryLiteral, so you could set it to [:].

Without this, you could parse the same query field twice in the same route parser, which is nonsensical and not what you want to happen:

AllQueries()  // parses ?surname=foo
Query {
  Field("surname") // also parses ?surname=foo ???
}

Also your print operation I think technically needs to find a way to prepend to the query property, because URLRequestData.Fields considers order significant (it wraps an OrderedDictionary), and if you lose order with a merge operation, your ParserPrinter might fail a round-trip test. I'm not sure if URLRequestData.Fields exposes any way to do this; you may actually want to parse to an OrderedDictionary directly, because OrderedDictionary does have an updateValue(_:forKey:insertingAt:) method, letting you explicitly prepend.