address review: recognise object branches with type union (e.g. {object,null})

CodeRabbit pointed out that 'branch.type == "object"' misses union type
arrays produced by nullable normalisation (type = {"object", "null"}).
Added a small helper that treats branch.type as either a string or a list.
Added a regression test covering the nullable object branch.

(Did not adopt the proposal to per-branch validate and pick the matching
object branch: parse_deep_object is schema-agnostic about which keys it
collects, so all object branches see the same parsed object, and the
downstream jsonschema validator on the full anyOf/oneOf already evaluates
every branch. Branch order only affects per-property type coercion via
coerce_object_values, and in practice deepObject filters use uniform
property types — adding per-branch jsonschema validation here would
duplicate work without changing acceptance behaviour.)

Author: jarvis9443

lib/resty/openapi_validator/params.lua

@@ -262,8 +262,18 @@ local function deserialize_param(raw_value, param, query_args)
     if style == "deepObject" and stype ~= "object"
        and (schema.anyOf or schema.oneOf) then
         local branches = schema.anyOf or schema.oneOf
+        local function branch_has_object(b)
+            local bt = b and b.type
+            if bt == "object" then return true end
+            if type(bt) == "table" then
+                for _, t in ipairs(bt) do
+                    if t == "object" then return true end
+                end
+            end
+            return false
+        end
         for _, branch in ipairs(branches) do
-            if branch.type == "object" then
+            if branch_has_object(branch) then
                 local obj = parse_deep_object(param.name, query_args or {}, branch)
                 if obj ~= nil then
                     return obj

t/unit/test_params.lua

@@ -272,4 +272,24 @@ T.describe("params: deepObject anyOf rejects unmatched scalar", function()
     T.ok(errs and #errs >= 1, "error reported")
 end)
 
+-- Union type arrays from nullable normalization, e.g. type = {"object","null"},
+-- must still be recognised as an object branch.
+T.describe("params: deepObject anyOf nullable object branch", function()
+    local route = make_route({
+        { name = "created", ["in"] = "query", required = false,
+          style = "deepObject", explode = true,
+          schema = { anyOf = {
+              { type = { "object", "null" }, properties = {
+                  gt = { type = "integer" },
+              } },
+              { type = "integer" },
+          } } },
+    }, "query")
+
+    local ok, errs = params_mod.validate(route,
+        {}, { ["created[gt]"] = "1700000000" }, {})
+    T.ok(ok, "nullable object branch parsed")
+    T.ok(not errs or #errs == 0, "no errors")
+end)
+
 T.done()