From 5c7b2445da701e495f1156e667002e67bfdcd183 Mon Sep 17 00:00:00 2001 From: "d.belincev" Date: Thu, 29 Jan 2026 09:09:04 +0300 Subject: [PATCH 1/4] fix: convert errors, return error from match_cmp_type --- jsonpath.lua | 120 +++++++++++++++++++++++++++++++++++++++----------- test/test.lua | 46 +++++++++---------- 2 files changed, 118 insertions(+), 48 deletions(-) diff --git a/jsonpath.lua b/jsonpath.lua index 6ef01d8..a0e56a3 100755 --- a/jsonpath.lua +++ b/jsonpath.lua @@ -100,6 +100,18 @@ ]]-- local M = {} +local codes = { + SUCCESS = 200, + BAD_REQUEST = 400, + NOT_FOUND = 404, + INTERNAL_ERR = 500, +} + +local errors = require('errors') + +local JsonPathError = errors.new_class("JsonPathError") +local JsonPathNotFoundError = errors.new_class("JsonPathNotFoundError") + local ffi = require('ffi') -- Use Roberto Ierusalimschy's fabulous LulPeg pattern-matching library @@ -554,10 +566,12 @@ local function eval_ast(ast, obj) -- Helper helper: evaluate variable expression inside abstract syntax tree local function eval_var(expr, obj) if obj == nil then - return nil, 'object is not set' + return nil, Bad_request_error('object is not set') end if type(obj) ~= "table" then - return nil, 'object is primitive' + local err = JsonPathNotFoundError:new('object is primitive') + err.rc = codes.NOT_FOUND + return nil, err end for i = 2, #expr do -- [1] is "var" @@ -568,7 +582,9 @@ local function eval_ast(ast, obj) member = type(member) == 'number' and member + 1 or member obj = obj[member] if is_nil(obj) then - return nil, 'object doesn\'t contain an object or attribute "' .. member .. '"' + local err = JsonPathNotFoundError:new('object doesn\'t contain an object or attribute "'.. member ..'"') + err.rc = codes.NOT_FOUND + return nil, err end end return obj @@ -585,7 +601,10 @@ local function eval_ast(ast, obj) local function eval_union(expr, obj) local matches = {} -- [1] is "union" for i = 2, #expr do - local result = eval_ast(expr[i], obj) + local result, err = eval_ast(expr[i], obj) + if err then + return nil, err + end if type(result) == 'table' then for _, j in ipairs(result) do table.insert(matches, j) @@ -599,16 +618,31 @@ local function eval_ast(ast, obj) -- Helper helper: evaluate 'filter' expression inside abstract syntax tree local function eval_filter(expr, obj) - return eval_ast(expr[2], obj) and true or false + local result, err = eval_ast(expr[2], obj) + if err then + if err.rc == codes.NOT_FOUND then + return false + end + return nil, err + end + return result and true or false end -- Helper helper: evaluate 'slice' expression inside abstract syntax tree local function eval_slice(expr, obj) local matches = {} -- [1] is "slice" if #expr == 4 then - local from = tonumber(eval_ast(expr[2], obj)) - local to = tonumber(eval_ast(expr[3], obj)) - local step = tonumber(eval_ast(expr[4], obj)) + local from_result, err = eval_ast(expr[2], obj) + if err then return nil, err end + local to_result, err = eval_ast(expr[3], obj) + if err then return nil, err end + local step_result, err = eval_ast(expr[4], obj) + if err then return nil, err end + + local from = tonumber(from_result) + local to = tonumber(to_result) + local step = tonumber(step_result) + if (from == nil) or (from < 0) or (to == nil) or (to < 0) then local len = eval_var_length(obj) if from == nil then @@ -672,8 +706,7 @@ local function eval_ast(ast, obj) elseif ast[1] == 'filter' then return eval_filter(ast, obj) elseif ast[1] == 'slice' then - local result = eval_slice(ast, obj) - return result + return eval_slice(ast, obj) end return 0 @@ -705,7 +738,10 @@ local function match_path(ast, path, parent, obj) end elseif ast_spec[1] == 'union' or ast_spec[1] == 'slice' then -- match union or slice expression (on parent object) - local matches = eval_ast(ast_spec, parent) + local matches, err = eval_ast(ast_spec, parent) + if err then + return nil, err + end --- @cast matches table[] for _, i in pairs(matches) do match_component = tostring(i) == tostring(component) @@ -715,7 +751,16 @@ local function match_path(ast, path, parent, obj) end elseif ast_spec[1] == 'filter' then -- match filter expression - match_component = eval_ast(ast_spec, obj) and true or false + local filter_result, err = eval_ast(ast_spec, obj) + if err then + if err.rc == codes.NOT_FOUND then + match_component = false + else + return nil, err + end + else + match_component = filter_result and true or false + end end else if ast_spec == '*' then @@ -734,7 +779,16 @@ local function match_path(ast, path, parent, obj) if path_index == #path and ast_spec ~= "array" and match_component then local _, next_ast_spec = next(ast, ast_key) if next_ast_spec ~= nil and next_ast_spec[1] == 'filter' then - match_component = eval_ast(next_ast_spec, obj) and true or false + local filter_result, err = eval_ast(next_ast_spec, obj) + if err then + if err.rc == codes.NOT_FOUND then + match_component = false + else + return nil, err + end + else + match_component = filter_result and true or false + end ast_key, ast_spec = ast_iter(ast, ast_key) end end @@ -769,7 +823,10 @@ end local function match_tree(nodes, ast, path, parent, obj, count) -- Try to match every node against AST - local match = match_path(ast, path, parent, obj) + local match, err = match_path(ast, path, parent, obj) + if err then + return err + end if match == MATCH_ONE or match == MATCH_DESCENDANTS then -- This node matches. Add path and value to result -- (if max result count not yet reached) @@ -792,7 +849,10 @@ local function match_tree(nodes, ast, path, parent, obj, count) table.insert(path1, p) end table.insert(path1, type(key) == 'string' and key or (key - 1)) - match_tree(nodes, ast, path1, obj, child, count) + local err = match_tree(nodes, ast, path1, obj, child, count) + if err then + return err + end end end end @@ -818,15 +878,15 @@ end -- function M.parse(expr) if expr == nil or type(expr) ~= 'string' then - return nil, "missing or invalid 'expr' argument" + return nil, Bad_request_error("missing or invalid 'expr' argument") end local ast = Ct(jsonpath_grammer * Cp()):match(expr) if ast == nil or #ast ~= 2 then - return nil, 'invalid expression "' .. expr .. '"' + return nil, Bad_request_error('invalid expression "' .. expr .. '"') end if ast[2] ~= #expr + 1 then - return nil, 'invalid expression "' .. expr .. '" near "' .. expr:sub(ast[2]) .. '"' + return nil, Bad_request_error('invalid expression "' .. expr .. '" near "' .. expr:sub(ast[2]) .. '"') end return ast[1] end @@ -850,13 +910,16 @@ end -- function M.nodes(obj, expr, count) if obj == nil or type(obj) ~= 'table' then - return nil, "missing or invalid 'obj' argument" + local err = Bad_request_error("missing or invalid 'obj' argument") + return nil, err end if expr == nil or (type(expr) ~= 'string' and type(expr) ~= 'table') then - return nil, "missing or invalid 'expr' argument" + local err = Bad_request_error("missing or invalid 'expr' argument") + return nil, err end if count ~= nil and type(count) ~= 'number' then - return nil, "invalid 'count' argument" + local err = Bad_request_error("invalid 'count' argument") + return nil, err end local ast, err @@ -868,7 +931,11 @@ function M.nodes(obj, expr, count) ast = expr end if ast == nil then - return nil, err or 'internal error' + if not err then + local err = JsonPathError:new("internal error") + err.rc = codes.INTERNAL_ERR + end + return nil, err end if count ~= nil and count == 0 then @@ -885,8 +952,10 @@ function M.nodes(obj, expr, count) end local matches = {} - match_tree(matches, ast, { '$' }, {}, obj, count) - + local err = match_tree(matches, ast, { '$' }, {}, obj, count) + if err then + return nil, err + end -- Sort results by path local sorted = {} for p, v in pairs(matches) do @@ -938,7 +1007,8 @@ function M.value(obj, expr, count) return nodes[1].value end - return nil, 'no element matching expression' + local err = Bad_request_error('no element matching expression') + return nil, err end diff --git a/test/test.lua b/test/test.lua index 84416a0..422d9fe 100755 --- a/test/test.lua +++ b/test/test.lua @@ -826,8 +826,8 @@ testQuery = { } local result, err = jp.query(data, "$..photo[?(@.size>'400')]") - lu.assertItemsEquals(result, {}) lu.assertNil(err) + lu.assertItemsEquals(result, {}) end, testFilterNull = function() @@ -984,8 +984,8 @@ testQuery = { lu.assertItemsEquals(result, { array[1] }) local result, err = jp.query(array, '$[?(@.value>1)]') - lu.assertNil(err) - lu.assertItemsEquals(result, {}) + lu.assertError(err) + lu.assertItemsEquals(result, nil) local result, err = jp.query(array, '$[?(@.value>=1)]') lu.assertNil(err) @@ -1006,24 +1006,24 @@ testQuery = { { id = 2, value = false }, } local result, err = jp.query(array, '$[?(@.value=="1")]') - lu.assertNil(err) - lu.assertItemsEquals(result, {}) + lu.assertError(err) + lu.assertItemsEquals(result, nil) local result, err = jp.query(array, '$[?(@.value>"1")]') - lu.assertNil(err) - lu.assertItemsEquals(result, {}) + lu.assertError(err) + lu.assertItemsEquals(result, nil) local result, err = jp.query(array, '$[?(@.value>="1")]') - lu.assertNil(err) - lu.assertItemsEquals(result, {}) + lu.assertError(err) + lu.assertItemsEquals(result, nil) local result, err = jp.query(array, '$[?(@.value<"1")]') - lu.assertNil(err) - lu.assertItemsEquals(result, {}) + lu.assertError(err) + lu.assertItemsEquals(result, nil) local result, err = jp.query(array, '$[?(@.value<="1")]') - lu.assertNil(err) - lu.assertItemsEquals(result, {}) + lu.assertError(err) + lu.assertItemsEquals(result, nil) end, testFilterArithmeticOpOnBool = function () @@ -1033,24 +1033,24 @@ testQuery = { { id = 2, value = 2 }, } local result, err = jp.query(array, '$[?(@.value==true+1)]') - lu.assertNil(err) - lu.assertItemsEquals(result, {}) + lu.assertError(err) + lu.assertItemsEquals(result, nil) local result, err = jp.query(array, '$[?(@.value==true*1)]') - lu.assertNil(err) - lu.assertItemsEquals(result, {}) + lu.assertError(err) + lu.assertItemsEquals(result, nil) local result, err = jp.query(array, '$[?(@.value==true/1)]') - lu.assertNil(err) - lu.assertItemsEquals(result, {}) + lu.assertError(err) + lu.assertItemsEquals(result, nil) local result, err = jp.query(array, '$[?(@.value==true%1)]') - lu.assertNil(err) - lu.assertItemsEquals(result, {}) + lu.assertError(err) + lu.assertItemsEquals(result, nil) local result, err = jp.query(array, '$[?(@.value<>false+1)]') - lu.assertNil(err) - lu.assertItemsEquals(result, {}) + lu.assertError(err) + lu.assertItemsEquals(result, nil) end, testFilterArithmeticOp = function () From 7dd3d92362d258c122177fe074f3c5001b6c15f3 Mon Sep 17 00:00:00 2001 From: "d.belincev" Date: Mon, 2 Feb 2026 15:30:21 +0300 Subject: [PATCH 2/4] fix: naming, add helper for not_found, delete code 200 --- jsonpath.lua | 25 ++++++++++--------------- 1 file changed, 10 insertions(+), 15 deletions(-) diff --git a/jsonpath.lua b/jsonpath.lua index a0e56a3..1af5f3d 100755 --- a/jsonpath.lua +++ b/jsonpath.lua @@ -101,7 +101,6 @@ local M = {} local codes = { - SUCCESS = 200, BAD_REQUEST = 400, NOT_FOUND = 404, INTERNAL_ERR = 500, @@ -566,12 +565,10 @@ local function eval_ast(ast, obj) -- Helper helper: evaluate variable expression inside abstract syntax tree local function eval_var(expr, obj) if obj == nil then - return nil, Bad_request_error('object is not set') + return nil, bad_request_error('object is not set') end if type(obj) ~= "table" then - local err = JsonPathNotFoundError:new('object is primitive') - err.rc = codes.NOT_FOUND - return nil, err + return nil, not_found_error('object is primitive') end for i = 2, #expr do -- [1] is "var" @@ -582,9 +579,7 @@ local function eval_ast(ast, obj) member = type(member) == 'number' and member + 1 or member obj = obj[member] if is_nil(obj) then - local err = JsonPathNotFoundError:new('object doesn\'t contain an object or attribute "'.. member ..'"') - err.rc = codes.NOT_FOUND - return nil, err + return nil, not_found_error('object doesn\'t contain an object or attribute "'.. member ..'"') end end return obj @@ -878,15 +873,15 @@ end -- function M.parse(expr) if expr == nil or type(expr) ~= 'string' then - return nil, Bad_request_error("missing or invalid 'expr' argument") + return nil, bad_request_error("missing or invalid 'expr' argument") end local ast = Ct(jsonpath_grammer * Cp()):match(expr) if ast == nil or #ast ~= 2 then - return nil, Bad_request_error('invalid expression "' .. expr .. '"') + return nil, bad_request_error('invalid expression "' .. expr .. '"') end if ast[2] ~= #expr + 1 then - return nil, Bad_request_error('invalid expression "' .. expr .. '" near "' .. expr:sub(ast[2]) .. '"') + return nil, bad_request_error('invalid expression "' .. expr .. '" near "' .. expr:sub(ast[2]) .. '"') end return ast[1] end @@ -910,15 +905,15 @@ end -- function M.nodes(obj, expr, count) if obj == nil or type(obj) ~= 'table' then - local err = Bad_request_error("missing or invalid 'obj' argument") + local err = bad_request_error("missing or invalid 'obj' argument") return nil, err end if expr == nil or (type(expr) ~= 'string' and type(expr) ~= 'table') then - local err = Bad_request_error("missing or invalid 'expr' argument") + local err = bad_request_error("missing or invalid 'expr' argument") return nil, err end if count ~= nil and type(count) ~= 'number' then - local err = Bad_request_error("invalid 'count' argument") + local err = bad_request_error("invalid 'count' argument") return nil, err end @@ -1007,7 +1002,7 @@ function M.value(obj, expr, count) return nodes[1].value end - local err = Bad_request_error('no element matching expression') + local err = bad_request_error('no element matching expression') return nil, err end From c35680c68a9f64c5f1fe3647b1e52db3dfb3fddc Mon Sep 17 00:00:00 2001 From: "d.belincev" Date: Mon, 2 Feb 2026 17:27:13 +0300 Subject: [PATCH 3/4] fix: convert error --- jsonpath.lua | 50 ++++++++++++++++++++++++++++++++------------------ test/test.lua | 23 ++++++++++++----------- 2 files changed, 44 insertions(+), 29 deletions(-) diff --git a/jsonpath.lua b/jsonpath.lua index 1af5f3d..2953de4 100755 --- a/jsonpath.lua +++ b/jsonpath.lua @@ -297,6 +297,24 @@ local jsonpath_grammer = (function() return jsonpath end)() +local function bad_request_error(err) + local err = JsonPathError:new(err) + err.rc = codes.BAD_REQUEST + return err +end + +local function not_found_error(err) + local err = JsonPathNotFoundError:new(err) + err.rc = codes.NOT_FOUND + return err +end + +local function internal_error(err) + local err = JsonPathNotFoundError:new(err) + err.rc = codes.INTERNAL_ERR + return err +end + --- @alias Operator 1|2|3|4|5|6|7|8|9|10|11|12|13 --- @alias OperatorType 1|2|3|4 @@ -451,18 +469,19 @@ local function exec_binary_op(op, lval, rval, op_str) if l_type == "string" then lval = tonumber(lval) if lval == nil then - return nil, ("can not parse string lvalue as number for operation %s"):format(op_str) + return nil, bad_request_error(("can not parse string lvalue as number for operation %s"):format(op_str)) end elseif l_type ~= "number" then - return nil, ("lvalue is not a number for operation %s"):format(op_str) + return nil, bad_request_error(("lvalue is not a number for operation %s"):format(op_str)) end if r_type == "string" then rval = tonumber(rval) if rval == nil then - return nil, ("can not parse string rvalue as number for operation %s"):format(op_str) + return nil, + bad_request_error(("can not parse string rvalue as number for operation %s"):format(op_str)) end elseif r_type ~= "number" then - return nil, ("rvalue is not a number for operation %s"):format(op_str) + return nil, bad_request_error(("rvalue is not a number for operation %s"):format(op_str)) end elseif op_type == OPERATOR_TYPES.LOGICAL then -- everything which is not null is a true boolean @@ -550,10 +569,10 @@ local function exec_binary_op(op, lval, rval, op_str) -- must be the same type if l_type ~= r_type then - return nil, ("can not apply %s on types %s and %s"):format(op_str, l_type, r_type) + return nil, bad_request_error(("can not apply %s on types %s and %s"):format(op_str, l_type, r_type)) end else - return nil, ("unknown operator %s"):format(op_str) + return nil, bad_request_error(("unknown operator %s"):format(op_str)) end return OPERATORS_FN[op](lval, rval), nil @@ -667,7 +686,7 @@ local function eval_ast(ast, obj) for i = 3, #expr, 2 do local op_str = expr[i] if op_str == nil then - return nil, 'missing expression operator' + return nil, bad_request_error('missing expression operator') end local op2, eval_err = eval_ast(expr[i + 1], obj) if is_nil(op2) then @@ -675,7 +694,7 @@ local function eval_ast(ast, obj) end local op = parse_operator(op_str) if op == 0 then - return nil, "unknown operator" + return nil, bad_request_error("unknown operator") end --- @cast op Operator local result, cast_err = exec_binary_op(op, op1, op2, op_str) @@ -905,16 +924,13 @@ end -- function M.nodes(obj, expr, count) if obj == nil or type(obj) ~= 'table' then - local err = bad_request_error("missing or invalid 'obj' argument") - return nil, err + return nil, bad_request_error("missing or invalid 'obj' argument") end if expr == nil or (type(expr) ~= 'string' and type(expr) ~= 'table') then - local err = bad_request_error("missing or invalid 'expr' argument") - return nil, err + return nil, bad_request_error("missing or invalid 'expr' argument") end if count ~= nil and type(count) ~= 'number' then - local err = bad_request_error("invalid 'count' argument") - return nil, err + return nil, bad_request_error("invalid 'count' argument") end local ast, err @@ -927,8 +943,7 @@ function M.nodes(obj, expr, count) end if ast == nil then if not err then - local err = JsonPathError:new("internal error") - err.rc = codes.INTERNAL_ERR + err = internal_error("internal error") end return nil, err end @@ -1002,8 +1017,7 @@ function M.value(obj, expr, count) return nodes[1].value end - local err = bad_request_error('no element matching expression') - return nil, err + return nil, bad_request_error('no element matching expression') end diff --git a/test/test.lua b/test/test.lua index 422d9fe..c9f3016 100755 --- a/test/test.lua +++ b/test/test.lua @@ -985,7 +985,7 @@ testQuery = { local result, err = jp.query(array, '$[?(@.value>1)]') lu.assertError(err) - lu.assertItemsEquals(result, nil) + lu.assertItemsEquals(result, {}) local result, err = jp.query(array, '$[?(@.value>=1)]') lu.assertNil(err) @@ -999,15 +999,16 @@ testQuery = { lu.assertNil(err) lu.assertItemsEquals(result, { array[1], array[2] }) end, - + testFilterBoolStrComparison = function () local array = { { id = 1, value = true }, { id = 2, value = false }, } local result, err = jp.query(array, '$[?(@.value=="1")]') - lu.assertError(err) - lu.assertItemsEquals(result, nil) + -- lu.assertError(err) + lu.assertNil(err) + lu.assertItemsEquals(result, {}) local result, err = jp.query(array, '$[?(@.value>"1")]') lu.assertError(err) @@ -1053,22 +1054,22 @@ testQuery = { lu.assertItemsEquals(result, nil) end, - testFilterArithmeticOp = function () + testFilterArithmeticOponStr = function () local array = { { id = 1, value = 0 }, { id = 1, value = "a" }, } local result, err = jp.query(array, '$[?(@.value=="a"+"b")]') - lu.assertNil(err) - lu.assertItemsEquals(result, {}) + lu.assertError(err) + lu.assertItemsEquals(result, nil) local result, err = jp.query(array, '$[?(@.value=="a"+null)]') - lu.assertNil(err) - lu.assertItemsEquals(result, {}) + lu.assertError(err) + lu.assertItemsEquals(result, nil) local result, err = jp.query(array, '$[?(@.value=="a"+1)]') - lu.assertNil(err) - lu.assertItemsEquals(result, {}) + lu.assertError(err) + lu.assertItemsEquals(result, nil) end, } From 463f8e55b38951b06267929c3caecbda3e1ac44a Mon Sep 17 00:00:00 2001 From: Alexandr Sorokin Date: Tue, 17 Feb 2026 10:40:38 +0300 Subject: [PATCH 4/4] Release 1.1.4 --- jsonpath-pico.1.1.4.rockspec | 28 ++++++++++++++++++++++++++++ 1 file changed, 28 insertions(+) create mode 100755 jsonpath-pico.1.1.4.rockspec diff --git a/jsonpath-pico.1.1.4.rockspec b/jsonpath-pico.1.1.4.rockspec new file mode 100755 index 0000000..f5bebf0 --- /dev/null +++ b/jsonpath-pico.1.1.4.rockspec @@ -0,0 +1,28 @@ +package = 'jsonpath' +version = 'pico.1.1.4-1' +source = { + url = 'git+https://github.com/picodata/lua-jsonpath', + tag = '1.1.4' +} +description = { + summary = 'Query Lua data structures with JsonPath expressions. Robust and safe JsonPath engine for Lua.', + detailed = [[ +This library implements Stefan Goessner's JsonPath syntax (http://goessner.net/articles/JsonPath/) in Lua. + +Lua JsonPath is compatible with David Chester's Javascript implementation (https://github.com/dchester/jsonpath). + +The Lua JsonPath library was written from scratch by Frank Edelhaeuser. It's a pure Lua implementation based on a PEG grammer handled by LulPeg pattern-matching library (https://github.com/pygy/LuLPeg.git). + ]], + homepage = 'https://github.com/tarantool/lua-jsonpath', + license = 'MIT' +} +dependencies = { + 'lua >= 5.1', + 'lulpeg ~> pico.0.1.3-1' +} +build = { + type = 'builtin', + modules = { + jsonpath = 'jsonpath.lua' + } +}