Fix serialization of keys containing single quote or backslash

Author: lionel-rowe

src/path/segments.ts

@@ -2,9 +2,18 @@ import { isArray, isObject, isString } from "../types";
 import { JSONPathEnvironment } from "./environment";
 import { JSONPathRecursionLimitError } from "./errors";
 import { JSONPathNode } from "./node";
-import { JSONPathSelector } from "./selectors";
+import { JSONPathSelector, NameSelector } from "./selectors";
 import { Token } from "./token";
 
+/**
+ * An identifier that is allowed in both JS and JSONPath.
+ * JSONPath identifiers are generally much more permissive than JS ones, but
+ * they don't allow the character "$", so we take the intersection of the two
+ * when deciding whether to use dot shorthand for canonical serialization of
+ * simple names.
+ */
+const SHORTHAND_COMPATIBLE_IDENTIFIER = /^[\p{ID_Start}_]\p{ID_Continue}*$/u;
+
 /** Base class for all JSONPath segments. Both shorthand and bracketed. */
 export abstract class JSONPathSegment {
   constructor(
@@ -52,7 +61,20 @@ export class ChildSegment extends JSONPathSegment {
   }
 
   public toString(): string {
-    return `[${this.selectors.map((s) => s.toString()).join(", ")}]`;
+    const { selectors } = this;
+    const [selector] = selectors;
+
+    if (selectors.length === 1 && selector instanceof NameSelector) {
+      const inner = selector.toString().slice(1, -1);
+
+      if (SHORTHAND_COMPATIBLE_IDENTIFIER.test(inner)) {
+        return `.${inner}`;
+      }
+
+      return `[${selector}]`;
+    }
+
+    return `[${selectors.map((s) => s.toString()).join(", ")}]`;
   }
 }
 

src/path/selectors.ts

@@ -71,7 +71,15 @@ export class NameSelector extends JSONPathSelector {
   }
 
   public toString(): string {
-    return `'${this.name}'`;
+    const jsonified = JSON.stringify(this.name);
+
+    const inner = jsonified.slice(1, -1);
+
+    if (inner.includes("'") && !inner.includes('"')) {
+      return jsonified;
+    }
+
+    return `'${inner.replaceAll('\\"', '"').replaceAll("'", "\\'")}'`;
   }
 }
 

tests/path/escaping.test.ts

@@ -0,0 +1,75 @@
+import { compile } from "../../src/path";
+
+const cases = [
+  { key: "a", serialized: "$.a" },
+
+  { key: 1, serialized: "$[1]" },
+  { key: "1", serialized: `$['1']` },
+  { key: "a1", serialized: "$.a1" },
+  { key: "1a", serialized: `$['1a']` },
+  { key: "a1a", serialized: "$.a1a" },
+  { key: "1a1", serialized: `$['1a1']` },
+
+  { key: "$", serialized: `$['$']` },
+  { key: "$a", serialized: `$['$a']` },
+  { key: "a$", serialized: `$['a$']` },
+  { key: "a$a", serialized: `$['a$a']` },
+  { key: "$a$", serialized: `$['$a$']` },
+
+  { key: "_", serialized: "$._" },
+  { key: "_a", serialized: "$._a" },
+  { key: "a_", serialized: "$.a_" },
+  { key: "a_a", serialized: "$.a_a" },
+  { key: "_a_", serialized: "$._a_" },
+
+  { key: " ", serialized: `$[' ']` },
+  { key: " a", serialized: `$[' a']` },
+  { key: "a ", serialized: `$['a ']` },
+  { key: "a a", serialized: `$['a a']` },
+  { key: " a ", serialized: `$[' a ']` },
+
+  { key: "\\", serialized: String.raw`$['\\']` },
+  { key: '"', serialized: String.raw`$['"']` },
+  { key: `'`, serialized: `$["'"]` },
+  { key: '\\"', serialized: String.raw`$['\\"']` },
+  { key: `\\'`, serialized: String.raw`$["\\'"]` },
+
+  { key: `'"`, serialized: String.raw`$['\'"']` },
+  { key: `"'`, serialized: String.raw`$['"\'']` },
+
+  { key: "*", serialized: `$['*']` },
+  { key: "@", serialized: `$['@']` },
+  { key: "[]", serialized: `$['[]']` },
+  { key: "💩", serialized: `$['💩']` },
+
+  { key: "文字", serialized: `$.文字` },
+
+  { key: "\u200c", serialized: `$['\u200c']` },
+  { key: "\u200ca", serialized: `$['\u200ca']` },
+  { key: "a\u200c", serialized: "$.a\u200c" },
+  { key: "a\u200ca", serialized: "$.a\u200ca" },
+  { key: "\u200ca\u200c", serialized: `$['\u200ca\u200c']` },
+
+  { key: "null", serialized: "$.null" },
+  { key: "Infinity", serialized: "$.Infinity" },
+  { key: "__proto__", serialized: "$.__proto__" },
+];
+
+const obj = Object.fromEntries(cases.map(({ key }) => [key, key]));
+const arr = Array.from({ length: 100 }, (_, i) => i);
+
+describe("escaping of keys", () => {
+  test.each(cases)("$key -> $serialized", ({ key, serialized }) => {
+    const input = `$${JSON.stringify([key])}`;
+    const jpq = compile(input);
+    const path = jpq.toString();
+    const roundTripped = compile(path);
+
+    expect(path).toBe(serialized);
+    expect(roundTripped.toString()).toBe(path);
+
+    const target = typeof key === "number" ? arr : obj;
+    expect(jpq.query(target).values()[0]).toBe(key);
+    expect(roundTripped.query(target).values()[0]).toBe(key);
+  });
+});

tests/path/normalized_path.test.ts

@@ -12,16 +12,16 @@ const testCases: Case[] = [
   { description: "empty", path: "", want: "", error: true },
   { description: "just root", path: "$", want: "$" },
   { description: "root dot", path: "$.", want: "", error: true },
-  { description: "shorthand name", path: "$.foo.bar", want: "$['foo']['bar']" },
+  { description: "shorthand name", path: "$.foo.bar", want: "$.foo.bar" },
   {
     description: "bracketed name, single quotes",
     path: "$['foo']['bar']",
-    want: "$['foo']['bar']",
+    want: "$.foo.bar",
   },
   {
     description: "bracketed name, double quotes",
     path: "$['foo']['bar']",
-    want: "$['foo']['bar']",
+    want: "$.foo.bar",
   },
   {
     description: "dot bracketed",
@@ -62,17 +62,17 @@ const testCases: Case[] = [
   {
     description: "wild shorthand",
     path: "$.foo.*",
-    want: "$['foo'][*]",
+    want: "$.foo[*]",
   },
   {
     description: "wild",
     path: "$.foo[*]",
-    want: "$['foo'][*]",
+    want: "$.foo[*]",
   },
   {
     description: "descend",
     path: "$.foo..[0]",
-    want: "$['foo']..[0]",
+    want: "$.foo..[0]",
   },
   {
     description: "bald descend",
@@ -83,37 +83,37 @@ const testCases: Case[] = [
   {
     description: "multiple selectors",
     path: "$.foo[1, 2:5, *, 'bar']",
-    want: "$['foo'][1, 2:5:1, *, 'bar']",
+    want: "$.foo[1, 2:5:1, *, 'bar']",
   },
   {
     description: "filter, relative query",
     path: "$[?@.foo]",
-    want: "$[?@['foo']]",
+    want: "$[?@.foo]",
   },
   {
     description: "filter, parenthesized",
     path: "$[?(@.foo)]",
-    want: "$[?@['foo']]",
+    want: "$[?@.foo]",
   },
   {
     description: "filter, logical and",
     path: "$[?@.foo && @.bar]",
-    want: "$[?(@['foo'] && @['bar'])]",
+    want: "$[?(@.foo && @.bar)]",
   },
   {
     description: "filter, logical or",
     path: "$[?@.foo || @.bar]",
-    want: "$[?(@['foo'] || @['bar'])]",
+    want: "$[?(@.foo || @.bar)]",
   },
   {
     description: "filter, logical not",
     path: "$[?!@.foo]",
-    want: "$[?!@['foo']]",
+    want: "$[?!@.foo]",
   },
   {
     description: "filter, comparison",
     path: "$[?@.foo == @.bar]",
-    want: "$[?@['foo'] == @['bar']]",
+    want: "$[?@.foo == @.bar]",
   },
 ];
 

tests/path/parse.test.ts

@@ -15,22 +15,22 @@ const TEST_CASES: TestCase[] = [
   {
     description: "not binds more tightly than and",
     path: "$[?!@.a && !@.b]",
-    want: "$[?(!@['a'] && !@['b'])]",
+    want: "$[?(!@.a && !@.b)]",
   },
   {
     description: "not binds more tightly than or",
     path: "$[?!@.a || !@.b]",
-    want: "$[?(!@['a'] || !@['b'])]",
+    want: "$[?(!@.a || !@.b)]",
   },
   {
     description: "control precedence with parens",
     path: "$[?!(@.a && !@.b)]",
-    want: "$[?!(@['a'] && !@['b'])]",
+    want: "$[?!(@.a && !@.b)]",
   },
   {
     description: "non-singular query in logical expression",
     path: "$[?@.* && @.b]",
-    want: "$[?(@[*] && @['b'])]",
+    want: "$[?(@[*] && @.b)]",
   },
 ];