config/schema: allow to index 'any' type in :get()

`<schema object>:get()` now can access a field inside an `any` type if
it is a `table` or `nil`/`box.NULL`.

`config:get()` now can access fields inside `app.cfg.<key>` and
`roles_cfg.<key>`.

Fixes tarantool#10205

NO_DOC=The `<schema object>:get()` update is included into
       tarantool/doc#4279.
       The `config:get()` reference on the website doesn't mention the
       constraint, so it doesn't need an update.

Author: Totktonada

changelogs/unreleased/config-schema-get-index-any.md

@@ -0,0 +1,6 @@
+## feature/config
+
+* `<schema object>:get()` now supports indexing values inside an `any` type
+  (gh-10205).
+* `config:get()` now supports indexing values inside `app.cfg.<key>` and
+  `roles_cfg.<key>` (gh-10205).

src/box/lua/config/utils/schema.lua

@@ -643,6 +643,36 @@ local function get_usage()
         'path: nil/string/table)', 0)
 end
 
+-- Access a given nested field without checks against a schema.
+local function get_schemaless(data, ctx)
+    local cur = data
+
+    while #ctx.journey > 0 do
+        local requested_field = table.remove(ctx.journey, 1)
+        assert(requested_field ~= nil)
+
+        -- Indexing box.NULL/nil should return nil. There is no
+        -- reason to follow the path down, because the path is not
+        -- checked against a schema inside an 'any' scalar and no
+        -- errors are possible.
+        if cur == nil then
+            return nil
+        end
+
+        -- A primitive type can't be indexed.
+        if type(cur) ~= 'table' then
+            walkthrough_error(ctx, 'Attempt to index a non-table value ' ..
+                '(%s) by field %q', type(cur), requested_field)
+        end
+
+        -- Step down.
+        walkthrough_enter(ctx, requested_field)
+        cur = cur[requested_field]
+    end
+
+    return cur
+end
+
 local function get_impl(schema, data, ctx)
     -- The journey is finished. Return what is under the feet.
     if #ctx.journey == 0 then
@@ -655,7 +685,10 @@ local function get_impl(schema, data, ctx)
     local requested_field = ctx.journey[1]
     assert(requested_field ~= nil)
 
-    if is_scalar(schema) then
+    if is_scalar(schema) and schema.type == 'any' then
+        return get_schemaless(data, ctx)
+    elseif is_scalar(schema) then
+        assert(schema.type ~= 'any')
         walkthrough_error(ctx, 'Attempt to index a scalar value of type %s ' ..
             'by field %q', schema.type, requested_field)
     elseif schema.type == 'record' then
@@ -705,7 +738,8 @@ end
 -- ('foo.bar' works like foo?.bar in TypeScript).
 --
 -- The function checks the path against the schema: it doesn't
--- allow to use a non-existing field or index a scalar value.
+-- allow to use a non-existing field or index a scalar value
+-- (except 'any').
 --
 -- The path is either array-like table or a string in the dot
 -- notation.
@@ -720,9 +754,10 @@ end
 -- Nuances:
 --
 -- * Array indexing is not supported yet.
--- * A scalar of the 'any' type can't be indexed, even when it is
---   a table. It is OK to acquire the whole value of the 'any'
---   type.
+-- * A scalar of the 'any' type can be indexed if it is a table
+--   or nil/box.NULL. In this case a tail of the path that is
+--   inside the 'any' type is not checked against a schema.
+--   Indexing nil/box.NULL always returns nil.
 function methods.get(self, data, path)
     local schema = rawget(self, 'schema')
 

test/config-luatest/config_get_test.lua

@@ -0,0 +1,67 @@
+local t = require('luatest')
+local cbuilder = require('test.config-luatest.cbuilder')
+local cluster = require('test.config-luatest.cluster')
+
+local g = t.group()
+
+g.before_all(cluster.init)
+g.after_each(cluster.drop)
+g.after_all(cluster.clean)
+
+-- gh-10205: verify that options inside app.cfg.<key> and
+-- roles_cfg.<key> can be accessed using config:get().
+g.test_basic = function(g)
+    -- Minimal config.
+    local mycfg = {foo = {bar = {baz = 42, n = box.NULL}}}
+    local config = cbuilder.new()
+        :add_instance('i-001', {})
+        :set_global_option('app.cfg', mycfg)
+        :set_global_option('roles_cfg', mycfg)
+        :config()
+
+    -- Minimal cluster.
+    local cluster = cluster.new(g, config)
+    cluster:start()
+
+    -- Test cases.
+    cluster['i-001']:exec(function()
+        local config = require('config')
+
+        -- A usual option defined in a strict part of the config.
+        t.assert_equals(config:get('memtx.memory'), 256 * 1024 * 1024)
+
+        -- An option inside app.cfg.<key> or roles_cfg.<key>.
+        t.assert_equals(config:get('app.cfg.foo.bar.baz'), 42)
+        t.assert_equals(config:get('roles_cfg.foo.bar.baz'), 42)
+
+        -- A missed option inside app.cfg.<key> or
+        -- roles_cfg.<key>.
+        t.assert_type(config:get('app.cfg.x.y.z'), 'nil')
+        t.assert_type(config:get('roles_cfg.x.y.z'), 'nil')
+
+        -- A box.NULL (null is YAML) option inside app.cfg.<key>
+        -- or roles_cfg.<key>.
+        t.assert_type(config:get('app.cfg.foo.bar.n'), 'cdata')
+        t.assert_type(config:get('roles_cfg.foo.bar.n'), 'cdata')
+
+        -- Indexing a box.NULL option inside app.cfg.<key> or
+        -- roles_cfg.<key>.
+        t.assert_type(config:get('app.cfg.foo.bar.n.i'), 'nil')
+        t.assert_type(config:get('roles_cfg.foo.bar.n.i'), 'nil')
+
+        -- Attempt to index a primitive value (except nil/box.NULL)
+        -- inside app.cfg.<key>.
+        local exp_err_msg = '[instance_config] app.cfg.foo.bar.baz: ' ..
+            'Attempt to index a non-table value (number) by field "fiz"'
+        t.assert_error_msg_equals(exp_err_msg, function()
+            config:get('app.cfg.foo.bar.baz.fiz')
+        end)
+
+        -- The same inside roles_cfg.<key>.
+        local exp_err_msg = '[instance_config] roles_cfg.foo.bar.baz: ' ..
+            'Attempt to index a non-table value (number) by field "fiz"'
+        t.assert_error_msg_equals(exp_err_msg, function()
+            config:get('roles_cfg.foo.bar.baz.fiz')
+        end)
+    end)
+end

test/config-luatest/schema_test.lua

@@ -1102,6 +1102,49 @@ g.test_get_nested_any_in_record = function()
     t.assert_equals(s:get(data, 'foo.bar'), scalar_data)
 end
 
+-- Verify that :get() allows to get a nested value from a scalar
+-- of the any type.
+g.test_get_nested_in_any = function()
+    local s = schema.new('myschema', schema.scalar({type = 'any'}))
+
+    -- Existing data.
+    local data = {foo = {bar = 'baz'}}
+    t.assert_equals(s:get(data, 'foo'), {bar = 'baz'})
+    t.assert_equals(s:get(data, 'foo.bar'), 'baz')
+
+    -- Non-existing data. Verify that :get() works in the optional
+    -- chaining way.
+    local data = {}
+    t.assert_type(s:get(data, 'foo'), 'nil')
+    t.assert_type(s:get(data, 'foo.bar'), 'nil')
+
+    -- The same, but the non-existing field is box.NULL.
+    --
+    -- Indexing of nil/box.NULL gives nil.
+    local data = {foo = box.NULL}
+    t.assert_type(s:get(data, 'foo.bar'), 'nil')
+
+    -- The same, but nil/box.NULL is on the 'any' scalar level,
+    -- not inside.
+    local data = nil
+    t.assert_type(s:get(data, 'foo'), 'nil')
+    local data = box.NULL
+    t.assert_type(s:get(data, 'foo'), 'nil')
+
+    -- If the path points to box.NULL, it is returned as is (not
+    -- as nil).
+    local data = {foo = box.NULL}
+    t.assert_type(s:get(data, 'foo'), 'cdata')
+
+    -- Attempt to index a primitive value (except nil/box.NULL).
+    local exp_err_msg = '[myschema] foo.bar: Attempt to index a non-table ' ..
+        'value (number) by field "baz"'
+    t.assert_error_msg_equals(exp_err_msg, function()
+        local data = {foo = {bar = 42}}
+        s:get(data, 'foo.bar.baz')
+    end)
+end
+
 -- Index a map.
 g.test_get_nested_in_map = function()
     local s = schema.new('myschema', schema.map({
@@ -1211,23 +1254,14 @@ end
 
 -- Attempt to index a scalar value.
 g.test_get_index_scalar = function()
-    -- Indexing a scalar is forbidden.
+    -- Indexing a scalar is forbidden (except 'any').
     local s = schema.new('myschema', schema.scalar({type = 'string'}))
     local exp_err_msg = '[myschema] Attempt to index a scalar value of type ' ..
         'string by field "foo"'
     t.assert_error_msg_equals(exp_err_msg, function()
         local data = 5
         s:get(data, 'foo')
     end)
-
-    -- The scalar of the 'any' type is the same in this regard.
-    local s = schema.new('myschema', schema.scalar({type = 'any'}))
-    local exp_err_msg = '[myschema] Attempt to index a scalar value of type ' ..
-        'any by field "foo"'
-    t.assert_error_msg_equals(exp_err_msg, function()
-        local data = {foo = {bar = 'baz'}}
-        s:get(data, 'foo')
-    end)
 end
 
 -- }}} <schema object>:get()