[julia] better serverside validation code

.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}}
-        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}}

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

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

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")

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")

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")

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")

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")

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")

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")