jmap-extension

doc/config.json

···
+{
+  "database": {
+    "host": "localhost",
+    "port": 5432,
+    "credentials": {
+      "username": "admin",
+      "password": "secret"
+    }
+  },
+  "features": ["auth", "logging", "metrics"]
+}

src/jsont_pointer.ml

···
       remove p json
   in
   Jsont.map Jsont.json ~dec ~enc:(fun j -> j)
+
+(* JMAP Extended Pointers - RFC 8620 Section 3.7 *)
+module Jmap = struct
+  (* Extended segment type: regular tokens or wildcard *)
+  type segment =
+    | Token of string  (* Unescaped reference token *)
+    | Wildcard         (* The * token for array mapping *)
+
+  type t = segment list
+
+  let parse_segments s =
+    if s = "" then []
+    else if s.[0] <> '/' then
+      Jsont.Error.msgf Jsont.Meta.none
+        "Invalid JMAP Pointer: must be empty or start with '/': %s" s
+    else
+      let rest = String.sub s 1 (String.length s - 1) in
+      let tokens = String.split_on_char '/' rest in
+      List.map (fun tok ->
+        if tok = "*" then Wildcard
+        else if tok = "-" then
+          Jsont.Error.msgf Jsont.Meta.none
+            "Invalid JMAP Pointer: '-' not supported in result reference paths"
+        else Token (Token.unescape tok)
+      ) tokens
+
+  let of_string s = parse_segments s
+
+  let of_string_result s =
+    try Ok (of_string s)
+    with Jsont.Error e -> Error (Jsont.Error.to_string e)
+
+  let segment_to_string = function
+    | Token s -> Token.escape s
+    | Wildcard -> "*"
+
+  let to_string p =
+    if p = [] then ""
+    else
+      let b = Buffer.create 64 in
+      List.iter (fun seg ->
+        Buffer.add_char b '/';
+        Buffer.add_string b (segment_to_string seg)
+      ) p;
+      Buffer.contents b
+
+  let pp ppf p = Format.pp_print_string ppf (to_string p)
+
+  (* Evaluation with wildcard support *)
+  let rec eval_segments segments json =
+    match segments with
+    | [] -> json
+    | Wildcard :: rest ->
+      (* Wildcard: map through array, flatten results *)
+      (match json with
+       | Jsont.Array (elements, meta) ->
+         let results = List.map (eval_segments rest) elements in
+         (* Flatten: if a result is an array, inline its contents *)
+         let flattened = List.concat_map (function
+           | Jsont.Array (elems, _) -> elems
+           | other -> [other]
+         ) results in
+         Jsont.Array (flattened, meta)
+       | _ ->
+         Jsont.Error.msgf (Jsont.Json.meta json)
+           "JMAP Pointer: '*' can only be used on arrays, got %s"
+           (json_sort_string json))
+    | Token token :: rest ->
+      (* Standard token: navigate into object or array *)
+      (match json with
+       | Jsont.Object (members, _) ->
+         (match get_member token members with
+          | Some (_, value) -> eval_segments rest value
+          | None ->
+            Jsont.Error.msgf (Jsont.Json.meta json)
+              "JMAP Pointer: member '%s' not found" token)
+       | Jsont.Array (elements, _) ->
+         (match Token.is_valid_array_index token with
+          | Some n ->
+            (match get_nth n elements with
+             | Some value -> eval_segments rest value
+             | None ->
+               Jsont.Error.msgf (Jsont.Json.meta json)
+                 "JMAP Pointer: index %d out of bounds (array has %d elements)"
+                 n (List.length elements))
+          | None ->
+            Jsont.Error.msgf (Jsont.Json.meta json)
+              "JMAP Pointer: invalid array index '%s'" token)
+       | _ ->
+         Jsont.Error.msgf (Jsont.Json.meta json)
+           "JMAP Pointer: cannot index into %s with '%s'"
+           (json_sort_string json) token)
+
+  let eval p json = eval_segments p json
+
+  let eval_result p json =
+    try Ok (eval p json)
+    with Jsont.Error e -> Error e
+
+  let find p json =
+    try Some (eval p json)
+    with Jsont.Error _ -> None
+
+  let jsont : t Jsont.t =
+    let dec _meta s = of_string s in
+    let enc p = to_string p in
+    Jsont.Base.string (Jsont.Base.map
+      ~kind:"JMAP Pointer"
+      ~doc:"RFC 8620 JMAP extended JSON Pointer"
+      ~dec ~enc ())
+
+  (* Query combinators *)
+
+  let path ?absent p codec =
+    let dec json =
+      match find p json with
+      | Some extracted ->
+        (match Jsont.Json.decode' codec extracted with
+         | Ok v -> v
+         | Error e -> raise (Jsont.Error e))
+      | None ->
+        match absent with
+        | Some v -> v
+        | None ->
+          Jsont.Error.msgf Jsont.Meta.none
+            "JMAP Pointer %s: path not found" (to_string p)
+    in
+    Jsont.map Jsont.json ~dec ~enc:(fun _ ->
+      Jsont.Error.msgf Jsont.Meta.none "Jmap.path: encode not supported")
+
+  let path_list p elem_codec =
+    path p (Jsont.list elem_codec)
+end

src/jsont_pointer.mli

···
 
     If [allow_absent] is [true] (default [false]), does nothing if
     the pointer doesn't resolve instead of raising. *)
+
+(** {1:jmap JMAP Extended Pointers}
+
+    {{:https://www.rfc-editor.org/rfc/rfc8620#section-3.7}RFC 8620 Section 3.7}
+    extends JSON Pointer with a wildcard token [*] for mapping through arrays.
+    This is used in JMAP result references.
+
+    The wildcard semantics are:
+    {ul
+    {- When the current value is an array and the token is [*], apply the rest
+       of the pointer to each element, collecting results into a new array.}
+    {- If a mapped result is itself an array, its contents are flattened into
+       the output (i.e., array of arrays becomes a single array).}}
+
+    Example: Given [{"list": \[{"id": "a"}, {"id": "b"}\]}], the extended
+    pointer [/list/*/id] evaluates to [["a", "b"]].
+
+    {b Note}: These extended pointers are {e not} valid RFC 6901 JSON Pointers.
+    They should only be used for JMAP result reference resolution. *)
+
+module Jmap : sig
+  (** JMAP extended JSON Pointer with wildcard support. *)
+
+  type t
+  (** The type for JMAP extended pointers. Unlike standard pointers, these
+      may contain [*] tokens for array mapping. *)
+
+  val of_string : string -> t
+  (** [of_string s] parses a JMAP extended pointer.
+
+      The syntax is the same as RFC 6901 JSON Pointer, except [*] is allowed
+      as a reference token for array mapping.
+
+      @raise Jsont.Error if [s] has invalid syntax. *)
+
+  val of_string_result : string -> (t, string) result
+  (** [of_string_result s] is like {!of_string} but returns a result. *)
+
+  val to_string : t -> string
+  (** [to_string p] serializes [p] to string form. *)
+
+  val pp : Format.formatter -> t -> unit
+  (** [pp] formats a pointer using {!to_string}. *)
+
+  val eval : t -> Jsont.json -> Jsont.json
+  (** [eval p json] evaluates the extended pointer [p] against [json].
+
+      For [*] tokens on arrays, maps through all elements and collects results.
+      Results that are arrays are flattened into the output.
+
+      @raise Jsont.Error if:
+      - A standard token doesn't resolve (member not found, index out of bounds)
+      - [*] is used on a non-array value
+      - [-] appears in the pointer (not supported in JMAP extended pointers) *)
+
+  val eval_result : t -> Jsont.json -> (Jsont.json, Jsont.Error.t) result
+  (** [eval_result p json] is like {!eval} but returns a result. *)
+
+  val find : t -> Jsont.json -> Jsont.json option
+  (** [find p json] is like {!eval} but returns [None] on errors. *)
+
+  val jsont : t Jsont.t
+  (** [jsont] is a {!Jsont.t} codec for JMAP extended pointers. *)
+
+  (** {2:combinators Query combinators}
+
+      These combinators integrate JMAP extended pointers with jsont codecs,
+      enabling typed extraction from JSON using pointer paths. *)
+
+  val path : ?absent:'a -> t -> 'a Jsont.t -> 'a Jsont.t
+  (** [path p codec] extracts the value at pointer [p] and decodes it with [codec].
+
+      If [absent] is provided and the pointer doesn't resolve, returns [absent].
+      Otherwise raises on pointer resolution failure.
+
+      Example: Extract all thread IDs from an Email/get response:
+      {[
+        let thread_ids =
+          Jmap.path
+            (Jmap.of_string "/list/*/threadId")
+            (Jsont.list Jsont.string)
+      ]}
+
+      @raise Jsont.Error if the pointer fails to resolve (and no [absent])
+      or if decoding with [codec] fails. *)
+
+  val path_list : t -> 'a Jsont.t -> 'a list Jsont.t
+  (** [path_list p codec] extracts the array at pointer [p] and decodes each
+      element with [codec].
+
+      This is a convenience for the common JMAP pattern where wildcards produce
+      arrays that need element-wise decoding:
+      {[
+        (* These are equivalent: *)
+        Jmap.path_list (Jmap.of_string "/list/*/id") Jsont.string
+        Jmap.path (Jmap.of_string "/list/*/id") (Jsont.list Jsont.string)
+      ]}
+
+      @raise Jsont.Error if pointer resolution fails, the result is not an array,
+      or any element fails to decode. *)
+end

src/top/dune

···
+(library
+ (name jsont_pointer_top)
+ (public_name jsont-pointer.top)
+ (libraries jsont-pointer jsont.bytesrw compiler-libs.toplevel))

src/top/jsont_pointer_top.ml

···
+(* Toplevel printers for Jsont_pointer.t, Jsont.json, and Jsont.Error.t
+
+   Usage in toplevel:
+     #require "jsont-pointer.top";;
+     #install_printer Jsont_pointer_top.nav_printer;;
+     #install_printer Jsont_pointer_top.append_printer;;
+     #install_printer Jsont_pointer_top.json_printer;;
+     #install_printer Jsont_pointer_top.error_printer;;
+*)
+
+let nav_printer ppf (p : Jsont_pointer.nav Jsont_pointer.t) =
+  Jsont_pointer.pp_verbose ppf p
+
+let append_printer ppf (p : Jsont_pointer.append Jsont_pointer.t) =
+  Jsont_pointer.pp_verbose ppf p
+
+let json_printer ppf (json : Jsont.json) =
+  match Jsont_bytesrw.encode_string Jsont.json json with
+  | Ok s -> Format.pp_print_string ppf s
+  | Error e -> Format.fprintf ppf "<json encoding error: %s>" e
+
+let error_printer ppf (e : Jsont.Error.t) =
+  Format.pp_print_string ppf (Jsont.Error.to_string e)

src/top/jsont_pointer_top.mli

···
+(** Toplevel printers for {!Jsont_pointer}, {!Jsont.json}, and {!Jsont.Error.t}.
+
+    To use in the OCaml toplevel or utop:
+    {[
+      #require "jsont-pointer.top";;
+      #install_printer Jsont_pointer_top.nav_printer;;
+      #install_printer Jsont_pointer_top.append_printer;;
+      #install_printer Jsont_pointer_top.json_printer;;
+      #install_printer Jsont_pointer_top.error_printer;;
+    ]}
+
+    After installation, JSON Pointers will display their structure:
+    {[
+      # Jsont_pointer.of_string_nav "/foo/0";;
+      - : Jsont_pointer.nav Jsont_pointer.t = [Mem "foo"; Nth 0]
+    ]}
+
+    JSON values will display as formatted JSON strings:
+    {[
+      # Jsont_bytesrw.decode_string Jsont.json {|{"foo": [1, 2]}|};;
+      - : Jsont.json = {"foo": [1, 2]}
+    ]}
+
+    And errors will display as readable messages:
+    {[
+      # Jsont_pointer.of_string "invalid";;
+      Exception: Jsont.Error: Invalid JSON Pointer: must be empty or start with '/'
+    ]} *)
+
+val nav_printer : Format.formatter -> Jsont_pointer.nav Jsont_pointer.t -> unit
+(** [nav_printer] formats a navigation JSON Pointer showing its index structure.
+    Suitable for use with [#install_printer]. *)
+
+val append_printer : Format.formatter -> Jsont_pointer.append Jsont_pointer.t -> unit
+(** [append_printer] formats an append JSON Pointer showing its index structure.
+    Suitable for use with [#install_printer]. *)
+
+val json_printer : Format.formatter -> Jsont.json -> unit
+(** [json_printer] formats a {!Jsont.json} value as a human-readable
+    JSON string. Suitable for use with [#install_printer]. *)
+
+val error_printer : Format.formatter -> Jsont.Error.t -> unit
+(** [error_printer] formats a {!Jsont.Error.t} as a human-readable
+    error message. Suitable for use with [#install_printer]. *)

test/data/jmap_emails.json

···
+{
+  "accountId": "A1",
+  "state": "123456",
+  "list": [
+    {
+      "id": "msg1023",
+      "threadId": "trd194",
+      "from": [{"email": "[e-mail]"}],
+      "subject": "Hello"
+    },
+    {
+      "id": "msg223",
+      "threadId": "trd114",
+      "from": [{"email": "[e-mail]"}],
+      "subject": "Re: Project"
+    },
+    {
+      "id": "msg110",
+      "threadId": "trd99",
+      "from": [{"email": "[e-mail]"}],
+      "subject": "Meeting"
+    }
+  ],
+  "notFound": []
+}

test/data/jmap_threads.json

···
+{
+  "accountId": "A1",
+  "state": "123456",
+  "list": [
+    {
+      "id": "trd194",
+      "emailIds": ["msg1020", "msg1021", "msg1023"]
+    },
+    {
+      "id": "trd114",
+      "emailIds": ["msg201", "msg223"]
+    },
+    {
+      "id": "trd99",
+      "emailIds": ["msg42"]
+    }
+  ],
+  "notFound": []
+}

test/dune

···
        data/nulls.json
        data/booleans.json
        data/unicode.json
-       data/numeric_keys.json))
+       data/numeric_keys.json
+       data/jmap_threads.json
+       data/jmap_emails.json))

test/jmap.t

···
+JMAP Extended JSON Pointer Tests (RFC 8620 Section 3.7)
+
+This tests the wildcard (*) extension to JSON Pointer for JMAP result references.
+
+Parsing JMAP extended pointers:
+
+Basic pointers (no wildcards, same as RFC 6901):
+  $ ./test_pointer.exe jmap-parse ""
+  OK: (root)
+  $ ./test_pointer.exe jmap-parse "/foo"
+  OK: /foo
+  $ ./test_pointer.exe jmap-parse "/foo/0"
+  OK: /foo/0
+  $ ./test_pointer.exe jmap-parse "/a~1b"
+  OK: /a~1b
+
+Wildcard pointers:
+  $ ./test_pointer.exe jmap-parse "/*"
+  OK: /*
+  $ ./test_pointer.exe jmap-parse "/list/*"
+  OK: /list/*
+  $ ./test_pointer.exe jmap-parse "/list/*/id"
+  OK: /list/*/id
+  $ ./test_pointer.exe jmap-parse "/list/*/emailIds"
+  OK: /list/*/emailIds
+  $ ./test_pointer.exe jmap-parse "/a/*/b/*/c"
+  OK: /a/*/b/*/c
+
+Error: "-" not allowed in JMAP pointers:
+  $ ./test_pointer.exe jmap-parse "/-"
+  ERROR: Invalid JMAP Pointer: '-' not supported in result reference paths
+  $ ./test_pointer.exe jmap-parse "/foo/-"
+  ERROR: Invalid JMAP Pointer: '-' not supported in result reference paths
+
+Error: Invalid syntax:
+  $ ./test_pointer.exe jmap-parse "foo"
+  ERROR: Invalid JMAP Pointer: must be empty or start with '/': foo
+  $ ./test_pointer.exe jmap-parse "/~"
+  ERROR: Invalid JSON Pointer: incomplete escape sequence at end
+
+Evaluation without wildcards:
+
+Root pointer:
+  $ ./test_pointer.exe jmap-eval '{"foo":"bar"}' ""
+  OK: {"foo":"bar"}
+
+Simple member access:
+  $ ./test_pointer.exe jmap-eval '{"foo":"bar"}' "/foo"
+  OK: "bar"
+
+Array index:
+  $ ./test_pointer.exe jmap-eval '{"arr":[1,2,3]}' "/arr/1"
+  OK: 2
+
+Nested access:
+  $ ./test_pointer.exe jmap-eval '{"a":{"b":{"c":"deep"}}}' "/a/b/c"
+  OK: "deep"
+
+Evaluation with wildcards (RFC 8620 examples):
+
+Extract single field from each object in array:
+  $ ./test_pointer.exe jmap-eval '{"list":[{"id":"a"},{"id":"b"},{"id":"c"}]}' "/list/*/id"
+  OK: ["a","b","c"]
+
+Extract threadId from Email/get response (RFC 8620 pattern):
+  $ ./test_pointer.exe jmap-eval-file data/jmap_emails.json "/list/*/threadId"
+  OK: ["trd194","trd114","trd99"]
+
+Extract emailIds from Thread/get response (RFC 8620 pattern) - results flattened:
+  $ ./test_pointer.exe jmap-eval-file data/jmap_threads.json "/list/*/emailIds"
+  OK: ["msg1020","msg1021","msg1023","msg201","msg223","msg42"]
+
+Extract nested field:
+  $ ./test_pointer.exe jmap-eval '{"items":[{"data":{"value":1}},{"data":{"value":2}}]}' "/items/*/data/value"
+  OK: [1,2]
+
+Wildcard on empty array:
+  $ ./test_pointer.exe jmap-eval '{"list":[]}' "/list/*/id"
+  OK: []
+
+Multiple wildcards (nested arrays):
+  $ ./test_pointer.exe jmap-eval '{"a":[{"b":[{"c":1},{"c":2}]},{"b":[{"c":3}]}]}' "/a/*/b/*/c"
+  OK: [1,2,3]
+
+Wildcard returning non-arrays (no flattening needed):
+  $ ./test_pointer.exe jmap-eval '{"list":[{"name":"alice"},{"name":"bob"}]}' "/list/*/name"
+  OK: ["alice","bob"]
+
+Flattening behavior - arrays of arrays become flat:
+  $ ./test_pointer.exe jmap-eval '{"items":[{"tags":["a","b"]},{"tags":["c"]},{"tags":["d","e","f"]}]}' "/items/*/tags"
+  OK: ["a","b","c","d","e","f"]
+
+Error cases:
+
+Wildcard on non-array:
+  $ ./test_pointer.exe jmap-eval '{"obj":{"a":1}}' "/obj/*"
+  ERROR: JMAP Pointer: '*' can only be used on arrays, got object
+  File "-":
+  $ ./test_pointer.exe jmap-eval '"string"' "/*"
+  ERROR: JMAP Pointer: '*' can only be used on arrays, got string
+  File "-":
+
+Member not found:
+  $ ./test_pointer.exe jmap-eval '{"foo":"bar"}' "/baz"
+  ERROR: JMAP Pointer: member 'baz' not found
+  File "-":
+
+Index out of bounds:
+  $ ./test_pointer.exe jmap-eval '{"arr":[1,2]}' "/arr/5"
+  ERROR: JMAP Pointer: index 5 out of bounds (array has 2 elements)
+  File "-":
+
+Member not found after wildcard:
+  $ ./test_pointer.exe jmap-eval '{"list":[{"a":1},{"b":2}]}' "/list/*/a"
+  ERROR: JMAP Pointer: member 'a' not found
+  File "-":
+
+Real JMAP patterns:
+
+Get IDs from query response:
+  $ ./test_pointer.exe jmap-eval '{"queryState":"abc","ids":["id1","id2","id3"]}' "/ids"
+  OK: ["id1","id2","id3"]
+
+Get created IDs from changes response:
+  $ ./test_pointer.exe jmap-eval '{"oldState":"a","newState":"b","created":["f1","f4"],"updated":[],"destroyed":[]}' "/created"
+  OK: ["f1","f4"]
+
+Complex nested extraction:
+  $ ./test_pointer.exe jmap-eval '{"results":[{"emails":[{"from":"[e-mail]"},{"from":"[e-mail]"}]},{"emails":[{"from":"[e-mail]"}]}]}' "/results/*/emails/*/from"
+  OK: ["[e-mail]","[e-mail]","[e-mail]"]
+
+Typed extraction with Jmap.path combinator:
+
+Extract string list with wildcard:
+  $ ./test_pointer.exe jmap-path-strings '{"list":[{"id":"a"},{"id":"b"},{"id":"c"}]}' "/list/*/id"
+  OK: [a, b, c]
+
+Extract IDs from JMAP-style response:
+  $ ./test_pointer.exe jmap-path-strings '{"ids":["id1","id2","id3"]}' "/ids"
+  OK: [id1, id2, id3]
+
+Extract threadIds (JMAP Email/get pattern):
+  $ ./test_pointer.exe jmap-path-strings '{"list":[{"threadId":"t1"},{"threadId":"t2"}]}' "/list/*/threadId"
+  OK: [t1, t2]
+
+Extract integers:
+  $ ./test_pointer.exe jmap-path-ints '{"items":[{"count":10},{"count":20},{"count":30}]}' "/items/*/count"
+  OK: [10, 20, 30]
+
+Extract single string value:
+  $ ./test_pointer.exe jmap-path-single '{"account":{"id":"acc123"}}' "/account/id"
+  OK: acc123
+
+Extract with absent default (path exists):
+  $ ./test_pointer.exe jmap-path-absent '{"name":"alice"}' "/name" "default"
+  OK: alice
+
+Extract with absent default (path missing):
+  $ ./test_pointer.exe jmap-path-absent '{"other":"value"}' "/name" "default"
+  OK: default
+
+Nested wildcard extraction:
+  $ ./test_pointer.exe jmap-path-strings '{"a":[{"b":[{"c":"x"},{"c":"y"}]},{"b":[{"c":"z"}]}]}' "/a/*/b/*/c"
+  OK: [x, y, z]
+
+Empty array result:
+  $ ./test_pointer.exe jmap-path-strings '{"list":[]}' "/list/*/id"
+  OK: []
+
+Type mismatch error (expecting strings, got ints):
+  $ ./test_pointer.exe jmap-path-strings '{"list":[{"id":1},{"id":2}]}' "/list/*/id"
+  ERROR: Expected string but found number
+  File "-":
+  File "-": at index 0 of
+  File "-": array<string>

test/test_pointer.ml

···
   with Jsont.Error e ->
     Printf.printf "ERROR: %s\n" (Jsont.Error.to_string e)
 
+(* Test: JMAP extended pointer parse *)
+let test_jmap_parse pointer_str =
+  try
+    let p = Jsont_pointer.Jmap.of_string pointer_str in
+    let s = Jsont_pointer.Jmap.to_string p in
+    if s = "" then Printf.printf "OK: (root)\n"
+    else Printf.printf "OK: %s\n" s
+  with Jsont.Error e ->
+    Printf.printf "ERROR: %s\n" (Jsont.Error.to_string e)
+
+(* Test: JMAP extended pointer evaluation *)
+let test_jmap_eval json_str pointer_str =
+  try
+    let json = parse_json json_str in
+    let p = Jsont_pointer.Jmap.of_string pointer_str in
+    let result = Jsont_pointer.Jmap.eval p json in
+    Printf.printf "OK: %s\n" (json_to_string result)
+  with
+  | Jsont.Error e ->
+    Printf.printf "ERROR: %s\n" (Jsont.Error.to_string e)
+  | Failure e ->
+    Printf.printf "FAIL: %s\n" e
+
+(* Test: JMAP extended pointer evaluation from file *)
+let test_jmap_eval_file json_path pointer_str =
+  try
+    let json = parse_json (read_file json_path) in
+    let p = Jsont_pointer.Jmap.of_string pointer_str in
+    let result = Jsont_pointer.Jmap.eval p json in
+    Printf.printf "OK: %s\n" (json_to_string result)
+  with
+  | Jsont.Error e ->
+    Printf.printf "ERROR: %s\n" (Jsont.Error.to_string e)
+  | Failure e ->
+    Printf.printf "FAIL: %s\n" e
+
+(* Test: JMAP path combinator - extract strings *)
+let test_jmap_path_strings json_str pointer_str =
+  try
+    let json = parse_json json_str in
+    let p = Jsont_pointer.Jmap.of_string pointer_str in
+    let codec = Jsont_pointer.Jmap.path_list p Jsont.string in
+    let result = match Jsont.Json.decode' codec json with
+      | Ok v -> v
+      | Error e -> raise (Jsont.Error e)
+    in
+    Printf.printf "OK: [%s]\n" (String.concat ", " result)
+  with
+  | Jsont.Error e ->
+    Printf.printf "ERROR: %s\n" (Jsont.Error.to_string e)
+  | Failure e ->
+    Printf.printf "FAIL: %s\n" e
+
+(* Test: JMAP path combinator - extract ints *)
+let test_jmap_path_ints json_str pointer_str =
+  try
+    let json = parse_json json_str in
+    let p = Jsont_pointer.Jmap.of_string pointer_str in
+    let codec = Jsont_pointer.Jmap.path_list p Jsont.int in
+    let result = match Jsont.Json.decode' codec json with
+      | Ok v -> v
+      | Error e -> raise (Jsont.Error e)
+    in
+    Printf.printf "OK: [%s]\n" (String.concat ", " (List.map string_of_int result))
+  with
+  | Jsont.Error e ->
+    Printf.printf "ERROR: %s\n" (Jsont.Error.to_string e)
+  | Failure e ->
+    Printf.printf "FAIL: %s\n" e
+
+(* Test: JMAP path combinator - extract single value *)
+let test_jmap_path_single json_str pointer_str =
+  try
+    let json = parse_json json_str in
+    let p = Jsont_pointer.Jmap.of_string pointer_str in
+    let codec = Jsont_pointer.Jmap.path p Jsont.string in
+    let result = match Jsont.Json.decode' codec json with
+      | Ok v -> v
+      | Error e -> raise (Jsont.Error e)
+    in
+    Printf.printf "OK: %s\n" result
+  with
+  | Jsont.Error e ->
+    Printf.printf "ERROR: %s\n" (Jsont.Error.to_string e)
+  | Failure e ->
+    Printf.printf "FAIL: %s\n" e
+
+(* Test: JMAP path combinator with absent *)
+let test_jmap_path_absent json_str pointer_str default =
+  try
+    let json = parse_json json_str in
+    let p = Jsont_pointer.Jmap.of_string pointer_str in
+    let codec = Jsont_pointer.Jmap.path ~absent:default p Jsont.string in
+    let result = match Jsont.Json.decode' codec json with
+      | Ok v -> v
+      | Error e -> raise (Jsont.Error e)
+    in
+    Printf.printf "OK: %s\n" result
+  with
+  | Jsont.Error e ->
+    Printf.printf "ERROR: %s\n" (Jsont.Error.to_string e)
+  | Failure e ->
+    Printf.printf "FAIL: %s\n" e
+
 let () =
   match Array.to_list Sys.argv with
   | _ :: "parse" :: pointer :: _ ->
···
     test_test json pointer expected
   | _ :: "has" :: json :: pointer :: _ ->
     test_has json pointer
+  | _ :: "jmap-parse" :: pointer :: _ ->
+    test_jmap_parse pointer
+  | _ :: "jmap-eval" :: json :: pointer :: _ ->
+    test_jmap_eval json pointer
+  | _ :: "jmap-eval-file" :: json_path :: pointer :: _ ->
+    test_jmap_eval_file json_path pointer
+  | _ :: "jmap-path-strings" :: json :: pointer :: _ ->
+    test_jmap_path_strings json pointer
+  | _ :: "jmap-path-ints" :: json :: pointer :: _ ->
+    test_jmap_path_ints json pointer
+  | _ :: "jmap-path-single" :: json :: pointer :: _ ->
+    test_jmap_path_single json pointer
+  | _ :: "jmap-path-absent" :: json :: pointer :: default :: _ ->
+    test_jmap_path_absent json pointer default
   | _ ->
     Printf.printf "Usage:\n";
     Printf.printf "  test_pointer parse <pointer>\n";
···
     Printf.printf "  test_pointer copy <json> <from> <path>\n";
     Printf.printf "  test_pointer test <json> <pointer> <expected>\n";
     Printf.printf "  test_pointer has <json> <pointer>\n";
+    Printf.printf "  test_pointer jmap-parse <pointer>\n";
+    Printf.printf "  test_pointer jmap-eval <json> <pointer>\n";
+    Printf.printf "  test_pointer jmap-eval-file <json-file> <pointer>\n";
     exit 1