Nested object

[BeniVF]

Objective

You can find, the objectives for all these PRs here: https://github.com/47deg/marlow/issues/188

Generating http4s client code based on a Open API specification using http4s v0.20 and 0.18 using circe to encode/decode.

Problem

Open api spec is based on Yaml/Json to define types, this means that not all the types have a name. You can inline objects if you want to. However, this can create a problematic situation when the objects are nested inside the Yaml/Json tree. Let's look at an example when Person is inline inside a Owner.

   Owner:
      required:
        - person
      properties:
        address: 
          type: string
        person:
          type: object
          required:
           - name
           - surname
          properties:
            name:
              type: string
            surname:
              type: string
            age: 
              type: integer

However, when we generate code, we can create the following situations:

final case class Owner(address: Option[String], person: final case class Person(name: String, surname: String, age: Option[Int]))

As we can see this code is not valid scala code, then we need to figure out a way to extract these nested objects from the json/yaml tree. Ideally, we should try to generate the following code:

final case class Owner(address: Option[String], person: Person)
final case class Person(name: String, surname: String, age: Option[Int])

We need to apply this solution to the schemas itself (T) and to the components, requestBody and responses in the OpenApi Tree.

Solution

In order to solve this, we have created the following entry functions to avoid the problem described above:

• For Schemas (check outNestedObjectSpecification for more details):

def nestedTypes[T: Basis[JsonSchemaF, ?]]: T => NestedTypesState[T, T]

NestedTypesState is type used to accumulate the (String, T) we find (e.g. Person) and with a counter to avoid duplicated types (anonymous or not). At the end of the execution of NestedTypesState we should incorporate all the new schemas found into #/components/schemas.

• For OpenApi (check out OpenApiNestedObjectSpecification for more details):

def extractNestedTypes[T: Basis[JsonSchemaF, ?]](openApi: OpenApi[T]): OpenApi[T]

Previous PRs

• Print encoders #109
• Ff/print multiple responses #102
• Ff/print open api #97
• Ff/open api to mu #90
• Adds the parameters to an operation #81

[vil1]

This looks pretty good!
I think that traversing the tree within a State is definitely the way to go.

I think the implementation could be made more efficient by adding more information in the state though. And I also have a question about some corner cases.

[juanpedromoreno]

👍

[pepegar]

Looks great, thanks Beni :)