From b1de687c7f8afaa9bca6eb860108b80a0cceebfd Mon Sep 17 00:00:00 2001 From: Tanmay Mohapatra Date: Thu, 10 Apr 2025 23:30:29 +0530 Subject: [PATCH] [julia] better serverside validation code (#21072) * [julia] better serverside validation code Updating the code generated for julia server to add more checks in the validation stage of incoming requests. Particularly adds checks for request body and required parameters. Updates the generated models with some helper methods that are used in validation filter. * bump OpenAPI.jl version to use for CI --- .github/workflows/samples-julia.yaml | 2 +- .../partial_model_single.mustache | 15 +- .../main/resources/julia-server/api.mustache | 60 +++---- .../partial_model_single.mustache | 15 +- .../julia/src/models/model_ApiResponse.jl | 15 +- .../julia/src/models/model_Category.jl | 13 +- .../julia/src/models/model_MappedModel.jl | 13 +- .../petstore/julia/src/models/model_Order.jl | 21 ++- .../petstore/julia/src/models/model_Pet.jl | 21 ++- .../petstore/julia/src/models/model_Tag.jl | 13 +- .../petstore/julia/src/models/model_User.jl | 25 +-- .../petstore/julia/src/apis/api_FakeApi.jl | 13 ++ .../petstore/julia/src/apis/api_PetApi.jl | 159 ++++++++++++++++++ .../petstore/julia/src/apis/api_StoreApi.jl | 41 ++++- .../petstore/julia/src/apis/api_UserApi.jl | 113 ++++++++++++- .../julia/src/models/model_AnotherModel.jl | 13 +- .../julia/src/models/model_ApiResponse.jl | 15 +- .../julia/src/models/model_Category.jl | 13 +- .../petstore/julia/src/models/model_Order.jl | 21 ++- .../petstore/julia/src/models/model_Pet.jl | 21 ++- .../petstore/julia/src/models/model_Tag.jl | 13 +- .../petstore/julia/src/models/model_User.jl | 25 +-- 22 files changed, 522 insertions(+), 138 deletions(-) diff --git a/.github/workflows/samples-julia.yaml b/.github/workflows/samples-julia.yaml index c9c62f77210..4f2446fcb75 100644 --- a/.github/workflows/samples-julia.yaml +++ b/.github/workflows/samples-julia.yaml @@ -30,7 +30,7 @@ jobs: # Using develop mode to install package so that it is easier to modify the package test files julia -e "using Pkg; Pkg.develop(\"OpenAPI\");" cd ~/.julia/dev/OpenAPI - git checkout v0.1.25 + git checkout v0.2.0 cd $currdir rm -rf ~/.julia/dev/OpenAPI/test/client/openapigenerator_petstore_v3/petstore rm -rf ~/.julia/dev/OpenAPI/test/server/openapigenerator_petstore_v3/petstore diff --git a/modules/openapi-generator/src/main/resources/julia-client/partial_model_single.mustache b/modules/openapi-generator/src/main/resources/julia-client/partial_model_single.mustache index 8ea5cb243de..50e461e7c7d 100644 --- a/modules/openapi-generator/src/main/resources/julia-client/partial_model_single.mustache +++ b/modules/openapi-generator/src/main/resources/julia-client/partial_model_single.mustache @@ -17,17 +17,16 @@ Base.@kwdef mutable struct {{classname}} <: OpenAPI.APIModel {{/allVars}} function {{classname}}({{#allVars}}{{{name}}}, {{/allVars}}) - {{#allVars}} - OpenAPI.validate_property({{classname}}, Symbol("{{#lambda.escapeDollar}}{{baseName}}{{/lambda.escapeDollar}}"), {{{name}}}) - {{/allVars}} - return new({{#allVars}}{{{name}}}, {{/allVars}}) + o = new({{#allVars}}{{{name}}}, {{/allVars}}) + OpenAPI.validate_properties(o) + return o end end # type {{classname}} const _property_types_{{classname}} = Dict{Symbol,String}({{#allVars}}Symbol("{{#lambda.escapeDollar}}{{baseName}}{{/lambda.escapeDollar}}")=>"{{datatype}}", {{/allVars}}) OpenAPI.property_type(::Type{ {{classname}} }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_{{classname}}[name]))} -function check_required(o::{{classname}}) +function OpenAPI.check_required(o::{{classname}}) {{#allVars}} {{#required}} o.{{{name}}} === nothing && (return false) @@ -36,6 +35,12 @@ function check_required(o::{{classname}}) true end +function OpenAPI.validate_properties(o::{{classname}}) + {{#allVars}} + OpenAPI.validate_property({{classname}}, Symbol("{{#lambda.escapeDollar}}{{baseName}}{{/lambda.escapeDollar}}"), o.{{{name}}}) + {{/allVars}} +end + function OpenAPI.validate_property(::Type{ {{classname}} }, name::Symbol, val) {{#allVars}} {{#isEnum}}{{#allowableValues}} diff --git a/modules/openapi-generator/src/main/resources/julia-server/api.mustache b/modules/openapi-generator/src/main/resources/julia-server/api.mustache index e007ad91902..bf96e3cc262 100644 --- a/modules/openapi-generator/src/main/resources/julia-server/api.mustache +++ b/modules/openapi-generator/src/main/resources/julia-server/api.mustache @@ -24,41 +24,31 @@ end function {{operationId}}_validate(handler) function {{operationId}}_validate_handler(req::HTTP.Request) openapi_params = req.context[:openapi_params] - {{#allParams}}{{#hasValidation}} - {{#maxLength}} - OpenAPI.validate_param("{{#lambda.escapeDollar}}{{baseName}}{{/lambda.escapeDollar}}", "{{operationId}}", :maxLength, openapi_params["{{#lambda.escapeDollar}}{{baseName}}{{/lambda.escapeDollar}}"], {{maxLength}}) - {{/maxLength}} - {{#minLength}} - OpenAPI.validate_param("{{#lambda.escapeDollar}}{{baseName}}{{/lambda.escapeDollar}}", "{{operationId}}", :minLength, openapi_params["{{#lambda.escapeDollar}}{{baseName}}{{/lambda.escapeDollar}}"], {{minLength}}) - {{/minLength}} - {{#maximum}} - OpenAPI.validate_param("{{#lambda.escapeDollar}}{{baseName}}{{/lambda.escapeDollar}}", "{{operationId}}", :maximum, openapi_params["{{#lambda.escapeDollar}}{{baseName}}{{/lambda.escapeDollar}}"], {{maximum}}, {{#exclusiveMaximum}}true{{/exclusiveMaximum}}{{^exclusiveMaximum}}false{{/exclusiveMaximum}}) - {{/maximum}} - {{#minimum}} - OpenAPI.validate_param("{{#lambda.escapeDollar}}{{baseName}}{{/lambda.escapeDollar}}", "{{operationId}}", :minimum, openapi_params["{{#lambda.escapeDollar}}{{baseName}}{{/lambda.escapeDollar}}"], {{minimum}}, {{#exclusiveMinimum}}true{{/exclusiveMinimum}}{{^exclusiveMinimum}}false{{/exclusiveMinimum}}) - {{/minimum}} - {{#maxItems}} - OpenAPI.validate_param("{{#lambda.escapeDollar}}{{baseName}}{{/lambda.escapeDollar}}", "{{operationId}}", :maxItems, openapi_params["{{#lambda.escapeDollar}}{{baseName}}{{/lambda.escapeDollar}}"], {{maxItems}}) - {{/maxItems}} - {{#minItems}} - OpenAPI.validate_param("{{#lambda.escapeDollar}}{{baseName}}{{/lambda.escapeDollar}}", "{{operationId}}", :minItems, openapi_params["{{#lambda.escapeDollar}}{{baseName}}{{/lambda.escapeDollar}}"], {{minItems}}) - {{/minItems}} - {{#uniqueItems}} - OpenAPI.validate_param("{{#lambda.escapeDollar}}{{baseName}}{{/lambda.escapeDollar}}", "{{operationId}}", :uniqueItems, openapi_params["{{#lambda.escapeDollar}}{{baseName}}{{/lambda.escapeDollar}}"], {{uniqueItems}}) - {{/uniqueItems}} - {{#maxProperties}} - OpenAPI.validate_param("{{#lambda.escapeDollar}}{{baseName}}{{/lambda.escapeDollar}}", "{{operationId}}", :maxProperties, openapi_params["{{#lambda.escapeDollar}}{{baseName}}{{/lambda.escapeDollar}}"], {{maxProperties}}) - {{/maxProperties}} - {{#minProperties}} - OpenAPI.validate_param("{{#lambda.escapeDollar}}{{baseName}}{{/lambda.escapeDollar}}", "{{operationId}}", :minProperties, openapi_params["{{#lambda.escapeDollar}}{{baseName}}{{/lambda.escapeDollar}}"], {{minProperties}}) - {{/minProperties}} - {{#pattern}} - OpenAPI.validate_param("{{#lambda.escapeDollar}}{{baseName}}{{/lambda.escapeDollar}}", "{{operationId}}", :pattern, openapi_params["{{#lambda.escapeDollar}}{{baseName}}{{/lambda.escapeDollar}}"], r"{{{pattern}}}") - {{/pattern}} - {{#multipleOf}} - OpenAPI.validate_param("{{#lambda.escapeDollar}}{{baseName}}{{/lambda.escapeDollar}}", "{{operationId}}", :multipleOf, openapi_params["{{#lambda.escapeDollar}}{{baseName}}{{/lambda.escapeDollar}}"], {{multipleOf}}) - {{/multipleOf}} - {{/hasValidation}}{{/allParams}} + op = "{{operationId}}"{{#allParams}} + + n = "{{#lambda.escapeDollar}}{{baseName}}{{/lambda.escapeDollar}}" + v = get(openapi_params, n, nothing){{#required}} + isnothing(v) && throw(OpenAPI.ValidationException(;reason="missing parameter $n", operation_or_model=op)){{/required}} + if !isnothing(v){{#hasValidation}}{{#maxLength}} + OpenAPI.validate_param(n, op, :maxLength, v, {{maxLength}}){{/maxLength}}{{#minLength}} + OpenAPI.validate_param(n, op, :minLength, v, {{minLength}}){{/minLength}}{{#maximum}} + OpenAPI.validate_param(n, op, :maximum, v, {{maximum}}, {{#exclusiveMaximum}}true{{/exclusiveMaximum}}{{^exclusiveMaximum}}false{{/exclusiveMaximum}}){{/maximum}}{{#minimum}} + OpenAPI.validate_param(n, op, :minimum, v, {{minimum}}, {{#exclusiveMinimum}}true{{/exclusiveMinimum}}{{^exclusiveMinimum}}false{{/exclusiveMinimum}}){{/minimum}}{{#maxItems}} + OpenAPI.validate_param(n, op, :maxItems, v, {{maxItems}}){{/maxItems}}{{#minItems}} + OpenAPI.validate_param(n, op, :minItems, v, {{minItems}}){{/minItems}}{{#uniqueItems}} + OpenAPI.validate_param(n, op, :uniqueItems, v, {{uniqueItems}}){{/uniqueItems}}{{#maxProperties}} + OpenAPI.validate_param(n, op, :maxProperties, v, {{maxProperties}}){{/maxProperties}}{{#minProperties}} + OpenAPI.validate_param(n, op, :minProperties, v, {{minProperties}}){{/minProperties}}{{#pattern}} + OpenAPI.validate_param(n, op, :pattern, v, r"{{{pattern}}}"){{/pattern}}{{#multipleOf}} + OpenAPI.validate_param(n, op, :multipleOf, v, {{multipleOf}}){{/multipleOf}}{{/hasValidation}}{{^hasValidation}} + if isa(v, OpenAPI.APIModel) + OpenAPI.validate_properties(v) + if !OpenAPI.check_required(v) + throw(OpenAPI.ValidationException(;reason="$n is missing required properties", operation_or_model=op)) + end + end{{/hasValidation}} + end{{/allParams}} + return handler(req) end end diff --git a/modules/openapi-generator/src/main/resources/julia-server/partial_model_single.mustache b/modules/openapi-generator/src/main/resources/julia-server/partial_model_single.mustache index 8ea5cb243de..50e461e7c7d 100644 --- a/modules/openapi-generator/src/main/resources/julia-server/partial_model_single.mustache +++ b/modules/openapi-generator/src/main/resources/julia-server/partial_model_single.mustache @@ -17,17 +17,16 @@ Base.@kwdef mutable struct {{classname}} <: OpenAPI.APIModel {{/allVars}} function {{classname}}({{#allVars}}{{{name}}}, {{/allVars}}) - {{#allVars}} - OpenAPI.validate_property({{classname}}, Symbol("{{#lambda.escapeDollar}}{{baseName}}{{/lambda.escapeDollar}}"), {{{name}}}) - {{/allVars}} - return new({{#allVars}}{{{name}}}, {{/allVars}}) + o = new({{#allVars}}{{{name}}}, {{/allVars}}) + OpenAPI.validate_properties(o) + return o end end # type {{classname}} const _property_types_{{classname}} = Dict{Symbol,String}({{#allVars}}Symbol("{{#lambda.escapeDollar}}{{baseName}}{{/lambda.escapeDollar}}")=>"{{datatype}}", {{/allVars}}) OpenAPI.property_type(::Type{ {{classname}} }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_{{classname}}[name]))} -function check_required(o::{{classname}}) +function OpenAPI.check_required(o::{{classname}}) {{#allVars}} {{#required}} o.{{{name}}} === nothing && (return false) @@ -36,6 +35,12 @@ function check_required(o::{{classname}}) true end +function OpenAPI.validate_properties(o::{{classname}}) + {{#allVars}} + OpenAPI.validate_property({{classname}}, Symbol("{{#lambda.escapeDollar}}{{baseName}}{{/lambda.escapeDollar}}"), o.{{{name}}}) + {{/allVars}} +end + function OpenAPI.validate_property(::Type{ {{classname}} }, name::Symbol, val) {{#allVars}} {{#isEnum}}{{#allowableValues}} diff --git a/samples/client/petstore/julia/src/models/model_ApiResponse.jl b/samples/client/petstore/julia/src/models/model_ApiResponse.jl index e840bde445b..1d6b4131d9f 100644 --- a/samples/client/petstore/julia/src/models/model_ApiResponse.jl +++ b/samples/client/petstore/julia/src/models/model_ApiResponse.jl @@ -21,20 +21,25 @@ Base.@kwdef mutable struct ApiResponse <: OpenAPI.APIModel message::Union{Nothing, String} = nothing function ApiResponse(code, type, message, ) - OpenAPI.validate_property(ApiResponse, Symbol("code"), code) - OpenAPI.validate_property(ApiResponse, Symbol("type"), type) - OpenAPI.validate_property(ApiResponse, Symbol("message"), message) - return new(code, type, message, ) + o = new(code, type, message, ) + OpenAPI.validate_properties(o) + return o end end # type ApiResponse const _property_types_ApiResponse = Dict{Symbol,String}(Symbol("code")=>"Int64", Symbol("type")=>"String", Symbol("message")=>"String", ) OpenAPI.property_type(::Type{ ApiResponse }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_ApiResponse[name]))} -function check_required(o::ApiResponse) +function OpenAPI.check_required(o::ApiResponse) true end +function OpenAPI.validate_properties(o::ApiResponse) + OpenAPI.validate_property(ApiResponse, Symbol("code"), o.code) + OpenAPI.validate_property(ApiResponse, Symbol("type"), o.type) + OpenAPI.validate_property(ApiResponse, Symbol("message"), o.message) +end + function OpenAPI.validate_property(::Type{ ApiResponse }, name::Symbol, val) if name === Symbol("code") diff --git a/samples/client/petstore/julia/src/models/model_Category.jl b/samples/client/petstore/julia/src/models/model_Category.jl index 79d9a8acd1c..417ca80a7fb 100644 --- a/samples/client/petstore/julia/src/models/model_Category.jl +++ b/samples/client/petstore/julia/src/models/model_Category.jl @@ -18,19 +18,24 @@ Base.@kwdef mutable struct Category <: OpenAPI.APIModel name::Union{Nothing, String} = nothing function Category(id, name, ) - OpenAPI.validate_property(Category, Symbol("id"), id) - OpenAPI.validate_property(Category, Symbol("name"), name) - return new(id, name, ) + o = new(id, name, ) + OpenAPI.validate_properties(o) + return o end end # type Category const _property_types_Category = Dict{Symbol,String}(Symbol("id")=>"Int64", Symbol("name")=>"String", ) OpenAPI.property_type(::Type{ Category }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_Category[name]))} -function check_required(o::Category) +function OpenAPI.check_required(o::Category) true end +function OpenAPI.validate_properties(o::Category) + OpenAPI.validate_property(Category, Symbol("id"), o.id) + OpenAPI.validate_property(Category, Symbol("name"), o.name) +end + function OpenAPI.validate_property(::Type{ Category }, name::Symbol, val) if name === Symbol("id") diff --git a/samples/client/petstore/julia/src/models/model_MappedModel.jl b/samples/client/petstore/julia/src/models/model_MappedModel.jl index 0203cbc6b54..a7c1c561ba3 100644 --- a/samples/client/petstore/julia/src/models/model_MappedModel.jl +++ b/samples/client/petstore/julia/src/models/model_MappedModel.jl @@ -18,19 +18,24 @@ Base.@kwdef mutable struct MappedModel <: OpenAPI.APIModel uuid_default_value::Union{Nothing, String} = nothing function MappedModel(mappedProperty, uuid_default_value, ) - OpenAPI.validate_property(MappedModel, Symbol("another_property"), mappedProperty) - OpenAPI.validate_property(MappedModel, Symbol("uuid_default_value"), uuid_default_value) - return new(mappedProperty, uuid_default_value, ) + o = new(mappedProperty, uuid_default_value, ) + OpenAPI.validate_properties(o) + return o end end # type MappedModel const _property_types_MappedModel = Dict{Symbol,String}(Symbol("another_property")=>"Int64", Symbol("uuid_default_value")=>"String", ) OpenAPI.property_type(::Type{ MappedModel }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_MappedModel[name]))} -function check_required(o::MappedModel) +function OpenAPI.check_required(o::MappedModel) true end +function OpenAPI.validate_properties(o::MappedModel) + OpenAPI.validate_property(MappedModel, Symbol("another_property"), o.mappedProperty) + OpenAPI.validate_property(MappedModel, Symbol("uuid_default_value"), o.uuid_default_value) +end + function OpenAPI.validate_property(::Type{ MappedModel }, name::Symbol, val) if name === Symbol("another_property") diff --git a/samples/client/petstore/julia/src/models/model_Order.jl b/samples/client/petstore/julia/src/models/model_Order.jl index 4073ad540b6..c1e95bcea8f 100644 --- a/samples/client/petstore/julia/src/models/model_Order.jl +++ b/samples/client/petstore/julia/src/models/model_Order.jl @@ -30,23 +30,28 @@ Base.@kwdef mutable struct Order <: OpenAPI.APIModel complete::Union{Nothing, Bool} = false function Order(id, petId, quantity, shipDate, status, complete, ) - OpenAPI.validate_property(Order, Symbol("id"), id) - OpenAPI.validate_property(Order, Symbol("petId"), petId) - OpenAPI.validate_property(Order, Symbol("quantity"), quantity) - OpenAPI.validate_property(Order, Symbol("shipDate"), shipDate) - OpenAPI.validate_property(Order, Symbol("status"), status) - OpenAPI.validate_property(Order, Symbol("complete"), complete) - return new(id, petId, quantity, shipDate, status, complete, ) + o = new(id, petId, quantity, shipDate, status, complete, ) + OpenAPI.validate_properties(o) + return o end end # type Order const _property_types_Order = Dict{Symbol,String}(Symbol("id")=>"Int64", Symbol("petId")=>"Int64", Symbol("quantity")=>"Int64", Symbol("shipDate")=>"ZonedDateTime", Symbol("status")=>"String", Symbol("complete")=>"Bool", ) OpenAPI.property_type(::Type{ Order }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_Order[name]))} -function check_required(o::Order) +function OpenAPI.check_required(o::Order) true end +function OpenAPI.validate_properties(o::Order) + OpenAPI.validate_property(Order, Symbol("id"), o.id) + OpenAPI.validate_property(Order, Symbol("petId"), o.petId) + OpenAPI.validate_property(Order, Symbol("quantity"), o.quantity) + OpenAPI.validate_property(Order, Symbol("shipDate"), o.shipDate) + OpenAPI.validate_property(Order, Symbol("status"), o.status) + OpenAPI.validate_property(Order, Symbol("complete"), o.complete) +end + function OpenAPI.validate_property(::Type{ Order }, name::Symbol, val) if name === Symbol("id") diff --git a/samples/client/petstore/julia/src/models/model_Pet.jl b/samples/client/petstore/julia/src/models/model_Pet.jl index afe35a0ab55..47f8f831971 100644 --- a/samples/client/petstore/julia/src/models/model_Pet.jl +++ b/samples/client/petstore/julia/src/models/model_Pet.jl @@ -30,25 +30,30 @@ Base.@kwdef mutable struct Pet <: OpenAPI.APIModel status::Union{Nothing, String} = nothing function Pet(id, category, name, photoUrls, tags, status, ) - OpenAPI.validate_property(Pet, Symbol("id"), id) - OpenAPI.validate_property(Pet, Symbol("category"), category) - OpenAPI.validate_property(Pet, Symbol("name"), name) - OpenAPI.validate_property(Pet, Symbol("photoUrls"), photoUrls) - OpenAPI.validate_property(Pet, Symbol("tags"), tags) - OpenAPI.validate_property(Pet, Symbol("status"), status) - return new(id, category, name, photoUrls, tags, status, ) + o = new(id, category, name, photoUrls, tags, status, ) + OpenAPI.validate_properties(o) + return o end end # type Pet const _property_types_Pet = Dict{Symbol,String}(Symbol("id")=>"Int64", Symbol("category")=>"Category", Symbol("name")=>"String", Symbol("photoUrls")=>"Vector{String}", Symbol("tags")=>"Vector{Tag}", Symbol("status")=>"String", ) OpenAPI.property_type(::Type{ Pet }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_Pet[name]))} -function check_required(o::Pet) +function OpenAPI.check_required(o::Pet) o.name === nothing && (return false) o.photoUrls === nothing && (return false) true end +function OpenAPI.validate_properties(o::Pet) + OpenAPI.validate_property(Pet, Symbol("id"), o.id) + OpenAPI.validate_property(Pet, Symbol("category"), o.category) + OpenAPI.validate_property(Pet, Symbol("name"), o.name) + OpenAPI.validate_property(Pet, Symbol("photoUrls"), o.photoUrls) + OpenAPI.validate_property(Pet, Symbol("tags"), o.tags) + OpenAPI.validate_property(Pet, Symbol("status"), o.status) +end + function OpenAPI.validate_property(::Type{ Pet }, name::Symbol, val) if name === Symbol("id") diff --git a/samples/client/petstore/julia/src/models/model_Tag.jl b/samples/client/petstore/julia/src/models/model_Tag.jl index aeea1601b5e..2743b59e753 100644 --- a/samples/client/petstore/julia/src/models/model_Tag.jl +++ b/samples/client/petstore/julia/src/models/model_Tag.jl @@ -18,19 +18,24 @@ Base.@kwdef mutable struct Tag <: OpenAPI.APIModel name::Union{Nothing, String} = nothing function Tag(id, name, ) - OpenAPI.validate_property(Tag, Symbol("id"), id) - OpenAPI.validate_property(Tag, Symbol("name"), name) - return new(id, name, ) + o = new(id, name, ) + OpenAPI.validate_properties(o) + return o end end # type Tag const _property_types_Tag = Dict{Symbol,String}(Symbol("id")=>"Int64", Symbol("name")=>"String", ) OpenAPI.property_type(::Type{ Tag }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_Tag[name]))} -function check_required(o::Tag) +function OpenAPI.check_required(o::Tag) true end +function OpenAPI.validate_properties(o::Tag) + OpenAPI.validate_property(Tag, Symbol("id"), o.id) + OpenAPI.validate_property(Tag, Symbol("name"), o.name) +end + function OpenAPI.validate_property(::Type{ Tag }, name::Symbol, val) if name === Symbol("id") diff --git a/samples/client/petstore/julia/src/models/model_User.jl b/samples/client/petstore/julia/src/models/model_User.jl index 5497ba8fa6e..8e95c9ac67b 100644 --- a/samples/client/petstore/julia/src/models/model_User.jl +++ b/samples/client/petstore/julia/src/models/model_User.jl @@ -36,25 +36,30 @@ Base.@kwdef mutable struct User <: OpenAPI.APIModel userStatus::Union{Nothing, Int64} = nothing function User(id, username, firstName, lastName, email, password, phone, userStatus, ) - OpenAPI.validate_property(User, Symbol("id"), id) - OpenAPI.validate_property(User, Symbol("username"), username) - OpenAPI.validate_property(User, Symbol("firstName"), firstName) - OpenAPI.validate_property(User, Symbol("lastName"), lastName) - OpenAPI.validate_property(User, Symbol("email"), email) - OpenAPI.validate_property(User, Symbol("password"), password) - OpenAPI.validate_property(User, Symbol("phone"), phone) - OpenAPI.validate_property(User, Symbol("userStatus"), userStatus) - return new(id, username, firstName, lastName, email, password, phone, userStatus, ) + o = new(id, username, firstName, lastName, email, password, phone, userStatus, ) + OpenAPI.validate_properties(o) + return o end end # type User const _property_types_User = Dict{Symbol,String}(Symbol("id")=>"Int64", Symbol("username")=>"String", Symbol("firstName")=>"String", Symbol("lastName")=>"String", Symbol("email")=>"String", Symbol("password")=>"String", Symbol("phone")=>"String", Symbol("userStatus")=>"Int64", ) OpenAPI.property_type(::Type{ User }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_User[name]))} -function check_required(o::User) +function OpenAPI.check_required(o::User) true end +function OpenAPI.validate_properties(o::User) + OpenAPI.validate_property(User, Symbol("id"), o.id) + OpenAPI.validate_property(User, Symbol("username"), o.username) + OpenAPI.validate_property(User, Symbol("firstName"), o.firstName) + OpenAPI.validate_property(User, Symbol("lastName"), o.lastName) + OpenAPI.validate_property(User, Symbol("email"), o.email) + OpenAPI.validate_property(User, Symbol("password"), o.password) + OpenAPI.validate_property(User, Symbol("phone"), o.phone) + OpenAPI.validate_property(User, Symbol("userStatus"), o.userStatus) +end + function OpenAPI.validate_property(::Type{ User }, name::Symbol, val) if name === Symbol("id") diff --git a/samples/server/petstore/julia/src/apis/api_FakeApi.jl b/samples/server/petstore/julia/src/apis/api_FakeApi.jl index d4bce31b949..be695388060 100644 --- a/samples/server/petstore/julia/src/apis/api_FakeApi.jl +++ b/samples/server/petstore/julia/src/apis/api_FakeApi.jl @@ -16,7 +16,20 @@ end function uuid_default_value_validate(handler) function uuid_default_value_validate_handler(req::HTTP.Request) openapi_params = req.context[:openapi_params] + op = "uuid_default_value" + n = "uuid_parameter" + v = get(openapi_params, n, nothing) + isnothing(v) && throw(OpenAPI.ValidationException(;reason="missing parameter $n", operation_or_model=op)) + if !isnothing(v) + if isa(v, OpenAPI.APIModel) + OpenAPI.validate_properties(v) + if !OpenAPI.check_required(v) + throw(OpenAPI.ValidationException(;reason="$n is missing required properties", operation_or_model=op)) + end + end + end + return handler(req) end end diff --git a/samples/server/petstore/julia/src/apis/api_PetApi.jl b/samples/server/petstore/julia/src/apis/api_PetApi.jl index 074ddfdb084..8f42cf3f280 100644 --- a/samples/server/petstore/julia/src/apis/api_PetApi.jl +++ b/samples/server/petstore/julia/src/apis/api_PetApi.jl @@ -15,7 +15,20 @@ end function add_pet_validate(handler) function add_pet_validate_handler(req::HTTP.Request) openapi_params = req.context[:openapi_params] + op = "add_pet" + n = "Pet" + v = get(openapi_params, n, nothing) + isnothing(v) && throw(OpenAPI.ValidationException(;reason="missing parameter $n", operation_or_model=op)) + if !isnothing(v) + if isa(v, OpenAPI.APIModel) + OpenAPI.validate_properties(v) + if !OpenAPI.check_required(v) + throw(OpenAPI.ValidationException(;reason="$n is missing required properties", operation_or_model=op)) + end + end + end + return handler(req) end end @@ -45,7 +58,31 @@ end function delete_pet_validate(handler) function delete_pet_validate_handler(req::HTTP.Request) openapi_params = req.context[:openapi_params] + op = "delete_pet" + n = "petId" + v = get(openapi_params, n, nothing) + isnothing(v) && throw(OpenAPI.ValidationException(;reason="missing parameter $n", operation_or_model=op)) + if !isnothing(v) + if isa(v, OpenAPI.APIModel) + OpenAPI.validate_properties(v) + if !OpenAPI.check_required(v) + throw(OpenAPI.ValidationException(;reason="$n is missing required properties", operation_or_model=op)) + end + end + end + + n = "api_key" + v = get(openapi_params, n, nothing) + if !isnothing(v) + if isa(v, OpenAPI.APIModel) + OpenAPI.validate_properties(v) + if !OpenAPI.check_required(v) + throw(OpenAPI.ValidationException(;reason="$n is missing required properties", operation_or_model=op)) + end + end + end + return handler(req) end end @@ -73,7 +110,20 @@ end function find_pets_by_status_validate(handler) function find_pets_by_status_validate_handler(req::HTTP.Request) openapi_params = req.context[:openapi_params] + op = "find_pets_by_status" + n = "status" + v = get(openapi_params, n, nothing) + isnothing(v) && throw(OpenAPI.ValidationException(;reason="missing parameter $n", operation_or_model=op)) + if !isnothing(v) + if isa(v, OpenAPI.APIModel) + OpenAPI.validate_properties(v) + if !OpenAPI.check_required(v) + throw(OpenAPI.ValidationException(;reason="$n is missing required properties", operation_or_model=op)) + end + end + end + return handler(req) end end @@ -101,7 +151,20 @@ end function find_pets_by_tags_validate(handler) function find_pets_by_tags_validate_handler(req::HTTP.Request) openapi_params = req.context[:openapi_params] + op = "find_pets_by_tags" + n = "tags" + v = get(openapi_params, n, nothing) + isnothing(v) && throw(OpenAPI.ValidationException(;reason="missing parameter $n", operation_or_model=op)) + if !isnothing(v) + if isa(v, OpenAPI.APIModel) + OpenAPI.validate_properties(v) + if !OpenAPI.check_required(v) + throw(OpenAPI.ValidationException(;reason="$n is missing required properties", operation_or_model=op)) + end + end + end + return handler(req) end end @@ -129,7 +192,20 @@ end function get_pet_by_id_validate(handler) function get_pet_by_id_validate_handler(req::HTTP.Request) openapi_params = req.context[:openapi_params] + op = "get_pet_by_id" + n = "petId" + v = get(openapi_params, n, nothing) + isnothing(v) && throw(OpenAPI.ValidationException(;reason="missing parameter $n", operation_or_model=op)) + if !isnothing(v) + if isa(v, OpenAPI.APIModel) + OpenAPI.validate_properties(v) + if !OpenAPI.check_required(v) + throw(OpenAPI.ValidationException(;reason="$n is missing required properties", operation_or_model=op)) + end + end + end + return handler(req) end end @@ -156,7 +232,20 @@ end function update_pet_validate(handler) function update_pet_validate_handler(req::HTTP.Request) openapi_params = req.context[:openapi_params] + op = "update_pet" + n = "Pet" + v = get(openapi_params, n, nothing) + isnothing(v) && throw(OpenAPI.ValidationException(;reason="missing parameter $n", operation_or_model=op)) + if !isnothing(v) + if isa(v, OpenAPI.APIModel) + OpenAPI.validate_properties(v) + if !OpenAPI.check_required(v) + throw(OpenAPI.ValidationException(;reason="$n is missing required properties", operation_or_model=op)) + end + end + end + return handler(req) end end @@ -188,7 +277,42 @@ end function update_pet_with_form_validate(handler) function update_pet_with_form_validate_handler(req::HTTP.Request) openapi_params = req.context[:openapi_params] + op = "update_pet_with_form" + n = "petId" + v = get(openapi_params, n, nothing) + isnothing(v) && throw(OpenAPI.ValidationException(;reason="missing parameter $n", operation_or_model=op)) + if !isnothing(v) + if isa(v, OpenAPI.APIModel) + OpenAPI.validate_properties(v) + if !OpenAPI.check_required(v) + throw(OpenAPI.ValidationException(;reason="$n is missing required properties", operation_or_model=op)) + end + end + end + + n = "name" + v = get(openapi_params, n, nothing) + if !isnothing(v) + if isa(v, OpenAPI.APIModel) + OpenAPI.validate_properties(v) + if !OpenAPI.check_required(v) + throw(OpenAPI.ValidationException(;reason="$n is missing required properties", operation_or_model=op)) + end + end + end + + n = "status" + v = get(openapi_params, n, nothing) + if !isnothing(v) + if isa(v, OpenAPI.APIModel) + OpenAPI.validate_properties(v) + if !OpenAPI.check_required(v) + throw(OpenAPI.ValidationException(;reason="$n is missing required properties", operation_or_model=op)) + end + end + end + return handler(req) end end @@ -220,7 +344,42 @@ end function upload_file_validate(handler) function upload_file_validate_handler(req::HTTP.Request) openapi_params = req.context[:openapi_params] + op = "upload_file" + n = "petId" + v = get(openapi_params, n, nothing) + isnothing(v) && throw(OpenAPI.ValidationException(;reason="missing parameter $n", operation_or_model=op)) + if !isnothing(v) + if isa(v, OpenAPI.APIModel) + OpenAPI.validate_properties(v) + if !OpenAPI.check_required(v) + throw(OpenAPI.ValidationException(;reason="$n is missing required properties", operation_or_model=op)) + end + end + end + + n = "additionalMetadata" + v = get(openapi_params, n, nothing) + if !isnothing(v) + if isa(v, OpenAPI.APIModel) + OpenAPI.validate_properties(v) + if !OpenAPI.check_required(v) + throw(OpenAPI.ValidationException(;reason="$n is missing required properties", operation_or_model=op)) + end + end + end + + n = "file" + v = get(openapi_params, n, nothing) + if !isnothing(v) + if isa(v, OpenAPI.APIModel) + OpenAPI.validate_properties(v) + if !OpenAPI.check_required(v) + throw(OpenAPI.ValidationException(;reason="$n is missing required properties", operation_or_model=op)) + end + end + end + return handler(req) end end diff --git a/samples/server/petstore/julia/src/apis/api_StoreApi.jl b/samples/server/petstore/julia/src/apis/api_StoreApi.jl index b982905d37a..4a8b69f1986 100644 --- a/samples/server/petstore/julia/src/apis/api_StoreApi.jl +++ b/samples/server/petstore/julia/src/apis/api_StoreApi.jl @@ -16,7 +16,20 @@ end function delete_order_validate(handler) function delete_order_validate_handler(req::HTTP.Request) openapi_params = req.context[:openapi_params] + op = "delete_order" + n = "orderId" + v = get(openapi_params, n, nothing) + isnothing(v) && throw(OpenAPI.ValidationException(;reason="missing parameter $n", operation_or_model=op)) + if !isnothing(v) + if isa(v, OpenAPI.APIModel) + OpenAPI.validate_properties(v) + if !OpenAPI.check_required(v) + throw(OpenAPI.ValidationException(;reason="$n is missing required properties", operation_or_model=op)) + end + end + end + return handler(req) end end @@ -42,7 +55,8 @@ end function get_inventory_validate(handler) function get_inventory_validate_handler(req::HTTP.Request) openapi_params = req.context[:openapi_params] - + op = "get_inventory" + return handler(req) end end @@ -70,10 +84,16 @@ end function get_order_by_id_validate(handler) function get_order_by_id_validate_handler(req::HTTP.Request) openapi_params = req.context[:openapi_params] + op = "get_order_by_id" - OpenAPI.validate_param("orderId", "get_order_by_id", :maximum, openapi_params["orderId"], 5, false) - OpenAPI.validate_param("orderId", "get_order_by_id", :minimum, openapi_params["orderId"], 1, false) - + n = "orderId" + v = get(openapi_params, n, nothing) + isnothing(v) && throw(OpenAPI.ValidationException(;reason="missing parameter $n", operation_or_model=op)) + if !isnothing(v) + OpenAPI.validate_param(n, op, :maximum, v, 5, false) + OpenAPI.validate_param(n, op, :minimum, v, 1, false) + end + return handler(req) end end @@ -100,7 +120,20 @@ end function place_order_validate(handler) function place_order_validate_handler(req::HTTP.Request) openapi_params = req.context[:openapi_params] + op = "place_order" + n = "Order" + v = get(openapi_params, n, nothing) + isnothing(v) && throw(OpenAPI.ValidationException(;reason="missing parameter $n", operation_or_model=op)) + if !isnothing(v) + if isa(v, OpenAPI.APIModel) + OpenAPI.validate_properties(v) + if !OpenAPI.check_required(v) + throw(OpenAPI.ValidationException(;reason="$n is missing required properties", operation_or_model=op)) + end + end + end + return handler(req) end end diff --git a/samples/server/petstore/julia/src/apis/api_UserApi.jl b/samples/server/petstore/julia/src/apis/api_UserApi.jl index d0bdcf033bc..65f5cddf490 100644 --- a/samples/server/petstore/julia/src/apis/api_UserApi.jl +++ b/samples/server/petstore/julia/src/apis/api_UserApi.jl @@ -15,7 +15,20 @@ end function create_user_validate(handler) function create_user_validate_handler(req::HTTP.Request) openapi_params = req.context[:openapi_params] + op = "create_user" + n = "User" + v = get(openapi_params, n, nothing) + isnothing(v) && throw(OpenAPI.ValidationException(;reason="missing parameter $n", operation_or_model=op)) + if !isnothing(v) + if isa(v, OpenAPI.APIModel) + OpenAPI.validate_properties(v) + if !OpenAPI.check_required(v) + throw(OpenAPI.ValidationException(;reason="$n is missing required properties", operation_or_model=op)) + end + end + end + return handler(req) end end @@ -42,7 +55,20 @@ end function create_users_with_array_input_validate(handler) function create_users_with_array_input_validate_handler(req::HTTP.Request) openapi_params = req.context[:openapi_params] + op = "create_users_with_array_input" + n = "User" + v = get(openapi_params, n, nothing) + isnothing(v) && throw(OpenAPI.ValidationException(;reason="missing parameter $n", operation_or_model=op)) + if !isnothing(v) + if isa(v, OpenAPI.APIModel) + OpenAPI.validate_properties(v) + if !OpenAPI.check_required(v) + throw(OpenAPI.ValidationException(;reason="$n is missing required properties", operation_or_model=op)) + end + end + end + return handler(req) end end @@ -69,7 +95,20 @@ end function create_users_with_list_input_validate(handler) function create_users_with_list_input_validate_handler(req::HTTP.Request) openapi_params = req.context[:openapi_params] + op = "create_users_with_list_input" + n = "User" + v = get(openapi_params, n, nothing) + isnothing(v) && throw(OpenAPI.ValidationException(;reason="missing parameter $n", operation_or_model=op)) + if !isnothing(v) + if isa(v, OpenAPI.APIModel) + OpenAPI.validate_properties(v) + if !OpenAPI.check_required(v) + throw(OpenAPI.ValidationException(;reason="$n is missing required properties", operation_or_model=op)) + end + end + end + return handler(req) end end @@ -97,7 +136,20 @@ end function delete_user_validate(handler) function delete_user_validate_handler(req::HTTP.Request) openapi_params = req.context[:openapi_params] + op = "delete_user" + n = "username" + v = get(openapi_params, n, nothing) + isnothing(v) && throw(OpenAPI.ValidationException(;reason="missing parameter $n", operation_or_model=op)) + if !isnothing(v) + if isa(v, OpenAPI.APIModel) + OpenAPI.validate_properties(v) + if !OpenAPI.check_required(v) + throw(OpenAPI.ValidationException(;reason="$n is missing required properties", operation_or_model=op)) + end + end + end + return handler(req) end end @@ -125,7 +177,20 @@ end function get_user_by_name_validate(handler) function get_user_by_name_validate_handler(req::HTTP.Request) openapi_params = req.context[:openapi_params] + op = "get_user_by_name" + n = "username" + v = get(openapi_params, n, nothing) + isnothing(v) && throw(OpenAPI.ValidationException(;reason="missing parameter $n", operation_or_model=op)) + if !isnothing(v) + if isa(v, OpenAPI.APIModel) + OpenAPI.validate_properties(v) + if !OpenAPI.check_required(v) + throw(OpenAPI.ValidationException(;reason="$n is missing required properties", operation_or_model=op)) + end + end + end + return handler(req) end end @@ -154,9 +219,27 @@ end function login_user_validate(handler) function login_user_validate_handler(req::HTTP.Request) openapi_params = req.context[:openapi_params] + op = "login_user" - OpenAPI.validate_param("username", "login_user", :pattern, openapi_params["username"], r"^[a-zA-Z0-9]+[a-zA-Z0-9\.\-_]*[a-zA-Z0-9]+$") + n = "username" + v = get(openapi_params, n, nothing) + isnothing(v) && throw(OpenAPI.ValidationException(;reason="missing parameter $n", operation_or_model=op)) + if !isnothing(v) + OpenAPI.validate_param(n, op, :pattern, v, r"^[a-zA-Z0-9]+[a-zA-Z0-9\.\-_]*[a-zA-Z0-9]+$") + end + n = "password" + v = get(openapi_params, n, nothing) + isnothing(v) && throw(OpenAPI.ValidationException(;reason="missing parameter $n", operation_or_model=op)) + if !isnothing(v) + if isa(v, OpenAPI.APIModel) + OpenAPI.validate_properties(v) + if !OpenAPI.check_required(v) + throw(OpenAPI.ValidationException(;reason="$n is missing required properties", operation_or_model=op)) + end + end + end + return handler(req) end end @@ -182,7 +265,8 @@ end function logout_user_validate(handler) function logout_user_validate_handler(req::HTTP.Request) openapi_params = req.context[:openapi_params] - + op = "logout_user" + return handler(req) end end @@ -211,7 +295,32 @@ end function update_user_validate(handler) function update_user_validate_handler(req::HTTP.Request) openapi_params = req.context[:openapi_params] + op = "update_user" + n = "username" + v = get(openapi_params, n, nothing) + isnothing(v) && throw(OpenAPI.ValidationException(;reason="missing parameter $n", operation_or_model=op)) + if !isnothing(v) + if isa(v, OpenAPI.APIModel) + OpenAPI.validate_properties(v) + if !OpenAPI.check_required(v) + throw(OpenAPI.ValidationException(;reason="$n is missing required properties", operation_or_model=op)) + end + end + end + + n = "User" + v = get(openapi_params, n, nothing) + isnothing(v) && throw(OpenAPI.ValidationException(;reason="missing parameter $n", operation_or_model=op)) + if !isnothing(v) + if isa(v, OpenAPI.APIModel) + OpenAPI.validate_properties(v) + if !OpenAPI.check_required(v) + throw(OpenAPI.ValidationException(;reason="$n is missing required properties", operation_or_model=op)) + end + end + end + return handler(req) end end diff --git a/samples/server/petstore/julia/src/models/model_AnotherModel.jl b/samples/server/petstore/julia/src/models/model_AnotherModel.jl index d40f233d010..be45a6765df 100644 --- a/samples/server/petstore/julia/src/models/model_AnotherModel.jl +++ b/samples/server/petstore/julia/src/models/model_AnotherModel.jl @@ -18,19 +18,24 @@ Base.@kwdef mutable struct AnotherModel <: OpenAPI.APIModel uuid_default_value::Union{Nothing, String} = nothing function AnotherModel(another_property, uuid_default_value, ) - OpenAPI.validate_property(AnotherModel, Symbol("another_property"), another_property) - OpenAPI.validate_property(AnotherModel, Symbol("uuid_default_value"), uuid_default_value) - return new(another_property, uuid_default_value, ) + o = new(another_property, uuid_default_value, ) + OpenAPI.validate_properties(o) + return o end end # type AnotherModel const _property_types_AnotherModel = Dict{Symbol,String}(Symbol("another_property")=>"Int64", Symbol("uuid_default_value")=>"String", ) OpenAPI.property_type(::Type{ AnotherModel }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_AnotherModel[name]))} -function check_required(o::AnotherModel) +function OpenAPI.check_required(o::AnotherModel) true end +function OpenAPI.validate_properties(o::AnotherModel) + OpenAPI.validate_property(AnotherModel, Symbol("another_property"), o.another_property) + OpenAPI.validate_property(AnotherModel, Symbol("uuid_default_value"), o.uuid_default_value) +end + function OpenAPI.validate_property(::Type{ AnotherModel }, name::Symbol, val) if name === Symbol("another_property") diff --git a/samples/server/petstore/julia/src/models/model_ApiResponse.jl b/samples/server/petstore/julia/src/models/model_ApiResponse.jl index e840bde445b..1d6b4131d9f 100644 --- a/samples/server/petstore/julia/src/models/model_ApiResponse.jl +++ b/samples/server/petstore/julia/src/models/model_ApiResponse.jl @@ -21,20 +21,25 @@ Base.@kwdef mutable struct ApiResponse <: OpenAPI.APIModel message::Union{Nothing, String} = nothing function ApiResponse(code, type, message, ) - OpenAPI.validate_property(ApiResponse, Symbol("code"), code) - OpenAPI.validate_property(ApiResponse, Symbol("type"), type) - OpenAPI.validate_property(ApiResponse, Symbol("message"), message) - return new(code, type, message, ) + o = new(code, type, message, ) + OpenAPI.validate_properties(o) + return o end end # type ApiResponse const _property_types_ApiResponse = Dict{Symbol,String}(Symbol("code")=>"Int64", Symbol("type")=>"String", Symbol("message")=>"String", ) OpenAPI.property_type(::Type{ ApiResponse }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_ApiResponse[name]))} -function check_required(o::ApiResponse) +function OpenAPI.check_required(o::ApiResponse) true end +function OpenAPI.validate_properties(o::ApiResponse) + OpenAPI.validate_property(ApiResponse, Symbol("code"), o.code) + OpenAPI.validate_property(ApiResponse, Symbol("type"), o.type) + OpenAPI.validate_property(ApiResponse, Symbol("message"), o.message) +end + function OpenAPI.validate_property(::Type{ ApiResponse }, name::Symbol, val) if name === Symbol("code") diff --git a/samples/server/petstore/julia/src/models/model_Category.jl b/samples/server/petstore/julia/src/models/model_Category.jl index 79d9a8acd1c..417ca80a7fb 100644 --- a/samples/server/petstore/julia/src/models/model_Category.jl +++ b/samples/server/petstore/julia/src/models/model_Category.jl @@ -18,19 +18,24 @@ Base.@kwdef mutable struct Category <: OpenAPI.APIModel name::Union{Nothing, String} = nothing function Category(id, name, ) - OpenAPI.validate_property(Category, Symbol("id"), id) - OpenAPI.validate_property(Category, Symbol("name"), name) - return new(id, name, ) + o = new(id, name, ) + OpenAPI.validate_properties(o) + return o end end # type Category const _property_types_Category = Dict{Symbol,String}(Symbol("id")=>"Int64", Symbol("name")=>"String", ) OpenAPI.property_type(::Type{ Category }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_Category[name]))} -function check_required(o::Category) +function OpenAPI.check_required(o::Category) true end +function OpenAPI.validate_properties(o::Category) + OpenAPI.validate_property(Category, Symbol("id"), o.id) + OpenAPI.validate_property(Category, Symbol("name"), o.name) +end + function OpenAPI.validate_property(::Type{ Category }, name::Symbol, val) if name === Symbol("id") diff --git a/samples/server/petstore/julia/src/models/model_Order.jl b/samples/server/petstore/julia/src/models/model_Order.jl index 4073ad540b6..c1e95bcea8f 100644 --- a/samples/server/petstore/julia/src/models/model_Order.jl +++ b/samples/server/petstore/julia/src/models/model_Order.jl @@ -30,23 +30,28 @@ Base.@kwdef mutable struct Order <: OpenAPI.APIModel complete::Union{Nothing, Bool} = false function Order(id, petId, quantity, shipDate, status, complete, ) - OpenAPI.validate_property(Order, Symbol("id"), id) - OpenAPI.validate_property(Order, Symbol("petId"), petId) - OpenAPI.validate_property(Order, Symbol("quantity"), quantity) - OpenAPI.validate_property(Order, Symbol("shipDate"), shipDate) - OpenAPI.validate_property(Order, Symbol("status"), status) - OpenAPI.validate_property(Order, Symbol("complete"), complete) - return new(id, petId, quantity, shipDate, status, complete, ) + o = new(id, petId, quantity, shipDate, status, complete, ) + OpenAPI.validate_properties(o) + return o end end # type Order const _property_types_Order = Dict{Symbol,String}(Symbol("id")=>"Int64", Symbol("petId")=>"Int64", Symbol("quantity")=>"Int64", Symbol("shipDate")=>"ZonedDateTime", Symbol("status")=>"String", Symbol("complete")=>"Bool", ) OpenAPI.property_type(::Type{ Order }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_Order[name]))} -function check_required(o::Order) +function OpenAPI.check_required(o::Order) true end +function OpenAPI.validate_properties(o::Order) + OpenAPI.validate_property(Order, Symbol("id"), o.id) + OpenAPI.validate_property(Order, Symbol("petId"), o.petId) + OpenAPI.validate_property(Order, Symbol("quantity"), o.quantity) + OpenAPI.validate_property(Order, Symbol("shipDate"), o.shipDate) + OpenAPI.validate_property(Order, Symbol("status"), o.status) + OpenAPI.validate_property(Order, Symbol("complete"), o.complete) +end + function OpenAPI.validate_property(::Type{ Order }, name::Symbol, val) if name === Symbol("id") diff --git a/samples/server/petstore/julia/src/models/model_Pet.jl b/samples/server/petstore/julia/src/models/model_Pet.jl index afe35a0ab55..47f8f831971 100644 --- a/samples/server/petstore/julia/src/models/model_Pet.jl +++ b/samples/server/petstore/julia/src/models/model_Pet.jl @@ -30,25 +30,30 @@ Base.@kwdef mutable struct Pet <: OpenAPI.APIModel status::Union{Nothing, String} = nothing function Pet(id, category, name, photoUrls, tags, status, ) - OpenAPI.validate_property(Pet, Symbol("id"), id) - OpenAPI.validate_property(Pet, Symbol("category"), category) - OpenAPI.validate_property(Pet, Symbol("name"), name) - OpenAPI.validate_property(Pet, Symbol("photoUrls"), photoUrls) - OpenAPI.validate_property(Pet, Symbol("tags"), tags) - OpenAPI.validate_property(Pet, Symbol("status"), status) - return new(id, category, name, photoUrls, tags, status, ) + o = new(id, category, name, photoUrls, tags, status, ) + OpenAPI.validate_properties(o) + return o end end # type Pet const _property_types_Pet = Dict{Symbol,String}(Symbol("id")=>"Int64", Symbol("category")=>"Category", Symbol("name")=>"String", Symbol("photoUrls")=>"Vector{String}", Symbol("tags")=>"Vector{Tag}", Symbol("status")=>"String", ) OpenAPI.property_type(::Type{ Pet }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_Pet[name]))} -function check_required(o::Pet) +function OpenAPI.check_required(o::Pet) o.name === nothing && (return false) o.photoUrls === nothing && (return false) true end +function OpenAPI.validate_properties(o::Pet) + OpenAPI.validate_property(Pet, Symbol("id"), o.id) + OpenAPI.validate_property(Pet, Symbol("category"), o.category) + OpenAPI.validate_property(Pet, Symbol("name"), o.name) + OpenAPI.validate_property(Pet, Symbol("photoUrls"), o.photoUrls) + OpenAPI.validate_property(Pet, Symbol("tags"), o.tags) + OpenAPI.validate_property(Pet, Symbol("status"), o.status) +end + function OpenAPI.validate_property(::Type{ Pet }, name::Symbol, val) if name === Symbol("id") diff --git a/samples/server/petstore/julia/src/models/model_Tag.jl b/samples/server/petstore/julia/src/models/model_Tag.jl index aeea1601b5e..2743b59e753 100644 --- a/samples/server/petstore/julia/src/models/model_Tag.jl +++ b/samples/server/petstore/julia/src/models/model_Tag.jl @@ -18,19 +18,24 @@ Base.@kwdef mutable struct Tag <: OpenAPI.APIModel name::Union{Nothing, String} = nothing function Tag(id, name, ) - OpenAPI.validate_property(Tag, Symbol("id"), id) - OpenAPI.validate_property(Tag, Symbol("name"), name) - return new(id, name, ) + o = new(id, name, ) + OpenAPI.validate_properties(o) + return o end end # type Tag const _property_types_Tag = Dict{Symbol,String}(Symbol("id")=>"Int64", Symbol("name")=>"String", ) OpenAPI.property_type(::Type{ Tag }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_Tag[name]))} -function check_required(o::Tag) +function OpenAPI.check_required(o::Tag) true end +function OpenAPI.validate_properties(o::Tag) + OpenAPI.validate_property(Tag, Symbol("id"), o.id) + OpenAPI.validate_property(Tag, Symbol("name"), o.name) +end + function OpenAPI.validate_property(::Type{ Tag }, name::Symbol, val) if name === Symbol("id") diff --git a/samples/server/petstore/julia/src/models/model_User.jl b/samples/server/petstore/julia/src/models/model_User.jl index 5497ba8fa6e..8e95c9ac67b 100644 --- a/samples/server/petstore/julia/src/models/model_User.jl +++ b/samples/server/petstore/julia/src/models/model_User.jl @@ -36,25 +36,30 @@ Base.@kwdef mutable struct User <: OpenAPI.APIModel userStatus::Union{Nothing, Int64} = nothing function User(id, username, firstName, lastName, email, password, phone, userStatus, ) - OpenAPI.validate_property(User, Symbol("id"), id) - OpenAPI.validate_property(User, Symbol("username"), username) - OpenAPI.validate_property(User, Symbol("firstName"), firstName) - OpenAPI.validate_property(User, Symbol("lastName"), lastName) - OpenAPI.validate_property(User, Symbol("email"), email) - OpenAPI.validate_property(User, Symbol("password"), password) - OpenAPI.validate_property(User, Symbol("phone"), phone) - OpenAPI.validate_property(User, Symbol("userStatus"), userStatus) - return new(id, username, firstName, lastName, email, password, phone, userStatus, ) + o = new(id, username, firstName, lastName, email, password, phone, userStatus, ) + OpenAPI.validate_properties(o) + return o end end # type User const _property_types_User = Dict{Symbol,String}(Symbol("id")=>"Int64", Symbol("username")=>"String", Symbol("firstName")=>"String", Symbol("lastName")=>"String", Symbol("email")=>"String", Symbol("password")=>"String", Symbol("phone")=>"String", Symbol("userStatus")=>"Int64", ) OpenAPI.property_type(::Type{ User }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_User[name]))} -function check_required(o::User) +function OpenAPI.check_required(o::User) true end +function OpenAPI.validate_properties(o::User) + OpenAPI.validate_property(User, Symbol("id"), o.id) + OpenAPI.validate_property(User, Symbol("username"), o.username) + OpenAPI.validate_property(User, Symbol("firstName"), o.firstName) + OpenAPI.validate_property(User, Symbol("lastName"), o.lastName) + OpenAPI.validate_property(User, Symbol("email"), o.email) + OpenAPI.validate_property(User, Symbol("password"), o.password) + OpenAPI.validate_property(User, Symbol("phone"), o.phone) + OpenAPI.validate_property(User, Symbol("userStatus"), o.userStatus) +end + function OpenAPI.validate_property(::Type{ User }, name::Symbol, val) if name === Symbol("id")