[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

@@ -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

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}}
+        o = new({{#allVars}}{{{name}}}, {{/allVars}})
-        OpenAPI.validate_property({{classname}}, Symbol("{{#lambda.escapeDollar}}{{baseName}}{{/lambda.escapeDollar}}"), {{{name}}})
+        OpenAPI.validate_properties(o)
-        {{/allVars}}
+        return o
-        return new({{#allVars}}{{{name}}}, {{/allVars}})
     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}}

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}}
+        op = "{{operationId}}"{{#allParams}}
-        {{#maxLength}}
+        
-        OpenAPI.validate_param("{{#lambda.escapeDollar}}{{baseName}}{{/lambda.escapeDollar}}", "{{operationId}}", :maxLength, openapi_params["{{#lambda.escapeDollar}}{{baseName}}{{/lambda.escapeDollar}}"], {{maxLength}})
+        n = "{{#lambda.escapeDollar}}{{baseName}}{{/lambda.escapeDollar}}"
-        {{/maxLength}}
+        v = get(openapi_params, n, nothing){{#required}}
-        {{#minLength}}
+        isnothing(v) && throw(OpenAPI.ValidationException(;reason="missing parameter $n", operation_or_model=op)){{/required}}
-        OpenAPI.validate_param("{{#lambda.escapeDollar}}{{baseName}}{{/lambda.escapeDollar}}", "{{operationId}}", :minLength, openapi_params["{{#lambda.escapeDollar}}{{baseName}}{{/lambda.escapeDollar}}"], {{minLength}})
+        if !isnothing(v){{#hasValidation}}{{#maxLength}}
-        {{/minLength}}
+            OpenAPI.validate_param(n, op, :maxLength, v, {{maxLength}}){{/maxLength}}{{#minLength}}
-        {{#maximum}}
+            OpenAPI.validate_param(n, op, :minLength, v, {{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}})
+            OpenAPI.validate_param(n, op, :maximum, v, {{maximum}}, {{#exclusiveMaximum}}true{{/exclusiveMaximum}}{{^exclusiveMaximum}}false{{/exclusiveMaximum}}){{/maximum}}{{#minimum}}
-        {{/maximum}}
+            OpenAPI.validate_param(n, op, :minimum, v, {{minimum}}, {{#exclusiveMinimum}}true{{/exclusiveMinimum}}{{^exclusiveMinimum}}false{{/exclusiveMinimum}}){{/minimum}}{{#maxItems}}
-        {{#minimum}}
+            OpenAPI.validate_param(n, op, :maxItems, v, {{maxItems}}){{/maxItems}}{{#minItems}}
-        OpenAPI.validate_param("{{#lambda.escapeDollar}}{{baseName}}{{/lambda.escapeDollar}}", "{{operationId}}", :minimum, openapi_params["{{#lambda.escapeDollar}}{{baseName}}{{/lambda.escapeDollar}}"], {{minimum}}, {{#exclusiveMinimum}}true{{/exclusiveMinimum}}{{^exclusiveMinimum}}false{{/exclusiveMinimum}})
+            OpenAPI.validate_param(n, op, :minItems, v, {{minItems}}){{/minItems}}{{#uniqueItems}}
-        {{/minimum}}
+            OpenAPI.validate_param(n, op, :uniqueItems, v, {{uniqueItems}}){{/uniqueItems}}{{#maxProperties}}
-        {{#maxItems}}
+            OpenAPI.validate_param(n, op, :maxProperties, v, {{maxProperties}}){{/maxProperties}}{{#minProperties}}
-        OpenAPI.validate_param("{{#lambda.escapeDollar}}{{baseName}}{{/lambda.escapeDollar}}", "{{operationId}}", :maxItems, openapi_params["{{#lambda.escapeDollar}}{{baseName}}{{/lambda.escapeDollar}}"], {{maxItems}})
+            OpenAPI.validate_param(n, op, :minProperties, v, {{minProperties}}){{/minProperties}}{{#pattern}}
-        {{/maxItems}}
+            OpenAPI.validate_param(n, op, :pattern, v, r"{{{pattern}}}"){{/pattern}}{{#multipleOf}}
-        {{#minItems}}
+            OpenAPI.validate_param(n, op, :multipleOf, v, {{multipleOf}}){{/multipleOf}}{{/hasValidation}}{{^hasValidation}}
-        OpenAPI.validate_param("{{#lambda.escapeDollar}}{{baseName}}{{/lambda.escapeDollar}}", "{{operationId}}", :minItems, openapi_params["{{#lambda.escapeDollar}}{{baseName}}{{/lambda.escapeDollar}}"], {{minItems}})
+            if isa(v, OpenAPI.APIModel)
-        {{/minItems}}
+                OpenAPI.validate_properties(v)
-        {{#uniqueItems}}
+                if !OpenAPI.check_required(v)
-        OpenAPI.validate_param("{{#lambda.escapeDollar}}{{baseName}}{{/lambda.escapeDollar}}", "{{operationId}}", :uniqueItems, openapi_params["{{#lambda.escapeDollar}}{{baseName}}{{/lambda.escapeDollar}}"], {{uniqueItems}})
+                    throw(OpenAPI.ValidationException(;reason="$n is missing required properties", operation_or_model=op))
-        {{/uniqueItems}}
+                end
-        {{#maxProperties}}
+            end{{/hasValidation}}
-        OpenAPI.validate_param("{{#lambda.escapeDollar}}{{baseName}}{{/lambda.escapeDollar}}", "{{operationId}}", :maxProperties, openapi_params["{{#lambda.escapeDollar}}{{baseName}}{{/lambda.escapeDollar}}"], {{maxProperties}})
+        end{{/allParams}}
-        {{/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}}
         return handler(req)
     end
 end

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}}
+        o = new({{#allVars}}{{{name}}}, {{/allVars}})
-        OpenAPI.validate_property({{classname}}, Symbol("{{#lambda.escapeDollar}}{{baseName}}{{/lambda.escapeDollar}}"), {{{name}}})
+        OpenAPI.validate_properties(o)
-        {{/allVars}}
+        return o
-        return new({{#allVars}}{{{name}}}, {{/allVars}})
     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}}

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)
+        o = new(code, type, message, )
-        OpenAPI.validate_property(ApiResponse, Symbol("type"), type)
+        OpenAPI.validate_properties(o)
-        OpenAPI.validate_property(ApiResponse, Symbol("message"), message)
+        return o
-        return new(code, type, message, )
     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")

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)
+        o = new(id, name, )
-        OpenAPI.validate_property(Category, Symbol("name"), name)
+        OpenAPI.validate_properties(o)
-        return new(id, name, )
+        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")

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)
+        o = new(mappedProperty, uuid_default_value, )
-        OpenAPI.validate_property(MappedModel, Symbol("uuid_default_value"), uuid_default_value)
+        OpenAPI.validate_properties(o)
-        return new(mappedProperty, uuid_default_value, )
+        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")

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)
+        o = new(id, petId, quantity, shipDate, status, complete, )
-        OpenAPI.validate_property(Order, Symbol("petId"), petId)
+        OpenAPI.validate_properties(o)
-        OpenAPI.validate_property(Order, Symbol("quantity"), quantity)
+        return o
-        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, )
     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")

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)
+        o = new(id, category, name, photoUrls, tags, status, )
-        OpenAPI.validate_property(Pet, Symbol("category"), category)
+        OpenAPI.validate_properties(o)
-        OpenAPI.validate_property(Pet, Symbol("name"), name)
+        return o
-        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, )
     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")

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)
+        o = new(id, name, )
-        OpenAPI.validate_property(Tag, Symbol("name"), name)
+        OpenAPI.validate_properties(o)
-        return new(id, name, )
+        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")

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)
+        o = new(id, username, firstName, lastName, email, password, phone, userStatus, )
-        OpenAPI.validate_property(User, Symbol("username"), username)
+        OpenAPI.validate_properties(o)
-        OpenAPI.validate_property(User, Symbol("firstName"), firstName)
+        return o
-        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, )
     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")

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

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

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)
+        n = "orderId"
-        OpenAPI.validate_param("orderId", "get_order_by_id", :minimum, openapi_params["orderId"], 1, false)
+        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

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

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)
+        o = new(another_property, uuid_default_value, )
-        OpenAPI.validate_property(AnotherModel, Symbol("uuid_default_value"), uuid_default_value)
+        OpenAPI.validate_properties(o)
-        return new(another_property, uuid_default_value, )
+        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")

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)
+        o = new(code, type, message, )
-        OpenAPI.validate_property(ApiResponse, Symbol("type"), type)
+        OpenAPI.validate_properties(o)
-        OpenAPI.validate_property(ApiResponse, Symbol("message"), message)
+        return o
-        return new(code, type, message, )
     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")

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)
+        o = new(id, name, )
-        OpenAPI.validate_property(Category, Symbol("name"), name)
+        OpenAPI.validate_properties(o)
-        return new(id, name, )
+        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")

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)
+        o = new(id, petId, quantity, shipDate, status, complete, )
-        OpenAPI.validate_property(Order, Symbol("petId"), petId)
+        OpenAPI.validate_properties(o)
-        OpenAPI.validate_property(Order, Symbol("quantity"), quantity)
+        return o
-        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, )
     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")

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)
+        o = new(id, category, name, photoUrls, tags, status, )
-        OpenAPI.validate_property(Pet, Symbol("category"), category)
+        OpenAPI.validate_properties(o)
-        OpenAPI.validate_property(Pet, Symbol("name"), name)
+        return o
-        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, )
     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")

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)
+        o = new(id, name, )
-        OpenAPI.validate_property(Tag, Symbol("name"), name)
+        OpenAPI.validate_properties(o)
-        return new(id, name, )
+        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")

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)
+        o = new(id, username, firstName, lastName, email, password, phone, userStatus, )
-        OpenAPI.validate_property(User, Symbol("username"), username)
+        OpenAPI.validate_properties(o)
-        OpenAPI.validate_property(User, Symbol("firstName"), firstName)
+        return o
-        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, )
     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")