matching keys with regex

[rafalkrupinski]

Hi
Thank you for this super project.

Is there a way to match regex against keys using the extended syntax?

I'm trying to select a funny key from an OpenAPI document:

paths:
  /path:
    get:
      responses:
        200:
          content:
            application/json; version=2.4.49:
               schema:
                 $ref: "#/components/schemas/MyResponse"

I want to select all content nodes with such child (the version changes over time, thus regex)

$..content[?match(???, "version=")]

[jg-rp]

Hi @rafalkrupinski,

The search filter function and current key identifier (#) should do what you need.

I've added an extra "content" property in this example to show that the regex filter is only selecting objects with a property name containing "version=".

import { jsonpath } from "json-p3";

const data = JSON.parse(`
{
  "paths": {
    "/path": {
      "get": {
        "responses": {
          "200": {
            "content": {
              "application/json; version=2.4.49": {
                "schema": {
                  "$ref": "#/components/schemas/MyResponse"
                }
              }
            }
          }
        }
      }
    }
  },
  "content": {
    "foo": {
      "schema": {
        "$ref": "#/components/schemas/MyResponse"
      }
    }
  }
}`);

const env = new jsonpath.JSONPathEnvironment({ strict: false });
const nodes = env.query(`$..content[?search(#, "version=")]`, data);
console.log(JSON.stringify(nodes.values(), undefined, "  "));

Output

[
  {
    "schema": {
      "$ref": "#/components/schemas/MyResponse"
    }
  }
]

(aside: I've just noticed this works without setting strict to false, which is a bug. You should still set strict to false for when the bug gets fixed.)

[rafalkrupinski]

I'm new with jsonPath, but shouldn't it return the contents of content node instead of its grandchild? I thought [?] is a filter and it still uses the previous selector (here content)

[jg-rp]

This is the intended behaviour. ..content selects the value associated with the property name content, giving us...

{
  "application/json; version=2.4.49": {
    "schema": {
      "$ref": "#/components/schemas/MyResponse"
    }
  }
}

Then the filter selector is selecting values where the property name matches our regex. So, unlike JavaScript's Array.filter, which keeps objects where the callback function returns true, JSONPath selects the object's values where the filter expression evaluates to true.

[rafalkrupinski]

How is it different from the example here

The query $.users[?@.admin] selects all values under users that match the predicate has admin property. In my case, it should result with children of content nodes whose value match the predicate, but it returns its grandchildren.

Is it because the example is an array and in my case it's an object?

[jg-rp]

Yes. When you filter a node with an array value, you are visiting every element in the array and @ refers to the current element.

When you filter a node with an object value, you are visiting the object's values. Notice in this example that d does not appear in the output node's value.

import { inspect } from "util";
import { jsonpath } from "json-p3";

const data = {
  someArray: [{ b: 1 }, { c: 2 }],
  someObject: { d: { e: 3 }, foo: { g: 4 } },
};

let q = `$.someArray[?@.c]`;
let nodes = jsonpath.query(q, data);

console.log(inspect(nodes, { colors: true, depth: null }));

q = `$.someObject[?@.e]`;
nodes = jsonpath.query(q, data);

// Notice `d` does not appear in the node's value
console.log(inspect(nodes, { colors: true, depth: null }));

Output

JSONPathNodeList {
  nodes: [
    JSONPathNode {
      value: { c: 2 },
      location: [ 'someArray', 1 ],
      root: {
        someArray: [ { b: 1 }, { c: 2 } ],
        someObject: { d: { e: 3 }, foo: { g: 4 } }
      }
    }
  ]
}
JSONPathNodeList {
  nodes: [
    JSONPathNode {
      value: { e: 3 },
      location: [ 'someObject', 'd' ],
      root: {
        someArray: [ { b: 1 }, { c: 2 } ],
        someObject: { d: { e: 3 }, foo: { g: 4 } }
      }
    }
  ]
}

[jg-rp]

This alternative query selects objects with a content property and content has a property name containing version=.

$..[?search(value(@.content.~), "version=")]

Output

[
  {
    "content": {
      "application/json; version=2.4.49": {
        "schema": {
          "$ref": "#/components/schemas/MyResponse"
        }
      }
    }
  }
]

But this only works if content has a single property.

[rafalkrupinski]

How to get

[
  {
    "application/json; version=2.4.49": {
      "schema": {
        "$ref": "#/components/schemas/MyResponse"
      }
    }
  }
]

as the output :)

No, there may be more properties in content.

[rafalkrupinski]

how about non-descending filter, so like [?...] but keeping selection at @

[rafalkrupinski]

Another option would be a parent selector, like jsonpath-plus and the original xpath have. But I guess they're bigger changes than an extension function

[jg-rp]

👍 Either could work, but would require additional syntax, whereas function extensions are well-defined and already part of the spec.

[jg-rp]

Probably not the most intuitive solution, but here's a prototype implementation of has (in TypeScript, some of these helper functions are not currently exported)..

import { check } from "iregexp-check";
import { FilterFunction, FunctionExpressionType } from "./function";
import { isObject, isString } from "../../types";
import { mapRegexp } from "./pattern";

/**
 * A function extension that returns `true` if the first argument is an object
 * value and it contains a property matching the second argument.
 */
export class Has implements FilterFunction {
  readonly argTypes = [
    FunctionExpressionType.ValueType,
    FunctionExpressionType.ValueType,
  ];

  readonly returnType = FunctionExpressionType.LogicalType;

  public call(value: unknown, pattern: string): boolean {
    // Silently return false if the pattern is invalid.
    if (!isString(pattern) || !check(pattern)) return false;

    // TODO: cache the compiled regex
    const re = new RegExp(mapRegexp(pattern), "u");

    if (isObject(value)) return Object.keys(value).some((k) => !!k.match(re));
    return false;
  }
}

With this query, we get your desired result.

$..[?has(@.content, 'version=')].content

With a normalized path of $.paths['/path'].get.responses['200'].content.

What do you think? Would this be an acceptable solution?

[rafalkrupinski]

At first it sounded bit too narrow in scope, i.e. too specific to my problem, but now that I see it, I think that's pretty elegant.

Cheers.

[rafalkrupinski]

{
  "responses": {
    "200": {
      "description": "OK",
      "content": {
        "application/json; version=1": {
          "schema": {}
        },
        "application/json": {
          "schema": {}
        }
      }
    }
  }
}

$..[?@.content[?search(#, "version")]]

result (paths)

[
  "$.responses['200']"
]

for json path

$..content[?search(#, "version")]

result

[
  "$.responses['200'].content['application/json; version=1']"
]

how to get

[
  "$.responses['200'].content"
]

BTW, it's really cool that nested filters work

[rafalkrupinski]

btw
https://www.npmjs.com/package/betterer-json