feat(refs): resolve $dynamicRef/$dynamicAnchor (2020-12)

Implement resolution of $dynamicRef and $dynamicAnchor keywords
from JSON Schema Draft 2020-12 (used in OpenAPI 3.1 specs).

During ref resolution, $dynamicAnchor targets are collected from
the entire spec tree. When a $dynamicRef like '#anchor' is found,
it's resolved to the matching $dynamicAnchor target inline, just
like regular $ref resolution. This enables validation of schemas
that use dynamic references for polymorphic type constraints.

Author: jarvis9443

lib/resty/openapi_validator/normalize.lua

@@ -11,8 +11,6 @@ local tab_insert = table.insert
 
 -- Keywords that are Draft 2020-12 only and have no Draft 7 equivalent
 local UNSUPPORTED_31_KEYWORDS = {
-    ["$dynamicRef"] = true,
-    ["$dynamicAnchor"] = true,
     ["unevaluatedProperties"] = true,
     ["unevaluatedItems"] = true,
 }
@@ -99,6 +97,19 @@ local function normalize_31_schema(schema, warnings, strict)
         return nil
     end
 
+    -- Strip $dynamicAnchor (resolved during refs phase)
+    schema["$dynamicAnchor"] = nil
+
+    -- Warn about any remaining $dynamicRef (should have been resolved)
+    if schema["$dynamicRef"] then
+        if strict then
+            return "unresolved $dynamicRef: " .. schema["$dynamicRef"]
+        end
+        tab_insert(warnings, "unresolved $dynamicRef ignored: "
+                             .. schema["$dynamicRef"])
+        schema["$dynamicRef"] = nil
+    end
+
     -- Check for unsupported 2020-12 keywords
     for kw in pairs(UNSUPPORTED_31_KEYWORDS) do
         if schema[kw] ~= nil then

lib/resty/openapi_validator/refs.lua

@@ -36,6 +36,25 @@ local function resolve_pointer(root, pointer)
 end
 
 
+-- Collect all $dynamicAnchor targets from a spec tree.
+-- Returns a map from anchor name to the table containing the anchor.
+local function collect_dynamic_anchors(node, anchors, visited)
+    if type(node) ~= "table" or visited[node] then
+        return
+    end
+    visited[node] = true
+
+    local anchor = node["$dynamicAnchor"]
+    if anchor then
+        anchors[anchor] = node
+    end
+
+    for _, v in pairs(node) do
+        collect_dynamic_anchors(v, anchors, visited)
+    end
+end
+
+
 -- Walk the spec tree and resolve every $ref node in place.
 --
 -- Strategy:
@@ -57,6 +76,10 @@ function _M.resolve(spec)
     local registry = {}
     local walked = {}
 
+    -- Collect $dynamicAnchor targets for $dynamicRef resolution
+    local dynamic_anchors = {}
+    collect_dynamic_anchors(spec, dynamic_anchors, {})
+
     local walk
 
     local function resolve_ref(ref)
@@ -116,6 +139,32 @@ function _M.resolve(spec)
                     else
                         node[k] = resolved
                     end
+                elseif v["$dynamicRef"] then
+                    -- Resolve $dynamicRef by looking up the anchor
+                    local dyn_ref = v["$dynamicRef"]
+                    local anchor_name = dyn_ref:match("^#(.+)$")
+                    if anchor_name and dynamic_anchors[anchor_name] then
+                        local target = dynamic_anchors[anchor_name]
+                        walk(target)
+
+                        -- collect sibling keys
+                        local siblings, has_siblings
+                        for sk, sv in pairs(v) do
+                            if sk ~= "$dynamicRef" then
+                                siblings = siblings or {}
+                                siblings[sk] = sv
+                                has_siblings = true
+                            end
+                        end
+
+                        if has_siblings then
+                            walk(siblings)
+                            node[k] = { allOf = { target, siblings } }
+                        else
+                            node[k] = target
+                        end
+                    end
+                    -- unresolved $dynamicRef: leave for normalize to warn/error
                 else
                     walk(v)
                 end