jsonpath-plus nested store query: working versions (tested 2026-10-16)

{
  "name": "jsonpath-plus-query",
  "private": true,
  "type": "module",
  "scripts": {
    "test": "node --import tsx --test test/*.test.ts"
  },
  "dependencies": {
    "jsonpath-plus": "11.2.1"
  },
  "devDependencies": {
    "@types/node": "26.6.5",
    "tsx": "4.23.15"
  }
}

import { JSONPath } from "jsonpath-plus";

export type Author = { name: string };

export type StoreBook = {
  title: string;
  price: number;
  category: string;
  author: Author;
};

export type Store = {
  store: {
    name: string;
    book: StoreBook[];
    bicycle: { color: string; price: number };
  };
};

export const store: Store = {
  store: {
    name: "Corner Shop",
    book: [
      { title: "Book A", price: 10, category: "fiction", author: { name: "Ann" } },
      { title: "Book B", price: 20, category: "reference", author: { name: "Bob" } },
      { title: "Book C", price: 30, category: "fiction", author: { name: "Cara" } },
    ],
    bicycle: { color: "red", price: 100 },
  },
};

export function values<T = unknown>(json: unknown, path: string): T[] {
  const result = JSONPath({ path, json, resultType: "value" });
  return result as unknown as T[];
}

export function paths(json: unknown, path: string): string[] {
  const result = JSONPath({ path, json, resultType: "path" });
  return result as unknown as string[];
}

import { test } from "node:test";
import assert from "node:assert/strict";
import { store, values, paths, type StoreBook } from "../src/query.ts";

function simplify(path: string): string {
  return path
    .replace(/\[['"]([^'"]+)['"]\]/g, ".$1")
    .replace(/\[(\d+)\]/g, ".$1");
}

test("filter selects books under a price", () => {
  const titles = values<string>(store, "$.store.book[?(@.price < 20)].title");
  assert.deepEqual(titles, ["Book A"]);
});

test("recursive descent collects every price", () => {
  const prices = values<number>(store, "$..price");
  assert.deepEqual(prices, [10, 20, 30, 100]);
});

test("wildcard maps over the book array", () => {
  const names = values<string>(store, "$.store.book[*].author.name");
  assert.deepEqual(names, ["Ann", "Bob", "Cara"]);
});

test("resultType value returns matched nodes", () => {
  const books = values<StoreBook>(store, "$.store.book[?(@.category == 'fiction')]");
  assert.deepEqual(books.map((b) => b.title), ["Book A", "Book C"]);
});

test("resultType path returns matched locations", () => {
  const found = paths(store, "$.store.book[*].title");
  assert.deepEqual(found.map(simplify), [
    "$.store.book.0.title",
    "$.store.book.1.title",
    "$.store.book.2.title",
  ]);
});

test("returned paths round-trip back to the same values", () => {
  const found = paths(store, "$.store.book[*].title");
  const roundTripped = found.map((p) => values<string>(store, p)[0]);
  assert.deepEqual(roundTripped, ["Book A", "Book B", "Book C"]);
});

test("wildcard over an object collects its values", () => {
  const details = values<unknown>(store, "$.store.bicycle.*");
  assert.deepEqual(details, ["red", 100]);
});