[typescript-angular] Primitive typed parameters

[kewinbrand]

Hi,

I have some API's that contain primitive parameters in the request body of POST requests.
The problem is that primtive parameters are forced to be JSON encoded, generating random
interfaces like:

export interface Body2 {
usuario: OctopusEntitiesColetorTUsuario;
iRecnoSolicitacao: number;
}

This also happens to responses classes.

Thank you.

Swagger-codegen version

2.4.0.
Also tested on 2.3.0. Same problem.

Swagger declaration file content or url

"/WmsService/AlocarTransferirMateriaisWms":{
         "post":{
            "tags":[
               "WmsService"
            ],
            "operationId":"IWmsService.AlocarTransferirMateriaisWms",
            "consumes":[
               "application/json"
            ],
            "produces":[
               "application/json"
            ],
            "parameters":[
               {
                  "in":"body",
                  "name":"body",
                  "required":true,
                  "schema":{
                     "type":"object",
                     "properties":{
                        "sCodigoItem":{
                           "type":"string"
                        },
                        "sLote":{
                           "type":"string"
                        },
                        "sMotivoMovimentacao":{
                           "type":"string"
                        },
                        "sUsuarioSistema":{
                           "type":"string"
                        },
                        "dQtdeMovimentacao":{
                           "type":"number"
                        },
                        "iNumeroOdf":{
                           "type":"integer"
                        },
                        "iCodigoLocalOrigem":{
                           "type":"integer"
                        },
                        "iCodigoLocalDestino":{
                           "type":"integer"
                        },
                        "iEmpresaRecno":{
                           "type":"integer"
                        }
                     },
                     "required":[
                        "sCodigoItem",
                        "sLote",
                        "sMotivoMovimentacao",
                        "sUsuarioSistema",
                        "dQtdeMovimentacao",
                        "iNumeroOdf",
                        "iCodigoLocalOrigem",
                        "iCodigoLocalDestino",
                        "iEmpresaRecno"
                     ]
                  }
               }
            ],
            "responses":{
               "200":{
                  "description":"Successful response",
                  "schema":{
                     "type":"object",
                     "properties":{
                        "value":{
                           "type":"boolean"
                        }
                     }
                  }
               }
            }
         }
      },

[macjohnny]

@kewinbrand I would say this is how it is supposed to work.
What code would you expect with your API definition?

[kewinbrand]

Hi @macjohnny,

Should not codegen generate the methods with the primitive parameters instead of force to be classes?
Thank you.

[macjohnny]

@kewinbrand since you are transferring data with content-type "application/json" and your body is an object with several properties, the codegen does what I would expect.
I think this issue should be closed.

[kewinbrand]

Hi @macjohnny,

Actually my body is not an object with several properties. The method takes 9 primitive parameters:

AlocarTransferirMateriaisWms(string param1, string param2....)

Should not codegen generate something like:

alocarTransferirMateriaisWms(string param1, string param2...)

Thank you.

[macjohnny]

@kewinbrand in your parameters array, there is only one entry, i.e.

          "parameters":[
               {
                  "in":"body",
                  "name":"body",
                  "required":true,
                  "schema":{
                     "type":"object",
                     "properties":{
                        "sCodigoItem":{
                           "type":"string"
                        },
                        "sLote":{
                           "type":"string"
                        },
                  ...
               }
          ]

This one entry is the definition of your request body format, and containts several properties.
There can only be one body parameter, as your request sends this as a whole and can't merge multiple body entries.

I believe this is the reason for generating the interface to define your body format.

See also https://github.com/OAI/OpenAPI-Specification/blob/master/versions/2.0.md#body-parameters

[macjohnny]

I think this issue should be closed.
@wing328 what is your opinion on that?

[kewinbrand]

hi @macjohnny,

So my swagger declaration is incorrect? If so how should it be to codegen treat them as primitive parameters?

Thank you.

[macjohnny]

@kewinbrand your swagger declaration is correct,
IMHO you can't have body parts specified as separate primitive parameters.

[wlandgraf]

@macjohnny, I think what is being asked here is a feature in swagger-codegen: if the body parameter only contains primitive properties, the generated interface could make the method more user friendly and receive the parameters as primitives.

What would be your suggestion to send primitive parameters to the server, without sending them through the URL?

[macjohnny]

@wlandgraf @kewinbrand you are right, it would make the generated method signatures more user-friendly.
However, I think this would mean a lot of work to achieve this, since you can't loop through parameters but you need to loop through the properties of one parameter, and you need to check in advance whether to do so.
So IMHO having one parameter typed by a well defined interface is good enough, since

myApi.myMethod({bodyParam1: 88, bodyParam2: 66})

isn't that different from

myApi.myMethod(88, 66)

is it?

[kewinbrand]

@macjohnny

I agree that having only one typed parameter is enough, but is it possible to at least define the names of these interfaces being generated instead of being "Body2, Body3, etc"?

[kewinbrand]

@macjohnny

Maybe the -operationid-Body could be used as interface name when this case happens?

[macjohnny]

@kewinbrand I agree with you that if the operationId is set, this would represent a better name for the interface.
Would you like to give it a try and file a PR?