Is a fractional part of ".0" allowed for integers?

[mkauf]

Please clarify: Are values like 1.0 valid for the integer data type?

JSON schema allows values like 1.0 for integers. But the OpenAPI specification contains this sentence:

Note that integer as a type is also supported and is defined as a JSON number without a fraction or exponent part.

"without a fraction or exponent part" - does that mean that the number is not allowed to have a fraction part at all, e.g. 1 is valid but 1.0 is invalid? Or does it mean that a fraction of 0 is allowed, so 1 is valid and 1.0 is also valid?

Are the rules the same for JSON parameters and for query parameters?

For example, consider this OpenAPI specification:

{
    "openapi": "3.0.0",
    "info": {
        "title": "Integers",
        "version": "1.0"
    },
    "paths": {
        "/path1": {
            "post": {
                "requestBody": {
                    "content": {
                        "application/json": {
                            "schema": {
                                "type": "object",
                                "properties": {
                                    "value": {
                                        "type": "integer"
                                    }
                                }
                            }
                        }
                    }
                },
                "responses": {
                    "default": {
                        "description": "test"
                    }
                }
            }
        },
        "/path2": {
            "get": {
                "parameters": [
                    {
                        "in": "query",
                        "name": "a",
                        "schema": {
                            "type": "integer"
                        }
                    }
                ],
                "responses": {
                    "default": {
                        "description": "test"
                    }
                }
            }
        }
    }
}

Are these requests valid?

• Request 1:

curl -H "Content-Type: application/json" --data '{ "value": 1.0 }' 'http://localhost/path1'

• Request 2:

curl 'http://localhost/path2?a=1.0'

[webron]

It looks like you're referencing OpenAPI 3.0 which uses JSON Schema draft-6/draft-0. That version of JSON Schema does not have an integer data type. The definition was added since we moved from draft 4, which did have an integer definition, though otherwise the draft versions are pretty much identical.

Draft 06 does have some additional information about mathematical integers, and suggest not using a decimal point for integer values, even though it is technically supported.

Long story short, the fractional part is not allowed.

[webron]

Yeah, I'm aware of it, just didn't mention it 😬. However, I believe since then it was decided not to bring it back? The current version says:

Note that JSON Schema vocabularies are free to define their own extended type system. This should not be confused with the core data model types defined here. As an example, "integer" is a reasonable type for a vocabulary to define as a value for a keyword, but the data model makes no distinction between integers and other numbers.

[mkauf]

@webron Thank you very much for the clarification!

I got confused by a wrong HTTP request presented by a customer, and by this document. So I thought that ".0" is maybe not a fractional part after all...

But now I understand that OpenAPI overrides this and does not accept ".0" for integers.

[jdesrosiers]

@webron No, "integer" is and always has been a valid type. I agree that that quote is confusing. It should probably also mention that not only is it reasonable, but that's exactly what the validation vocabulary does with the type keyword.

[webron]

@jdesrosiers is there a reason why it's not mentioned as a type here then? Seems confusing.

[jdesrosiers]

It's definitely confusing. The JSON Schema data model is based on JSON, which is what this section is describing. The JSON Schema type keyword is a validation keyword. It's not declaring the actual type of the value like int x = 0;. It's asking the question, "is this thing an integer?". In the case of the other types, that's equivalent to checking the JSON type, but for "integer" it means checking if it's of type "number" and is mathematically in the set of integers. That's why JSON Schema considers 1.0 an integer. Because there is no integer type in JSON, integers are represented with numbers. Therefore, 1 and 1.0 are both numbers and are indistinguishable in the JSON data model. There's no way to tell the difference.

I guess you can say there is no "integer" type in JSON Schema, but can use "integer" as a value for type as a shorthand for { "type": "number", "multipleOf": 1 }.

[handrews]

Answered, closing.