I am defining a REST API in OpenAPI3 (Swagger).
I have an API that has a POST which uses a Model I have defined in teh components section as follows:
post:
summary: "Used to add some data"
operationId: postMyData
requestBody:
content:
application/json:
schema:
$ref: '#/components/schemas/MyModel'
required: true
components:
schemas:
MyModel:
type: object
properties:
SomeProperty1:
type: string
SomeProperty2:
type: string
SomeProperty3:
$ref: '#/components/schemas/SomeOtherModel'
SomeProperty4:
type: string
Now I have a PATCH API call that I want to use to update only some data of MyModel, e.g. SomeProperty1 and SomeProperty4.
Should I define a new Model for this PATCH operation? like so:
MyPATCHModel:
type: object
properties:
SomeProperty1:
type: string
SomeProperty4:
type: string
And then use this new MyPATCHModel in the requestBody of the PATCH operation? What is the standard practice here as I will have several API that are similar to this.
Check the docs on combining JSON schemas.
In your case you could for example define a shared MyModel schema with the two properties used in the PATCH method, and then another NewMyModel schema that uses allOf to combine MyModel with the POST-only properties.
Check this question for a concrete example.
Related
In my service schema I've got a single object that has two choices of properties. Meaning;
Object A needs: property 1 or 2, and property 3 or 4.
To realise this in OAS I'm using an object with an allOf property, which contains two items containing a oneOf property. I don't see a reason why this construction would be illegal. However, when using the swagger editor (https://editor.swagger.io/) and the Swagger Viewer extension in VSCode, it merges the two oneOf properties into a single one, effectively instructing the user to either include property 1, 2, 3 or 4.
One other way to achieve the same is to define a schema for every combination of choice 1 and 2, but this gets very tedious as the amount of options expands (effectively multiplying for every combination of the two choices).
Is my interpretation of the way this should work correct? If not, how can I achieve my goal without the spec becoming too verbose? If yes, I take it this is an issue in both tools I'm using, in that case I'll raise an issue in the respective issue trackers.
Example OAS spec:
openapi: 3.0.3
info:
description: Test API
version: 0.1.0
title: Test API
paths:
/test:
post:
requestBody:
required: true
content:
application/json:
schema:
$ref: '#/components/schemas/TestComplexObject'
responses:
'200':
description: OK
components:
schemas:
TestComplexObject:
type: object
allOf:
- type: object
properties:
defaultString:
type: string
- oneOf:
- $ref: '#/components/schemas/TestStr1'
- $ref: '#/components/schemas/TestStr2'
- oneOf:
- $ref: '#/components/schemas/TestStr3'
- $ref: '#/components/schemas/TestStr4'
TestStr1:
type: object
properties:
testString1:
type: string
required: [testString1]
TestStr2:
type: object
properties:
testString2:
type: string
required: [testString2]
TestStr3:
type: object
properties:
testString3:
type: string
required: [testString3]
TestStr4:
type: object
properties:
testString4:
type: string
required: [testString4]
I described my controller using Swagger but when I tried to extract .yaml description of controller, as response of endpoints I found list of objects. How to make Swagger describe those list as list of particular objects such as list of cars, list of houses, list of animals, etc. and then to describe what particular object like car, house or animal is.
My case is:
/dummy_endpoint:
get:
tags:
- foo-controller
summary: Get foo list
description: Send GET request to obtain foo list
operationId: findAllFooUsingGET
produces:
- application/json
responses:
'200':
description: Foo list obtained successfully
schema:
type: array
items:
type: object
'401':
description: Unauthorized
'403':
description: Forbidden
'404':
description: Not Found
What I want to get:
/dummy_endpoint:
get:
tags:
- foo-controller
summary: Get foo list
description: Send GET request to obtain foo list
operationId: findAllFooUsingGET
produces:
- application/json
responses:
'200':
description: Foo list obtained successfully
schema:
type: array
items:
type: Foo
'401':
description: Unauthorized
'403':
description: Forbidden
'404':
description: Not Found
definitions:
Foo:
type: object
properties:
id:
type: integer
format: int32
name:
type: String
I assume OpenAPI version 2.0 (based on the syntax in example). If you're using 3.0, let me know.
What you are looking for is ref. Check-in Swagger specification in section Input and Output Models and here in section Array and Multi-Value Parameters about arrays.
For example:
...
responses:
'200':
description: Foo list obtained successfully
schema:
type: array
items:
$ref: "#/definitions/Foo"
...
definitions:
Foo:
type: object
properties:
...
Thing that solved my problem was the usage of responseContainer property from #ResponseApi annotation, where I put type of response container like List, Array etc. and putting into response property type of objects that are stored into container.
Here the documentation explains how to define discriminators when an OpenAPI schema is dependent on the value of a property. In my own project, I have a schema that is dependent on the values of two properties, not just one. I wonder whether there is any way to model that in an OpenAPI file?
Let's say we have a list of requests with two required enum properties:
requestType: It could be either of these values:
New
Old
periodType: It could be either of these values:
Temporary
Permanent
The values of the rest of properties are somehow dependent on the values of these 2 fields. So there are 4 possible schemas which we want to discriminate them based on these 2 fields. One possible solution that came to my mind was to use a nested structure like this:
ListResponse:
type: array
items:
oneOf:
- $ref: '#/components/schemas/NewRequestResponse'
- $ref: '#/components/schemas/OldRequestResponse'
discriminator:
propertyName: requestType
mapping:
'New':
oneOf:
- $ref: '#/components/schemas/NewTemporaryRequestResponse'
- $ref: '#/components/schemas/NewPermanentRequestResponse'
discriminator:
propertyName: periodType
mapping:
'Temporary': '#/components/schemas/NewTemporaryRequestResponse'
'Permanent': '#/components/schemas/NewPermanentRequestResponse'
'Old':
oneOf:
- $ref: '#/components/schemas/OldTemporaryRequestResponse'
- $ref: '#/components/schemas/OldPermanentRequestResponse'
discriminator:
propertyName: periodType
mapping:
'Temporary': '#/components/schemas/OldTemporaryRequestResponse'
'Permanent': '#/components/schemas/OldPermanentRequestResponse'
uniqueItems: true
But seemingly this is not a valid schema. So, how could it be done?
The swagger docs site shows an example for this case, but it does not follow through all the way to show the definition of the Pet schema.
E.g.:
paths:
/pets:
post:
summary: Add a new pet
requestBody:
$ref: '#/components/requestBodies/PetBody'
/pets/{petId}
put:
summary: Update a pet
parameters: [ ... ]
requestBody:
$ref: '#/components/requestBodies/PetBody'
components:
requestBodies:
PetBody:
description: A JSON object containing pet information
required: true
content:
application/json:
schema:
$ref: '#/components/schemas/Pet'
I don't understand where the request body parameter names go in this scenario. I want to see the definition of #/components/schemas/Pet. For query parameters you have the components/parameters where you can define a name and a schema for each parameter. But I don't see the equivalent for the request body parameters. For example if I have a POST /api/pets with an application/json body of:
{ "name": "Fluffy", "type": "cat", "legs": 4 }
Where do I describe the parameters name, type and legs including their names?
Also on an unrelated topic it would be nice if there was a tag for OpenAPI v3.0 (not sure how to create one)
Also possible related question here.
After scouring the swagger docs I think I understand it now, I think the Pet schema would be:
components:
schemas:
Pet:
type: object
properties:
name:
type: string
type:
type: string
legs:
type: integer
required:
- type
I was missing out on the properties attribute.
I would like to post an array of strings like
[
"id1",
"id2"
]
to a Swagger based API. In my swagger file, I have those lines:
paths:
/some_url:
post:
parameters:
- name: ids
in: body
required: true
What is the correct way to specify the type of ids as an array of strings?
Update:
According to the specification, the following should work in my option:
parameters:
- in: body
description: xxx
required: true
schema:
type: array
items:
type: string
https://github.com/Yelp/swagger_spec_validator does not accept it and returns a long list of convoluted errors, which look like the code expects some $ref.
Your description of an array of string is correct, but the parameter definition misses the name property to be valid.
Here's a full working example:
swagger: "2.0"
info:
title: A dummy title
version: 1.0.0
paths:
/path:
post:
parameters:
- in: body
description: xxx
required: true
name: a name
schema:
type: array
items:
type: string
responses:
default:
description: OK
Try the online editor to check your OpenAPI (fka. Swagger) specs: http://editor.swagger.io/
I have created a swagger issue as the help provided by Arnaud, although is valid yaml, will give you NPE exceptions when trying to generate. You will need to provide an object like the following:
myDataItem:
type: object
description: A list of values
required:
- values
properties:
values:
type: array
items:
type: string
And then refer to it (in your post item etc):
schema:
$ref: "#/definitions/myDataItem"
For reference the github issue:
https://github.com/swagger-api/swagger-codegen/issues/6745
Note, the issue has been fixed in version 2.3.0 and higher, ideally you should upgrade to that version.
None of the answers worked for me. As it is stated in the following Baeldung article:
To better document the API and instruct the user, we can use the example label of how to insert values
So the full working example would be something like that:
swagger: "2.0"
info:
title: A dummy title
version: 1.0.0
paths:
/path:
post:
parameters:
- in: body
description: xxx
required: true
name: a name
schema:
type: array
items:
type: string
example: ["str1", "str2", "str3"]
responses:
default:
description: OK
You can check how the Example Value is now better informed in the Swagger editor.
For Array containing Object as it's content, definition for Object can be also expressed using definitions & $ref.
Example:
schema:
type: array
items:
$ref: '#/definitions/ObjectSchemaDefinition'
definitions:
ObjectSchemaDefinition:
type: string
The answer with the most votes got me in the right direction. I just needed an example of an array of objects where each one of them had a property which was an array of strings with more than one value in the strings array. Thanks to the documentation I got it working like this:
MyObject:
type: object
properties:
body:
type: array
items:
type: object
properties:
type:
type: string
values:
type: array
items:
type: string
example:
- type: "firstElement"
values: ["Active", "Inactive"]
- type: "SecondElement"
values: ["Active", "Inactive"]
One thing to keep in mind is that indentation is of paramount importance to swagger. If you don't indent things well, swagger will give you strange error messages.